데린이 고인물되기

[프로젝트] LGAimers 7기 본선 후기

데린이 성장 중 — Wed, 17 Sep 2025 00:48:09 +0900

눈물의 본선

[TIL] 250916 - 파이썬 반올림 / 올림 / 내림 / 버림

데린이 성장 중 — Wed, 17 Sep 2025 00:28:20 +0900

1. 반올림 (round)

round(x) : 가장 가까운 정수로 반올림
import math를 사용하지 않음

print(round(3.5))  # 4
print(round(2.5))  # 2 (주의!)
print(round(2.675, 2))  # 2.67 (부동소수점 특성)

주의
- 파이썬의 round는 "Banker's Rounding" (또는 Round half to even) 규칙을 사용
  - 딱 .5로 끝나는 경우, 가까운 짝수 정수 쪽으로 반올림함. 그래서 :

print(round(1.5))  # 2 (짝수로 감)
print(round(2.5))  # 2 (짝수로 감)
print(round(3.5))  # 4 (짝수로 감)

2. 올림 (math.ceil)

항상 큰 정수로 올림

import math
print(math.ceil(2.1))  # 3
print(math.ceil(-2.1)) # -2

3. 내림 (math.floor)

항상 작은 정수로 내림

import math
print(math.floor(2.9))  # 2
print(math.floor(-2.9)) # -3

4. 버림 (math.trunc)

소수점 버리고 0 쪽으로 가까워짐

import math
print(math.trunc(2.9))   # 2
print(math.trunc(-2.9))  # -2

나는 주로 그냥 int(2.9) 로 처리해버리긴 한다

[TIL] 250916 - 파이썬 datetime 사용법

데린이 성장 중 — Wed, 17 Sep 2025 00:22:30 +0900

"05:34"와 "04:56"의 시간 차이를 분 단위로 구하는 방법

from datetime import datetime

t1, t2 = "05:34", "04:56"
fmt = "%H:%M"

dt1 = datetime.strptime(t1, fmt)
dt2 = datetime.strptime(t2, fmt)

diff_minutes = abs((dt1 - dt2).seconds // 60)
print(diff_minutes)  # 38

코테에서 더 유용한 단순 계산 (더 빠르다)

h1, m1 = map(int, t1.split(":"))
h2, m2 = map(int, t2.split(":"))

minutes1 = h1 * 60 + m1
minutes2 = h2 * 60 + m2

print(abs(minutes1 - minutes2))  # 38

⚠️이 방법을 사용할 경우 주의점 : 하루를 넘어가는 경우(`23:50` vs `00:20`)까지 고려하려면 추가적인 사고가 필요하다.
- 예를 들어 "23:50" 과 "00:20" 의 차이를 분으로 구하는 경우
  - 그냥 단순히 분으로 바꾸면:
    - "23:50" → 23*60 + 50 = 1430
    - "00:20" → 0*60 + 20 = 20
    - 차이 = 1430 - 20 = 1410분
  - 하지만, 실제로는 30분 차이 (23:50에서 다음날 00:20까지 30분)
- 해결법
  - 하루는 24*60 = 1440분.
  - 따라서 단순 차이를 1440으로 나눈 나머지로 바꿔주면, 하루를 넘어가는 경우에도 제대로 계산됨

h1, m1 = map(int, "23:50".split(":"))
h2, m2 = map(int, "00:20".split(":"))

minutes1 = h1 * 60 + m1  # 1430
minutes2 = h2 * 60 + m2  # 20

# 하루(1440분)로 나머지를 구함
diff = (minutes2 - minutes1) % (24*60)
print(diff)  # 30

결론 : 머리아프니까 datetime 으로 하자 그냥

[TIL] 250916 - defaultdict에 원소가 있는 리스트를 디폴트로 넣는 방법

데린이 성장 중 — Wed, 17 Sep 2025 00:15:42 +0900

defaultdict는 함수(callable)를 인자로 받아야 함.
리스트를 그대로 넣으면 모든 키가 같은 리스트 객체를 공유하게 되므로 위험.
예를들어, 각 키마다 독립적인 [9,9,9] 리스트가 필요하다면 lambda로 감싸야 함:

from collections import defaultdict

d = defaultdict(lambda: [9, 9, 9])
print(d['a'])  # [9, 9, 9]
print(d['b'])  # [9, 9, 9] (서로 다른 객체)

[TIL] 250916 프로그래머스 - 주차요금계산

데린이 성장 중 — Tue, 16 Sep 2025 23:38:54 +0900

문제 설명

문제 설명

주차장의 요금표와 차량이 들어오고(입차) 나간(출차) 기록이 주어졌을 때, 차량별로 주차 요금을 계산하려고 합니다. 아래는 하나의 예시를 나타냅니다.

요금표

기본 시간(분)	기본 요금(원)	단위 시간(분)	단위 요금(원)
180	5000	10	600

입/출차 기록

시각(시:분)	차량 번호	내역
05:34	5961	입차
06:00	0000	입차
06:34	0000	출차
07:59	5961	출차
07:59	0148	입차
18:59	0000	입차
19:09	0148	출차
22:59	5961	입차
23:00	5961	출차

자동차별 주차 요금

차량 번호	누적 주차 시간(분)	주차 요금(원)
0000	34 + 300 = 334	5000 + ⌈(334 - 180) / 10⌉ x 600 = 14600
0148	670	5000 +⌈(670 - 180) / 10⌉x 600 = 34400
5961	145 + 1 = 146	5000

어떤 차량이 입차된 후에 출차된 내역이 없다면, 23:59에 출차된 것으로 간주합니다.
- 0000번 차량은 18:59에 입차된 이후, 출차된 내역이 없습니다. 따라서, 23:59에 출차된 것으로 간주합니다.
00:00부터 23:59까지의 입/출차 내역을 바탕으로 차량별 누적 주차 시간을 계산하여 요금을 일괄로 정산합니다.
누적 주차 시간이 기본 시간이하라면, 기본 요금을 청구합니다.
누적 주차 시간이 기본 시간을 초과하면, 기본 요금에 더해서, 초과한 시간에 대해서 단위 시간 마다 단위 요금을 청구합니다.
- 초과한 시간이 단위 시간으로 나누어 떨어지지 않으면, 올림합니다.
- ⌈a⌉ : a보다 작지 않은 최소의 정수를 의미합니다. 즉, 올림을 의미합니다.

주차 요금을 나타내는 정수 배열 fees, 자동차의 입/출차 내역을 나타내는 문자열 배열 records가 매개변수로 주어집니다. 차량 번호가 작은 자동차부터 청구할 주차 요금을 차례대로 정수 배열에 담아서 return 하도록 solution 함수를 완성해주세요.

제한사항

fees의 길이 = 4
- fees[0] = 기본 시간(분)
- 1 ≤ fees[0] ≤ 1,439
- fees[1] = 기본 요금(원)
- 0 ≤ fees[1] ≤ 100,000
- fees[2] = 단위 시간(분)
- 1 ≤ fees[2] ≤ 1,439
- fees[3] = 단위 요금(원)
- 1 ≤ fees[3] ≤ 10,000
1 ≤ records의 길이 ≤ 1,000
- records의 각 원소는 "시각 차량번호 내역" 형식의 문자열입니다.
- 시각, 차량번호, 내역은 하나의 공백으로 구분되어 있습니다.
- 시각은 차량이 입차되거나 출차된 시각을 나타내며, HH:MM 형식의 길이 5인 문자열입니다.
  - HH:MM은 00:00부터 23:59까지 주어집니다.
  - 잘못된 시각("25:22", "09:65" 등)은 입력으로 주어지지 않습니다.
- 차량번호는 자동차를 구분하기 위한, `0'~'9'로 구성된 길이 4인 문자열입니다.
- 내역은 길이 2 또는 3인 문자열로, IN 또는 OUT입니다. IN은 입차를, OUT은 출차를 의미합니다.
- records의 원소들은 시각을 기준으로 오름차순으로 정렬되어 주어집니다.
- records는 하루 동안의 입/출차된 기록만 담고 있으며, 입차된 차량이 다음날 출차되는 경우는 입력으로 주어지지 않습니다.
- 같은 시각에, 같은 차량번호의 내역이 2번 이상 나타내지 않습니다.
- 마지막 시각(23:59)에 입차되는 경우는 입력으로 주어지지 않습니다.
- 아래의 예를 포함하여, 잘못된 입력은 주어지지 않습니다.
  - 주차장에 없는 차량이 출차되는 경우
  - 주차장에 이미 있는 차량(차량번호가 같은 차량)이 다시 입차되는 경우

입출력 예

fees	records	result
[180, 5000, 10, 600]	["05:34 5961 IN", "06:00 0000 IN", "06:34 0000 OUT", "07:59 5961 OUT", "07:59 0148 IN", "18:59 0000 IN", "19:09 0148 OUT", "22:59 5961 IN", "23:00 5961 OUT"]	[14600, 34400, 5000]
[120, 0, 60, 591]	["16:00 3961 IN","16:00 0202 IN","18:00 3961 OUT","18:00 0202 OUT","23:58 3961 IN"]	[0, 591]
[1, 461, 1, 10]	["00:00 1234 IN"]	[14841]

입출력 예 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

요금표

기본 시간(분)	기본 요금(원)	단위 시간(분)	단위 요금(원)
120	0	60	591

입/출차 기록

시각(시:분)	차량 번호	내역
16:00	3961	입차
16:00	0202	입차
18:00	3961	출차
18:00	0202	출차
23:58	3961	입차

자동차별 주차 요금

차량 번호	누적 주차 시간(분)	주차 요금(원)
0202	120	0
3961	120 + 1 = 121	0 +⌈(121 - 120) / 60⌉x 591 = 591

3961번 차량은 2번째 입차된 후에는 출차된 내역이 없으므로, 23:59에 출차되었다고 간주합니다.

입출력 예 #3

요금표

기본 시간(분)	기본 요금(원)	단위 시간(분)	단위 요금(원)
1	461	1	10

입/출차 기록

시각(시:분)	차량 번호	내역
00:00	1234	입차

자동차별 주차 요금

차량 번호	누적 주차 시간(분)	주차 요금(원)
1234	1439	461 +⌈(1439 - 1) / 1⌉x 10 = 14841

1234번 차량은 출차 내역이 없으므로, 23:59에 출차되었다고 간주합니다.

제한시간 안내

정확성 테스트 : 10초

def money(fees, minute):
    # 분이 들어오면 요금 계산
    # 기본시간 이하면 기본 요금 청구
    # 기본 시간 초과하면 기본요금 + 초과시간에 대해  단위 시간마다 단위 요금 청구
    if minute <= fees[0]:
        return fees[1]
    
    import math
    extra = math.ceil((minute - fees[0])/fees[2])*fees[3]
    return fees[1] + extra
    
def solution(fees, records):
    return_answer = []
    # 입차하고 출차한적없으면 23:59에 나간걸로
    # 기본시간 이하면 기본 요금 청구
    # 기본 시간 초과하면 기본요금 + 초과시간에 대해  단위 시간마다 단위 요금 청구
    
    # 딕셔너리 만들어서 key를 차 번호 value를 시간으로 주면 될듯
    # value 를 list로 만들고 [머무른 시간, 마지막에 in 또는 out 한 시각, 등장 횟수]
    # 이렇게  만들고 딕셔너리 완성되면
    # value 에 list에 등장 횟수를 보고 그게 홀수면 -> 아직 out를 안한 차니까 (23:59 - 마지막에 in 또는 out 한 시각 ) 해서
    # 머무른 시간에 더해줘야함
    # value 에 list에 등장 횟수를 보고 그게 짝수면 out한거니까 신경 쓰지 않아도 됨
    # 머무른 시간 업뎃 칠 때는  마지막에 in 또는 out 한 시각 이거 보고 계산해서 업뎃 치면 되고
    from collections import defaultdict
    from datetime import datetime
    answer = defaultdict(lambda: [0,0,0]) #[머무른 시간, 마지막에 in 또는 out 한 시각, 마지막이 in인지 out인지]
    car = set() # 차 번호 저장
    for record in records:
        time = record.split(' ')[0]
        car_num = record.split(' ')[1]
        inorout = record.split(' ')[2]
        
        car.add(int(car_num))
        
        answer[car_num][2] = inorout
        
        if answer[car_num][2] == 'IN': # 처음 등장한 차
            answer[car_num][1] = time
        
        else: # 나가는 차인경우
            prevtime = answer[car_num][1]
            fmt = "%H:%M"
            staymin = datetime.strptime(time,fmt) - datetime.strptime(prevtime,fmt) # 머무른 시간
            
            # 몇시간 몇분 이렇게 나오는걸 초로 바꿔서 60으로 나눠서 분 단위로 뽑아주기
            answer[car_num][0] += staymin.seconds//60 
        
    for check in answer.values():# 마지막 기록이 in인 차는 23:59에 빼야함
        if check[2] == "IN":
            fmt = '%H:%M'
            staymin = datetime.strptime('23:59',fmt) - datetime.strptime(check[1],fmt)
            check[0] += staymin.seconds//60
            
    car = list(car)
    car.sort()
    for c in car: # 정렬된 차번호
        c = str(c)
        c = (4 - len(c))*'0' + c
        return_answer.append(money(fees,answer[c][0]))
    return return_answer

크게 어렵지도 않았지만, 익숙하지 않은 코드가 있어서 ⬇️ 시간이 걸렸다. 거의 한시간은 쓴듯?
그래도 한 번에 정답을 맞추긴 함
어떻게 풀고 구현할지도 한 번에 떠올리긴 했는데 시간이 좀 많이 걸렸다
정답률 60%의 문제. 어렵지는 않아서 정답률이 좀 더 낮은 문제로 넘어가야 할 것 같다.

익숙해져야할 내용

[TIL] 250916 - 프로그래머스 뉴스 클러스터링

데린이 성장 중 — Tue, 16 Sep 2025 00:24:28 +0900

문제 설명

뉴스 클러스터링

여러 언론사에서 쏟아지는 뉴스, 특히 속보성 뉴스를 보면 비슷비슷한 제목의 기사가 많아 정작 필요한 기사를 찾기가 어렵다. Daum 뉴스의 개발 업무를 맡게 된 신입사원 튜브는 사용자들이 편리하게 다양한 뉴스를 찾아볼 수 있도록 문제점을 개선하는 업무를 맡게 되었다.

개발의 방향을 잡기 위해 튜브는 우선 최근 화제가 되고 있는 "카카오 신입 개발자 공채" 관련 기사를 검색해보았다.

카카오 첫 공채..'블라인드' 방식 채용
카카오, 합병 후 첫 공채.. 블라인드 전형으로 개발자 채용
카카오, 블라인드 전형으로 신입 개발자 공채
카카오 공채, 신입 개발자 코딩 능력만 본다
카카오, 신입 공채.. "코딩 실력만 본다"
카카오 "코딩 능력만으로 2018 신입 개발자 뽑는다"

기사의 제목을 기준으로 "블라인드 전형"에 주목하는 기사와 "코딩 테스트"에 주목하는 기사로 나뉘는 걸 발견했다. 튜브는 이들을 각각 묶어서 보여주면 카카오 공채 관련 기사를 찾아보는 사용자에게 유용할 듯싶었다.

유사한 기사를 묶는 기준을 정하기 위해서 논문과 자료를 조사하던 튜브는 "자카드 유사도"라는 방법을 찾아냈다.

자카드 유사도는 집합 간의 유사도를 검사하는 여러 방법 중의 하나로 알려져 있다. 두 집합 A, B 사이의 자카드 유사도 J(A, B)는 두 집합의 교집합 크기를 두 집합의 합집합 크기로 나눈 값으로 정의된다.

예를 들어 집합 A = {1, 2, 3}, 집합 B = {2, 3, 4}라고 할 때, 교집합 A ∩ B = {2, 3}, 합집합 A ∪ B = {1, 2, 3, 4}이 되므로, 집합 A, B 사이의 자카드 유사도 J(A, B) = 2/4 = 0.5가 된다. 집합 A와 집합 B가 모두 공집합일 경우에는 나눗셈이 정의되지 않으니 따로 J(A, B) = 1로 정의한다.

자카드 유사도는 원소의 중복을 허용하는 다중집합에 대해서 확장할 수 있다. 다중집합 A는 원소 "1"을 3개 가지고 있고, 다중집합 B는 원소 "1"을 5개 가지고 있다고 하자. 이 다중집합의 교집합 A ∩ B는 원소 "1"을 min(3, 5)인 3개, 합집합 A ∪ B는 원소 "1"을 max(3, 5)인 5개 가지게 된다. 다중집합 A = {1, 1, 2, 2, 3}, 다중집합 B = {1, 2, 2, 4, 5}라고 하면, 교집합 A ∩ B = {1, 2, 2}, 합집합 A ∪ B = {1, 1, 2, 2, 3, 4, 5}가 되므로, 자카드 유사도 J(A, B) = 3/7, 약 0.42가 된다.

이를 이용하여 문자열 사이의 유사도를 계산하는데 이용할 수 있다. 문자열 "FRANCE"와 "FRENCH"가 주어졌을 때, 이를 두 글자씩 끊어서 다중집합을 만들 수 있다. 각각 {FR, RA, AN, NC, CE}, {FR, RE, EN, NC, CH}가 되며, 교집합은 {FR, NC}, 합집합은 {FR, RA, AN, NC, CE, RE, EN, CH}가 되므로, 두 문자열 사이의 자카드 유사도 J("FRANCE", "FRENCH") = 2/8 = 0.25가 된다.

입력 형식

입력으로는 str1과 str2의 두 문자열이 들어온다. 각 문자열의 길이는 2 이상, 1,000 이하이다.
입력으로 들어온 문자열은 두 글자씩 끊어서 다중집합의 원소로 만든다. 이때 영문자로 된 글자 쌍만 유효하고, 기타 공백이나 숫자, 특수 문자가 들어있는 경우는 그 글자 쌍을 버린다. 예를 들어 "ab+"가 입력으로 들어오면, "ab"만 다중집합의 원소로 삼고, "b+"는 버린다.
다중집합 원소 사이를 비교할 때, 대문자와 소문자의 차이는 무시한다. "AB"와 "Ab", "ab"는 같은 원소로 취급한다.

출력 형식

입력으로 들어온 두 문자열의 자카드 유사도를 출력한다. 유사도 값은 0에서 1 사이의 실수이므로, 이를 다루기 쉽도록 65536을 곱한 후에 소수점 아래를 버리고 정수부만 출력한다.

예제 입출력

str1	str2	answer
FRANCE	french	16384
handshake	shake hands	65536
aa1+aa2	AAAA12	43690
E=M*C^2	e=m*c^2	65536

# dict 완성하는 함수
def dict_com(instr):
    from collections import defaultdict
    num_dict = defaultdict(int)
    instr = instr.lower()
    # 글자 2개 나눠서 알파벳으로만 구성됐는지 확인하고 그렇다면 dict에 저장. key는 알파벳 value는 개수
    for i in range(1,len(instr)):
        if i+1 == len(instr):
            split_str = instr[i-1:]
        split_str = instr[i-1:i+1]
        
        if split_str.isalpha(): # 알파벳으로만 이루어져 있으면 dict에 저장
            num_dict[split_str] += 1
    return num_dict
            
            
def solution(str1, str2):
    up = 0 # 분자
    down = 0 # 분모
    # 공집합이면 1
    # 같은수면 교집합은 min개수 합집합은 max 개수
    str1_dict = dict_com(str1)
    str2_dict = dict_com(str2)
    # print(str1_dict) #  {'ha': 2, 'an': 1, 'nd': 1, 'ds': 1, 'sh': 1, 'ak': 1, 'ke': 1}
    # print(str2_dict)
    str1_keys = set(str1_dict.keys())
    str2_keys = set(str2_dict.keys())
    if not str1_keys and not str2_keys:
        return 1*65536
    
    # 2개씩 끊어놓은거 종류 뽑아서 그 2개 교집합인 요소들을 뽑음
    # 그러면 그 교집합인 것들에 대해서만min max 판단해주면 되고 나머지는 분모할때 그냥 그거 value를 더해주면 됨
    # 주의해야하는 교집합인 요소들
#     if not str1_keys and not str2_keys:
#         return 1*65536
    
    inter_str12 = str1_keys.intersection(str2_keys)
    if inter_str12:
        for inter in inter_str12:
            str1_value = str1_dict[inter]
            str2_value = str2_dict[inter]
            
            up += min(str1_value,str2_value)
            down += max(str1_value,str2_value)
    else: 
        return 0
    
    # 분모에 교집합 외 안채워진것들 더해주는 시간
    str1_diff = str1_keys - inter_str12
    str2_diff = str2_keys - inter_str12
    for diff in str1_diff:
        down += str1_dict[diff]
    for diff in str2_diff:
        down += str2_dict[diff]
    answer = int(up/down *65536)
    return answer

크게 고민하고 풀지 않았다.
알아가야할건 알파벳인지 확인해주는 isalpha() 정도?
갑자기 백준 허브 연동이 안된다. 문제가 뭔지 모르겠음 ㅜㅜ 슬프다
정답률 63%인 문제인데, 다음부터는 이것보다는 정답률이 낮은걸 푸는게 좋을 것 같다

[TIL] 250911 - 프로그래머스 숫자의 표현

데린이 성장 중 — Thu, 11 Sep 2025 20:48:16 +0900

문제

Finn은 요즘 수학공부에 빠져 있습니다. 수학 공부를 하던 Finn은 자연수 n을 연속한 자연수들로 표현 하는 방법이 여러개라는 사실을 알게 되었습니다. 예를들어 15는 다음과 같이 4가지로 표현 할 수 있습니다.

1 + 2 + 3 + 4 + 5 = 15
4 + 5 + 6 = 15
7 + 8 = 15
15 = 15

자연수 n이 매개변수로 주어질 때, 연속된 자연수들로 n을 표현하는 방법의 수를 return하는 solution를 완성해주세요.

제한사항

n은 10,000 이하의 자연수 입니다.

입출력 예

n	result
15	4

입출력 예 설명

입출력 예#1
문제의 예시와 같습니다.

나의 답

# 짝수개로 나눠질 수 있으려면 -> 1 2 3 4 5 6 -> 21 에서 1,6/2,5/3,4 쌍으로 합이 7이니까 7*3 = 21. 즉, 짝수로 k개로 수가 나뉠 수 있으려면 k/2 만큼의 나머지가 남아야함. 그리고 각 쌍 더한게 k이상이어야함.
# 홀수개로 이 수가 나눠질 수 있으려면 -> 1 + 2 + 3 + 4 + 5  = 15에서 중간에 있는 값 3 기준으로 양 옆 2,4/ 1,5의 합이 3의 2배임. 즉, 합해서 나오는 수는 중간에 있는 값 a 기준으로 a(1+ 홀수개//2). 걍 n이 그 홀수갯수(k)로 나눠떨어지면 되는거임. 그리고 나누어 떨어진 와중에 k개로 나누어 떨어졌다면 n/k*2 가 k 보다 커야함. 
def solution(n):
    answer = 0
    # n//2 까지 탐색
    for k in range(1, n//2+2):
        if k % 2 == 0 : # 항의 수가 짝수
            value = n/k # 값
            remain = n%k # 나머지
            if remain == k/2 and value*2 >= k:
                answer += 1
        else: # 항의 수가 홀수
            if n % k == 0 and n/k*2 > k: # 나누어 떨어지면
                answer += 1
    return answer

[TIL] 250630 - 파이썬 itertools.product 사용법

데린이 성장 중 — Tue, 1 Jul 2025 01:47:26 +0900

itertools.product는 중복을 허용하며, 주어진 리스트의 모든 가능한 조합(데카르트 곱)을 만들어주는 도구

기본 사용법

from itertools import product

for p in product(['A', 'B'], repeat=2):
    print(p)

출력 결과:

('A', 'A')
('A', 'B')
('B', 'A')
('B', 'B')

repeat=2는 두 글자로 조합한다는 뜻
중복 허용
순서 고려함 → ('A', 'B')와 ('B', 'A')는 다르게 봄

사용 예시

'A', 'E', 'I', 'O', 'U'로 만들 수 있는 단어 생성

from itertools import product

alphabet = ['A', 'E', 'I', 'O', 'U']
all_words = []

for i in range(1, 6):  # 길이 1~5짜리 단어 생성
    for p in product(alphabet, repeat=i):
        all_words.append(''.join(p))

[TIL] 250630 프로그래머스 - 더 맵게

데린이 성장 중 — Mon, 30 Jun 2025 01:13:09 +0900

문제 설명

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

Leo는 모든 음식의 스코빌 지수가 K 이상이 될 때까지 반복하여 섞습니다.
Leo가 가진 음식의 스코빌 지수를 담은 배열 scoville과 원하는 스코빌 지수 K가 주어질 때, 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 하도록 solution 함수를 작성해주세요.

제한 사항

scoville의 길이는 2 이상 1,000,000 이하입니다.
K는 0 이상 1,000,000,000 이하입니다.
scoville의 원소는 각각 0 이상 1,000,000 이하입니다.
모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우에는 -1을 return 합니다.

입출력 예

scoville	K	return
[1, 2, 3, 9, 10, 12]	7	2

입출력 예 설명

스코빌 지수가 1인 음식과 2인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.
새로운 음식의 스코빌 지수 = 1 + (2 * 2) = 5
가진 음식의 스코빌 지수 = [5, 3, 9, 10, 12]
스코빌 지수가 3인 음식과 5인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.
새로운 음식의 스코빌 지수 = 3 + (5 * 2) = 13
가진 음식의 스코빌 지수 = [13, 9, 10, 12]

모든 음식의 스코빌 지수가 7 이상이 되었고 이때 섞은 횟수는 2회입니다.

나의 답

def solution(scoville, K):
    import heapq 
    heapq.heapify(scoville) # 리스트를 우선순위 힙으로
    answer = 0
    
    
    while scoville[0] < K:
        if len(scoville) == 1: # 1개까지 가도 스코빌 지수가 안넘었으면
            return -1
        min1 = heapq.heappop(scoville) # k보다 작다는 제일 작은 수
        min2 = heapq.heappop(scoville)
        
        mix = min1 + min2*2
        answer += 1
                
        heapq.heappush(scoville, mix)
    
    return answer

초반에 고민은 좀 했으나, 크게 어렵지 않게 풀었습니다
- 처음에는 for i in range(len(scoville)) 방식으로 접근하려고 했지만, for문 안에서 scoville 리스트를 계속 변경해야 하다 보니 문제 생길 여지가 있어 while 루프로 구현 방식을 바꿨습니다.

[TIL] 250629 우선순위 큐(힙(Heap))

데린이 성장 중 — Mon, 30 Jun 2025 00:31:53 +0900

1. 개념 정리: 힙(Heap) = 우선순위 큐

우선순위 큐는 일반적인 큐와 달리, 값의 크기에 따라 먼저 나가는 순서가 결정됨
파이썬의 heapq는 최소 힙(min heap) 기반:
- 항상 가장 작은 값이 먼저 나옴
최대 힙(max heap)을 쓰고 싶을 땐 값을 음수로 저장해서 우회

2. 힙 사용법 (파이썬 heapq)

- 최소 힙 (기본 동작)

import heapq

heap = []

# 삽입: heappush
heapq.heappush(heap, 4)
heapq.heappush(heap, 1)
heapq.heappush(heap, 7)

# 출력 (가장 작은 값)
print(heapq.heappop(heap))  # 1
print(heapq.heappop(heap))  # 4
print(heapq.heappop(heap))  # 7

- 최대 힙 (음수 활용)

import heapq

heap = []

# 값을 음수로 넣어 최대 힙처럼 사용
heapq.heappush(heap, -4)
heapq.heappush(heap, -1)
heapq.heappush(heap, -7)

# pop할 때 다시 음수로 바꿔줌
print(-heapq.heappop(heap))  # 7
print(-heapq.heappop(heap))  # 4
print(-heapq.heappop(heap))  # 1

3. 힙 주요 함수 정리

함수명	설명	시간 복잡도
heapq.heappush(heap, item)	item을 힙에 추가	O(log n)
heapq.heappop(heap)	가장 작은 item을 제거하고 반환	O(log n)
heapq.heapify(list)	기존 리스트를 in-place로 힙으로 만듦	O(log n)
heapq.heappushpop(heap, item)	item을 넣고, 가장 작은 값 바로 꺼냄 (더 빠름)	O(n)
heapq.nlargest(n, iterable)	가장 큰 n개 요소 리턴 (정렬 아님)	O(n log k)
heapq.nsmallest(n, iterable)	가장 작은 n개 요소 리턴	O(n log k)

4. 우선순위가 튜플일 경우

(우선순위, 값) 형식으로 넣으면 우선순위 기준 정렬됨

import heapq

tasks = []
heapq.heappush(tasks, (2, "cleaning"))
heapq.heappush(tasks, (1, "study"))
heapq.heappush(tasks, (3, "sleep"))

print(heapq.heappop(tasks))  # (1, 'study') -> 가장 우선순위 높은 작업

5. heapq.nsmallest(n, iterable)

heapq.nsmallest(n, iterable)는 iterable(반복 가능한 자료)에서 가장 작은 값 n개를 찾아서 정렬된 리스트로 반환해주는 함수

사용법

import heapq

nums = [10, 4, 1, 20, 7]

# 가장 작은 3개 원소 반환
smallest = heapq.nsmallest(3, nums)

print(smallest)  # [1, 4, 7]

정렬된 결과를 반환함 (min → max)
내부적으로는 최대 힙(Max Heap) 크기 n 유지 → 시간 복잡도: O(n log k)

nsmallest + key 인자 (정렬 기준 커스텀)

students = [
    {"name": "Alice", "score": 82},
    {"name": "Bob", "score": 91},
    {"name": "Charlie", "score": 78}
]

# 점수(score)가 가장 낮은 2명
top2 = heapq.nsmallest(2, students, key=lambda x: x["score"])

for s in top2:
    print(s["name"], s["score"])
# 출력:
# Charlie 78
# Alice 82

6. 튜플로 여러 우선순위를 동시에 설정하기

파이썬은 튜플을 비교할 때 자동으로 사전식(lexicographical) 비교를 수행함.
즉 (a, b, c)끼리 비교할 때는
1. 첫 요소 a를 먼저 비교하고
2. 같으면 두 번째 요소 b를 비교하며
3. 그래도 같으면 세 번째 요소 c를 기준으로 비교합니다.
이 성질 덕분에 heapq에 아래처럼 튜플을 넣으면:

import heapq

heap = []
heapq.heappush(heap, (priority1, priority2, data))

priority1이 작을수록 더 우선
같다면 priority2 비교
또 같으면 data(또는 다른 요소)까지 비교

이렇게 다중 우선순위 기준을 쉽게 적용할 수 있음

실전 예제: 세 가지 기준으로 정렬되는 힙

학생들을 (등급, 나이, 이름) 기준으로 우선순위를 주려고 한다면:

import heapq

students = [
    ('A', 22, 'Charlie'),
    ('B', 20, 'Alice'),
    ('A', 20, 'Bob'),
    ('A', 22, 'Anne'),
]

heap = []
for grade, age, name in students:
    heapq.heappush(heap, (grade, age, name))

while heap:
    print(heapq.heappop(heap))

결과는 아래와 같음

('A', 20, 'Bob')
('A', 22, 'Anne')
('A', 22, 'Charlie')
('B', 20, 'Alice')

등급 A 우선,
나이 같다면 20살 먼저,
나이도 같다면 이름 알파벳 순

이렇게 튜플을 그대로 넣는 것만으로 다중 우선순위를 적용할 수 있음