on my way

[프로그래머스 코딩테스트 연습] 하노이의 탑 (Python3)

wingbeat — Mon, 10 Feb 2025 23:20:06 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/12946#

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

하노이의 탑 프로세스

1. start의 N-1개의 원반을 보조 기둥으로 옮긴다 (aux)

2. 가장 큰 원반을 end로 옮긴다.

3. 보조의 N-1개의 원반을 end로 옮긴다.

def move(n, start, end, aux, answer):
    if n==1: 
        answer.append([start, end])
        return
    move(n-1, start, aux, end, answer) # n-1개 원반을 보조로 이동
    answer.append([start,end]) # 가장 큰 원반을 목적지로
    move(n-1, aux, end, start, answer) # 보조의 n-1개 원반을 목적지로
def solution(n):
    answer = []
    move(n, 1, 3, 2, answer)
    return answer

[프로그래머스 코딩테스트 연습] 다리를 지나는 트럭 (Python3)

wingbeat — Wed, 29 Jan 2025 20:37:51 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42583

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

# 1트 (돌아가긴 하나 비효율)
from collections import deque
def solution(bridge_length, weight, truck_weights):
    i, cnt, flag = 0, 0, True
    time, queue = deque(), deque()
    while True:
        cnt += 1
        time = deque([t+1 for t in time])
        if time and time[0] >= bridge_length:
            queue.popleft()
            time.popleft()
        if flag and len(queue) < bridge_length:
            w = truck_weights[i]
            if sum(queue) + w <= weight:
                queue.append(w)
                time.append(0)
                i+=1
                if i==len(truck_weights): flag=False
        if not flag and not queue: break
    return cnt

⚡️ 나의 1트 코드의 문제점

sum(queue) 사용으로 매번 다리 위의 총 무게 계산 (O(N)) → 비효율적
- sum(queue)는 매번 리스트의 모든 요소를 더하는 연산이므로, 시간 복잡도가 O(N)
- 트럭이 많을수록 성능 저하 발생
time 리스트를 매번 새로 생성 (O(N)) → 비효율적
- time = deque([t+1 for t in time]) → 리스트 전체를 다시 만들면서 메모리 낭비
불필요한 조건문 (flag 체크)
- flag = False는 사실 필요 없음 → i == len(truck_weights)일 때 break 가능

# 리팩토링
from collections import deque
def solution(bridge_length, weight, truck_weights):
    bridge = deque([0] * bridge_length)
    total_weight, time = 0, 0
    for w in truck_weights:
        while True:
            time += 1
            total_weight -= bridge.popleft()
            if total_weight + w <= weight:
                bridge.append(w)
                total_weight += w
                break
            bridge.append(0)
    return time + bridge_length

⚡️ 리팩토링 코드의 개선점

sum(queue) 대신 total_weight 변수를 사용
- O(N) → O(1)로 최적화
- total_weight를 유지하면서 매번 더하지 않고 빼고 더하는 방식으로 시간 절약
매번 리스트 재생성 없이 popleft() 사용하여 시간 업데이트
- time 리스트를 따로 만들지 않고 그냥 time 변수를 직접 증가시키는 방식으로 최적화
while True를 사용해 한 번에 트럭을 올릴 수 있는 시점까지 반복
- 불필요한 flag 제거 → i == len(truck_weights) 체크 없이 간결해짐
마지막 트럭이 다리를 건너는 시간 추가 (time + bridge_length)
- 트럭이 다리를 다 건너는 마지막 시간을 따로 처리하여 명확한 종료 조건 적용

[프로그래머스 코딩테스트 연습] 기능개발 (Python3)

wingbeat — Tue, 21 Jan 2025 04:10:36 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42586

import math
def solution(progresses, speeds):
    days = [math.ceil((100-p)/s) for p, s in zip(progresses, speeds)]
    answer = []
    cur, func = 0, 0
    for i, d in enumerate(days):
        if cur < d:
            if i: answer.append(func)
            cur, func = d, 1
        else: func += 1
    answer.append(func)
    return answer

먼저 소요일을 구하고,

소요일 배열을 기준으로 같이 배포될 수 있을지를 순회한다.

cur는 기준배포일, func은 기능 수를 카운트하는 변수

기준 배포일보다 큰 값이 나오면 새 그룹이므로 그 전까지 answer에 기능의 수를 넣고 기준배포일과 기능수 초기화 (cur, func = d, 1)

# Queue로 풀이
from collections import deque
import math
def solution(progresses, speeds):
    days = deque([math.ceil((100-p)/s) for p, s in zip(progresses, speeds)])
    answer = []
    while days:
        cur, func = days.popleft(), 1
        while days and days[0] <= cur:
            days.popleft()
            func += 1
        answer.append(func)
    return answer

Queue로 풀면, 하나씩 pop하면서 기준일보다 작을때까지 기능 수를 더해서 answer에 넣어준다.

queue가 있을 때 까지 반복

[백준 2164번] 카드2 (Python3, 실버4)

wingbeat — Tue, 21 Jan 2025 03:34:29 +0900

https://www.acmicpc.net/problem/2164

from collections import deque
import sys
queue = deque(range(1, int(sys.stdin.readline())+1))
while len(queue) > 1:
    queue.popleft()
    queue.rotate(-1)
print(queue[0])

[프로그래머스 코딩테스트 연습] 주식가격 (Python3)

wingbeat — Tue, 21 Jan 2025 03:25:33 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42584

def solution(prices):
    N = len(prices)
    answer = [0 for _ in range(N)]
    stack = []
    
    for now, price in enumerate(prices):
        # 스택 인덱스 가격과 현재 가격 비교. 
        # 마지막 가격이 현재가격보다 크면 가격 떨어진 것이므로 인덱스 꺼냄
        while stack and prices[stack[-1]] > price:
            idx = stack.pop()
            answer[idx] = now - idx # 현재 인덱스 - 꺼낸 인덱스 
        stack.append(now) # 현재 인덱스 추가
        
    while stack:
        idx = stack.pop()
        answer[idx] = N-idx-1 # 끝까지 남은 경우
    return answer

요약

1. 스택에는 인덱스만 저장한다.

2. 가격이 떨어질 때 마다 스택에서 값을 꺼내 시간을 계산해 answer에 저장

3. 최종적으로 스택에 남은 값은 끝까지 유지된 시간을 계산한다.

prices = [1,2,3,2,3] 일 때의 단계를 살펴보자

초기 상태 : stack = [], answer = [0,0,0,0,0]

1초 (now=0, price=1) : stack = [0], answer = [0,0,0,0,0]

2초 (now=1, price=2) : stack = [0, 1], answer = [0,0,0,0,0]

3초 (now=2, price=3) : stack = [0, 1, 2], answer = [0,0,0,0,0]

4초 (now=3, price=2) : 가격이 떨어지는 구간

stack[-1] = 2으로, 스택 마지막 가격 prices[2] = 3 > 현재 price = 2 조건 진입.

idx = 2. answer[2] = 3 - 2 = 1

stack = [0, 1, 3], answer = [0,0,1,0,0]

5초 (now=4, price=3) : stack = [0, 1, 3, 4], answer = [0,0,1,0,0]

while stack: 구간을 통해 종료 후 스택을 처리한다.

(최종적으로 스택에 남은 값은 끝까지 유지된 시간을 계산하게 된다.)

idx=4, answer[4] = 5-4-1 = 0, answer = [0,0,1,0,0]

idx=3, answer[3] = 5-3-1 = 1, answer = [0,0,1,1,0]

idx=1, answer[1] = 5-1-1 = 3, answer = [0,3,1,1,0]

idx=0, answer[0] = 5-0-1 = 4, answer = [4,3,1,1,0]

[프로그래머스 코딩테스트 연습] 괄호 회전하기 (Python3)

wingbeat — Mon, 20 Jan 2025 04:27:54 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/76502

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

# 리팩토링 전
def solution(s):
    result = 0
    for _ in range(len(s)):
        s = s[1:] + s[0]
        stack = []
        for c in s:
            if c in '({[': stack.append(c)
            else:
                if not stack: break
                if c==')' and stack[-1]=='(':
                    stack.pop()
                elif c=='}' and stack[-1]=='{':
                    stack.pop()
                elif c==']' and stack[-1]=='[':
                    stack.pop()
        else: # 정상적으로 종료시 실행
            if not stack: result += 1
    return result

내가 짠 버전은 문자열을 s[1:]+s[0]으로 반복하면서 검사하는 코드.

파이썬을 몇년을 했는데 for-else를 몰랐어서 창피하다.

for문이 정상 종료되면 실행되는 역할을 한다. 중간에 break로 강제종료되면 else는 실행안됨

# 리팩토링
from collections import deque
def solution(s):
    result = 0
    s = deque(s)
    for _ in range(len(s)):
        stack = []
        for c in s:
            if c in '({[': stack.append(c)
            else:
                if not stack: break
                if (c==')' and stack[-1]=='(') or (c=='}' and stack[-1]=='{') or (c==']' and stack[-1]=='['):
                    stack.pop()
        else:
            if not stack: result += 1
        s.rotate(-1)
    return result

deque의 rotate(-1)라는 신박한 기능을 발견했다.

rotate(1) : 오른쪽으로 회전, rotate(-1) : 왼쪽으로 회전

[백준 1874번] 스택 수열 (Python3, 실버4)

wingbeat — Mon, 20 Jan 2025 03:58:47 +0900

https://www.acmicpc.net/problem/1874

처음엔 문제부터 이해하기 어려웠는데

스택에 1부터 n까지 숫자에 대해 하나하나 수를 push, 해당 수이면 pop하고, 다음 수를 탐색하고.. 이런 과정의 반복

1. push 1 (+), push 2 (+), push 3 (+), push 4 (+)
   현재 스택: [1, 2, 3, 4]
   수열에서 필요한 숫자: 4
   -> pop 4 (-)
   현재 스택: [1, 2, 3]

2. pop 3 (-)
   현재 스택: [1, 2]

3. push 5 (+), push 6 (+)
   현재 스택: [1, 2, 5, 6]
   수열에서 필요한 숫자: 6
   -> pop 6 (-)
   현재 스택: [1, 2, 5]

4. push 7 (+), push 8 (+)
   현재 스택: [1, 2, 5, 7, 8]
   수열에서 필요한 숫자: 8
   -> pop 8 (-), pop 7 (-)
   현재 스택: [1, 2, 5]

5. pop 5 (-), pop 2 (-), pop 1 (-)
   현재 스택: []

대략 이런 과정이다.

# 리팩토링 전
import sys
N = int(sys.stdin.readline())
seq = [int(sys.stdin.readline()) for _ in range(N)]

stack, op = [], []
cur = 1

for num in seq:
    # num 될때까지 숫자 추가
    while cur <= num:
        stack.append(cur)
        op.append('+')
        cur += 1
    if stack and stack[-1] == num:
        stack.pop()
        op.append('-')
    else:
        op.append('X')
        break
print("NO" if op[-1]=='X' else '\n'.join(op))

프로그래머스면 바로 return 하면 되는데 백준은 어쩌지 싶었더니 sys.exit(0) 라는게 있더라

    else:
        print("NO")
        sys.exit(0)
print('\n'.join(op))

시간은 4ms 정도 빠름

[프로그래머스 코딩테스트 연습] 압축 (Python3)

wingbeat — Mon, 20 Jan 2025 03:12:24 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/17684

def solution(msg):
    d = {chr(i+65): i+1 for i in range(26)}
    pos, idx = 0, 27
    answer = [] 
    
    while pos < len(msg):
        w = msg[pos]
        while pos+1 < len(msg) and w+msg[pos+1] in d:
            pos += 1
            w += msg[pos]
        answer.append(d[w])
        
        if pos+1 < len(msg):
            d[w+msg[pos+1]] = idx
            idx += 1
        pos += 1
    return answer

문자열을 순차적으로 처리하기 위해 위치를 나타내는 pos 변수를 두고

pos < len(msg)로 순차적으로 처리했다.

현재 입력과 일치하는 가장 긴 문자열 w를 찾기 위해

현재 w = msg[pos]

그리고 다음의 최대 문자열(pos+1<len(msg))이 사전에 있을때까지(w+msg[pos+1] in d), while문으로 pos += 1 해서 찾으며 현재 문자열 w를 확인

최대의 문자열을 answer에 추가

작업 후에, 현재 문자열과 그 다음의 문자열을 더해서 사전 d에 추가한다. idx += 1

작업이 끝나면 다음 위치부터 찾기 시작 pos += 1

[프로그래머스 코딩테스트 연습] 귤 고르기 (Python3)

wingbeat — Thu, 16 Jan 2025 21:28:19 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/138476

def solution(k, tangerine):
    answer = 0
    for _, cnt in Counter(tangerine).most_common():
        k -= cnt
        answer += 1
        if k <= 0: return answer

# 리팩토링
from collections import Counter
def solution(k, tangerine):
    for i, cnt in enumerate(sorted(Counter(tangerine).values(), reverse=True)):
        k -= cnt
        if k <= 0: return i+1

속도는 리팩한게 더 빠른거 같긴한데

most_common() 유용하다

[프로그래머스 코딩테스트 연습] 베스트 앨범 (Python3)

wingbeat — Thu, 16 Jan 2025 21:14:21 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42579

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

# 리팩 전
from collections import defaultdict

def solution(genres, plays):
    totalPlay = defaultdict(int)
    songs = defaultdict(list)
    for i, [genre, play] in enumerate(zip(genres, plays)):
        totalPlay[genre] += play
        songs[genre].append([play, i])

    best = []
    for genre, play in sorted(totalPlay.items(), key=lambda x: -x[1]):
        for idx, [play, num] in enumerate(sorted(songs[genre], key=lambda x: -x[0])):
            if idx > 1: break
            best.append(num)
    return best
    
# 리팩토링
from collections import defaultdict

def solution(genres, plays):
    totalPlay = defaultdict(int)
    songs = defaultdict(list)
    for i, [genre, play] in enumerate(zip(genres, plays)):
        totalPlay[genre] += play
        songs[genre].append([play, i])

    best = []
    for genre in sorted(totalPlay, key=totalPlay.get, reverse=True):
        for play, cnt in sorted(songs[genre], key=lambda x: -x[0])[:2]:
            best.append(cnt)
    return best

왜 sorted()[:2]를 생각하지 못했을까....

get함수도 key로 사용하는 법을 배웠다.