입문

def solution(age): return 2023 - age # 2022 - age + 1

def solution(num1,num2): return num1 // num2

def solution(num1,num2): return num1 * num2

solution = lambda num1, num2 : num1 % num2

# 같으면 1, 다르면 -1 리턴 def solution(num1,num2): if num1 == num2: return 1 else : return -1

def solution(angle): if angle < 90 : return 1 elif angle == 90 : return 2 elif angle < 180 : return 3 else : return 4

# 다른 풀이 # def solution(angle): answer = (angle // 90) * 2 + (angle % 90 > 0) * 1 return answer

def solution(num1,num2): return int(num1 / num2 * 1000)

import math def solution(num1,num2): return math.trunc(num1/num2*1000)

def solution(n, k): answer = 12000*n + 2000*(k-(n//10)) return answer

def solution(numbers): return sum(numbers) / len(numbers)

def solution(array, height): cnt = 0 for i in array: if i > height: cnt += 1 return cnt

def solution(array, n): cnt = 0 for i in array: if i == n: cnt += 1 return cnt

def solution(array,n): return array.count(n)

def solution(n): sum = 0 while n > 0 : if n % 2 == 0: sum += n n -= 1 return sum

def solution(n): sum = 0 for i in range(2,n+1): if i % 2 == 0: sum += i return sum

def solution(n): return sum([i for i in range(2,n+1,2)])

def solution(n): if n % 7 != 0: answer = n//7 + 1 else : answer = n//7 # 딱 나눠떨어질 경우 몫으로 피자 수 계산 return answer

def solution(n): return (n - 1) // 7 + 1

def solution(numbers): answer = [i*2 for i in numbers] return answer

def solution(numbers): return list(map(lambda x : x * 2, numbers))

def solution(my_string): return my_string[::-1]

def solution(my_string): return list(reversed(my_string))

def solution(strlist): answer = [] for i in strlist: answer.append(len(i)) return answer

def solution(strlist): return [len(i) for i in strlist]

def solution(num_list): even = 0 odd = 0 for i in num_list: if i % 2 == 0: even += 1 else : odd += 1 answer = [even, odd] return answer

def solution(num_list): answer = [0,0] for i in num_list: answer[i%2] += 1 # 나머지값으로 짝수, 홀수 한꺼번에 처리 return answer

def solution(num_list): answer = [0,0] for i in num_list: if i%2 == 0: # 짝수 answer[0] += 1 else : answer[1] += 1 return answer

def solution(numbers): numbers.sort(reverse=True) # 내림차순 정렬 a = numbers[0] # 가장 큰 수 b = numbers[1] # 두번째로 큰 수 return a * b

def solution(my_string, letter): answer = my_string.replace(letter,'') return answer

def solution(money): answer = [0,0] answer[0] = money // 5500 answer[1] = money % 5500 return answer

def solution(money): answer = [money // 5500, money % 5500] return answer

def solution(slice, n): if n % slice == 0: # 나머지가 없으면 몫이 필요한 판의 수다 answer = n // slice else : answer = n // slice + 1 return answer

def solution(numbers, num1, num2): return numbers[num1:num2+1]

def solution(dot): if dot[0] > 0 and dot[1] > 0 : return 1 elif dot[0] > 0 and dot[1] < 0 : return 4 elif dot[0] < 0 and dot[1] > 0 : return 2 else: return 3

def solution(sides): sides.sort() #오름차순 정렬 if sides[2] < sides[0] + sides[1]: # 삼각형 조건 return 1 else: return 2

def solution(sides): return 1 if sides[0] + sides[1] > sides[2] else 2

def solution(my_string,n): answer = [] for i in range(len(my_string)): # 각 원소에 대해서 for j in range(n): # n번씩 반복 answer.append(my_string[i]) return ''.join(answer)

def solution(message): answer = len(message)*2 return answer

def solution(n): answer = [int(i) for i in str(n)] return sum(answer)

def solution(s1, s2): sum = 0 for i in s1: if s2.count(i) == 1: sum += 1 return sum

def solution(s1,s2): count = 0 for val in s1: if val in s2: count += 1 return count

# 리스트 중복 찾기 a = [2,3,4] b = [4,5,6] common = set(a).intersection(b) print(common) # {4} # 위의 공식을 사용해보면 답은 아래와 같이 할 수 있다

# 리스트 중복 찾기 a = [2,3,4] b = [4,5,6] common = set(a).intersection(b) print(common) # {4} # 위의 공식을 사용해보면 답은 아래와 같이 할 수 있다 def solution(s1,s2): return len(set(s1).intersection(s2))

def solution(n): count = 0 for i in range(1,n+1): if n % i == 0: count += 1 return count

def solution(n): return len([i for i in range(1, n+1) if n%i == 0])

def solution(n): x = n ** (1/2) # 일단 제곱근을 구한다음 if x % 1 == 0: # 정수 1로 나눴을 때 나머지가 생기지 않는다면 return 1 # 제곱수가 되고 else: return 2

import math def solution(price): if price >= 500000: return math.trunc(price*0.8) elif price >= 300000: return math.trunc(price*0.9) elif price >= 100000: return math.trunc(price*0.95) else : return price

def solution(price): if price >= 500000: price = price*0.8 elif price >= 300000: price = price*0.9 elif price >= 100000: price = price*0.95 return int(price)

def solution(str1, str2): if str1.count(str2) >= 1: return 1 else: return 2

def solution(str1,str2): return 1 if str2 in str1 else 2

def solution(array): array.sort() if len(array) % 2 == 0: # 짝수 idx = len(array) // 2 result = (array[idx-1] + array[idx]) / 2 else: # 홀수 idx = len(array) // 2 result = array[idx] return result

def solution(array): return sorted(array)[len(array)//2]

def solution(my_string): vowel = ('a','e','i','o','u') for i in my_string: if i in vowel: # 모음에 속하면 my_string = my_string.replace(i,'') # 해당 원소를 문자열에서 제거해준다. return my_string

def solution(my_string): return "".join([i for i in my_string if not(i in 'aeiou')])

def solution(my_string): vowel = ['a','e','i','o','u'] for v in vowel: my_string = my_string.replace(v,'') return my_string

import re def solution(my_string): answer = re.findall(r'\d', my_string) # 결과는 문자형인 숫자를 원소로 갖는 리스트 answer = [int(i) for i in answer] # 숫자형으로 변환해준다 return sum(answer) # 리스트 원소들을 더한다.

def solution(hp): general = hp // 5 # 장군 개미의 개수 soldier = (hp % 5) // 3 # 병정 개미의 개수 normal = ((hp % 5) % 3) // 1 # 일반 개미의 개수 return general + soldier + normal

def solution(box, n): a = box[0] // n # 가로에 들어가는 주사위의 개수 b = box[1] // n # 세로에 들어가는 주사위의 개수 c = box[2] // n # 높이에 들어가는 주사위의 개수 answer = a*b*c return answer

def solution(n, t): answer = n * (2**t) return answer

def solution(n,t): return n << t

def solution(n, numlist): answer = [i for i in numlist if i % n == 0] return answer

n = int(input()) for i in range(n): print((i+1)*"*")

import re def solution(my_string): answer = re.findall(r'\d',my_string) # 문자열에 숫자 모양이 나타난다면 answer = [int(i) for i in answer] # 해당 값들을 정수로 변환한 뒤 리스트 원소로 저장 answer = sorted(answer) return answer

def solution(my_string): return sorted([int(i) for i in my_string if i.isdigit()])

def solution(cipher, code): answer = [] for i in range(len(cipher)): if (i+1) % code == 0: answer.append(cipher[i]) answer = "".join(answer) return answer

def solution(cipher, code): answer = '' for i in range(len(cipher)): if (i+1) % code == 0: # code의 배수번째에 해당하는 값이라면 answer += cipher[i] return answer

def solution(my_string): answer = '' for i in my_string: if i.isupper(): # 대문자라면 answer += i.lower() else: # 소문자라면 answer += i.upper() return answer

def solution(rsp): answer = '' for i in rsp: if int(i) == 2: answer += "0" elif int(i) == 0: answer += "5" else: answer += "2" return answer

def solution(array): answer = [] for i in array: if i == max(array): answer.append(i) # 가장 큰 값과 answer.append(array.index(i)) # 그 값의 위치 return answer

def solution(array): return [max(array),array.index(max(array))]

def solution(n): answer = [] for i in range(1,n+1): if n % i == 0: answer.append(i) answer.sort() # 원본값은 변하지 않음. return answer

def solution(n): answer = [i for i in range(1,n+1) if n % i == 0] return answer

def solution(numbers, direction): answer = [] if direction == 'right': for i in range(len(numbers)): if i == len(numbers)-1: answer.insert(0,numbers[i]) else: answer.insert(i+1,numbers[i]) else: for i in range(len(numbers)): if i == 0: answer.insert(len(numbers)-1,numbers[i]) else: answer.insert(i-1,numbers[i]) return answer

def solution(numbers, direction): if direction == 'right': answer = [numbers[-1]] + numbers[:len(numbers)-1] else: answer = numbers[1:] + [numbers[0]] return answer

def solution(numbers, direction): return [numbers[-1]] + numbers[:-1] if direction == 'right' else numbers[1:] + [numbers[0]]

def solution(age): answer = '' word = ['a','b','c','d','e','f','g','h','i','j'] for i in str(age): answer += word[int(i)] return answer

def solution(age): answer = '' return answer.join([chr( ) for i in str(age)])

def solution(numbers): # 음수끼리 곱했을 경우도 고려 numbers.sort(reverse=True) # 내림차순으로 정렬 return max(numbers[0]*numbers[1],numbers[-1]*numbers[-2])

def solution(my_string, num1, num2): my_string = list(my_string) my_string[num2],my_string[num1] = my_string[num1],my_string[num2] return ''.join(my_string)

def solution(n): pizza = 1 while (6*pizza) % n != 0: pizza += 1 return pizza

def solution(num, k): n = list(map(int,str(num))) if n.count(k) >= 1: answer = n.index(k)+1 # 특정 원소의 위치 찾기 else: answer = -1 # 없다면 -1 출력 return answer

def solution(num,k): return -1 if str(k) not in str(num) else str(num).find(str(k)) + 1

# for 반복문 사용 def solution(order): answer = 0 for i in str(order): if i == '3' or i == '6' or i =='9': answer += 1 return answer

# .count('특정원소') 함수 사용 def solution(order): order = str(order) return order.count('3') + order.count('6') + order.count('9')

def solution(order): return sum(map(lambda x: str(order).count(str(x)),[3,6,9]))

def solution(my_string): my_string = my_string.lower() # 모두 소문자로 변환 my_string = list(my_string) # 리스트로 변환 my_string.sort() # 오름차순 정렬 return ''.join(my_string)

def solution(my_string): return ''.join(sorted(my_string.lower()))

def solution(n): answer = [] cnt = 0 for i in range(1,n+1): for j in range(1,i+1): if i % j == 0: answer.append(i) if answer.count(i) >= 3: cnt += 1 return cnt

def solution(n): answer = 0 for i in range(1,n+1): cnt = 0 for j in range(1,i+1): if i % j == 0: cnt += 1 if cnt >= 3: answer += 1 return answer

# for 반복문 사용 def solution(my_string): answer = [] for i in list(my_string): if answer.count(i) == 0: # if i not in answer: answer.append(i) return ''.join(answer) # 리스트 원소들을 합쳐 문자로 반환

# 딕셔너리로 사용하는 방법 def solution(my_string): result = dict.fromkeys(my_string) return ''.join(list(result))

morse = { '.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f', '--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l', '--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r', '...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x', '-.--':'y','--..':'z' } def solution(letter): answer = '' for word in letter.split(' '): for char in word.split(' '): answer += morse[char] return answer

# 재귀함수로 팩토리얼 구현하기 def my_factorial(n): if(n > 1): return n * my_factorial(n-1) else: return 1 a = int(input('팩토리얼을 구할 숫자를 입력하시오: ')) print(my_factorial(a))

# for문을 사용해서 팩토리얼 구현하기 a = int(input('팩토리얼을 구할 숫자를 입력하시오: ')) result = 1 for item in range(1,a+1,1): result *= item print(result)

# math 라이브러리를 이용해서 팩토리얼 구현하기 import math a = int(input('팩토리얼을 구할 숫자를 입력하시오: ')) print(math.factorial(a))

# 정수 n이 주어질 때 i! <= n 을 만족하는 가장 큰 정수 i를 리턴하는 함수 만들기 # 제한 사항 : 0 < n ≤ 3,628,800(= 10!) from math import factorial def solution(n): k = 10 while n < factorial(k): k -= 1 return k

def solution(before, after): before = list(before) after = list(after) answer = 0 for b in before: if before.count(b) == after.count(b): answer += 1 return 1 if answer == len(before) else 0

def solution(before, after): before = sorted(before) after = sorted(after) if before == after: return 1 else: return 0

import numpy as np def solution(num_list,n): return (np.array(num_list).reshape((len(num_list)//n, n))).tolist()

def solution(i, j, k): answer = 0 for i in range(i,j+1): for j in str(i): if j in str(k): answer += 1 return answer

def solution(i,j,k): answer = 0 for x in range(i,j+1): answer += sum([1 for x in list(str(x)) if x == str(k)]) return answer

def solution(array, n): return array[sorted([[index,abs(n-num),num] for index, num in enumerate(array)], key=lambda x: (x[1],x[-1]))[0][0]]

def solution(array,n): array.sort(key = lambda x: (abs(n-x), x-n)) answer = array[0] return answer

def solution(emergency): dict = {num: index for index, num in enumerate(sorted(emergency,reverse=True),start=1)} return [dict[x] for x in emergency]

def solution(s): answer = '' for i in s: if s.count(i) == 1: answer += i elif s.count(i) >= 2: pass return ''.join(sorted(answer))

def solution(array): answer = '' for i in array: answer += str(i) return answer.count('7')

def solution(bin1, bin2): a = int(bin1,2) b = int(bin2,2) answer = bin(a+b) return answer[2:] # Ob 없애주기 위해

import re def solution(my_string): result = 0 answer = re.findall(r'[0-9]+', my_string) for i in answer: result += int(i) return result

def solution(numbers,k): players = numbers[0::2] if len(numbers) % 2 == 0 else numbers[0::2] + numbers[1::2] return players[(k % len(players)) - 1]

def solution(numbers,k): index = 0 while k > 1: index += 2 index %= len(numbers) k -= 1 return numbers[index]

# 최적화된 gcd(최대공약수)를 활용한 solution def gcd(a,b): if a % b == 0: return b return gcd(b, a % b) # 재귀함수 활용 def solution(denum1, num1, denum2, num2): boonmo = num1 * num2 boonja = denum1 * num2 + denum2 * num1 # 최대공약수 게산 gcd_value = gcd(boonmo, boonja) # gcd로 나눈 값을 answer에 저장 answer = [boonja / gcd_value, boonmo / gcd_value] return answer

def solution(denum1, num1, denum2, num2): # 두 분수의 합 계산 boonmo = num1 * num2 boonja = num1 * denum2 + num2 * denum1 # 최대공약수로 약분하기 위해 최대공약수 계산하기 start = max(boonmo, boonja) gcd_value = 1 for num in range(start,0,-1): # 하나씩 줄여나가면서 최대공약수 찾아나가기 if boonmo % num == 0 and boonja % num == 0: gcd_value = num break # 분모와 분자를 최대공약수로 약분한 값을 저장하기 answer = [boonja / gcd_value , boonmo / gcd_value] return answer

# math library 를 활용한 solution import math def solution(denum1, num1, denum2, num2): boonmo = num1 * num2 boonja = denum1 * num2 + denum2 * num1 gcd_value = math.gcd(boonmo, boonja) answer = [boonja / gcd_value, boonmo / gcd_value] return answer

input = [2,2,2,5,5,5,6,6,6,6,6,6,9,9,11,11,11,11,11,11] # 사실은 최빈값이 두개 max_input = max(input) new_list = [0] * max_input for i in input: new_list[i-1] += 1 print('new_list의 index를 1부터라고 했을 때, 최빈값은 %d이며, 총 %d번 나왔다' %(new_list.index(max(new_list))+1, max(new_list))) # new_list의 index를 1부터라고 했을 때, 최빈값은 6이며, 총 6번 나왔다

input = [2,2,2,5,5,5,6,6,6,6,6,6,9,9,11,11,11,11,11,11] max_input = max(input) new_list = [0] * max_input for i in input: new_list[i-1] += 1 num = 0 # 최빈값의 개수 초기화 my_most = 0 # 최빈값을 알기 위한 변수 -> new_list의 위치 + 1 for k in new_list: my_most += 1 if k == max(new_list) num += 1 # 최빈값일 경우만 증가시킨다 print('input 리스트에서, 여러 최빈값중 %d번째 최빈값은 %d이며, 총 %d번 나왔다.' %(num,my_most,max(new_list))) print('이 input리스트에서 최빈값의 개수는 %d개 이다' %num)

def solution(my_str, n, num = 0): answer = [] q = len(my_str) // n r = len(my_str) % n for i in range(q): answer.append(my_str[num:n*(i+1)]) num += n if r != 0: answer.append(my_str[-r:]) return answer

def solution(my_str,n): return [my_str[i:i+n] for i in range(0,len(my_str),n)]

def factorization(x): d = 2 answer = [] while d <= x: # 반복루프 조건 if x % d == 0: # 2로 나누어떨어지는지 검사 if d not in answer: answer.append(d) x = x / d else: d += 1 # 나누어 떨어지지 않으면 값을 하나씩 더해가면서 반복

# solution def solution(n, d = 2): answer = [] while d <= n: if n % d == 0: n = n / d if d not in answer: answer.append(d) else: d += 1 return answer

def solution(numbers): nums = ['zero','one','two','three','four','five','six','seven','eight','nine'] for index,num in enumerate(nums): numbers = numbers.replace(num,str(index)) return int(numbers)

result = eval("(3 + 5) * 7") print(result)

# solution def solution(my_string): return eval(my_string)

def solution(balls, share): answer = 0 boonmo = 1 boonja = 1 for i in range(balls - share): boonmo = boonmo * (balls - i) for i in range(1,balls - share + 1): boonja = boonja * i return boonmo / boonja

import math def solution(balls, share): return math.comb(balls,share)

def factorial(n): result = 1 for i in range(1,n+1): result *= i return result def solution(balls, share): answer = factorial(balls) / (factorial(share)*factorial(balls - share)) return answer

def solution(M, N): answer = (M-1) + M * (N-1) return answer

def solution(spell, dic): spell = {i: 0 for i in spell} for x in dic: if len(x) == len(spell): for y in x: if y in spell: spell[y] += 1 else: break if len(set(spell.values())) == 1 and sum(set(spell.values())) == 1: return 1 spell = {i: 0 for i in spell} return 2

input_data = "1 2 Z 3" print('input:', input_data.split()) print() for data in input_data.split(): print(data) ----------------------------------------- input : ['1','2','Z','3'] 1 2 Z 3

input_data = "1 -2 Z 3" for data in input_data.split(): # 이때 음수값도 숫자로 구분해야되기 때문에 try: num = int(data) print('num:', num) except: print('str:', data)

input_data = "1 -2 Z 3" stack = [] for data in input_data.split(): try: num = int(data) stack.append(num) except: if stack: # stack에 데이터가 있으면 실행, 없으면 실행 x pop_data = stack.pop() print('stack:', stack)

# solution # result 변수를 만들어서 결과들을 더해주고 빼준다 # -> 숫자가 나온다면 하나씩 result에 더해주고 stack에 쌓는다. # -> 'Z'가 나온다면 stack에서 하나를 pop한 후, result에서 빼준다.input_data = "1 -2 Z 3" def solution(s): stack = [] for num in s.split(): try: stack.append(int(num)) except: if stack: # stack에 값이 있으면 수행 stack.pop() # stack의 마지막 값을 뽑아서 삭제 return sum(stack)

def solution(sides): # 주어진 두 변의 길이 중 최대 길이가 있을 경우 # max(sides) < min(sides) + unknown # 주어진 두 변 중 최대 길이가 없는 경우 # unknown < sum(sides) return sum(sides) - (max(sides) - min(sides)) - 1

def solution(sides): return 2 * min(sides) - 1

def solution(keyinput, board): answer = [0,0] for key in keyinput: if key == 'left' and abs(answer[0] - 1) < (board[0] / 2): answer[0] -= 1 elif key == 'right' and abs(answer[0] + 1) < (board[0] / 2): answer[0] += 1 elif key == 'up' and abs(answer[1] + 1) < (board[1] / 2): answer[1] += 1 elif key == 'down' and abs(answer[1] - 1) < (board[1] / 2): answer[1] -= 1 continue return answer

def solution(keyinput,board): # [가로,세로] dirs = {"left":(-1,0), "right":(1,0), "up":(0,1), "down":(0,-1)} H, V = (board[0] + 1) // 2, (board[1] + 1) // 2 # 한계값 지정 H_cur, V_cur = 0, 0 # 초기값(시작점) for d in keyinput: H_mov, V_mov = dirs[d] H_new, V_new = H_cur + H_mov, V_cur + V_mov if abs(H_new) < H and abs(V_new) < V: H_cur, V_cur = H_new, V_new return [H_cur,V_cur]