프로그래머스 Study 6주차

신고 결과 받기 - 2022 KAKAO BLIND RECRUITMENT, Level1

def solution(id_list, reports, k):
    answer = [0 for _ in range(len(id_list))]
    reports = list(set(reports)) # 동일한 유저에 대한 신고 횟수는 1회로 처리
    
    # id_index_dic: key= ID 인덱스, value= ID
    id_index_dic = {}
    for index, id_element in enumerate(id_list):
        id_index_dic[id_element] = index
        
    # reported_dic: key= 신고당한 ID, value= 신고한 ID 리스트
    reported_dic = {id_element: [] for id_element in id_list}
    for report in reports:
        reporter, reported = report.split()
        reported_dic[reported].append(reporter)
    
    # k번 이상 신고당한 ID에 대해 신고한 ID 인덱스 +1
    for reported, reporters in reported_dic.items():
        if len(reporters) >= k:
            for reporter in reporters:
                answer[id_index_dic[reporter]] += 1            
    
    return answer

1. 동일한 유저에 대한 신고 횟수는 1회로 처리해야 하므로 set을 이용해 중복 제거

2. 정답 형식을 맞추기 위한 key = ID 인덱스, value = ID인 딕셔너리 생성

3. key = 신고당한 ID, value = 신고한 ID 리스트인 딕셔너리 생성

4. k번 이상 신고당한 ID를 계산하고 정답 형식을 맞추어 반환

 

k진수에서 소수 개수 구하기 - 2022 KAKAO BLIND RECRUITMENT, Level2

from math import sqrt

'''
@param:     n: 변환될 숫자 (10진수)
            k: 변환할 진수
@return:    변환된 숫자 문자열 (k진수)
@descript:  진수 변환 함수
'''
def convert_decimal_number(n, k):
    k_number = ''
    while n >= 1:
        rest = n % k
        k_number = (str(rest) + k_number)
        n = n // k
    return k_number
    

'''
@param:     number: 입력 숫자
@return:    소수인지 boolean
'''
def is_prime_number(number):
    if number == 1:
        return False
    for i in range(2, int(sqrt(number)) + 1):
        if number % i == 0:
            return False
    return True


def solution(n, k):
    answer = 0
    k_number = convert_decimal_number(n, k)
    p_list = k_number.split('0')

    for p in p_list:
        if p != '' and is_prime_number(int(p)):
            answer += 1
    
    return answer

1. 10진수 숫자를 k진수 문자열로 전환

2. k진수 문자열을 '0'에 대해 구분하여 숫자 리스트 생성

3. 구분지어진 숫자 리스트를 순환하며 소수인지 판단 → 소수라면 정답 ++

 

주차 요금 계산 - 2022 KAKAO BLIND RECRUITMENT, Level2

def solution(fees, records):
    answer = []
    base_time, base_price, unit_time, unit_price = fees
    
    # car_time_dic: key= 차량번호, value= 주차시간
    car_time_dic = {}
    cars = []
    
    for record in records:
        time, car_number, in_out = record.split()
        hour, minute = map(int, time.split(':'))
        
        if in_out == 'IN':
            # car_time_dic 업데이트
            if car_number not in car_time_dic:
                car_time_dic[car_number] = 23 * 60 + 59 - (hour * 60 + minute)
                cars.append(car_number)
            else:
                car_time_dic[car_number] += 23 * 60 + 59 - (hour * 60 + minute)
        elif in_out == 'OUT':
            car_time_dic[car_number] += (hour * 60 + minute - (23 * 60 + 59))
    
    answer = [0 for _ in range(len(cars))]
    # car_price: key= car, value= price
    car_price = {}
    for car, time in car_time_dic.items():
        # 주차비 계산
        price = base_price
        if time > base_time:
            if (time - base_time) % unit_time == 0:
                price += ((time - base_time) // unit_time) * unit_price
            else:
                price += (((time - base_time) // unit_time) + 1) * unit_price
        car_price[car] = price
    
    cars.sort()
    for index, car in enumerate(cars):
        answer[index] = car_price[car]
    
    return answer

1. key = 차량번호, value = 주차 시간인 딕셔너리 생성

2. 차가 들어왔다면

    2.1) 처음으로 들어온 경우 23시 59분에서 현재 시간을 빼줌

    2.2) 처음으로 들어온 경우 23시 59분에서 현재 시간을 빼준 값을 더해줌

3. 차가 나갔다면 현재 시간에서 23시 59분을 뺀 값을 더해줌

4. 주차 시간을 통해 주차비를 계산

5. 각 차에 대한 주차비를 정답 형식을 맞추어 반환

 

양궁대회 - 2022 KAKAO BLIND RECRUITMENT, Level2

from collections import deque

def solution(n, info):
    answer = []
    
    q = deque([[]])
    ryan_scores = [] # 라이언이 맞힌 과녁 점수의 개수 리스트
    while q:
        ryan_score = q.popleft()
        if len(ryan_score) <= 10:
            # 1. 같은 점수에 대해 + 1로 이긴 상황
            ryan_score_1 = ryan_score + [info[len(ryan_score)] + 1]
            if sum(ryan_score_1) <= n:
                q.append(ryan_score_1)            
            # 2. 같은 점수에 대해 0발을 쏴서 지는 상황
            ryan_score_2 = ryan_score + [0]
            q.append(ryan_score_2)
            # 3. 남은 화살을 다 써야하는 상황
            if len(ryan_score) == 10:
                ryan_score_3 = ryan_score + [n - sum(ryan_score)]
                q.append(ryan_score_3)
        
        # 모든 과녁 점수에 총 n발을 쏜 경우
        elif len(ryan_score) == 11 and sum(ryan_score) == n:
            ryan_scores.append(ryan_score)
        
    score_difference = -987654321
    for ryan_score in ryan_scores:
        
        # 라이언, 어피치 점수 차이 계산
        temp_score_difference = 0
        for i in range(11):
            if ryan_score[i] == 0 and info[i] == 0:
                pass
            elif ryan_score[i] > info[i]:
                temp_score_difference += (10 - i)
            elif ryan_score[i] <= info[i]:
                temp_score_difference -= (10 - i)
        
        # 점수 차이가 가장 큰 경우 → 정답 = 라이언이 맞힌 과녁 점수의 개수
        if score_difference < temp_score_difference and 0 < temp_score_difference:
            score_difference = temp_score_difference
            answer = ryan_score
        
        # 점수 차이가 같은 경우 → 정답 = 가장 낮은 점수를 더 많이 맞힌 경우
        elif score_difference == temp_score_difference:
            for i in range(10, -1, -1):
                if answer[i] < ryan_score[i]:
                    answer = ryan_score
                    break
                elif answer[i] > ryan_score[i]:
                    break
            
    if score_difference < 0:
        answer = [-1]
    
    return answer

1. 라이언은 1점차로 이기거나 0점으로 져야  → 점수 차이 최대

2. 1과 같은 로직으로 모든 과녁 점수에 n발을 쏘는 라이언의 경우들 저장

3. 라이언과 어피치 점수 차이를 계산

    3.1) 점수 차이가 큰 경우 → 정답으로 저장

    3.2) 점수 차이가 같은 경우 가장 낮은 점수를 더 맞힌 경우 → 정답으로 저장

 

양과 늑대 - 2022 KAKAO BLIND RECRUITMENT, Level3

from collections import deque

def solution(info, edges):
    answer = 0
    
    q = deque([[[0], 1, 1]]) # [방문한 노드 리스트, 양과 늑대의 차이, 양]
    while q:
        nodes, diff_count, sheep = q.popleft()
        if answer < sheep:
            answer = sheep
        for node in nodes:
            for start, end in edges:
                if start == node and end not in nodes:
                    if info[end] == 0: # 1. 양인 경우
                        q.append([nodes + [end], diff_count + 1, sheep + 1])
                    elif info[end] == 1 and diff_count > 1: # 2. 늑대인 경우
                        q.append([nodes + [end], diff_count - 1, sheep])
                
                elif end == node and start not in nodes:
                    if info[start] == 0: # 1. 양인 경우
                        q.append([nodes + [start], diff_count + 1, sheep + 1])
                    elif info[start] == 1 and diff_count > 1: # 2. 늑대인 경우
                        q.append([nodes + [start], diff_count - 1, sheep])
        
    return answer

1. 양은 무조건 늑대보다 많도록 트리 순회

    1.1) 트리를 순회할 때 방문한 노드 리스트, 양과 늑대의 차이, 양의 수를 모두 기록

2. 양의 수가 가장 많은 경우  → 정답