프로그래머스 코딩 기초 트레이닝 Lv.0 124문제 파이썬 풀이

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

---

프로그래머스 코딩 기초 트레이닝 Lv.0 124문제

https://school.programmers.co.kr/learn/challenges/training?order=recent&page=1
문자열 연산, 배열, 조건문, 반복문 등 기본적인 파이썬 문법을 익힐 수 있는 문제들입니다.
정답률 높은 순으로 풀면 성취감 느끼며 기본을 다질 수 있습니다.

출력 문제 풀이

문자열 출력하기

str = input()
print(str)

a와 b 출력하기

a, b = map(str, input().strip().split(' '))
print('a = ' + a)
print('b = ' + b)

a, b = map(str, input().strip().split(' '))
print('a =', a)
print('b =', b)

문자열 반복해서 출력하기

a, b = input().strip().split(' ')

for _ in range(int(b)):
    print(a, end='')

a, b = input().strip().split(' ')
b = int(b)

result = a * b
print(result)

대소문자 바꿔서 출력하기

str = input()
list = list(str)
result = ""

for v in list:
    if v.islower():
        result += v.upper()
    else:
        result += v.lower()

print(result)

print(input().swapcase())

특수문자 출력하기

print("!@#$%^&*(\\'\"<>?:;")

print(r'!@#$%^&*(\'"<>?:;')

덧셈식 출력하기

a, b = map(int, input().strip().split(' '))
print(a, '+', b, '=', a + b)

a, b = map(int, input().strip().split(' '))
print(f"{a} + {b} = {a + b}")

문자열 붙여서 출력하기

str1, str2 = input().strip().split(' ')

print(f"{str1}{str2}")

print(input().strip().replace(' ', ''))

문자열 돌리기

str = input()

for v in str:
    print(v)

홀짝 구분하기

a = int(input())

if a % 2 == 0:
    print(a, 'is even')
else:
    print(a, 'is odd')

연산 문제 풀이

문자열 겹쳐쓰기

def solution(my_string, overwrite_string, s):
    answer = ''
    my_string_list = list(my_string)
    
    for i in range(len(overwrite_string)):
        my_string_list[s + i] = overwrite_string[i]
    
    for v in my_string_list:
        answer += v
    
    return answer

def solution(my_string, overwrite_string, s):
    return my_string[:s] + overwrite_string + my_string[s + len(overwrite_string):]

문자열 섞기

def solution(str1, str2):
    answer = ''
    str1_i, str2_i = 0, 0
    
    for i in range(len(str1)+len(str2)):
        if(i % 2 == 0):
            answer += str1[str1_i]
            str1_i += 1
        else:
            answer += str2[str2_i]
            str2_i += 1
    
    return answer

def solution(str1, str2):
    answer = ''
    for i in range(0, len(str1)):
        answer = answer + str1[i] + str2[i]
    return answer

문자 리스트를 문자열로 변환하기

def solution(arr):
    answer = ''
    
    for v in arr:
        answer += v
    
    return answer

def solution(arr):
    return ''.join(arr)

문자열 곱하기

def solution(my_string, k):
    answer = ''
    
    for i in range(k):
        answer += my_string
    
    return answer

def solution(my_string, k):
    return my_string * k

더 크게 합치기

def solution(a, b):
    str_a = str(a)
    str_b = str(b)
    str_a_and_b = int(str_a + str_b)
    str_b_and_a = int(str_b + str_a)
    
    if str_a_and_b > str_b_and_a:
        return str_a_and_b
    else:
        return str_b_and_a

def solution(a, b):
    return int(max(f"{a}{b}", f"{b}{a}"))

두 수의 연산값 비교하기

def solution(a, b):
    return max(int(f"{a}{b}"), 2*a*b)

n의 배수

def solution(num, n):
    if num % n == 0:
        return 1
    else:
        return 0

def solution(num, n):
    return int(not(num % n))

공배수

def solution(number, n, m):
    if number % n == 0 and number % m == 0:
        return 1
    else:
        return 0

파이썬에서 &는 비트연산자이므로 and를 사용해야 합니다.

조건문 문제 풀이

홀짝에 따라 다른 값 반환하기

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

조건 문자열

def solution(ineq, eq, n, m):
    answer = 0
    
    if eq == "=":
        ineq += eq
    
    if ineq == ">=":
        if n >= m:
            return 1
        else:
            return 0
    elif ineq == "<=":
        if n <= m:
            return 1
        else:
            return 0
    elif ineq == ">":
        if n > m:
            return 1
        else:
            return 0
    elif ineq == "<":
        if n < m:
            return 1
        else:
            return 0
    
    return answer

def solution(ineq, eq, n, m):
    return int(eval(str(n) + ineq + eq.replace("!", "") + str(m)))

flag에 따라 다른 값 반환하기

def solution(a, b, flag):
    if flag:
        return a + b
    else:
        return a - b

코드 처리하기

def solution(code):
    ret = ""
    mode = 0
    
    for i, v in enumerate(code):
        if mode == 0:
            if v == "1":
                mode = 1
            elif i % 2 == 0:
                ret += v
        else:
            if v == "1":
                mode = 0
            elif i % 2 == 1:
                ret += v
    
    return ret or "EMPTY"

def solution(code):
    return "".join(code.split("1"))[::2] or "EMPTY"

등차수열의 특정한 항만 더하기

def solution(a, d, included):
    arr = [v for v in range(a, a+len(included)*d, d)]
    return sum(arr[i] for i, v in enumerate(included) if v == True)

주사위 게임 2

def solution(a, b, c):
    if a == b and b == c:
        return (a + b + c) * (a**2 + b**2 + c**2 ) * (a**3 + b**3 + c**3 )
    elif a == b or b == c or c == a:
        return  (a + b + c) * (a**2 + b**2 + c**2 )
    else:
        return a + b + c

def solution(a, b, c):
    sameDel = len(set([a, b, c]))
    
    if sameDel == 1:
        return (a + b + c) * (a**2 + b**2 + c**2 ) * (a**3 + b**3 + c**3 )
    elif sameDel == 2:
        return  (a + b + c) * (a**2 + b**2 + c**2 )
    else:
        return a + b + c

원소들의 곱과 합

def solution(num_list):
    gop = 1
    hap = 0
    
    for v in num_list:
        gop *= v
        hap += v
        
    return int(gop < (hap * hap))

def solution(num_list):
    gop = eval("*".join(str(x) for x in num_list))
    hap_2 = sum(num_list)**2 
        
    return int(gop < hap_2)

이어 붙인 수

def solution(num_list):
    odd = ""
    even = ""
    
    for v in num_list:
        if v % 2 == 1:
            odd += str(v)
        else:
            even += str(v)
    
    return int(odd) + int(even)

마지막 두 원소

def solution(num_list):
    last_pre, last = num_list[-2:]
    
    if last > last_pre:
        num_list.append(last - last_pre)
    else:
        num_list.append(last * 2)
    
    return num_list

def solution(num_list):
    num_list.append(num_list[-1] - num_list[-2] if num_list[-1] > num_list[-2] else num_list[-1] * 2)
    
    return num_list

수 조작하기 1

def solution(n, control):
    for v in control:
        if "w" == v:
            n += 1
        elif "s" == v:
            n -= 1
        elif "d" == v:
            n += 10
        elif "a" == v:
            n -= 10
    return n

def solution(n, control):
    addNum = dict(zip(["w", "s", "d", "a"], [1, -1, 10, -10]))
    return n + sum(addNum[v] for v in control)

수 조작하기 2

def solution(numLog):
    answer = ""
    
    for i in range(0, len(numLog)-1):
        v = numLog[i+1] - numLog[i]
        
        while v != 0:
            if v >= 10:
                v = v - 10
                answer += "d"
            elif v >= 1:
                v = v - 1
                answer += "w"
            elif v <= -10:
                v = v + 10
                answer += "a"
            elif v <= -1:
                v = v + 1
                answer += "s"
    
    return answer

def solution(numLog):
    answer = ""
    moveDict = {1:"w", -1:"s", 10:"d", -10:"a"}
    
    for i in range(1, len(numLog)):
        answer += moveDict[numLog[i] - numLog[i-1]]
    
    return answer

간단한 논리 연산

def solution(x1, x2, x3, x4):
    return (x1 or x2) and (x3 or x4)

주사위 게임 3

def solution(a, b, c, d):
    nums = [a, b, c, d]
    counts = [nums.count(i) for i in nums]
    
    if max(counts) == 4:
        return a * 1111
    elif max(counts) == 3:
        p = nums[counts.index(3)]
        q = nums[counts.index(1)]
        return (10 * p + q) ** 2
    elif max(counts) == 2:
        if min(counts) == 2:
            return (a + c) * abs(a - c) if a == b else (a + b) * abs(a - b)
        else:
            p = nums[counts.index(2)]
            return (a * b * c * d) / p**2
    else:
        return min(nums)

이 문제는 아직 풀지 못해서 풀이 메모해두고 다시 볼 예정입니다.

배열의 원소 삭제하기

def solution(arr, delete_list):
    for v in delete_list:
        if v in arr:
            arr.remove(v)
    
    return arr

def solution(arr, delete_list):
    return [v for v in arr if v not in delete_list]

부분 문자열인지 확인하기

def solution(my_string, target):
    return int(target in my_string)

부분 문자열

def solution(str1, str2):
    return int(str1 in str2)

꼬리 문자열

def solution(str_list, ex):
    return "".join(v for v in str_list if ex not in v)

정수 찾기

def solution(num_list, n):
    return int(n in num_list)

주사위 게임 1

def solution(a, b):
    if a % 2 == 1 and b % 2 == 1:
        return (a * a) + (b * b)
    elif a % 2 == 1 or b % 2 == 1:
        return 2 * (a + b)
    else:
        return abs(a - b)

날짜 비교하기

def solution(date1, date2):
    dateInt1 = int("".join(map(str, date1)))
    dateInt2 = int("".join(map(str, date2)))
    
    return int(dateInt1 < dateInt2)

def solution(date1, date2):
    return int(date1 < date2)

커피 심부름

def solution(order):
    answer = 0
    
    for v in order:
        if "cafelatte" in v:
            answer += 5000
        else:
            answer += 4500
    
    return answer

반복문 문제 풀이

수열과 구간 쿼리 3

def solution(arr, queries):
    temp = 0
    
    for v in queries:
        temp = arr[v[1]]
        arr[v[1]] = arr[v[0]]
        arr[v[0]] = temp
    
    return arr

def solution(arr, queries):
    for i, j in queries:
        arr[i], arr[j] = arr[j], arr[i]
    
    return arr

수열과 구간 쿼리 2

def solution(arr, queries):
    answer = []
    
    for s, e, k in queries:
        k_up = [v for v in arr[s:e+1] if v > k]
        
        if k_up:
            answer.append(min(k_up))
        else:
            answer.append(-1)
    
    return answer

def solution(arr, queries):
    answer = []
    
    for s, e, k in queries:
        k_up = [v for v in arr[s:e+1] if v > k]
        
        answer.append(-1 if not k_up else min(k_up))
    
    return answer

수열과 구간 쿼리 4

def solution(arr, queries):
    for v in queries:
        for i in range(v[0], v[1]+1):
            if i % v[2] == 0:
                arr[i] += 1
    
    return arr

def solution(arr, queries):
    for s, e, k in queries:
        for i in range(s, e+1):
            if i % k == 0:
                arr[i] += 1
    
    return arr

배열 만들기 2

def solution(l, r):
    answer = []
    
    for i in range(l, r+1):
        fleg = True
        str_v = str(i)
        
        for v in str_v:
            if v != "0" and v != "5":
                fleg = False
                break
        
        if fleg == True:
            answer.append(i)
        
    return answer or [-1]

def solution(l, r):
    answer = []
    
    for i in range(l, r+1):
        if not set(str(i)) - set(['0', '5']):
            answer.append(i)
        
    return answer or [-1]

카운트 업

def solution(start_num, end_num):
    return list(range(start_num, end_num+1))

콜라츠 수열 만들기

def solution(n):
    answer = [n]
    
    while n > 1:
        if n % 2 == 0:
            n = n / 2
        else:
            n = 3 * n + 1
            
        answer.append(n)
    
    return answer

배열 만들기 4

def solution(arr):
    stk = []
    i = 0
    
    while i < len(arr):
        if stk and stk[-1] >= arr[i]:
            stk.pop()
        else:
            stk.append(arr[i])
            i += 1
        
    return stk

그림 확대

def solution(picture, k):
    answer = []
    
    for v in picture:
        line = ""
        
        for col_v in v:
            line += col_v * k
        
        for _ in range(k):
            answer.append(line)
    
    return answer

def solution(picture, k):
    answer = []
    for i in range(len(picture)):
        for _ in range(k):
            answer.append(picture[i].replace('.', '.' * k).replace('x', 'x' * k))
    
    return answer

조건에 맞게 수열 변환하기 3

def solution(arr, k):
    for i in range(len(arr)):
        if k % 2 == 1:
            arr[i] = arr[i] * k
        else:
            arr[i] = arr[i] + k
    return arr

def solution(arr, k):
    if k % 2 != 0:
        return list(map(lambda x: x * k, arr))

    return list(map(lambda x: x + k, arr))

l로 만들기

def solution(myString):
    myList = list(myString)
    
    for i, v in enumerate(myList):
        if v < "l":
            myList[i] = "l"
    return "".join(myList)

def solution(myString):
    return "".join([v if v > "l" else "l" for v in myString])

문자열 문제 풀이

글자 이어 붙여 문자열 만들기

def solution(my_string, index_list):
    answer = ""
    for v in index_list:
        answer += my_string[v]
    
    return answer

def solution(my_string, index_list):
    return "".join(my_string[i] for i in index_list)

9로 나눈 나머지

def solution(number):
    return sum(int(v) for v in number) % 9

def solution(number):
    return sum(list(map(int, number))) % 9

문자열 여러 번 뒤집기

def solution(my_string, queries):
    for s, e in queries:
        my_string = my_string[:s] + "".join(reversed(my_string[s:e+1])) + my_string[e+1:]
    
    return my_string

def solution(my_string, queries):
    my_list = list(my_string)
    
    for s, e in queries:
        my_list[s:e+1] = my_list[s:e+1][::-1]
    
    return "".join(my_list)

배열 만들기 5

def solution(intStrs, k, s, l):
    answer = []
    
    for v in intStrs:
        splitInt = int(v[s:s+l])
        
        if splitInt > k:
            answer.append(splitInt)
        
    return answer

부분 문자열 이어 붙여 문자열 만들기

def solution(my_strings, parts):
    answer = ""
    
    for i in range(len(my_strings)):
        answer += my_strings[i][parts[i][0]:parts[i][1]+1]
        
    return answer

def solution(my_strings, parts):
    answer = ""
    
    for i, (s, e) in enumerate(parts):
        answer += my_strings[i][s:e+1]
        
    return answer

문자열의 뒤의 n글자

def solution(my_string, n):
    str_len = len(my_string)
    answer = ""
    
    for i in range(n, 0, -1):
        answer += my_string[str_len - i]
    
    return answer

def solution(my_string, n):
    return my_string[-n:]

접미사 배열

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

def solution(my_string):
    return sorted(my_string[i:] for i in range(len(my_string)))

접미사인지 확인하기

def solution(my_string, is_suffix):
    return int(my_string.endswith(is_suffix))

문자열의 앞의 n글자

def solution(my_string, n):
    return my_string[:n]

접두사인지 확인하기

def solution(my_string, is_prefix):    
    return int(my_string[:len(is_prefix)] == is_prefix)

def solution(my_string, is_prefix):
    return int(my_string.startswith(is_prefix))

문자열 뒤집기

def solution(my_string, s, e):
    return my_string[:s] + "".join(my_string[i] for i in range(e, s-1, -1)) + my_string[e+1:]

def solution(my_string, s, e):
    return my_string[:s] + my_string[s:e+1][::-1] + my_string[e+1:]

세로 읽기

def solution(my_string, m, c):
    answer = ''
    
    for i in range(1, int(len(my_string)/m)+1):
        answer += my_string[(i-1)*m:i*m][c-1]
    
    return answer

def solution(my_string, m, c):
    return my_string[c-1::m]

qr code

def solution(q, r, code):
    return code[r::q]

원하는 문자열 찾기

def solution(myString, pat):
    return int(pat.lower() in myString.lower())

대문자로 바꾸기

def solution(myString):
    return myString.upper()

소문자로 바꾸기

def solution(myString):
    return myString.lower()

배열에서 문자열 대소문자 변환하기

def solution(strArr):
    for i, v in enumerate(strArr):
        if i % 2 == 0:
            strArr[i] = v.lower()
        else:
            strArr[i] = v.upper()
    
    return strArr

A 강조하기

def solution(myString):
    myList = list(myString)
    
    for i, v in enumerate(myList):
        if v.lower() == "a":
            myList[i] = "A"
        else:
            myList[i] = v.lower()
            
    return "".join(myList)

def solution(myString):
    return myString.lower().replace("a", "A")

특정한 문자를 대문자로 바꾸기

def solution(my_string, alp):
    return my_string.replace(alp, alp.upper())

특정 문자열로 끝나는 가장 긴 부분 문자열 찾기

def solution(myString, pat):
    for i in range(len(myString), len(pat)-1, -1):
        if myString[:i][-len(pat):] == pat:
            return myString[:i]

문자열이 몇 번 등장하는지 세기

def solution(myString, pat):
    answer = 0
    
    for i in range(0, len(myString)-len(pat)+1):
        v = myString[i:i+len(pat)]
        
        if v == pat:
            answer += 1
    
    return answer

def solution(myString, pat):
    answer = 0
    
    for i in range(len(myString)):
        if myString[i:].startswith(pat):
            answer += 1
    
    return answer

ad 제거하기

def solution(strArr):
    for i, v in reversed(list(enumerate(strArr))):
        change_v = v.replace("ad", "")
        
        if v != change_v:
            strArr.pop(i)
        
    return strArr

def solution(strArr):
    return [v for v in strArr if "ad" not in v]

공백으로 구분하기 1

def solution(my_string):
    return my_string.split(" ")

공백으로 구분하기 2

def solution(my_string):
    my_list = list(my_string.strip().split(" "))
    i = 0
    result_list = []
    
    for v in my_list:
        if v != "":
            result_list.append(v)
    
    return result_list

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

x 사이의 개수

def solution(myString):
    return [len(v) for v in myString.split("x")]

문자열 잘라서 정렬하기

def solution(myString):
    answer = myString.split("x")
    
    for i, v in reversed(list(enumerate(answer))):
        if v == "":
            answer.pop(i)
    
    return sorted(answer)

def solution(myString):
    return sorted(v for v in myString.split("x") if v != "")

간단한 식 계산하기

def solution(binomial):
    return eval(binomial)

문자열 바꿔서 찾기

def solution(myString, pat):
    new_myString = ""
    
    for v in myString:
        if v == "A":
            new_myString += "B"
        else:
            new_myString += "A"
            
    new_myString = new_myString.replace(pat, "*")
    
    for v in new_myString:
        if v == "*":
            return 1
    
    return 0

def solution(myString, pat):
    return int(pat in myString.replace("A", "C").replace("B", "A").replace("C", "B"))

rny_string

def solution(rny_string):
    return rny_string.replace("m", "rn")

세 개의 구분자

def solution(myStr):
    answer = []
    s = 0
    
    for i, v in enumerate(myStr):
        if v == "a" or v == "b" or v == "c":
            append_v = myStr[s:i]
            if append_v != "":
                answer.append(append_v)
            s = i+1
    
    if len(answer) == 0 and s == len(myStr):
        answer.append("EMPTY")
    else:
        answer.append(myStr[s:])
    
    return answer

배열 문제 풀이

문자 개수 세기

def solution(my_string):
    answer = [0]*52
    ord_A, ord_Z, ord_a = ord('A'), ord('Z'), ord('a')
    
    for v in my_string:
        v_ord = ord(v)
        if v_ord >= ord_A and v_ord <= ord_Z:
            answer[v_ord - ord_A] += 1
        else:
            answer[int(52/2) + v_ord - ord_a] += 1
    
    return answer

def solution(my_string):
    answer = [0]*52
    
    for v in my_string:
        if v.isupper():
            answer[ord(v) - ord('A')] += 1
        else:
            answer[int(52/2) + ord(v) - ord('a')] += 1
    
    
    return answer

배열 만들기 1

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

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

글자 지우기

def solution(my_string, indices):
    my_list = list(my_string)
    indices.sort()
    
    for v in reversed(indices):
        my_list.pop(v)
    
    return "".join(my_list)

def solution(my_string, indices):
    return "".join(v for i, v in enumerate(my_string) if i not in indices)

카운트 다운

def solution(start, end_num):
    list = []
    for i in range(start, end_num-1, -1):
        list.append(i)
    return list

def solution(start, end_num):
    return list(range(start, end_num-1, -1))

가까운 1 찾기

def solution(arr, idx):
    for i, v in enumerate(arr[idx:]):
        if v == 1:
            return idx + i
    
    return -1

def solution(arr, idx):
    for i in range(idx, len(arr)):
        if arr[i] == 1:
            return i
    
    return -1

리스트 자르기

def solution(n, slicer, num_list):
    a, b, c = slicer
    
    if n == 1:
        return num_list[0:b+1]
    elif n == 2:
        return num_list[a:]
    elif n == 3:
        return num_list[a:b+1]
    elif n == 4:
        return num_list[a:b+1:c]

첫 번째로 나오는 음수

def solution(num_list):
    for i in range(len(num_list)):
        if num_list[i] < 0:
            return i
        
    return -1

배열 만들기 3

def solution(arr, intervals):
    return arr[intervals[0][0]:intervals[0][1]+1] + arr[intervals[1][0]:intervals[1][1]+1]

def solution(arr, intervals):
    s1, e1 = intervals[0]
    s2, e2 = intervals[1]
    
    return arr[s1:e1+1] + arr[s2:e2+1]

2의 영역

def solution(arr):
    answer = []
    s, e = -1, 0
    
    for i, v in enumerate(arr):
        if v == 2:
            if s == -1:
                s = i
            e = i
            
    if s != -1:
        for i in range(s, e+1):
            answer.append(arr[i])
    
    return answer or [-1]

def solution(arr):
    if 2 not in arr:
        return [-1]
    
    return arr[arr.index(2) : len(arr) - arr[::-1].index(2)]

배열 조각하기

def solution(arr, query):
    for i, v in enumerate(query):
        if i % 2 == 0:
            arr = arr[:v+1]
        else:
            arr = arr[v:]
    
    return arr

n 번째 원소부터

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

순서 바꾸기

def solution(num_list, n):
    return num_list[n:] + num_list[:n]

왼쪽 오른쪽

def solution(str_list):
    for i, v in enumerate(str_list):
        if v == 'l':
            return str_list[:i]
        elif v == 'r':
            return str_list[i+1:]
        
    return []

n번째 원소까지

def solution(num_list, n):
    return num_list[:n]

n개 간격의 원소들

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

def solution(num_list, n):
    return num_list[::n]

홀수 vs 짝수

def solution(num_list):
    odd_sum = 0
    even_sum = 0
    
    for i in range(1, len(num_list)+1):
        if i % 2 == 1:
            odd_sum += num_list[i-1]
        else:
            even_sum += num_list[i-1]
            
    return max(odd_sum, even_sum)

def solution(num_list):
    return max(sum(num_list[::2]), sum(num_list[1::2]))

5명씩

def solution(names):
    return [names[i] for i in range(0, len(names), 5)]

def solution(names):
    return names[::5]

할 일 목록

def solution(todo_list, finished):
    answer = list()

    for i, v in enumerate(todo_list):
        if finished[i] == False:
            answer.append(v)
    
    return answer

def solution(todo_list, finished):
    return [v for i, v in enumerate(todo_list) if finished[i] == False]

n보다 커질 때까지 더하기

def solution(numbers, n):
    answer = 0
    
    for v in numbers:
        answer += v
        
        if n < answer:
            return answer

수열과 구간 쿼리 1

def solution(arr, queries):
    for i in range(len(queries)):
        s, e = queries[i]
        
        for add_i in range(s, e+1):
            arr[add_i] += 1
    
    return arr

조건에 맞게 수열 변환하기 1

def solution(arr):
    for i, v in enumerate(arr):
        if v >= 50 and v % 2 == 0:
            arr[i] = v / 2
        elif v < 50 and v % 2 == 1:
            arr[i] = v * 2
        
    return arr

조건에 맞게 수열 변환하기 2

def solution(arr):
    temp_list = []
    count = 0
    
    while True:
        temp_list = arr.copy()
        
        for i, v in enumerate(arr):
            if v > 50 and v % 2 == 0:
                arr[i] = int(v / 2)
            elif v < 50 and v % 2 == 1:
                arr[i] = int(v * 2 + 1)
                
        if arr == temp_list:
            break
            
        count += 1
            
    return count

1로 만들기

def solution(num_list):
    count = 0
    
    for v in num_list:
        while v != 1:
            if v % 2 == 0:
                v = v / 2
            else:
                v = (v-1) / 2
                
            count += 1
    
    return count

길이에 따른 연산

def solution(num_list):
    if len(num_list) >= 11:
        return sum(num_list)
    else:
        return eval("*".join(str(v) for v in num_list))

배열의 원소만큼 추가하기

def solution(arr):
    answer = []
    
    for v in arr:
        for i in range(v):
            answer.append(v)
    
    return answer

def solution(arr):
    return [v for v in arr for j in range(v)]

빈 배열에 추가, 삭제하기

def solution(arr, flag):
    arr_X = []
    
    for i, v in enumerate(flag):
        if v == True:
            for j in range(arr[i]):
                arr_X.append(arr[i])
                arr_X.append(arr[i])
        else:
            for j in range(arr[i]):
                arr_X.pop() 
    
    return arr_X

배열 만들기 6

def solution(arr):
    stk = []
    
    for i in range(len(arr)):
        if len(stk) == 0:
            stk.append(arr[i])
        elif stk[-1] == arr[i]:
            stk.pop()
        else:
            stk.append(arr[i])

    return stk if stk else [-1]

def solution(arr):
    stk = []
    for i in range(len(arr)):
        if stk and stk[-1] == arr[i]:
            stk.pop()
        else:
            stk.append(arr[i])

    return stk or [-1]

무작위로 K개의 수 뽑기

def solution(arr, k):
    answer = []
    
    for v in arr:
        if len(answer) < k:
            if v not in answer:
                answer.append(v)
        else:
            break
    
    for _ in range(k - len(answer)):
        answer.append(-1)
    
    return answer

def solution(arr, k):
    answer = []
    for i in arr:
        if i not in answer:
            answer.append(i)
            
        if len(answer) == k:
            break

    return answer + [-1] * (k - len(answer))

이차원 배열 문제 풀이

특별한 이차원 배열 1

def solution(n):
    answer = [[0]*n for _ in range(n)]
    
    for i in range(n):
        answer[i][i] = 1
    
    return answer

정수를 나선형으로 배치하기

def solution(n):
    add_num = [(0,1), (1,0), (0,-1), (-1,0)]
    answer = [[0]*n for _ in range(n)]
    cur_i, cur_j, next_i, next_j, mode = 0, 0, 0, 0, 0
    count = 0
    visited = set()
    
    while count < n*n:
        # 현재 위치에 값 저장 후 방문 처리
        count += 1
        answer[cur_i][cur_j] = count
        visited.add((cur_i, cur_j))
        
        # 현재 위치 기준으로 다음 위치 정하기 위해 mode 변경
        if mode == 0 and cur_j == n-1:
            mode = 1
        elif mode == 1 and cur_i == n-1:
            mode = 2
        elif mode == 2 and cur_j == 0:
            mode = 3
        elif mode == 3 and cur_i == 0:
            mode = 0
        
        # 다음 위치가 방문했던 위치면 mode 변경
        next_i = cur_i + add_num[mode][0]
        next_j = cur_j + add_num[mode][1]
        
        if (next_i, next_j) in visited:
            if mode == 0:
                mode = 1
            elif mode == 1:
                mode = 2
            elif mode == 2:
                mode = 3
            elif mode == 3:
                mode = 0
        
        # 현재 위치를 변경된 mode의 다음 위치로 변경
        cur_i += add_num[mode][0]
        cur_j += add_num[mode][1]
    
    return answer

특별한 이차원 배열 2

def solution(arr):
    for i in range(len(arr)):
        for j in range(len(arr[i])):
            if arr[i][j] != arr[j][i]:
                return 0
    
    return 1

정사각형으로 만들기

def solution(arr):
    for i, v in enumerate(arr):
        for _ in range(len(v), len(arr)):
            arr[i].append(0)
    
    for _ in range(len(arr), len(arr[0])):
        arr.append([0] * len(arr[0]))
    
    return arr

이차원 배열 대각선 순회하기

def solution(board, k):
    answer = 0
    
    for i in range(len(board)):
        for j in range(len(board[i])):
            if i + j <= k:
                answer += board[i][j]
    
    return answer

함수 문제 풀이

배열의 길이를 2의 거듭제곱으로 만들기

def solution(arr):
    i = 0

    while True: 
        if len(arr) <= 2**i:
            for _ in range(2**i - len(arr)):
                arr.append(0)
            break
    
        i += 1
    
    return arr

배열 비교하기

def solution(arr1, arr2):
    if len(arr1) == len(arr2):
        if sum(arr1) > sum(arr2):
            return 1
        elif sum(arr1) < sum(arr2):
            return -1
        else:
            return 0
    elif len(arr1) > len(arr2):
        return 1
    else:
        return -1

문자열 묶기

def solution(strArr):
    strHash = {}
    
    for v in strArr:
        v_len = len(v)
        
        if v_len not in strHash:
            strHash[v_len] = 1
        else:
            strHash[v_len] += 1
    
    return max(strHash.values())

배열의 길이에 따라 다른 연산하기

def solution(arr, n):
    for i, v in enumerate(arr):
        if len(arr) % 2 == 1 and i % 2 == 0:
            arr[i] = v + n
        elif len(arr) % 2 == 0 and i % 2 == 1:
            arr[i] = v + n
    return arr

뒤에서 5등까지

def solution(num_list):
    num_list.sort()
    
    return num_list[:5]
def solution(num_list):
    return sorted(num_list)[:5]

뒤에서 5등 위로

def solution(num_list):
    num_list.sort()

    for _ in range(5):
        num_list.pop(0)

    return num_list
def solution(num_list):
    return sorted(num_list)[5:]

전국 대회 선발 고사

def solution(rank, attendance):
    true_list = [(rank[i], i) for i in range(len(rank)) if attendance[i] == True]
    
    true_list.sort()
    
    return 10000 * true_list[0][1] + 100 * true_list[1][1] + true_list[2][1]

def solution(rank, attendance):
    true_list = sorted([(v, i) for i, v in enumerate(rank) if attendance[i]])
    return 10000 * true_list[0][1] + 100 * true_list[1][1] + true_list[2][1]

정수 부분

def solution(flo):
    return int(flo)

문자열 정수의 합

def solution(num_str):
    answer = 0
    for v in num_str:
        answer += int(v)
    return answer

def solution(num_str):
    return sum(map(int, num_str))

문자열을 정수로 변환하기

def solution(n_str):
    return int(n_str)

0 떼기

def solution(n_str):
    return str(int(n_str))

def solution(n_str):
    return n_str.lstrip("0")

두 수의 합

def solution(a, b):
    return str(int(a) + int(b))

문자열로 변환

def solution(n):
    return str(n)