초보 기술블로그

51

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

52

a=int(input())
print(a!=0)

53

a=bool(int(input()))
print(a!=True)

54

a, b = input().split()
print(bool(int(a)) and bool(int(b)))

55

a, b = input().split()
print(bool(int(a)) or bool(int(b)))

56

a, b = input().split()
print(bool(int(a)) ^ bool(int(b)))

57

a, b = input().split()
print(bool(int(a)) == bool(int(b)))

58

a, b = input().split()
print(bool(int(a)) == bool(int(b)) == False)

59

print(~int(input()))

60

a, b =input().split()
print(int(a) & int(b))

61

a, b =input().split()
print(int(a) | int(b))

62

a, b =input().split()
print(int(a) ^ int(b))

63

a, b =input().split()
print(max(int(a),int(b)))

64

a, b, c =input().split()
print(min(int(a),int(b),int(c)))

65

a, b, c =input().split()
if int(a)%2==0:
    print(int(a))
if int(b)%2==0:
    print(int(b))
if int(c)%2==0:
    print(int(c))

66

a, b, c =input().split()
if int(a)%2==0:
    print("even")
else:
    print("odd")
if int(b)%2==0:
    print("even")
else:
    print("odd")
if int(c)%2==0:
    print("even")
else:
    print("odd")

67

a = int(input())
if a<=0 and a%2==0:
    print("A")
elif (a<=0):
    print("B")
elif (a%2==0):
    print("C")
else:
    print("D")

68

a = int(input())
if a>=90:
    print("A")
elif (a>=70):
    print("B")
elif (a>=40):
    print("C")
else:
    print("D")

69

a = input()
if a=="A":
    print("best!!!")
elif (a=="B"):
    print("good!!")
elif (a=="C"):
    print("run!")
elif (a=="D"):
    print("slowly~")
else:
    print("what?")

70

a = int(input())
if a<3 or a==12:
    print("winter")
elif a<6:
    print("spring")
elif a<9:
    print("summer")
else:
    print("fall")

71

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

72

a = int(input())
for b in range(a):
    print(a-b)

73

a = int(input())
for b in range(a):
    print(a-b-1)

74

a = ord(input())
b = ord('a')
while b<=a :
  print(chr(b), end=' ')
  b += 1

75

a = int(input())
for i in range(a+1):
    print(i)

76

a = int(input())
for i in range(a+1):
    print(i)

77

n = int(input())
s = 0
for i in range(1, n+1) :
  if i%2==0 :
    s += i
print(s)

78

a = "b"
while(True):
    a = input()
    if a=="q":
        print(a)
        break
    else:
        print(a)

79

a = int(input())
for i in range(a):
    if ((i*(i+1))//2>=a):
        print(i)
        break

80

a,b=input().split()
for i in range(int(a)):
    for j in range(int(b)):
        print(i+1,j+1,sep=" ")

81

a = int(input(),16)
for i in range(1, 16):
    print("%x".upper()%n,"*","%x".upper()%i, "=", "%x".upper()%(n*i), sep="")

82

n = list(map(str, range(1, int(input())+1)))
for i in n:
    if "3" in i or "6" in i or "9" in i:
        n[n.index(i)] = "X"  
print(" ".join(n))

83

a,b,c=input().split()
for i in range(int(a)):
    for j in range(int(b)):
        for k in range(int(c)):
            print(i,j,k,sep=" ")
print((i+1)*(j+1)*(k+1))

84

h,b,c,s = input().split()
print(format(h * b * c * s / 8 / 1024 / 1024, ".1f"), "MB")

85

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

86

a = int(input())
for i in range(a+1):
    if ((i*(i+1))//2)>=a:
        print((i*(i+1))//2)
        break

87

a = int(input())
for i in range(1,a+1):
    if i%3==0:
        continue
    print(i,end=" ")

88

a,d,n = map(int,input().split())
print(a+d*(n-1))

89

a,r,n = map(int,input().split())
print(a*pow(r,(n-1)))

90

a,m,d,n= map(int,input().split())
result=a
for i in range(1,n):
    result=(result*m)+d
print(result)

91

import math
a,b,c= map(int,input().split())
print(math.lcm(a,b,c))

92

a = int(input())
a_list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23]
b_list = []
for i in range(23):
    b_list.append(0)
c_list = list(map(int,input().split()))
for j in c_list:
    b_list[a_list.index(j)]+=1
for k in b_list:
    print(k,end=" ")

93

a = int(input())
c_list = list(map(int,input().split()))
c_list = c_list[::-1]
for k in c_list:
    print(k,end=" ")

94

a = int(input())
c_list = list(map(int,input().split()))
c_list.sort()
print(c_list[0])

95

d=[]
for i in range(20) :
  d.append([])
  for j in range(20) : 
    d[i].append(0)
a = int(input())
for i in range(a):
    k,l = input().split()
    d[int(k)-1][int(l)-1]=1
for i in range(19):
  if i>=1:
      print("")
  for j in range(19):
    print(d[i][j],end=" ")

96

answer = []
for _ in range(19):
    arr = input().split()
    answer.append(arr)

n = int(input())

for _ in range(n):
    x, y = map(int, input().split())
    for k in range(19):
        answer[k][y-1] = str(int(not int(answer[k][y-1])))
        answer[x-1][k] = str(int(not int(answer[x-1][k])))
        
for k in answer:
    print(" ".join(k))

97

a, b = map(int, input().split())
matrix = [["0" for _ in range(b)] for _ in range(a)]

for _ in range(int(input())):
    l, d, x, y = map(int, input().split())
    if d == 0:
        for i in range(y-1, y+l-1):
            matrix[x-1][i] = "1"
    else:
        for i in range(x-1, x+l-1):
            matrix[i][y-1] = "1"

for k in matrix:
    print(" ".join(k))

98

matrix = []
for _ in range(10):
    matrix.append(input().split())
    
x, y = 1, 1
while x <= 8 and y <= 8:
    if matrix[x][y] == "2":
        matrix[x][y] = "9"
        break
    matrix[x][y] = "9"
    if matrix[x][y+1] == "1" and matrix[x+1][y] == "1":
        break
    elif matrix[x][y+1] == "1":
        x += 1
    else:
        y += 1

for k in matrix:
    print(" ".join(k))

클래스의 필요성

비슷한 기능과 쓰임을 가진 객체들을 신속하고 많이 만드는데 유리하며, 독립적으로 작용하는 객체를 만들 수 있기 때문.

만약 위 그림처럼 게임을 제작할 때 캐릭터들의 기본값을 저장해둔다고 하자.

기존의 방식으로는 검술사,요정,도적 등 각 직업의 체력,공격력,공격방법등을 전부 다시 정의해야 하지만

클래스를 사용하면 클래스 내부의 변수를 조정하는 것만으로도 새로운 직업을 만들 수도 있다.

클래스와 객체, 인스턴스

클래스(class)란 똑같은 무언가를 계속 만들어 낼 수 있는 설계 도면(과자 틀),

객체(object)란 클래스로 만든 피조물(과자 틀로 찍어 낸 과자)을 뜻한다.

또한, 각 객체들은 서로 독립적이며 영향을 주고받지 않는다.

인스턴스(instance)는 객체를 부르는 또 다른 표현이다. 다만, 인스턴스라는 말을 사용할 때에는

'a는 인스턴스다'라는 표현보다는 'a는 b클래스의 인스턴스다'라는 표현으로 사용한다.

파이썬에서의 클래스 정의

class Calculator:
     def __init__(self, first, second):
         self.first = first
         self.second = second
     def setdata(self, first, second):
         self.first = first
         self.second = second
     def add(self):
         result = self.first + self.second
         return result
     def mul(self):
         result = self.first * self.second
         return result
     def sub(self):
         result = self.first - self.second
         return result
     def div(self):
         result = self.first / self.second
         return result

위의 방식처럼 "class 클래스이름(입력받을 매개변수):" 의 형태로 정의하며,

그 아래에는 클래스 내부에서 사용할 내부변수와 함수의 정의로 이루어져 있다.

클래스의 상속

class 클래스_이름(상속할_클래스_이름)

기존 클래스를 변경하지 않고 기능을 추가하거나 기존 기능을 변경하려고 할 때 사용한다

예를 들어 위에 만든 calculator함수에 추가적으로 결괏값을 출력하는 함수를 만들고자 할 때

상속을 이용해서 제작할 수 있다.

class Print_Calculator(Calculator):
     def print_Cal(self):
     	print(Calculator.first,Calculator.second)​

Calculator를 상속하여 Calculator의 멤버변수 first와 second를 리턴하는 함수

메서드 오버라이딩

부모 클래스(상속한 클래스)에 있는 메서드를 동일한 이름으로 다시 만드는 것을 말한다.

메서드를 오버라이딩하면 부모 클래스의 메서드 대신 오버라이딩한 메서드가 호출된다.

class SafeFourCal(Calculator)
	def div(self):
		if self.second == 0:  # 나누는 값이 0인 경우 0을 리턴하도록 수정
			return 0
		else:
			return self.first / self.second

위처럼 safeFourCal이라는 클래스로 Calculator 클래스를 상속받아 사용했을 때, div 함수를 오버라이딩하면

나누는 값이 0일 경우의 오류를 방지할 수 있다.

함수를 사용하는 이유

코드 안에서 반복되는 부분이 존재할 때 함수를 사용해 이를 단순화 할 수 있기 때문

파이썬에서의 함수 정의법

def 함수명(입력 인수):
	수행할 문장1
   	return 결괏값

입력 인수는 여러개 일 수 있고,

입력 인수와 결괏값은 있을 수 도 있고 없을 수도 있음

일반적인 함수

def sum(a,b):
	return a+b
>>>sum(1,2)
3

입력 인수가 없는 함수

def say():
	return 'hi'
>>>say()
hi

결괏값이 없는 함수

def say():
	print("hi")
say()
hi

입력 인수가 얼마나 있을지 모르는 함수

def sum_many(*args):
	sum = 0
	for i in args:
		sum = sum+i
	return sum
    
>>>print(sum_many(1,2,3,4))
10
>>>print(sum_many(1,2))
3

입력 인수에 *를 붙여 사용

If문의 기본 구조

if 조건문:
	수행할 문장1
    	수행할 문장2
else:
	수행할 문장A
    	수행할 문장B

if 뒤에 조건문을 쓰고, 콜론(:)을 붙인 뒤 다음 문장은 들여쓰기를 한 후 입력한다.

들여쓰기는 Tap 한번이나, Spacebar 4번 중 1개를 선택해서 수행한다.

비교 연산자

비교 연산자는 다음과 같이 사용하며, 만약 식이 성립하면 True, 성립하지 않으면 False를 리턴한다.

리스트/튜플/문자열 안에 x가 존재하거나 존재하지 않으면 True/False를 리턴한다.

elif문의 기본 구조

if 조건문1:
	수행할문장1
    	수행할문장2
elif 조건문2:
	수행할문장3
    	수행할문장4
else:
	수행할문장A
    	수행할문장B

elif의 개수는 정해지지 않았으며, if문이 거짓일 때 다시 조건을 확인해서 만족하면 elif문 안의 문장을 수행한다.

while문의 기본 구조

while 조건문:
	수행할 문장1
	수행할 문장2
   	수행할 문장3

while문은 조건문이 참인 동안에 while문 아래에 속하는 문장들이 반복해서 수행한다.

Break와 Continue

Break문은 반복문에서 만나면 바로 반복문을 종료시키고,

Continue문은 반복문에서 만나면 반복문 처음으로 돌아가는 함수.

for문의 기본 구조

test_list = ['one','two','three']
for i in test_list:
	print(i)
    
one
two
three

집합이란?

중복을 허용하지 않으며, 순서가 없는 자료형이다.

= > 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없다.

집합을 파이썬에서 정의하는 방법

s1 = set([1,2,3])
>>>s1
{1,2,3}
s2 = set("Hello")
s2
{'e','l','o','H'}

위와 같이 set()의 괄호 안에 리스트를 입력하여 만들거나 아래와 같이 문자열을 입력하여 정의한다.

집합의 연산

s1=set([1,2,3,4,5,6])
s2=set([4,5,6,7,8,9])

교집합

s1&s2
>>>{4,5,6}
s1.intersection(s2)
>>>{4,5,6}

'&' 기호를 이용하거나 intersection함수를 이용하여 교집합을 구한다

합집합

s1|s2
>>>{1,2,3,4,5,6,7,8,9}
s1.union(s2)
>>>{1,2,3,4,5,6,7,8,9}

'|'기호를 이용하거나 union함수를 이용하여 합집합을 구한다. 

차집합

s1-s2
>>>{1,2,3}
s1.difference(s2)
>>>{1,2,3}
s2-s1
>>>{8,9,7}
s2.difference(s1)
>>>{8,9,7}

'-'기호를 이용하거나 difference함수를 이용하여 차집합을 구한다.

집합 함수들

값 1개 추가하기(add)

>>>s1 = set([1,2,3])
>>>s1.add(4)
>>>s1
{1,2,3,4}

값 여러개 추가하기(update)

>>>s1 = set([1,2,3])
>>>s1.update([4,5,6])
>>>s1
{1,2,3,4,5,6}

특정 값 제거하기(remove)

>>>s1 = set([1,2,3])
>>>s1.remove(2)
>>>s1
{1,3}

딕셔너리(Dictionary)란

딕셔너리는 Key와 Value를 쌍으로 갖는 자료형.

리스트나 튜플처럼 순차적으로 해당 요소값을 구하지 않고 Key를 통해 Value를 얻음.

딕셔너리를 파이썬에서 정의하는 방법

dic = {'name':pey','phone':'0119993323','birth':'1118','list1':[1,2,3]}

라는 방식으로 정의할 수 있으며, 위의 딕셔너리는 아래의 표 형태로 나타낼 수 있다.

딕셔너리의 Value에는 단순 string이나 int형 변수들 뿐 아니라 list형을 포함한 어떠한 자료형이든 추가가 가능하다

하지만, Key에는 immutable한 자료형들만 선언 가능하다.

따라서 tuple이나 dictionary는 key로 설정이 가능하나, list는 선언이 불가하다.

딕셔너리의 Key와 Value 사용방법

위의 dic 딕셔너리를 사용해 예시를 들겠다.

만약, name의 value값을 얻고 싶다면

dic['name']
>>>pey

으로 선언하면 value값인 pey를 return 받을 수 있다.

pey['hello']='english'

로 선언하면, pey는 마지막에 hello를 key값으로, english를 value값으로 가진 dictionary가 된다.

del pey['name']

로 선언하면, pey는 name을 key값으로 가진 항목을 전부 지워버린 dictionary가 된다.

딕셔너리 함수들

dic = {'name':pey','phone':'0119993323','birth':'1118'}

dic.keys()

dictionary의 key값만을 모아서 dick_keys라는 객체를 리턴하는 함수

리스트를 return하는 것이 아님. 리스트로 변환을 위해선 list()함수 사용 필요

dic.keys()
>>>dict_keys(['name','phone','birth'])

dic.values()

dictionary의 value값만을 모아서 dick_values라는 객체를 리턴하는 함수

리스트를 return하는 것이 아님.

dic.values()
>>>dict_values(['pey','0119993323','1118'])

dic.items()

key와 value의 쌍을 튜플로 묶은 값을 dict_items객체를 리턴하는 함수

리스트를 return하는 것이 아님.

dic.items()
>>>dict_items([('name','pey'),('phone','0119993323'),('birth','1118')])

dic.get(x,"default value")

x라는 key에 대응하는 value를 리턴하는 함수

만약 x라는 key가 dictionary에 없다면 default value를 리턴한다.

default value를 비워두면 None을 리턴한다.

dic.get('name')
>>>'pey'
dic.get('phone')
>>>'0119993323'
dic.get('nokey')
=>오류 발생
dic.get('nokey','bar')
>>>'bar'

 '그리디(greedy) 알고리즘'은 '현재 상황에서 가장 좋은 것을 고르는' 알고리즘이다.

문제에서 '가장 큰 순서대로', '가장 작은 순서대로'라는 말이 나오면 그리디 알고리즘을 고민해 볼 필요가 있다.

가장 대표적인 문제로는 '거스름돈' 문제를 들 수 있다.

'거스름돈' 문제는 간략하게

      무한히 많은 개수의 500원, 100원, 50원, 10원짜리 동전이 존재할 때 최소한의 동전 개수로 거스름돈을 주는 문제이다.

이를 그리디 알고리즘으로 접근하면 다음 코드처럼 작성할 수 있다.

n = int(input("총 금액은 얼마인가요"))
count = 0
coint_types=[500,100,50,10]
for coin in coin_types:
    count += n // coin    #현재 동전은 몇 개를 줄 수 있는지 카운트에 저장
    n%=coin                  #원래 금액에서 동전을 준 만큼은 빼고 금액을 저장
print(count)

 위 코드는 가장 큰 화폐 단위인 500원부터 가장 작은 화폐 단위인 10원까지 순차적으로 접근하는 방식으로 앞서 말했던 것처럼 '가장 큰 순서대로' 문제를 접근한 방식이다. 

다만, 문제를 조금 변형하여 500원, 100원, 50원, 10원이 아니라 500원, 400원, 100원인 경우를 생각해 보자.

이 경우는 800원을 거스름돈으로 주어야 할 때 그리디 알고리즘으로는 500+100+100+100으로 4개의 결괏값이 나오지만

사실 400원을 2개 주는 것이 최적값이라고 할 수 있다. 기존 문제를 그리디 알고리즘으로 풀 수 있었던 것은 

'큰 단위의 화폐가 항상 작은 단위의 배수 형태' 이므로 가능했다.

어떤 코딩 테스트 문제를 만났을 때, 바로 문제 유형을 파악하기 어렵다면 그리디 알고리즘을 의심하고, 만약 해답을 찾을 수 없다면 다이나믹 프로그래밍이나 그래프 알고리즘 등으로 문제를 해결할 수 있는지 고민해 볼 필요가 있다.