생각과 고민이 담긴 코드

Velog로 블로그 이전합니다!

0_Hun — Mon, 6 Mar 2023 15:59:12 +0900

항상 읽어주셔서 감사합니다!
다음 주소로 블로그 이전했습니다!

https://velog.io/@0_hun

프로그래머스 - 순위 검색 (2021 KAKAO Blind Recruitment) / Level 2

0_Hun — Wed, 2 Feb 2022 19:08:19 +0900

문제

https://programmers.co.kr/learn/courses/30/lessons/72412

코딩테스트 연습 - 순위 검색

["java backend junior pizza 150","python frontend senior chicken 210","python frontend senior chicken 150","cpp backend senior pizza 260","java backend junior chicken 80","python backend senior chicken 50"] ["java and backend and junior and pizza 100","pyt

programmers.co.kr

풀이

from collections import defaultdict
from itertools import product
from bisect import bisect_left


def solution(info, query):
    answer = []
    info_dict = defaultdict(list)

    for i in range(len(info)):
        info[i] = info[i].split()
        info[i][-1] = int(info[i][-1])
        
    info.sort(key=lambda x: x[4])  # 추후에 binary search를 사용하기 위한 정렬.

    for i in info:  # '-'를 포함하여 key-value 형태로 만듬.
        key_set = product([i[0], '-'], [i[1], '-'], [i[2], '-'], [i[3], '-'], )

        for j in key_set:
            info_dict["".join(j[:4])].append(i[-1])

    for i in range(len(query)):
        query[i] = query[i].replace("and", "")
        query[i] = query[i].split()
        query[i] = ["".join(query[i][:4]), int(query[i][-1])]

    for i in query:  # query를 돌면서 info_dict의 value인 list를 이진 탐색함.
        answer.append(len(info_dict[i[0]]) - bisect_left(info_dict[i[0]], i[1]))

    return answer

체감 난이도는 Level 3였던 매우 어려운 문제였다.

정확도 테스트를 통과하는 것은 딱 봐도 어렵지 않았다.

그러나 info 배열의 길이는 50,000이고 query 배열의 길이는 100,000이었다.

각각의 query에 대하여 info 배열을 탐색하면 50억이라는 무시무시한 숫자가 나오기에

절대 효율성 테스트를 통과하지 못할 것이다.

이 문제에서 알고리즘을 개선하기 위한 방안은 2가지이다.

이 2가지를 모두 적용해야 효율성 테스트를 통과할 수 있었기에 매우 어려웠다.

1. Key-Value 형태로 만들기.

매 query마다 info를 탐색하면 안 되기에 info를 적절하게 Dictionary 형태로 만들어서 상수 시간에 접근할 수 있도록 해야 한다.

4가지 문자열 값들을 합쳐서 key를 만들고 코딩 점수를 value로 갖도록 구성하였다.

key_set = product([i[0], '-'], [i[1], '-'], [i[2], '-'], [i[3], '-'],)

또한 query의 '-'를 처리하기 위해 위와 같은 형태로 하나의 info 값에 대한 16가지 경우의 수를 info_dict의 key로 추가해주었다.

2. Binary Search

위 과정까지 구현했다면 하나의 query에 대하여 상수 시간에 info_dict의 value

즉, 코딩 점수 리스트를 가져올 수 있다.

해당 리스트에서 query에서 지정하는 점수 이상의 사람 수를 구해야 하는데

여기서 O(n) 탐색을 해버린다면 효율성 테스트를 통과할 수 없다..

이진 탐색을 통해 시간 복잡도를 O(log n)으로 줄여야 비로소 효율성 테스트를 통과할 수 있다.

이진 탐색은 직접 구현할 수 도 있지만 bisect 라이브러리의 bisect_left 함수를 이용하면

해당 값이 리스트 내에 존재하지 않더라도 해당 값을 삽입할 경우, 정렬을 유지할 수 있는 위치의 index를 반환해준다.

(bisect_left는 동일한 값이 있을 경우 그 값의 왼쪽 index 값을 반환.)

이 함수는 내부적으로 이진 탐색을 사용하고

반환되는 index를 활용하여 해당 값 이상의 값들을 바로 구할 수 있기 때문에 사용하였다.

프로그래머스 - 튜플 (2019 카카오 개발자 겨울 인턴십) / Level 2

0_Hun — Sat, 22 Jan 2022 14:59:36 +0900

문제

https://programmers.co.kr/learn/courses/30/lessons/64065

코딩테스트 연습 - 튜플

"{{2},{2,1},{2,1,3},{2,1,3,4}}" [2, 1, 3, 4] "{{1,2,3},{2,1},{1,2,4,3},{2}}" [2, 1, 3, 4] "{{4,2,3},{3},{2,3,4,1},{2,3}}" [3, 2, 4, 1]

programmers.co.kr

풀이

def solution(s):
    answer = []
    
    s_list = []
    nums=[]
    temp_nums = ""
    
    for i in s:
        if i.isdigit():
            temp_nums += i
        elif i == ',':
            if temp_nums:
                nums.append(int(temp_nums))
            temp_nums = ""
        elif i == '}':
            if temp_nums:
                nums.append(int(temp_nums))
                s_list.append(nums)
            temp_nums = ""
            nums = []
    
    s_list.sort(key=lambda x : len(x))
    
    for i in s_list:
        for j in i:
            if j not in answer:
                answer.append(j)
    
    return answer

어렵지 않은 문제였다. 입력으로 들어온 문자열을 하나의 튜플로 귀결시키기 위해선

튜플은 순서가 유효하기 때문에 집합의 길이가 작은 순대로 넣어줘야 했다.

그래서 일단 문자열을 이중 리스트로 변환시켜주고 각각의 배열의 길이를 기준으로 정렬을 수행한 후

순회하면서 튜플에 넣어줬다.

프로그래머스 - 크레인 인형뽑기 게임 (2019 카카오 개발자 겨울 인턴십) / Level 1

0_Hun — Sun, 16 Jan 2022 12:23:00 +0900

문제 : https://programmers.co.kr/learn/courses/30/lessons/64061

코딩테스트 연습 - 크레인 인형뽑기 게임

[[0,0,0,0,0],[0,0,1,0,3],[0,2,5,0,1],[4,2,4,4,2],[3,5,1,3,1]] [1,5,3,5,1,2,1,4] 4

programmers.co.kr

풀이

def solution(board, moves):
    answer = 0
    stack = []
    n = len(board)
    
    for move in moves:
        for i in range(n):
            item = board[i][move-1]  # 현재 집게가 가리키는 item.
            
            if item != 0:  # 집게가 인형에 도달했을 경우.
                board[i][move-1] = 0  # 인형을 뽑아주고
                
                if stack:  # 바구니에 이전에 담긴 인형이 있으면
                    ex_item = stack.pop()
                    if item == ex_item:  # 같은 종류 인형인지 비교.
                        answer += 2
                    else:  # 다르면 둘 다 순서대로 다시 넣어줌.
                        stack.extend([ex_item, item])
                else:
                    stack.append(item)
                break
    return answer

문제 설명이 길고 복잡해 보이지만 실상을 들여다보면 어렵지 않은 문제였다.

문제에서 설명하는 게임 로직을 그대로 구현만 하면 된다.

유의할 점은 하나의 시도에서 인형을 뽑았으면 break문을 통해 다음 시도로 넘어가야 한다는 것이다.

프로그래머스 - 수식 최대화 (2020 카카오 인턴십) / Level 2

0_Hun — Thu, 13 Jan 2022 20:34:42 +0900

문제 : https://programmers.co.kr/learn/courses/30/lessons/67257

코딩테스트 연습 - 수식 최대화

IT 벤처 회사를 운영하고 있는 라이언은 매년 사내 해커톤 대회를 개최하여 우승자에게 상금을 지급하고 있습니다. 이번 대회에서는 우승자에게 지급되는 상금을 이전 대회와는 다르게 다음과

programmers.co.kr

풀이

from itertools import permutations


def solution(expression):
    answer = []
    operators = ["+", "*", "-"]

    cases = list(permutations(operators, 3))  # 3!의 경우의 수.

    for case in cases:
        temp_expression = expression
        for operator in case:  # operator를 하나씩 적용.
            target = ""
            calc_fg = False  # 현재 계산할 operator가 target에 들어올 경우 True
            for i in temp_expression[:]:
                if i in operators and len(target) > 0:  # i가 연산자이고 왼쪽 피연산자가 있으면

                    if calc_fg and target[-1] not in operators:  # 계산할 준비가 됐고, 오른쪽 피연산자가 있으면 계산.
                        temp_expression = temp_expression.replace(target, str(eval(target)))
                        target = str(eval(target))
                        calc_fg = False

                    if i == operator:  # i가 현재 우선순위에 있는 연산자라면 target에 넣어주고 계산 준비 완료 flag on.
                        target += i
                        calc_fg = True
                    elif target[-1] in operators:  # 연산자가 연달아온 경우 -인 unary operator이기 때문에 target에 저장.
                        target += i
                    else:  # 우선순위에 없는 연산자가 오면 target 초기화.
                        target = ""
                else:  # 숫자가 온 경우 target에 추가.
                    target += i

            if calc_fg:  # expression 탐색이 끝날때 계산 준비가 되어 있으면 계산해준다.
                temp_expression = temp_expression.replace(target, str(eval(target)))
        answer.append(abs(int(temp_expression)))

    return max(answer)

연산자 우선순위의 경우의 수가 3! = 6 이므로 당연하게 모든 경우를 탐색하여 최대값을 반환하고자 했다.

연산자 중 우선순위가 높은 거부터 차례대로 계산해주는 방식으로 진행했으며

eval 함수를 통한 계산한 결과값을 replace 함수로 문자열을 부분적으로 대체시켜주었다.

맨처음 짜인 로직 내에서 새로 발견된 예외들을 처리하려고 하다 보니 코드가 조금 지저분해진 것 같다.

그에 따른 추후 해결방안을 생각해봤다.

1. 코드 작성 전 알고리즘을 충분히 설계하고 작성하자.

2. 시험볼 때는 무조건 풀어내야 하니 어쩔 수 없지만 연습할 땐 추후 반드시 리팩토링 진행.

프로그래머스 - 키패드 누르기 ( 2020 카카오 인턴십) / Level 1

0_Hun — Mon, 3 Jan 2022 22:05:40 +0900

문제 : https://programmers.co.kr/learn/courses/30/lessons/67256

코딩테스트 연습 - 키패드 누르기

[1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5] "right" "LRLLLRLLRRL" [7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2] "left" "LRLLRRLLLRR" [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] "right" "LLRLLRLLRL"

programmers.co.kr

풀이

def solution(numbers, hand):
    answer = ''
    
    key_pad = [[1, 2, 3], [4, 5, 6], [7, 8, 9], ['*', 0, '#']]
    left_side = [1, 4, 7]
    right_side = [3, 6, 9]
    center = [2, 5, 8, 0]
    
    left = [3, 0]
    right = [3, 2]
    
    for num in numbers:
        if num in left_side:
            answer += 'L'
            left = [left_side.index(num), 0]
        elif num in right_side:
            answer += 'R'
            right = [right_side.index(num), 2]
        else:
            target = [center.index(num), 1]
            l_distance = abs(target[0]-left[0]) + abs(target[1]-left[1])
            r_distance = abs(target[0]-right[0]) + abs(target[1]-right[1])
            
            if l_distance > r_distance:
                answer += 'R'
                right = target
            elif l_distance < r_distance:
                answer += 'L'
                left = target
            else:
                if hand == "left":
                    answer += 'L'
                    left = target
                else:
                    answer += 'R'
                    right = target
    return answer

코드가 좀 길어졌지만 문제의 조건대로 하나씩 천천히 체크해서 짜면 어렵지 않은 문제였다.

2, 5, 8, 0번 조건을 판단하기 위해서 키패드를 2차원 배열을 통해 엄지 손가락의 현재 좌표를 관리하였다.

이런 문제는 시간복잡도 issue도 없기 때문에 매우 빠르게 풀고 넘어가야 한다.

해당 문제에서는 조금 코드가 복잡해지더라도 확신을 갖고 빠르게 쭉 구현하는 태도가 필요했다.

프로그래머스 - 거리두기 확인하기 (2021 카카오 채용연계 인턴십) / Level 2

0_Hun — Mon, 3 Jan 2022 21:59:10 +0900

문제 : https://programmers.co.kr/learn/courses/30/lessons/81302

코딩테스트 연습 - 거리두기 확인하기

[["POOOP", "OXXOX", "OPXPX", "OOXOX", "POXXP"], ["POOPX", "OXPXP", "PXXXO", "OXXXO", "OOOPP"], ["PXOPX", "OXOXP", "OXPOX", "OXXOP", "PXPOX"], ["OOOXX", "XOOOX", "OOOXX", "OXOOX", "OOOOO"], ["PXPXP", "XPXPX", "PXPXP", "XPXPX", "PXPXP"]] [1, 0, 1, 1, 1]

programmers.co.kr

풀이

def solution(places):
    answer = []
    global dx
    global dy
    global room
    dx = [1, -1, 0, 0]
    dy = [0, 0, 1, -1]
    n = 5
    
    for place in places:
        flag = False
        room = [list(i) for i in place]
        
        for i in range(n):
            for j in range(n):
                if room[i][j] == 'P':
                    if firstSearch(i, j) == 0:
                        flag = True
                        break
            if flag:
                break
        if flag:
            answer.append(0)
        else:
            answer.append(1)
        
    return answer

def firstSearch(x, y):
    for k in range(4):
        nx = x + dx[k]
        ny = y + dy[k]
        
        if 0 <= nx < 5 and 0 <= ny < 5:
            if room[nx][ny] == 'P':
                return 0
            elif room[nx][ny] == 'O':
                if secondSearch(nx, ny, x, y) == 0:
                    return 0

def secondSearch(x, y, start_x, start_y):
    for k in range(4):
        nx = x + dx[k]
        ny = y + dy[k]
        
        if 0 <= nx < 5 and 0 <= ny < 5  and (nx != start_x or ny != start_y):
            if room[nx][ny] == 'P':
                return 0
    return 1

오랜만에 푼 문제라 그런지 어렵진 않았지만 시간이 조금 걸린 문제였다.

전형적인 탐색 문제였지만 DFS, BFS를 사용하여 풀 수 도 있지만 맨해튼 거리가 2 이하에 응시자가 있는지

확인만 하면 되기 때문에 탐색 함수를 2번 호출해주면 된다.

첫번째 탐색할 때와 두 번째 탐색할 때 조건이 조금 다르게 때문에 함수를 따로 만들어 주었으며

탐색 도중 다른 응시자가 나오면 무조건 거리두기를 안 지켰다고 판단하고 break 해주었다.

첫 번째 탐색을 하고 만약 빈 공간이라면 해당 지점에서 두 번째 탐색을 진행하였다.

두 번째 탐색을 진행하고도 다른 응시자가 나오지 않으면 거리두기 지킨 것으로 판단하였다.

ps. 오랜만에 알고리즘 코딩을 해서 그런지 코드가 조금 지저분한 것 같다.

인턴 하느라 시간이 많이 부족하지만 그래도 하루에 하나씩은 푸는 걸 목표로 하고 있다.

프로그래머스 - 신규 아이디 추천 (2021 KAKAO 블라인드 채용) / Level 1

0_Hun — Sun, 12 Dec 2021 17:11:21 +0900

문제 : https://programmers.co.kr/learn/courses/30/lessons/72410

코딩테스트 연습 - 신규 아이디 추천

카카오에 입사한 신입 개발자 네오는 "카카오계정개발팀"에 배치되어, 카카오 서비스에 가입하는 유저들의 아이디를 생성하는 업무를 담당하게 되었습니다. "네오"에게 주어진 첫 업무는 새로

programmers.co.kr

풀이

def solution(new_id):
    target = "0123456789abcdefghijklmnopqrstuvwxyz-_."
    new_id = list(new_id)
    i = 0
    j = 0
    dot_cnt = 0
    
    while i < len(new_id):  # 1, 2단계
        new_id[i] = new_id[i].lower()
        
        if new_id[i] not in target:
            new_id.remove(new_id[i])
            i -= 1
        i += 1
    
    while j < len(new_id):  # 3단계
        
        if new_id[j] == '.':
            dot_cnt += 1
            if dot_cnt > 1:
                new_id.pop(j)
            else:
                j += 1
        else:
            dot_cnt = 0
            j += 1
    
    if len(new_id) != 0 and new_id[0] == '.':  # 4단계
        new_id.pop(0)
    if len(new_id) != 0 and new_id[-1] == '.':
        new_id.pop(-1)
    
    if not new_id:  # 5단계
        new_id.append('a')
    
    if len(new_id) >= 16:  # 6단계
        new_id = new_id[:15]
    if len(new_id) != 0 and new_id[-1] == '.':
        new_id.pop(-1)
    
    if len(new_id) <= 2:  # 7단계
        while len(new_id) < 3:
            new_id.append(new_id[-1])
    
    return "".join(new_id)

각 단계마다 시키는 대로 구현하면 쉬운 문제이다.

다른 사람들의 풀이도 공부해봤는데

정규식을 이용해 구현한 사람도 있었으며

2단계에서 isalpha() 과 isdigit()를 이용하여 더 쉽게 구현한 풀이도 있었다.

이런 쉬운 문제를 풀 때 제일 중요한 건 막힘 없이 빠르게 풀고 넘어가는 것이다.

프로그래머스 - 숫자 문자열과 영단어 (2021 카카오 채용연계 인턴십) / Level 1

0_Hun — Sun, 5 Dec 2021 12:37:42 +0900

문제 : https://programmers.co.kr/learn/courses/30/lessons/81301

코딩테스트 연습 - 숫자 문자열과 영단어

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다. 다음은 숫자의 일부 자

programmers.co.kr

풀이

def solution(s):
    
    nums = [str(i) for i in range(10)]
    en_nums = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
    word = []
    s = list(s)
    i = 0
    
    while True:
        
        if "".join(word) in en_nums:
                s.insert(i, str(en_nums.index("".join(word))))
                word = []
                i += 1
        elif s[i] not in nums:
            word.append(s[i])
            s.remove(s[i])
        else:
            i += 1
        
        if i >= len(s):
            if word:
                s.insert(i, str(en_nums.index("".join(word))))
                break
            else:
                break
    
    return int("".join(s))

쉬운 문제였다. 영어단어로 된 문자열을 해당하는 숫자로 바꿔주는 문제이다.

다만 리스트를 순회하면서 삽입, 삭제를 하기 때문에 index를 세심하게 체크해야 했다.

+ 다른 사람들의 풀이를 보니 replace 함수를 사용하여 더 쉽게 풀 수 있었다.

built-in 함수들을 더 숙달시켜야겠다.

프로그래머스 - 로또의 최고 순위와 최저 순위 (2021 Dev-Matching 웹백엔드) / Level 1

0_Hun — Sat, 4 Dec 2021 15:38:41 +0900

문제 : https://programmers.co.kr/learn/courses/30/lessons/77484

코딩테스트 연습 - 로또의 최고 순위와 최저 순위

로또 6/45(이하 '로또'로 표기)는 1부터 45까지의 숫자 중 6개를 찍어서 맞히는 대표적인 복권입니다. 아래는 로또의 순위를 정하는 방식입니다. 1 순위 당첨 내용 1 6개 번호가 모두 일치 2 5개 번호

programmers.co.kr

풀이

def solution(lottos, win_nums):
    answer = []
    rank = [6, 5, 4, 3, 2, 1]
    match = 0
    unknown = 0
    
    for lotto in lottos:
        if lotto == 0:
            unknown += 1
            continue
        for win_num in win_nums:
            if lotto == win_num:
                match += 1
                break
    if match == 0:
        if unknown == 0:
            answer.append(6)
        else:
            answer.append(rank.index(unknown) + 1)
        
        answer.append(6)
    
    else:
        answer.append(rank.index(match + unknown) + 1)
        answer.append(rank.index(match) + 1)
    
    return answer

level 1의 쉬운 문제였다. 코테에서 첫 번째 문제로 가끔씩 이렇게 쉬운 문제가 나온다.

빠르고 정확하게 풀고 넘어가는 연습을 해야겠다.

매칭 되는 숫자의 수와 0의 개수를 저장하고 그에 따라 순위를 출력해주면 됐다.

순위를 구할땐 if else문을 사용하지 않고 배열의 index를 이용하여 최대한 간단히 구하고자 했다.

그에 따라 0개 맞췄을 때는 따로 처리를 해줘야 했다.