끼룽의 블로그

# 프로그래머스 '다리를 지나는 트럭'
# https://programmers.co.kr/learn/courses/30/lessons/42583

from collections import deque

def solution(bridge_length, weight, truck_weights):
    time = 0

    i = 0
    w = 0
    que = deque([0 for _ in range(bridge_length)])

    while True:
        if i == len(truck_weights):
            time += bridge_length
            break
        
        w -= que.popleft()

        if w + truck_weights[i] <= weight:
            w += truck_weights[i]
            que.append(truck_weights[i])
            i += 1
        
        else:
            que.append(0)
        
        time += 1

    return time


if __name__=='__main__':
    test_cases = [
        {
            'bridge_length': 2,
            'weight': 10,
            'truck_weights': [7,4,5,6],
            'answer': 8
        }
    ]

    for test_case in test_cases:
        bridge_length = test_case['bridge_length']
        weight = test_case['weight']
        truck_weights = test_case['truck_weights']
        answer = test_case['answer']
        my_answer = solution(bridge_length, weight, truck_weights)

        print('answer: {}, my_answer: {}'.format(answer, my_answer))

# 프로그래머스 '주식 가격'
# https://programmers.co.kr/learn/courses/30/lessons/42584

class Stock:
    def __init__(self, price, time):
        self.price = price
        self.time = time

def solution(prices):

    answer = [0 for _ in range(len(prices))]

    stack = []

    time = 0

    while time < len(prices):
        if len(stack) == 0:
            stack.append(Stock(prices[time], time))
            time += 1
            continue

        price = prices[time]
        top = stack[-1]

        if top.price > price:
            answer[top.time] = time - top.time
            stack.pop()
            continue
        
        stack.append(Stock(price, time))
        time += 1

    time -= 1

    while len(stack):
        pop = stack.pop()
        answer[pop.time] = time - pop.time

    return answer


if __name__=='__main__':
    prices = [1, 2, 3, 2, 3]
    answer = [4, 3, 1, 1, 0]
    my_answer = solution(prices)

    print('answer: {}, my_answer: {}'.format(answer, my_answer))

# 프로그래머스 '프린터'
# https://programmers.co.kr/learn/courses/30/lessons/42587

from collections import deque

class Print:
    def __init__(self, idx, priority):
        self.idx = idx
        self.priority = priority


def solution(priorities, location):
    print_que = deque([])
    priority_que = deque([])
    cnt_list = [0 for _ in range(10)]

    for idx, priority in enumerate(priorities):
        print_que.append(Print(idx, priority))
        cnt_list[priority] += 1
    
    for priority in range(9, 0, -1):
        while cnt_list[priority]:
            priority_que.append(priority)
            cnt_list[priority] -= 1
    
    answer = 0
    while True:
        print: Print = print_que.popleft()
        if print.priority == priority_que[0]:
            answer += 1
            priority_que.popleft()
            if print.idx == location:
                break
        else:
            print_que.append(print)

    return answer

# 프로그래머스 '기능개발'
# https://programmers.co.kr/learn/courses/30/lessons/42586

from collections import deque
import math

def solution(progresses, speeds):

    p_que = deque(progresses)
    s_que = deque(speeds)

    
    time = 0
    answer = []

    while len(p_que):
        time = math.ceil((100 - p_que[0]) / s_que[0])
        
        cnt = 0
        while len(p_que)  and  100 - p_que[0] <= s_que[0] * time:
            p_que.popleft()
            s_que.popleft()
            cnt += 1
        
        answer.append(cnt)
    return answer


if __name__=='__main__':
    
    test_cases = [
        {
            'progresses': [93, 30, 55],
            'speeds': [1, 30, 5],
            'answer': [2, 1] 
        },
        {
            'progresses': [95, 90, 99, 99, 80, 99],
            'speeds': [1, 1, 1, 1, 1, 1],
            'answer': [1, 3, 2]
        }
    ]
    
    for test_case in test_cases:
        progresses = test_case['progresses']
        speeds = test_case['speeds']
        answer = test_case['answer']
        my_answer = solution(progresses, speeds)

        print(f'answer: {answer}, my_answer: {my_answer}')

# 프로그래머스 문제 '전화번호 목록'
# https://programmers.co.kr/learn/courses/30/lessons/42577

def solution(phone_book: list):
    book_dict = {}

    for phone_num in phone_book:
        book_dict[phone_num] = 1
    
    for phone_num in phone_book:
        for i in range(1, len(phone_num)):
            compare_num = phone_num[:i]
            if book_dict.get(compare_num):
                return False
    
    return True


if __name__=='__main__':

    test_cases = [
        {
            'phone_book': ["119", "97674223", "1195524421"],
            'answer': False 
        },
        {
            'phone_book': ["123","456","789"],
            'answer': True
        },
        {
            'phone_book': ["12","123","1235","567","88"],
            'answer': False
        }
    ]
    
    for test_case in test_cases:
        phone_book = test_case['phone_book']
        answer = test_case['answer']
        my_answer = solution(phone_book)

        print(f'answer: {answer}, my_answer: {my_answer}')

# 프로그래머스 문제 '완주하지 못한 선수'
# https://programmers.co.kr/learn/courses/30/lessons/42576

def solution(participant, completion):
    p_dict = dict()

    for player in participant:
        p_dict[player] = p_dict.get(player, 0) + 1

    for player in completion:
        p_dict[player] = p_dict[player] - 1

        if p_dict[player] == 0:
            del p_dict[player]

    answer = p_dict.popitem()[0]
    return answer


if __name__=='__main__':

    test_cases = [
        {
            'participant': ["leo", "kiki", "eden"],
            'completion': ["eden", "kiki"],
            'answer': "leo"
        },
        {
            'participant': ["marina", "josipa", "nikola", "vinko", "filipa"],
            'completion': ["josipa", "filipa", "marina", "nikola"],
            'answer': "vinko"
        },
        {
            'participant': ["mislav", "stanko", "mislav", "ana"],
            'completion': ["stanko", "ana", "mislav"],
            'answer': "mislav"
        }
    ]

    for test_case in test_cases:
        participant = test_case['participant']
        completion = test_case['completion']
        answer = test_case['answer']
        my_answer = solution(participant, completion)
        print(f'answer: {answer}, my_answer: {my_answer}')

# 프로그래머스 문제 '위장'
# https://programmers.co.kr/learn/courses/30/lessons/42578

def solution(clothes):

    cloth_dict = dict()

    for name, kind in clothes:
        cloth_dict[kind] = cloth_dict.get(kind, 0) + 1
    
    answer = 1
    for cloth_len in cloth_dict.values():
        answer *= (cloth_len + 1)

    return answer - 1


if __name__=='__main__':

    test_cases = [
        {
            'clothes': [["yellowhat", "headgear"], ["bluesunglasses", "eyewear"], ["green_turban", "headgear"]],
            'answer': 5 
        },
        {
            'clothes': [["crowmask", "face"], ["bluesunglasses", "face"], ["smoky_makeup", "face"]],
            'answer': 3
        }
    ]
    
    for test_case in test_cases:
        clothes = test_case['clothes']
        answer = test_case['answer']
        my_answer = solution(clothes)

        print(f'answer: {answer}, my_answer: {my_answer}')

# 프로그래머스 문제 '베스트앨범'
# https://programmers.co.kr/learn/courses/30/lessons/42579

class Song:

    def __init__(self, song_num, genre, play):
        self.song_num = song_num
        self.genre = genre
        self.play = play
    

def solution(genres, plays):
    genre_dict = {}
    genre_list = []

    for song_num, genre, play in zip(range(len(genres)), genres, plays):
        song = Song(song_num, genre, play)

        if not genre_dict.get(genre):
            genre_list.append(genre)
            genre_dict[genre] = {'total_plays': 0, 'song_list': []}
        
        genre_dict[genre]['total_plays'] += play
        genre_dict[genre]['song_list'].append(song)

    genre_list.sort(reverse=True, key=lambda genre: genre_dict[genre]['total_plays'])

    best_album = []
    for genre in genre_list:
        song_list = genre_dict[genre]['song_list']
        song_list.sort(reverse=True, key=lambda song: (song.play, -song.song_num))
        best_songs = song_list[:2]
        for song in best_songs:
            best_album.append(song.song_num)
    
    return best_album



def solution2(genres, plays):
    genre_dict = {}
    genre_list = []

    for song_num, genre, play in zip(range(len(genres)), genres, plays):
        song = Song(song_num, genre, play)

        if not genre_dict.get(genre):
            genre_dict[genre] = {'total_plays': 0, 'best_songs': [Song(-1, genre, -1), Song(-1, genre, -1)]}
            genre_list.append(genre)

        genre_dict[genre]['total_plays'] += play

        best_songs = genre_dict[genre]['best_songs']
        if best_songs[0].play < play:
            best_songs[1] = best_songs[0]
            best_songs[0] = song
            continue

        if best_songs[0].play == play:
            if best_songs[0].song_num > song_num:
                best_songs[1] = best_songs[0]
                best_songs[0] = song
                continue
        
        if best_songs[1].play < play:
            best_songs[1] = song
            continue
        
        if best_songs[1].play == play:
            if best_songs[1].song_num > song_num:
                best_songs[1] = song

    genre_list.sort(reverse=True, key=lambda genre: genre_dict[genre]['total_plays'])

    best_album = []

    for genre in genre_list:
        best_songs = genre_dict[genre]['best_songs']
        for song in best_songs:
            if song.play >= 0:
                best_album.append(song.song_num)

    return best_album


if __name__=='__main__':

    genres = ["classic", "pop", "classic", "classic", "pop"]
    plays = [500, 600, 150, 800, 2500]
    answer = [4, 1, 3, 0]
    my_answer = solution(genres, plays)

    print(f'answer: {answer}, my_answer: {my_answer}')