프로그래머스 코딩테스트 입문 Lv.0 100문제 파이썬 풀이

파이썬 입문자인 저의 풀이와 본받을 코드를 모아서 복습하는 글입니다.

---

프로그래머스 코딩테스트 입문 Lv.0 100문제

https://school.programmers.co.kr/learn/challenges/beginner?order=recent
입문 문제가 기초 트레이닝 문제보다 오히려 더 쉬운 것 같습니다.
정답률 높은 순으로 풀면 자신감이 붙어서 좋습니다.
한 문제에서 오래 막히는 경우, 질문으로 코드 남겨서 반례 요청 후 다른 문제 풀고 다시 와서 풀면 효율적입니다.

난이도 Lv. 0 100문제 풀이

옹알이 (1)

def solution(babbling):
    answer = 0
    says = ["aya", "ye", "woo", "ma"]
    
    for cur_str in babbling:
        cut_str = cur_str
        
        for say_word in says:
            if say_word in cur_str:
                cut_str = cut_str.replace(say_word, " ")
            
        if len(cut_str.strip()) == 0 :
            answer += 1

    return answer

다음에 올 숫자

def solution(common):
    answer = 0
    diff = {}
    common_len = len(common)
    common_last_val = common[common_len-1]
    
    for i in range(0, 2):
        diff[i] = (common[i], common[i+1] - common[i])
        
    if diff[0][1] == diff[1][1]:
        answer = common_last_val + diff[0][1]
    else:
        answer = common_last_val * (diff[1][0] / diff[0][0])
    
    return answer

연속된 수의 합

def solution(num, total):
    answer = []
    i = -num
    
    while True:
        answer.append(i)
        
        if len(answer) > num:
            answer.pop(0)
        
        if sum(answer) == total:
            return answer
        
        i = i+1

종이 자르기

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

문자열 밀기

def solution(A, B):
    count = 0
    
    for i in range(len(A), 0, -1):
        if A[i:] + A[:i] == B:
            return count
        else:
            count += 1
    
    return -1

def solution(A, B):
    return (B*2).find(A)

잘라서 배열로 저장하기

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

7의 개수

def solution(array):
    answer = 0
    
    for v in array:
        for char in str(v):
            if char == "7":
                answer += 1
    
    return answer

def solution(array):
    return str(array).count("7")

문자열 정렬하기 (2)

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

세균 증식

def solution(n, t):
    for i in range(t):
        n *= 2
    
    return n

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

제곱수 판별하기

import math

def solution(n):
    return 1 if math.sqrt(n) == int(math.sqrt(n)) else 2

def solution(n):
    return 1 if (n ** 0.5).is_integer() else 2

문자열안에 문자열

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

OX퀴즈

def solution(quiz):
    answer = []
    
    for v in quiz:
        quizArr = v.split(" = ")
    
        if eval(quizArr[0]) == int(quizArr[1]):
            answer.append("O")
        else:
            answer.append("X")
    
    return answer

자릿수 더하기

def solution(n):
    return sum(int(v) for v in str(n))

def solution(n):
    return sum(list(map(int, str(n))))

n의 배수 고르기

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

숫자 찾기

def solution(num, k):
    num_list = list(str(num))
    
    for v in num_list:
        if int(v) == k:
            return num_list.index(v)+1
    
    return -1

배열의 유사도

def solution(s1, s2):
    return len([v for v in s1 if v in s2])

def solution(s1, s2):
    return len(set(s1) & set(s2))

문자열 계산하기

def solution(my_string):
    return eval(my_string)

가장 큰 수 찾기

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

편지

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

약수 구하기

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

한 번만 등장한 문자

def solution(s):
    s_dict = dict()
    
    for v in s:
        if v in s_dict:
            s_dict[v] += 1
        else:
            s_dict[v] = 1
    
    return "".join(sorted(v for v in s if s_dict[v] == 1))

def solution(s):
    return "".join(sorted(v for v in s if s.count(v) == 1))

인덱스 바꾸기

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

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

영어가 싫어요

def solution(numbers):
    num_hash = {"zero": "0", "one": "1", "two": "2",
                "three": "3", "four": "4", "five": "5",
                "six": "6", "seven": "7", "eight": "8", "nine": "9"}
    
    for v in num_hash.keys():
        numbers = numbers.replace(v, num_hash[v])
    
    return int(numbers)

def solution(numbers):
    num_list = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
    
    for i, v in enumerate(num_list):
        numbers = numbers.replace(v, str(i))
    
    return int(numbers)

대문자와 소문자

def solution(my_string):
    return my_string.swapcase()

암호 해독

def solution(cipher, code):
    return cipher[code-1::code]

369게임

def solution(order):
    num_set = {"3", "6", "9"}
    return len([v for v in str(order) if v in num_set])

가까운 수

def solution(array, n):
    i = 0
    while True:
        if n - i in array:
            return n - i
        elif n + i in array:
            return n + i
        i += 1

삼각형의 완성조건 (1)

def solution(sides):
    max_num = max(sides)
    sides.remove(max_num)

    return 1 if max_num < (sides[0] + sides[1]) else 2
def solution(sides):
    return 1 if max(sides) < (sum(sides) - max(sides)) else 2

중복된 문자 제거

def solution(my_string):
    answer = ""
    
    for v in my_string:
        if v not in answer:
            answer += v
    
    return answer

k의 개수

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

A로 B 만들기

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

이진수 더하기

def solution(bin1, bin2):
    answer = ""
    maxLen = max(len(bin1), len(bin2))
    cur_bin1, cur_bin2, up = 0, 0, 0
    
    for i in range(maxLen):
        if len(bin1) > i:
            cur_bin1 = int(bin1[-1 + -i])
        else:
            cur_bin1 = 0
        
        if len(bin2) > i:
            cur_bin2 = int(bin2[-1 + -i])
        else:
            cur_bin2 = 0
            
        line_sum = cur_bin1 + cur_bin2 + up
        
        if line_sum >= 2:
            up = 1
            line_sum = line_sum -2
        else:
            up = 0
        
        answer += str(line_sum)
    
    if up == 1:
        answer += str(up)
    
    return answer[::-1]

def solution(bin1, bin2):
    return bin(int(bin1, 2) + int(bin2, 2))[2:]

치킨 쿠폰

def solution(chicken):
    service_sum = 0
    
    while chicken >= 10:
        service = chicken // 10
        coupon = chicken % 10
        chicken = service + coupon
        
        service_sum += service
    
    return service_sum

로그인 성공?

def solution(id_pw, db):
    db_hash = dict(db)
    user_id, pw = id_pw
    
    if user_id in db_hash.keys():
        if db_hash[user_id] == pw:
            return "login"
        else:
            return "wrong pw"
    
    return "fail"

등수 매기기

def solution(score):
    answer = [0] * len(score)
    score_list = [(v[0] + v[1]) / 2 for v in score]
    copy_list = score_list.copy()
    rank_hash = dict()
    rank = 0
    
    while score_list:
        max_score = max(score_list)
        rank += 1
        if max_score not in rank_hash:
            rank_hash[max_score] = rank
        score_list.remove(max_score)
    
    
    for i, v in enumerate(copy_list):
        answer[i] = rank_hash[v]
    
    return answer

def solution(score):
    sort_list = sorted([sum(v) for v in score], reverse = True)
    return [sort_list.index(sum(v))+1 for v in score]

특이한 정렬

def solution(numlist, n):
    sortlist = []
    
    for v in numlist:
        sortlist.append((abs(v - n), v))
    
    sortlist.sort()
    
    for i in range(len(sortlist)-1):
        cur_k, cur_v = sortlist[i]
        next_k, next_v = sortlist[i+1]
        
        if cur_k == next_k and cur_v < next_v:
            sortlist[i] = (next_k, next_v)
            sortlist[i+1] = (cur_k, cur_v)
        
    return [v for k, v in sortlist]

def solution(numlist, n):
    numlist.sort(key = lambda x: (abs(n - x), -x))
    return numlist

유한소수 판별하기

def solution(a, b):
    # 최대공약수 구하기
    for i in range(a, 1, -1):
        if b % i == 0 and a % i == 0:
            # 분모를 최대공약수로 나눈 몫으로 변경
            b //= i
            break
    
    # 분모에서 2의 배수 모두 제거
    while b % 2 == 0:
        b //= 2
        
    # 분모에서 5의 배수 모두 제거
    while b % 5 == 0:
        b //= 5
        
    # 분모가 1이 아니면 분모의 소인수가 2와 5만 존재하지 않는 것
    return 1 if b == 1 else 2

분자와 분모의 최대공약수로 약분하면 기약분수를 만들 수 있습니다. 소인수는 약수가 소수인 수를 말합니다.

겹치는 선분의 길이

def solution(lines):
    sets = [set(range(min(l), max(l))) for l in lines]
    return len(sets[0] & sets[1] | sets[0] & sets[2] | sets[1] & sets[2])

선분의 길이는 시작점부터 끝점인 max(l) 전까지의 구간으로 셀 수 있습니다.
set 자료구조로 중복을 제거할 수 있습니다.
sets 리스트에서 선들의 교집합을 찾고, 교집합들을 합집합을 계산하여 공통된 좌표의 수를 반환합니다.

평행

def solution(dots):
    line_1_x_diff = dots[2][0] - dots[0][0]
    line_1_y_diff = dots[2][1] - dots[0][1]
    line_2_x_diff = dots[3][0] - dots[1][0]
    line_2_y_diff = dots[3][1] - dots[1][1]
    
    if (line_2_x_diff / line_1_x_diff) == (line_2_y_diff / line_1_y_diff):
        return 1
    
    line_1_x_diff = dots[1][0] - dots[0][0]
    line_1_y_diff = dots[1][1] - dots[0][1]
    line_2_x_diff = dots[3][0] - dots[2][0]
    line_2_y_diff = dots[3][1] - dots[2][1]
    
    if (line_2_x_diff / line_1_x_diff) == (line_2_y_diff / line_1_y_diff):
        return 1
    
    return 0

파이썬에서 //는 나누고 소수점 이하를 버린 몫을 반환합니다.
기울기를 비교할 때, /로 나눠서 소수점도 비교해야 테스트 케이스 2를 통과할 수 있습니다.

저주의 숫자 3

def solution(n):
    answer = 0
    
    for _ in range(n):
        answer += 1
        
        while answer % 3 == 0 or "3" in str(answer):
            answer += 1
    
    return answer

외계어 사전

def solution(spell, dic):
    for word in dic:
        isWord = True
        
        for v in spell:
            if v not in word:
                isWord = False
        
        if isWord == True:
            return 1
    
    return 2

def solution(spell, dic):
    for word in dic:
        if not set(spell) - set(word):
            return 1
    
    return 2

삼각형의 완성조건 (2)

def solution(sides):
    a, b = sides
    answer = 0
    
    for _ in range(abs(a - b), max(sides)):
        answer += 1
    
    for _ in range(max(sides)+1, sum(sides)):
        answer += 1
    
    return answer

안전지대

def solution(board):
    answer = 0
    addArea = [[-1, -1], [-1, 0], [-1, 1],
               [0, -1], [0, 0], [0, 1],
               [1, -1], [1, 0], [1, 1]]
    
    for i in range(0, len(board)):
       for j in range(0, len(board[i])):
            
            safe = True
        
            # 좌표 더하기
            for [x, y] in addArea:
                added_x = i+x
                added_y = j+y
                
                if (added_x < 0 or added_x >= len(board)):
                    continue
                    
                if (added_y < 0 or added_y >= len(board[i])):
                    continue
                
                if (board[added_x][added_y] == 1):
                    safe = False
                    break
                    
            if safe == True:
                answer += 1
                
    return answer

def solution(board):
    n = len(board)
    danger = set()
    for i, row in enumerate(board):
        for j, x in enumerate(row):
            if not x:
                continue
            danger.update((i+di, j+dj) for di in [-1,0,1] for dj in [-1,0,1])
    return n*n - sum(0 <= i < n and 0 <= j < n for i, j in danger)

숨어있는 숫자의 덧셈 (2)

def solution(my_string):
    digit_str = ""
    answer = 0
    
    for v in my_string:
        if v.isdigit():
            digit_str += v
        else:
            if digit_str != "":
                answer += int(digit_str)
                digit_str = ""
    
    if digit_str != "":
        answer += int(digit_str)
    
    return answer

def solution(my_string):
    new_str = "".join(v if v.isdigit() else " " for v in my_string)
    return sum(int(v) for v in new_str.split())

다항식 더하기

def solution(polynomial):
    polyList = polynomial.strip().split(" + ")
    x_count = 0
    num = 0
    answer = ""
    
    for i, v in enumerate(polyList):
        if v[-1] == "x":
            if v == "x":
                x_count += 1
            else:
                x_count += int(v.replace("x", ""))
                print(v.replace("x", ""))
        else:
            num += int(v)
    
    if x_count == 1:
        answer = "x"
    elif x_count > 1:
        answer = str(x_count) + "x"
    
    if num > 0:
        if answer != "":
            answer += " + "
        
        answer += str(num)
    
    return answer

최댓값 만들기 (2)

def solution(numbers):
    minus_list = []
    plus_list = []
    minus_1, minus_2, plus_1, plus_2 = 0, 0, 0, 0
    
    for v in numbers:
        if v >= 0:
            plus_list.append(v)
        else:
            minus_list.append(v)
            
    # 테스트 케이스 7번, +- 원소가 1개씩인 경우
    if len(minus_list) == 1 and len(plus_list) == 1:
        return minus_list[0] * plus_list[0]
            
    if plus_list:
        plus_1 = max(plus_list)
        plus_list.remove(plus_1)
    if plus_list:
        plus_2 = max(plus_list)
    
    if minus_list:
        minus_1 = min(minus_list)
        minus_list.remove(minus_1)
    if minus_list:
        minus_2 = min(minus_list)
    
    return max(int(minus_1 * minus_2), int(plus_1 * plus_2))

def solution(numbers):
    numbers.sort()
    return max(numbers[0] * numbers[1], numbers[-1] * numbers[-2])

캐릭터의 좌표

def solution(keyinput, board):
    cur_location = [0, 0]
    key_hash = {"up":(0, 1), "down":(0, -1), "left":(-1, 0), "right":(1, 0)}
    max_x, max_y = int((board[0]-1)/2), int((board[1]-1)/2)
    min_x, min_y = -max_x, -max_y
    
    for key in keyinput:
        cur_x, cur_y = cur_location
        
        if (key == "right" and cur_x < max_x) or (key == "left" and cur_x > min_x):
            cur_location[0] += key_hash[key][0]
        
        if (key == "up" and cur_y < max_y) or (key == "down" and cur_y > min_y):
            cur_location[1] += key_hash[key][1]
    
    return cur_location

직사각형 넓이 구하기

def solution(dots):
    x = [v[0] for v in dots]
    y = [v[1] for v in dots]
    
    return (max(x) - min(x)) * (max(y) - min(y))

배열 원소의 길이

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

컨트롤 제트

def solution(s):
    s_list = s.split()
    answer = 0
    
    for i in range(len(s_list)):
        if s_list[i] == "Z":
            answer -= int(s_list[i-1])
        else:
            answer += int(s_list[i])
    
    return answer

소인수분해

def solution(n):
    answer = []
    
    for i in range(2, n+1):
        if n % i == 0:
            append_yn = True
            
            for j in range(2, i):
                if i % j == 0:
                    append_yn = False
                    break
            
            if append_yn:
                n = n / i
                answer.append(i)
    
    return answer

숨어있는 숫자의 덧셈 (1)

def solution(my_string):
    return sum([int(v) for v in my_string if ord(v) >= ord("0") and ord(v) <= ord("9")])

def solution(my_string):
    return sum(int(v) for v in my_string if v.isdigit())

문자열 정렬하기 (1)

def solution(my_string):
    my_list = list(my_string)
    my_list.sort()

    return [int(v) for v in my_list if ord(v) >= ord("0") and ord(v) <= ord("9")]

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

모음 제거

def solution(my_string):
    rm_set = ("a", "e", "i", "o", "u")
    
    return "".join([v for v in my_string if v not in rm_set])

팩토리얼

def solution(n):
    i = 1
    
    while factorial(i) <= n:
        i += 1
    
    return i - 1

def factorial(n):
    if n == 1:
        return 1
    
    return n * factorial(n-1)

def solution(n):
    i = 1
    factorial = 1
    while factorial <= n:
        i += 1
        factorial = factorial * i
    return i - 1

최댓값 만들기(1)

def solution(numbers):
    numbers.sort(reverse=True)
    
    return numbers[0] * numbers[1]

def solution(numbers):
    numbers.sort()
    
    return numbers[-1] * numbers[-2]

합성수 찾기

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

주사위의 개수

def solution(box, n):
    x, y, z = box
    return (x // n) * (y // n) * (z // n)

배열 회전시키기

def solution(numbers, direction):
    if direction == "right":
        numbers.insert(0, numbers.pop())
    else:
        numbers.append(numbers.pop(0))
    
    return numbers

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

공 던지기

def solution(numbers, k):
    index = (k-1) * 2
    num_len = len(numbers)
    
    while index > num_len:
        index -= num_len

    return numbers[index]

def solution(numbers, k):
    return numbers[(k - 1) * 2 % len(numbers)]

2차원으로 만들기

def solution(num_list, n):
    answer = []
    
    for i in range(0, len(num_list), n):
        sub_list = []
        for j in range(n):
            sub_list.append(num_list[i + j])
        
        answer.append(sub_list)
    
    return answer

def solution(num_list, n):
    answer = []
    
    for i in range(0, len(num_list), n):
        answer.append(num_list[i:i+n])
    
    return answer

점의 위치 구하기

def solution(dot):
    x, y = dot
    
    if x > 0 and y > 0:
        return 1
    elif x < 0 and y > 0:
        return 2
    elif x < 0 and y < 0:
        return 3
    else:
        return 4

구슬을 나누는 경우의 수

def solution(balls, share):    
    return factorial(balls) / (factorial(balls - share) * factorial(share))

def factorial(n):
    if n <= 1:
        return 1
    
    return n * factorial(n-1)

import math

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

가위 바위 보

def solution(rsp):
    win_case = {"2":"0", "0":"5", "5":"2"}
    answer = ''
                
    for v in rsp:
        answer += win_case[v]
    
    return answer

def solution(rsp):
    win_case = {"2":"0", "0":"5", "5":"2"}
    return "".join(win_case[v] for v in rsp)

모스부호 (1)

def solution(letter):  
    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'
    }
    answer = ''
    letter_list = letter.split()
    
    for v in letter_list:
        answer += morse[v]
    
    return answer

def solution(letter):  
    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'
    }
    return "".join(morse[v] for v in letter.split())

개미 군단

def solution(hp):
    count = 0
    
    while hp > 0:
        if hp >= 5:
            ant = int(hp / 5)
            hp -= (ant * 5)
        elif hp >= 3:
            ant = int(hp / 3)
            hp -= (ant * 3)
        elif hp >= 1:
            ant = int(hp / 1)
            hp -= (ant * 1)
        
        count += ant
    
    return count

def solution(hp):
    return hp // 5 + (hp % 5) // 3 + (hp % 5) % 3

순서쌍의 개수

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

진료순서 정하기

def solution(emergency):
    max_dict = dict()
    clone_list = emergency.copy()
    
    for i in range(len(emergency)):
        max_v = max(emergency)
        max_dict[max_v] = len(max_dict) + 1
        emergency.remove(max_v)
    
    for i, v in enumerate(clone_list):
        clone_list[i] = max_dict[v]
        
    return clone_list

외계행성의 나이

def solution(age):
    return "".join(chr(ord('a') + int(v)) for v in str(age))

배열 자르기

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

짝수의 합

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

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

양꼬치

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

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

각도기

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

특정 문자 제거하기

def solution(my_string, letter):
    return my_string.replace(letter, "")

문자 반복 출력하기

def solution(my_string, n):
    return "".join(v * n for v in my_string)

짝수 홀수 개수

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

직각삼각형 출력하기

n = int(input())

for i in range(1, n+1):
    print("*"*i)

문자열 뒤집기

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

배열 뒤집기

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

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

나이 출력

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

아이스 아메리카노

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

옷가게 할인 받기

def solution(price):
    sale_per = 0
    
    if price >= 500000:
        sale_per = 20
    elif price >= 300000:
        sale_per = 10
    elif price >= 100000:
        sale_per = 5
        
    return price if sale_per == 0 else int(price - (price * sale_per / 100))

배열의 평균값

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

피자 나눠 먹기 (3)

def solution(slice, n):
    return (n + (slice-1)) // slice

def solution(slice, n):
    return (n - 1) // slice + 1

피자 나눠 먹기 (2)

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

피자 나눠 먹기 (1)

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

짝수는 싫어요

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

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

최빈값 구하기

def solution(array):
    cnt_set = set()
    max_count = 0
    
    for v in array:
        cnt_set.add((array.count(v), v))
    
    for k, v in cnt_set:
        if k == max(cnt_set)[0]:
            max_count += 1
    
    if max_count > 1:
        return -1
    else:
        return max(cnt_set)[1]

중앙값 구하기

def solution(array):
    array.sort()
    
    return array[int(len(array) / 2)]

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

나머지 구하기

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

배열 두 배 만들기

def solution(numbers):
    return [v * 2 for v in numbers]

분수의 덧셈

def solution(numer1, denom1, numer2, denom2):
    answer = []
    
    numer = (numer1 * denom2) + (numer2 * denom1)
    denom = denom1 * denom2
    
    gcd = denom
    
    for i in range(gcd, 0, -1):
        if numer % i == 0 and denom % i == 0:
            gcd = i
            break
    
    # 기약분수 : 분자와 분모의 최대공약수로 약분한 몫
    answer.append(numer // gcd)
    answer.append(denom // gcd)
    
    return answer

import math

def solution(numer1, denom1, numer2, denom2):
    answer = []
    
    numer = (numer1 * denom2) + (numer2 * denom1)
    denom = denom1 * denom2
    
    gcd = math.gcd(numer, denom)
    
    answer.append(numer // gcd)
    answer.append(denom // gcd)
    
    return answer

math 라이브러리를 사용하면, 최대공약수를 간편하게 구할 수 있습니다.

숫자 비교하기

def solution(num1, num2):
    return 1 if num1 == num2 else -1

두 수의 나눗셈

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

몫 구하기

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

두 수의 곱

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

두 수의 차

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

두 수의 합

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

머쓱이보다 키 큰 사람

def solution(array, height):
    return len([i for i in array if i > height])

중복된 숫자 개수

def solution(array, n):
    return len([v for v in array if v == n])

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