[CodeUP] Python기초 100제

📌 Python 프로그래밍을 처음 배울 때 좋은 습관(단계)

1. 입력된 문자열을 정확하게 잘라낸다.(공백, 줄바꿈, 구분문자 등에 따라 정확하게 잘라낸다.)
2. 잘라낸 데이터들을 데이터형에 맞게 변환해 변수에 저장한다. (정수, 실수, 문자, 문자열 등에 따라 정확하게 변환한다.)
3. 값을 저장했다가 다시 사용하기 위해, 변수를 이용해 값을 저장하고, 변수를 이용해 계산을 한다.
4. 원하는 결과 값을 필요한 형태로 만들어 출력한다.(공백, 줄바꿈, 구분자, 등에 따라 원하는 형태로 만들어 출력한다.)

6018 : [기초-입출력] 시간 입력받아 그대로 출력하기

• print(?, ?, sep=':') 를 사용하면 콜론 : 기호를 사이에 두고 값을 출력

• sep는 분류기호(seperator)를 의미

a,b = input().split(":")
print(a,b,sep=":")

# 10:57 ↲
# 10:57

6020 : [기초-입출력] 주민번호 입력받아 형태 바꿔 출력하기

• 앞 자리 뒷자리 모두 붙여서 출력 ➞ + 이용하면 붙여서 출력

front,back = input().split("-")
print(front+back)

# 890429-0909098 ↲
# 8904290909098

6027 : [기초-출력변환] 10진 정수 입력받아 16진수로 출력하기

• 문자열 포맷팅

• "%x"%a: a에 저장되어있는 값을 16진수 소문자 형태 문자열로

a = int(input())
print("%x"%a)		# 16진수(hexadecimal) 소문자 형태 문자열로 출력
print("%X"%a)		# 16진수(hexadecimal) 대문자 형태 문자열로 출력

6029 : [기초-값변환] 16진 정수 입력받아 8진수로 출력하기

• int(a, 16) : 16진수 a를 10진수로 변환

• "o%"%n: n에 저장되어있는 값을 8진수(octal)로

num = input()
a = int(num, 16)
print("%o" %a)  

# 또는
a = int(input(), 16)
print("%o" %a)

# f ↲
# 17

6030~31 : [기초-값변환] 영문자 1개 입력받아 10진수로 변환하기, 정수 입력받아 유니코드 문자로 변환하기

• ord(문자): 특정 한 문자에 해당하는 유니코드 정수를 반환

• chr(정수): 하나의 정수를 인자로 받고 해당 정수에 해당하는 유니코드 문자를 반환

• 입력 값이 문자/문자열/정수/실수인지에 따라서 먼저 정확하게 변환시킨 다음에 사용하거나 계산하는 것이 좋다.

n = ord(input())
print(n)

# A ↲
# 65

c = int(input())
print(chr(c))

# 65 ↲
# A

6033 : [기초-산술연산] 문자 1개 입력받아 다음 문자 출력하기

• 문자를 받고 ➞ 유니코드 정수 반환 (n) ➞ 유니코드 정수+1을 유니코드 문자로 반환

• 영문자 'A'의 다음 문자는 'B'이고, 숫자 '0'의 다음 문자는 '1'

• 아스키문자표에서 'A'는 10진수 65로 저장되고 'B'는 10진수 66으로 저장된다. 따라서, 문자도 값으로 덧셈을 할 수 있다. 어떤 문자의 값에 1을 더하면 그 다음 문자의 값이 된다.

n = ord(input())
print(chr(n+1))

# a ↲
# b

6036 : [기초-산술연산] 단어 여러 번 출력하기

• 문자열 정수 (또는 정수 문자열)은 그 문자열을 여러 번 반복한 문자열을 만들어 준다.

w, n = input().split()
print(w * int(n))

# love 3 ↲
# lovelovelove

6042 : [기초-값변환] 실수 1개 입력받아 소숫점이하 자리 변환하기

• format(수, ".2f") 를 사용하면 원하는 자리까지의 정확도로 반올림 된 실수 값을 만들어 준다.

• 여기서 만들어진 값은 소수점 아래 3번째 자리에서 반올림한 값이다.

• round(n, ndigit): n은 숫자, ndigit은 소수점 아래 ndigit+1번째 자리에서 반올림한다는 뜻이고 생략하면 가장 가까운 정수 반환

• 컴퓨터가 실수를 정확히 표현하지 못한다는 것을 기억하자

a = float(input())
print(format(a, ".2f"))
# 또는
print(round(f,2))
 
# 3.141592 ↲
# 3.14

6046 : [기초-비트시프트연산] 정수 1개 입력받아 2배 곱해 출력하기

• 정수를 2배로 곱하거나(*2) 나누어 (/2)계산해 주는 비트단위시프트연산자 <<, >>를 이용할 수 있다.

  • 컴퓨터 내부에는 2진수 형태로 값들이 저장되기 때문에, 2진수 형태로 저장되어 있는 값들을 왼쪽(<<)이나 오른쪽(>>)으로 지정한 비트 수만큼 밀어주면 2배씩 늘어나거나 1/2로 줄어드는데,

  • 왼쪽 비트시프트(<<)가 될 때에는 오른쪽에 0이 주어진 개수만큼 추가되고, 오른쪽 비트시프트(>>)가 될 때에는 왼쪽에 0(0 또는 양의 정수인 경우)이나 1(음의 정수인 경우)이 개수만큼 추가되고, 가장 오른쪽에 있는 1비트는 사라진다.

    n = 10
    print(n<<1)  # 10을 2배 한 값인 20
    print(n>>1)  # 10을 반으로 나눈 값인 5
    print(n<<2)  # 10을 4배 한 값인 40
    print(n>>2)  # 10을 반으로 나눈 후 다시 반으로 나눈 값인 2

• 정수 10의 2진수 표현은 1010

  • 10 << 1 을 계산하면 ... 10100 = 10진수로 20
  • 10 >> 1 을 계산하면 ... 101 = 10진수로 5

• n = 10 과 같이 키보드로 입력받지 않고 직접 작성해 넣은 코드에서, 숫자로 시작하는 단어(식별자, identifier)는 자동으로 수로 인식된다.

  • n = 10 에서 10 은 10진수 정수 값으로 인식된다.
  • 변수 n 에 문자열을 저장하고 싶다면, n = "10" 또는 n = '10'으로 작성해 넣으면 되고,
  • n = 10.0 으로 작성해 넣으면 자동으로 실수 값으로 저장된다.
  • n = 0o10 으로 작성해 넣으면 8진수(octal) 10으로 인식되어 10진수 8값이 저장되고,
  • n = 0xf 나 n = 0XF 으로 작성해 넣으면 16진수(hexadecimal) F로 인식되어 10진수 15값으로 저장된다.

• python에서 실수 값에 대한 비트시프트 연산은 허용되지 않고 오류가 발생한다.
  (실수 값도 컴퓨터 내부적으로는 2진수 형태로 저장되고 비트시프트 처리가 될 수 있지만, python 에서는 허용하지 않는다.)

6047 : [기초-비트시프트연산] 2의 거듭제곱 배로 곱해 출력하기

• 정수 2개(a, b)를 입력받아 a를 2^b배 곱한 값으로 출력 = a << b

a,b = map(int,input().split())
print(a << b) 

# 1 3 ↲
# 8

6052 : [기초-논리연산] 정수 입력받아 참 거짓 평가하기

• bool( ) 을 이용하면 입력된 식이나 값을 평가해 bool형의 값(True 또는 False)을 출력해준다.
• 식이나 값을 계산해서 결과값이 만들어지는 것을 평가(evaluate)라고 한다.
• python 언어에서 정수값 0은 False(거짓)로 평가되고, 그 외의 값들은 모두 True(참)로 평가된다.
  

6053~54: [기초-논리연산] 참 거짓 바꾸기, 둘 다 참일 경우만 참 출력하기

• a = bool(int(input()))
  • 겹쳐 작성하면, 한 번에 한 단계씩 계산/처리/평가된다.
  • input( ), int( ), bool( ) 순서로
• 어떤 불 값이나 변수에 not True, not False, not a 와 같은 계산이 가능
• 참 또는 거짓의 논리값을 역(반대)으로 바꾸기 위해서 not 예약어(reserved word, keyword)를 사용할 수 있다.
  • 이러한 논리연산을 NOT 연산(boolean NOT)이라고도 부르고,
  • 프라임 '(작은 따옴표), 바(-), 문자 오른쪽 위에 c(여집합, complement) 등으로 표시한다. 모두 같은 의미
• 참, 거짓의 논리값 인 불(boolean) 값을 다루어주는 예약어는 not, and, or 이 있고, 불 값들 사이의 논리(not, and, or) 연산 결과도 마찬가지로 True 또는 False 의 불 값으로 계산 된다.
• 정수값 0은 False 이고, 나머지 정수 값들은 True 로 평가된다.
• 빈 문자열 ""or ''는 False 이고, 나머지 문자열들은 True 로 평가된다.

# 참거짓 바꾸기
n = bool(int(input()))
print(not n)

# 0 ↲
# True
# 1 ↲
# False

# 둘 다 참일 경우만 참 출력
n,m = map(int,input().split())
print(bool(n) and bool(m))

# 0 1 ↲
# False
# 1 2 ↲
# True

6056 : [기초-논리연산] 참/거짓이 서로 다를 때에만 참 출력하기

• 참 거짓이 서로 다를 때에만 True 로 계산하는 논리연산을 XOR(exclusive or, 배타적 논리합) 연산이라고도 부른다.

n,m = map(int,input().split())
a = bool(n)
b = bool(m)
print((a and (not b)) or ((not a) and b))

# 1 1 ↲
# False
# 1 0 ↲
# True

6057 : [기초-논리연산] 참/거짓이 서로 같을 때에만 참 출력하기

n,m = map(int,input().split())
a = bool(n)
b = bool(m)

print(((not a) and (not b)) or (a and b))

# 0 0 ↲
# True
# 0 1 ↲
# False

6059~62 : [기초-비트단위논리연산] 비트단위로 NOT/AND/OR/XOR 하여 출력하기

1. 비트단위로 NOT 출력

• 입력 된 정수를 비트단위로 참/거짓을 바꾼 후 정수로 출력해보자.
• 비트단위(bitwise)연산자 ~(tilde)를 붙이면 됨
• 비트단위 연산자
  • ~ (bitwise not)
  • & (bitwise and)
  • | (bitwise or)
  • ^ (bitwise xor)
  • << (bitwise left shift)
  • >> (bitwise right shift)
  • 예를 들어 1이 입력되었을 때 저장되는 1을 32비트 2진수로 표현하면 00000000 00000000 00000000 00000001 이고,
    ~1은 11111111 11111111 11111111 11111110 가 되는데 이는 -2를 의미

참고
컴퓨터에 저장되는 모든 데이터들은 2진수 형태로 바뀌어 저장된다.
0과 1로만 구성되는 비트단위들로 변환되어 저장되는데,
양의 정수는 2진수 형태로 바뀌어 저장되고, 음의 정수는 "2의 보수 표현"방법으로 저장된다.
양의 정수 5를 32비트로 저장하면, 5의 2진수 형태인 101이 32비트로 만들어져
00000000 00000000 00000000 00000101로 저장된다.
(공백은 보기 편하도록 임의로 분리)
32비트 형의 정수 0은 00000000 00000000 00000000 00000000 그리고 -1은 0에서 1을 더 빼고 32비트만 표시하는 형태로
11111111 11111111 11111111 11111111 로 저장된다.
-2는 -1에서 1을 더 빼면 된다.
11111111 11111111 11111111 11111110 로 저장된다.
이러한 내용을 간단히 표현하면, 정수 n이라고 할 때,
~n = -n - 1
-n = ~n + 1 과 같은 관계로 표현할 수 있다.

2. 비트단위로 AND 출력

• 입력된 정수 두 개를 비트단위로 and 연산한 후 그 결과를 정수로 출력해보자.
• 비트단위 and 연산(&, 앰퍼샌드)은 두 비트열이 주어졌을 때, 둘 다 1인 부분의 자리만 1로 만들어주는 것과 같다.
• 예를 들어 3과 5가 입력되었을 때를 살펴보면
  3 : 00000000 00000000 00000000 00000011
  5 : 00000000 00000000 00000000 00000101
  3 & 5 : 00000000 00000000 00000000 00000001
• 이 연산을 이용하면 어떤 비트열의 특정 부분만 모두 0으로도 만들 수 있는데
  192.168.0.31 : 11000000.10101000.00000000.00011111
  255.255.255.0 : 11111111.11111111.11111111.00000000
  두 개의 ip 주소를 & 연산하면
  192.168.0.0 : 110000000.10101000.0000000.00000000 을 계산할 수 있다.
• 실제로 이 계산은 네트워크에 연결되어 있는 두 개의 컴퓨터가 데이터를 주고받기 위해 같은 네트워크에 있는지 아닌지를 판단하는데 사용된다. 이러한 비트단위 연산은 빠른 계산이 필요한 그래픽처리에서 마스크연산(특정 부분을 가리고 출력하는)을 수행하는 데에도 효과적으로 사용된다.

3. 비트단위로 OR 출력

• 입력된 정수 두 개를 비트단위로 or 연산(|, 파이프)한 후 그 결과를 정수로 출력해보자.
• 예를 들어 3과 5가 입력되었을 때를 살펴보면
  3 : 00000000 00000000 00000000 00000011
  5 : 00000000 00000000 00000000 00000101
  3 | 5 : 00000000 00000000 00000000 00000111
• 비트단위 or 연산은 둘 중 하나라도 1인 자리를 1로 만들어주는 것과 같다.
• 이러한 비트단위 연산은 빠른 계산이 필요한 그래픽처리에서도 효과적으로 사용된다.

4. 비트단위로 XOR 출력

• 입력된 정수 두 개를 비트단위로 xor 연산(^, 서컴플렉스,카릿)한 후 그 결과를 정수로 출력해보자.
• 예를 들어 3과 5가 입력되었을 때를 살펴보면
  3 : 00000000 00000000 00000000 00000011
  5 : 00000000 00000000 00000000 00000101
  3 ^ 5 : 00000000 00000000 00000000 00000110
• 이러한 비트단위 연산은 빠른 계산이 필요한 그래픽처리에서도 효과적으로 사용된다.

구체적으로 설명하자면, 두 장의 이미지가 겹쳐졌을 때 색이 서로 다른 부분만 처리할 수 있다. 배경이 되는 그림과 배경 위에서 움직이는 그림이 있을 때, 두 그림에서 차이만 골라내 배경 위에서 움직이는 그림의 색으로 바꿔주면 전체 그림을 구성하는 모든 점들의 색을 다시 계산해 입히지 않고 보다 효과적으로 그림을 처리할 수 있게 되는 것이다. 비행기 슈팅게임 등을 상상해보면 된다.

# 비트단위로 NOT 연산
# 비트 단위로 1 -> 0, 0 -> 1로 바꾼 후 그 값을 10진수로 출력
n = int(input())
print(~n)    
# 2 ↲
# -3

# 비트단위로 AND 연산
# 두 정수를 비트단위(bitwise)로 and 계산을 수행한 결과를 10진수로 출력한다.
n,m = map(int,input().split())
print(n & m)
# 3 5 ↲
# 1

# 비트단위로 OR 연산
# 두 정수를 비트단위(bitwise)로 or 계산을 수행한 결과를 10진수로 출력한다.
n,m = map(int,input().split())
print(n | m)
# 3 5 ↲
# 7

# 비트단위로 XOR 연산
# 두 정수를 비트단위(bitwise)로 or 계산을 수행한 결과를 10진수로 출력한다.
n,m = map(int,input().split())
print(n ^ m)
# 3 5 ↲
# 6

6064 : [기초-3항연산] 정수 3개 입력받아 가장 작은 값 출력하기

• 입력된 세 정수 a, b, c 중 가장 작은 값을 출력하는 프로그램을 작성해보자

a,b,c = map(int,input().split())
print(c if ((b if a > b else a) > c) else (b if a > b else a))

# 3 -1 5 ↲
# -1

6071 : [기초-반복실행구조] 0 입력될 때까지 무한 출력하기

• 입력된 정수를 줄을 바꿔 하나씩 출력하는데, 0이 입력되면 종료한다.

while True: 
    a = int(input())
    if a == 0: 
        break 
    else:
    	print(a)

6074 : [기초-반복실행구조] 문자 1개 입력받아 알파벳 출력하기

• 영문 소문자(a ~ z) 1개가 입력되었을 때, a부터 그 문자까지의 알파벳을 순서대로 출력해보자.
• print(..., end=' ') 와 같이 작성하면 값 출력 후 공백문자 ' '를 출력한다. 즉, 마지막에 줄을 바꾸지 않고 빈칸만 띄운다.
• end='\n'로 작성하거나 생략하면, 값을 출력한 후 마지막(end)에 줄바꿈(newline)이 된다.

n = ord(input())            # 입력 받은 문자를 유니코드로 변환

for i in range(97,n+1):     # 'a'가 97이므로 a 부터 입력받은 입력받은 n까지 출력하기
  print(chr(i), end=' ')
  
# f ↲
# a b c d e f

n = ord(input())
for i in range(97,n+1):
  print(chr(i))
  
# f ↲
# a
# b
# c
# d
# e
# f

6079 : [기초-종합] 언제까지 더해야 할까?

• 1, 2, 3, 4, 5 ... 를 순서대로 계속 더해 합을 만들어가다가, 입력된 정수와 같거나 커졌을 때, 마지막에 더한 정수를 출력

num = int(input())
sum = 0
i = 0

while sum < num :
  i = i + 1
  sum = sum + i
  
print(i)
# 55 ↲
# 10

6081 : [기초-종합] 16진수 구구단 출력하기

• 16진수로 한 자리 수를 입력 받아 (A~F) 16진수 구구단 출력

n = input()		# 16진수 입력받고
a = int(n, 16)  	# 10진수로 변환

for i in range(1, 16):
  print(('%X*'%a),('%X'%i),('=%X'%(a*i)),sep='')
  
# B ↲
# B*1=B
# B*2=16
# B*3=21
# B*4=2C
# B*5=37
# B*6=42
# B*7=4D
# B*8=58
# B*9=63
# B*A=6E
# B*B=79
# B*C=84
# B*D=8F
# B*E=9A
# B*F=A5

6082 : [기초-종합] 3 6 9 게임의 왕이 되자

• 3, 13, 23, 33, 43,…을 10으로 나누었을 때 나머지가 3
• 6, 16, 26, 36, 46,…을 10으로 나누었을 때 나머지가 6
• 9, 19, 29, 39, 49,…를 10으로 나누었을 때 나머지가 9

n = int(input())

for i in range(1,n+1):
  if i % 10 == 3:
    print("X",end=" ")
  elif i % 10 == 6:
    print("X",end=" ")
  elif i % 10 == 9:
    print("X",end=" ")
  else:
    print(i,end=" ")

# 9 ↲
# 1 2 X 4 5 X 7 8 X

6083 : [기초-종합] 빛 섞어 색 만들기

• r,g,b 빛의 가짓수를 입력하고, 만들 수 있는 rgb색의 정보를 오름차순으로 출력

#r,g,b = map(int,input().split())
# for x in range(0,r):  
#   for y in range(0,g):
#     for z in range(0,b):
#       print(x,y,z)
#       z += 1
#   y += 1
# x += 1
# print(r*g*b)

# 처음 작성한 코드 정답은 맞지만, 멍청한 코드ㅋ
# 반복문은 1씩 증가하면서 돈다.. 굳이 1을 안 더해도 된다고.. 

r,g,b = map(int,input().split())

for x in range(0,r):  
  for y in range(0,g):
    for z in range(0,b):
      print(x,y,z)
print(r*g*b)

# 2 2 2 ↲
# 0 0 0
# 0 0 1
# 0 1 0
# 0 1 1
# 1 0 0
# 1 0 1
# 1 1 0
# 1 1 1
# 8

6085 : [기초-종합] 그림 파일 저장용량 계산하기

w,h,b = map(int,input().split())
print(format(w*h*b/8/1024/1024,".2f"),"MB")

# 또는
result = w*h*b/8/1024/1024
print("%.2f"%result,"MB")

# 1024 768 24↲
# 2.25 MB

6090 : [기초-종합] 수 나열하기3

• 시작 값(a), 곱할 값(m), 더할 값(d), 몇 번째 인지를 나타내는 정수(n)가 입력되고 n번째 수를 출력

a,m,d,n = map(int,input().split())

for i in range(1,n):
  a = a * m + d
print(a)

# 1 -2 1 8 ↲
# -85

6091 : [기초-종합] 함께 문제 푸는 날

• 같은 날 가입한 3명이 규칙적으로 방문하는 방문 주기를 입력하고, 3명이 함께 모이는 날을 출력
• 최소공배수

x,y,z = map(int,input().split())
d = 1

while True:
  if d % x == 0 and d % y == 0 and  d % z == 0:
    print(d)
    break
  else:
    d += 1
    
 # 3 7 9 ↲
 # 63

6092~94 : [기초-리스트] 이상한 출석 번호 부르기

6092

• 출석 번호 부른 횟수 n, 불린 출석 번호들 call을 입력 받으면 1번부터 번호가 불린 횟수를 출력

num = int(input())
# 불린 출석번호들을 리스트에 저장
call  = list(map(int,input().split()))
ls = []

# 각 출석번호(1~23)들이 불린 횟수 0으로 초기화한 리스트 생성
ls = [0 for _ in range(24)]

# 불린 번호들 횟수 증가시키기
for i in range(num):
  ls[call[i]] += 1

# 출력
for i in range(1,24):
  print(ls[i],end=" ")
  
# 10 ↲
# 1 3 2 2 5 6 7 4 5 9 ↲
# 1 2 1 1 2 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

6093

• 출석 부른 번호 순서를 반대로 출력
• range(시작, 끝, 증감)

num = int(input())
call  = list(map(int,input().split()))

# 9, 8, 7, 6,...0
for i in range(num-1,-1,-1):
  print(call[i],end=" ")

# 10 ↲
# 1 2 3 4 5 6 7 8 9 0 ↲
# 0 9 8 7 6 5 4 3 2 1

6094

• 리스트에서 최솟값 출력

num = int(input())
call  = list(map(int,input().split()))
s = call[0]

for i in range(num):
  if s > call[i]:
    s = call[i]
print(s)

# 또는
num = int(input())
call  = list(map(int,input().split()))
print(min(call))

# 10 ↲
# 10 4 2 3 6 6 7 9 8 5 ↲
# 2

6095 : [기초-리스트] 바둑판에 흰 돌 놓기

• 바둑판(19*19)에 올려 놓을 흰 돌의 개수 n, n개의 흰 돌의 좌표 (x,y)입력하고 흰 돌이 놓여진 바둑판 출력
• 리스트컴프리헨션으로 2차원 리스트 초기화

# 2차원 배열로 바둑판 그리기
board = [[0 for _ in range(20)] for _ in range(20)]

n = int(input())

# x,y 좌표를 입력 받고 해당 좌표를 1로 변경
for i in range(n):
  x,y = map(int,input().split())
  board[x][y] = 1

# 바둑판 출력
for i in range(1,20):
  for j in range(1,20):
    print(board[i][j],end=" ")
  # 줄 바꿈
  print("")

⭐️ 6096 : [기초-리스트] 바둑알 십자 뒤집기

• 십자 뒤집기: 해당 위치에 있는 모든 가로줄 돌의 색을 반대(1->0, 0->1)로 바꾼 후, 다시 그 위치에 있는 모든 세로줄 돌의 색을 반대로 바꾸는 것이다. 어떤 위치를 골라 십자 뒤집기를 하면, 그 위치를 제외한 가로줄과 세로줄의 색이 모두 반대로 바뀐다.
• 어려움 ㅠ

# 바둑판 틀 만들기
board = [[]*19 for _ in range(19)]

# 입력된 바둑판 상황
for i in range(19):
   board[i]=list(map(int,input().split()))

n = int(input())

for i in range(n):
    x,y=map(int,input().split())
    
    for j in range(19):
    # 가로줄 반대로 바꾸기
        if (board[x-1][j]==1):
            board[x-1][j]=0
        else: 
          board[x-1][j]=1 
    # 세로줄 반대로 바꾸기
        if(board[j][y-1]==1):
            board[j][y-1]=0
        else: 
          board[j][y-1]=1

# 바둑판 상황 그리기
for i in range(19):
    for j in range(19):
        print(board[i][j],end=' ')
    print()

⭐️ 6097 : [기초-리스트] 설탕과자 뽑기

• 격자판의 세로(h), 가로(w), 막대의 개수(n), 각 막대의 길이(l), 막대를 놓는 방향(d:가로는 0, 세로는 1)과 막대를 놓는 막대의 가장 왼쪽 또는 위쪽의 위치(x, y)가 주어질 때, 격자판을 채운 막대의 모양을 출력

w,h = map(int, input().split())

board = [[0]*h for _ in range(w)]

n = int(input())

for i in range(n):
  l,d,x,y = map(int,input().split()) 
  if d == 0:
    # 가로일 때
    # -1씩 빼줘야함
    for j in range(l):
      board[x-1][y-1+j] = 1
  else:
    # 세로일 때
    for j in range(l):
      board[x-1+j][y-1] = 1

# 격자판 출력
# range 주의
for i in range(w):
  for j in range(h):
    print(board[i][j],end=" ")
  print("")


# 5 5 ↲
# 3 ↲
# 2 0 1 1 ↲
# 3 1 2 3 ↲
# 4 1 2 5 ↲

# 1 1 0 0 0
# 0 0 1 0 1
# 0 0 1 0 1
# 0 0 1 0 1
# 0 0 0 0 1

⭐️ 6098 : [기초-리스트] 성실한 개미

• 10*10크기의 미로 상자, 개미는 (2,2)에서 출발하고, 이동한 경로는 9로 표시
• 0은 갈 수 있는 곳이므로 오른쪽으로 이동, 1은 벽 또는 장애물로 갈 수 없으므로 아래로 이동
• 단, 맨 아래의 가장 오른쪽에 도착한 경우, 더 이상 움직일 수 없는 경우, 먹이를 찾은 경우에는 더 이상 이동하지 않는다.
• 미로를 입력하고, 개미의 이동경로가 표시된 미로를 출력

# 10*10크기의 미로 상자 틀
board = [[]*10 for _ in range(10)]

# 입력된 미로
for i in range(10):
   board[i]=list(map(int,input().split()))

# 개미는 (2,2)에서 출발하니까 -1을 뺀 1,1
x, y = 1, 1 

while True: 
  if (board[x][y] == 0): 
    board[x][y] = 9 
  elif (board[x][y] == 2): 
    board[x][y] = 9 
    break 
  if ((board[x][y+1] == 1 and board[x+1][y] == 1)):       
  	break 
  if (board[x][y+1] != 1): 
    y = y + 1 
  elif (board[x+1][y] != 1): 
  	x = x + 1 

for i in range(10): 
    for j in range(10): 
      print(board[i][j], end=' ')
    print()