🥶 총평

• 문제 난이도가 어렵지는 않았다.
• 다만 시뮬레이션이 많아 읽고 푸는데 많은 시간이 소요되었다.
• 총 6문제를 3시간 안에 풀어야했던 만큼 시간 압박이 심했다.
• 테스트 케이스 기준 6 문제 중 5문제를 풀었다.
• 마지막 문제는 블랙잭 규칙에 관한 것이었는데, 예외와 요구 사항이 많아 시간이 부족했다.

⭐ 부정행위 관련 안내

• 역시나 내 코드를 올리는 것은 상관이 없을 것 같아 아래 올린다

🤞 후기 인증용 정답

1번 문제 풀이

def solution(boxes):
    count = 0
    data = set()
    for box in boxes:
        a, b = box
        if a in data:
            count += 1
            data.remove(a)
        else:
            data.add(a)
        if b in data:
            count += 1
            data.remove(b)
        else:
            data.add(b)
    return len(boxes) - count

2번 문제 풀이

def solution(ball, order):
    answer = []
    queue = [-1, -1]
    for number in order:
        if ball[0] == number:
            answer.append(ball.pop(0))

            while ball:
                for index in range(-1, -len(queue) + 1, -1):
                    if queue[index] == ball[0]:
                        answer.append(ball.pop(0))
                        queue.pop(index)
                        break
                else:
                    break

        elif ball[-1] == number:
            answer.append(ball.pop(-1))

            while ball:
                for index in range(-1, -len(queue) + 1, -1):
                    if queue[index] == ball[-1]:
                        answer.append(ball.pop(-1))
                        queue.pop(index)
                        break
                else:
                    break

        else:
            queue.insert(2, number)

    return answer

3번 문제 풀이

answer_count = float('inf')
answer_number = -1


def bfs(current, count):
    global answer_count, answer_number
    if len(current) > 2:
        length = len(current)
        mid = length // 2
        if length % 2:
            # 홀수니까 양쪽으로 쪼개야 함. 0인 경우에는 양쪽 탐색

            if current[mid] != "0":
                bfs(str(int(current[:mid]) + int(current[mid:])), count+1)
            else:
                for index in range(mid+1, len(current)):
                    if current[index] != "0":
                        bfs(str(int(current[:index]) + int(current[index:])), count + 1)
                else:
                    bfs(current[:-1], count + 1)

            mid += 1
            if current[mid] != "0":
                bfs(str(int(current[:mid]) + int(current[mid:])), count+1)
            else:
                for index in range(mid+1, len(current)):
                    if current[index] != "0":
                        bfs(str(int(current[:index]) + int(current[index:])), count + 1)
                else:
                    bfs(current[:-1], count + 1)

        else:
            # 짝수니까 정 중앙에서 쪼개야 함. 0인 경우에는 양쪽 탐색
            if current[mid] != "0":
                bfs(str(int(current[:mid]) + int(current[mid:])), count+1)
            else:
                for index in range(mid+1, len(current)):
                    if current[index] != "0":
                        bfs(str(int(current[:index]) + int(current[index:])), count + 1)
                else:
                    bfs(current[:-1], count + 1)

    elif len(current) == 2:
        bfs(str(int(current[0]) + int(current[1])), count + 1)
    else:
        if count < answer_count:
            answer_count = count
            answer_number = current


def solution(n):
    global answer_count, answer_number
    string_number = str(n)
    bfs(string_number, 0)
    return [answer_count, int(answer_number)]

4번 문제 풀이

rotation = {
    "up": ["left", "up", "right", "down"],
    "left": ["down", "left", "up", "right"],
    "down": ["right", "down", "left", "up"],
    "right": ["up", "right", "down", "left"]
}

direction = {
    "up": [0, -1],
    "left": [-1, 0],
    "down": [0, 1],
    "right": [1, 0]
}


def solution(maze):
    global rotation, direction
    size = len(maze)
    answer = 0
    coord = [0, 0, "right"]
    while True:
        x, y, arrow = coord
        for rot in rotation[arrow]:
            dx, dy = direction[rot]
            new_x, new_y = x + dx, y + dy
            if 0 <= new_x < size and 0 <= new_y < size and not maze[new_y][new_x]:
                coord = [new_x, new_y, rot]
                answer += 1
                break
        if coord[0] == size - 1 and coord[1] == size - 1:
            break
    return answer

5번 문제 풀이: 못 풀어서 안 올림

6번 문제 풀이:

def solution(companies, applicants):

    answer = []

    company_state = {}
    applicant_status = []

    data_companies = {}
    for company in companies:
        name, hope, count = company.split()
        data_companies[name] = [list(hope), int(count)]
        company_state[name] = []

    data_applicants = {}
    for applicant in applicants:
        name, hope, count = applicant.split()
        data_applicants[name] = list(hope[:int(count)])
        applicant_status.append(name)

    while applicant_status:

        # 지원자 1순위 기업에 지원하기
        for applicant in applicant_status:
            if data_applicants.get(applicant):
                hope = data_applicants[applicant].pop(0)
                if not data_applicants[applicant]:
                    del data_applicants[applicant]
                company_state[hope].append(applicant)

        applicant_status = []

        # 기업이 우선 순위에 맞춰 짜르기
        for company in company_state:
            if len(company_state[company]) > data_companies[company][1]:
                # 우선순위에 맞춰 자르자
                limit = data_companies[company][1]
                failed_list = set(company_state[company])
                passed_list = set()
                for hope in data_companies[company][0]:
                    if hope in failed_list:
                        passed_list.add(hope)
                        limit -= 1
                        if limit == 0:
                            break
                for passed in passed_list:
                    failed_list.remove(passed)
                company_state[company] = list(passed_list)
                applicant_status += list(failed_list)

        # 잔여자 외는 전부 지우기
        new_applicant_status = []
        for applicant in applicant_status:
            new_applicant_status.append(applicant)
        applicant_status = new_applicant_status

    for company in company_state:
        passed = "".join(sorted(company_state[company]))
        answer.append(company+"_"+passed)

    return answer