개발하는 장씨

프로그래머스: [체육복]

개발하는 장씨 — Mon, 10 Mar 2025 18:09:15 +0900

프로그래머스: [체육복]

문제 접근 방식

체육복을 도난당한 학생(lost)과 여벌 체육복을 가진 학생(reserve)을 고려하여 최대한 많은 학생이 체육 수업을 듣게 해야 함.
**도난당한 학생과 여벌이 있는 학생이 겹치는 경우(lost ∩ reserve)**를 먼저 처리.
앞뒤 학생에게 빌려줄 수 있도록 greedy 방식으로 해결.

Solution

def solution(n, lost, reserve): 
    answer = [1 for _ in range(n)]
    
    for i in lost:
        answer[i - 1] -= 1
    for r in reserve:
        answer[r - 1] += 1
    
    for i in range(n):
        if answer[i] == 0:
            if i - 1 >= 0 and answer[i - 1] == 2:
                answer[i - 1] = 1
                answer[i] = 1
                continue
            if i + 1 < n and answer[i + 1] == 2:
                answer[i + 1] = 1
                answer[i] = 1
                
    result = sum(1 for i in answer if i >= 1)
    
    return result

시간 복잡도 분석 ⏲️

리스트 초기화: O(N)
도난 및 여벌 체육복 적용: O(N)
빌려주는 과정: O(N)
최종 연산: O(N)
총 시간 복잡도: O(N)

공간 복잡도 분석 ️

공간 복잡도: O(N),
- answer 리스트가 필요.

리팩토링 ️

def solution(n, lost, reserve):
    lost_set = set(lost) - set(reserve)
    reserve_set = set(reserve) - set(lost)

    for r in sorted(reserve_set):
        if r - 1 in lost_set:
            lost_set.remove(r - 1)
        elif r + 1 in lost_set:
            lost_set.remove(r + 1)

    return n - len(lost_set)

리팩토링 후 시간 복잡도 분석 ⏲️

set 연산(O(1))을 활용하여 중복 제거.
reserve_set을 순회(O(N))하며 lost_set에서 제거.
최종적으로 O(N log N) (정렬 포함).

리팩토링 후 공간 복잡도 분석 ️

공간 복잡도: O(N),
- set을 사용하여 lost_set과 reserve_set을 저장.

리팩토링 개선점

리스트(answer)를 사용하지 않고 set으로 중복 제거 및 빠른 탐색 수행 (O(1))
체육복 빌려주는 과정(for r in sorted(reserve_set))을 간결하게 처리
마지막 반환값을 n - len(lost_set)으로 계산하여 추가 연산 제거

프로그래머스: [모의고사]

개발하는 장씨 — Mon, 10 Mar 2025 01:53:00 +0900

프로그래머스: [모의고사]

문제 링크

문제 접근 방식

수포자들의 반복되는 패턴을 리스트로 저장하고, 각 패턴을 순회하며 정답과 비교.
정답을 맞힌 개수를 저장한 후, 최대 점수를 가진 사람을 반환.
불필요한 리스트 사용을 줄이고 enumerate()를 활용하여 깔끔한 코드로 리팩토링.

Solution

def solution(answers):
    patterns = [
        [1, 2, 3, 4, 5], 
        [2, 1, 2, 3, 2, 4, 2, 5], 
        [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    ]
    
    scores = [sum(a == pattern[i % len(pattern)] for i, a in enumerate(answers)) for pattern in patterns]
    
    max_score = max(scores)
    
    return [i + 1 for i, score in enumerate(scores) if score == max_score]

시간 복잡도 분석 ⏲️

패턴 검사: O(N * 3) (N은 answers 길이)
최대 점수 탐색: O(3)
최종 결과 리스트 생성: O(3)
총 시간 복잡도: O(N)

공간 복잡도 분석 ️

공간 복잡도: O(1),
- patterns 및 scores 리스트는 고정된 크기(3)를 유지.

프로그래머스: [K번째 수]

개발하는 장씨 — Mon, 10 Mar 2025 01:41:30 +0900

프로그래머스: [K번째 수]

문제 링크

문제 접근 방식

commands 리스트를 순회하면서 각 요청([i, j, k])을 처리.
주어진 배열의 i번째부터 j번째까지 자른 후 정렬.
정렬된 배열에서 k번째 원소를 선택하여 결과 리스트에 추가.

Solution

def solution(array, commands):
    answer = []
    for command in commands:
        arr = sorted(array[command[0]-1:command[1]])
        answer.append(arr[command[2]-1])
    return answer

시간 복잡도 분석 ⏲️

자르기(array[i-1:j]): O(N)
정렬(sorted()): O(N log N)
선택(arr[k-1]): O(1)
총 시간 복잡도: O(M * N log N),
- M은 commands의 길이, N은 배열의 크기.

공간 복잡도 분석 ️

공간 복잡도: O(M),
- answer 리스트에 M개의 값을 저장.

프로그래머스: [같은 숫자는 싫어]

개발하는 장씨 — Mon, 10 Mar 2025 01:32:50 +0900

프로그래머스: [같은 숫자는 싫어]

문제 링크

문제 접근 방식

주어진 리스트에서 연속된 중복 숫자를 제거하고 순서를 유지하는 문제.
answer 리스트의 마지막 값과 비교하여 다를 경우에만 추가.
첫 번째 요소는 무조건 포함하므로 미리 answer.append(arr[0])을 수행.

Solution

def solution(arr):
    answer = [arr[0]]
    
    for i in arr[1:]:
        if answer[-1] != i:
            answer.append(i)
        
    return answer

시간 복잡도 분석 ⏲️

시간 복잡도: O(N),
- 리스트를 한 번 순회하면서 조건 확인 후 append() 연산 수행.
공간 복잡도: O(N),
- 중복이 없는 경우 모든 요소를 저장하므로 입력 크기 N에 비례.

프로그래머스: [단어 변환]

개발하는 장씨 — Sat, 8 Mar 2025 06:02:50 +0900

프로그래머스: [단어 변환]

문제 링크

문제 접근 방식

begin에서 target으로 단어를 변환하는 과정에서 한 번에 하나의 문자만 변경 가능.
주어진 words 리스트 내에서 변환을 수행하며, 최소 단계로 target에 도달하는 경로를 찾아야 함.
BFS(너비 우선 탐색)을 사용하여 가장 빠른 변환 경로를 탐색.

Solution

from collections import deque
    
def solution(begin, target, words):
    if target not in words:
        return 0
    
    visited = set()
    q = deque()
    q.append((begin, 0))
    visited.add(begin)
    
    while q:
        p, result = q.popleft()
        if p == target:
            return result
        for word in words:
            if word not in visited:
                diff = sum(1 for a, b in zip(p, word) if a != b)
                if diff == 1:
                    visited.add(word)
                    q.append((word, result + 1))
                    
    return 0

시간 복잡도 분석 ⏲️

BFS 탐색: O(N * M),
- N은 단어 개수, M은 단어 길이.
- 각 단어에 대해 문자 비교 연산 수행 (O(M)).
- 최악의 경우 O(50 * 10) = O(500) 정도로 충분히 수행 가능.

공간 복잡도 분석 ️

공간 복잡도: O(N),
- visited 집합과 큐에 저장된 단어 개수에 비례.

프로그래머스: [전력망을 둘로 나누기]

개발하는 장씨 — Sat, 8 Mar 2025 05:47:12 +0900

프로그래머스: [전력망을 둘로 나누기]

문제 링크

문제 설명

하나의 전력망으로 연결된 n개의 송전탑이 있다.
wires 리스트는 송전탑을 연결하는 전선 정보를 제공한다.
전선 하나를 끊어 두 개의 네트워크로 분리할 때, 두 네트워크의 송전탑 개수 차이를 최소화해야 한다.

문제 접근 방식

모든 전선을 하나씩 제거한 후, 남은 네트워크에서 DFS를 사용하여 연결된 송전탑 개수를 계산.
하나의 네트워크 크기를 구하면, 나머지 네트워크의 개수는 전체 개수에서 빼면 됨.
가장 작은 차이를 찾도록 갱신.

Solution

from collections import defaultdict

def search(index, visit, graph):
    count = 1
    for i in graph[index]:
        if i not in visit:
            visit.add(i)
            count += search(i, visit, graph)
    return count

def solution(n, wires):
    answer = float('inf')
    graph = defaultdict(list)
    
    for s, e in wires:
        graph[s].append(e)
        graph[e].append(s)
    
    for s, e in wires:
        graph[s].remove(e)
        graph[e].remove(s)
        
        visited = set()
        visited.add(s)
        one = search(s, visited, graph)
        
        two = n - one
        answer = min(answer, abs(one - two))
        
        graph[s].append(e)
        graph[e].append(s)
    
    return answer

시간 복잡도 분석 ⏲️

시간 복잡도: O(N^2),
- N개의 간선을 하나씩 제거하면서 O(N) DFS 탐색 수행.
공간 복잡도: O(N),
- 그래프를 저장하는 defaultdict 및 방문 기록을 위한 set 사용.

프로그래머스: [베스트앨범]

개발하는 장씨 — Sat, 8 Mar 2025 05:02:07 +0900

프로그래머스: [베스트앨범]

문제 링크

문제 설명

장르별로 가장 많이 재생된 곡을 우선적으로 선택하여 앨범을 구성한다.
장르별로 최대 2곡씩 선택하며, 재생 횟수가 같다면 고유 번호가 작은 순서대로 정렬한다.
장르의 순서는 총 재생 횟수가 높은 순서대로 정렬한다.

문제 접근 방식

장르별로 곡을 묶고, 각 곡을 (재생 횟수, 고유 번호) 기준으로 정렬한다.
장르별 총 재생 횟수를 기준으로 내림차순 정렬하여, 가장 인기 있는 장르부터 선택한다.
각 장르에서 최대 2곡을 선택하며, 재생 횟수가 같다면 고유 번호가 작은 순서대로 정렬한다.
우선순위 큐(heapq)를 활용하여 정렬을 효율적으로 수행한다.

Solution

from collections import defaultdict
import heapq

def solution(genres, plays):
    pattern = defaultdict(list)
    
    for i, (gen, play) in enumerate(zip(genres, plays)):
        heapq.heappush(pattern[gen], (-play, i)) 

    q = []
    for key, value in pattern.items():
        total = sum(-i[0] for i in value) 
        heapq.heappush(q, (-total, key))

    answer = []
    while q:
        key, value = heapq.heappop(q) 
        for _ in range(2):
            if pattern[value]: 
                answer.append(heapq.heappop(pattern[value])[1])

    return answer

시간 복잡도 분석 ⏲️

장르별로 곡을 저장하는 과정: O(N log N)
장르별 총 재생 횟수를 계산하는 과정: O(N)
힙을 이용한 정렬 및 선택: O(N log N)
총 시간 복잡도: O(N log N), N은 곡의 개수

공간 복잡도 분석 ️

공간 복잡도: O(N)
- pattern 딕셔너리 및 heapq를 이용한 저장 구조 활용.

프로그래머스: [위장]

개발하는 장씨 — Sat, 8 Mar 2025 03:32:05 +0900

프로그래머스: [위장]

문제 링크

문제 설명

각 의상의 종류별로 한 개씩 착용할 수 있으며, 최소 하나 이상의 의상을 선택해야 한다.
같은 종류의 의상을 여러 개 소유할 수 있지만, 같은 종류에서 한 개만 선택 가능하다.
의상의 조합 수를 구하는 문제.

문제 접근 방식

의상의 종류별로 개수를 세고 조합을 계산해야 한다.
특정 종류의 의상을 착용하는 경우의 수는 (해당 종류 개수 + 1)이다. (선택하지 않는 경우 포함)
따라서, 모든 종류의 의상을 곱한 값에서 1을 빼면 총 조합 개수가 된다. (모든 의상을 선택하지 않는 경우 제외)

Solution

from collections import defaultdict

def solution(clothes):
    pattern = defaultdict(list)
    
    for clothe in clothes:
        pattern[clothe[1]].append(clothe[0])
    
    answer = 1
    for i in pattern.values():
        answer *= (len(i) + 1)
    
    return answer - 1

시간 복잡도 분석 ⏲️

시간 복잡도: O(N),
- N은 의상의 개수.
- 해시맵(Dictionary)에 의상 정보를 저장 (O(N))
- 종류별로 개수를 계산하여 곱셈 연산 (O(K), K는 의상 종류 개수)
- 전체적으로 O(N + K) ≈ O(N)

공간 복잡도 분석 ️

공간 복잡도: O(K),
- K는 의상 종류 개수.
- defaultdict에 의상 정보를 저장하는데, 최대 K개의 키만 필요.

리팩토링 ️

from collections import Counter

def solution(clothes):
    count = Counter([kind for _, kind in clothes])
    answer = 1
    for c in count.values():
        answer *= (c + 1)
    return answer - 1

시간 복잡도 분석 ⏲️

시간 복잡도: O(N),
- Counter()를 이용해 한 번의 순회로 종류별 개수를 세므로 효율적.

공간 복잡도 분석 ️

공간 복잡도: O(K),
- 의상의 종류 개수만큼 저장.

프로그래머스 [양궁대회]

개발하는 장씨 — Thu, 6 Mar 2025 21:16:47 +0900

프로그래머스 [92342]: 양궁대회

문제 링크

문제 설명

어피치와 라이언이 n발의 화살로 점수를 겨루는 게임. 어피치는 이미 화살을 쏜 상태이고, 라이언은 남은 n발을 적절히 배분하여 가장 큰 점수 차이로 승리해야 한다. 만약 동일한 점수 차이가 나면 낮은 점수를 더 많이 맞힌 경우를 선택한다.

문제 접근 방식

DFS(깊이 우선 탐색) 백트래킹을 활용하여 모든 가능한 라이언의 화살 배치를 탐색.
라이언이 어피치보다 +1개 더 맞추거나, 해당 점수를 포기하는 두 가지 선택이 가능.
점수 차이를 계산하여 best_diff를 갱신하고, 가장 큰 점수 차이를 가진 경우를 선택.
best_diff가 0 이하라면 라이언이 승리할 방법이 없으므로 [-1]을 반환.
여러 경우가 있을 경우 가장 낮은 점수를 많이 맞힌 경우를 선택.

Solution

import sys
sys.setrecursionlimit(10**7)

def solution(n, info):
    global best_diff, candidates
    best_diff = 0  
    candidates = []  
    
    def dfs(remain, lion_arrows, index):
        global best_diff, candidates
        if index == -1:
            lion_arrows[10] += remain  
            
            lion_score = 0
            apeach_score = 0
            
            for i in range(11):
                if lion_arrows[i] == 0 and info[i] == 0:
                    continue
                if lion_arrows[i] > info[i]:
                    lion_score += (10 - i)
                else:
                    apeach_score += (10 - i)
            diff = lion_score - apeach_score
            
            if diff > best_diff:
                best_diff = diff
                candidates = [lion_arrows[:]]
            elif diff == best_diff:
                candidates.append(lion_arrows[:])
                
            lion_arrows[10] -= remain  
            return
        
        dfs(remain, lion_arrows[:], index-1)
        
        arrows_needed = info[index] + 1
        if arrows_needed <= remain:
            new_arrows = lion_arrows[:]
            new_arrows[index] = arrows_needed
            dfs(remain - arrows_needed, new_arrows, index-1)
    
    dfs(n, [0]*11, 10)
    
    if best_diff <= 0:
        return [-1]
    
    candidates.sort(key=lambda arr: arr[::-1], reverse=True)
    return candidates[0]

시간 복잡도 분석 ⏲️

시간 복잡도: O(2^11)
- 11개의 점수에서 각각 선택(맞추거나 안 맞추거나)해야 하므로 최악의 경우 2^11 = 2048번의 재귀 호출 발생.

공간 복잡도 분석 ️

공간 복잡도: O(2^11 * 11)
- candidates 리스트에 최적의 결과를 저장하므로 최대 O(2048 * 11) ≈ O(10^4) 정도의 메모리 사용.

리팩토링 ️

from itertools import combinations

def solution(n, info):
    best_diff = 0
    best_shot = [-1]

    for comb in combinations(range(11), n):  
        lion_arrows = [0] * 11
        for i in comb:
            lion_arrows[i] = info[i] + 1  

        remain = n - sum(lion_arrows)
        if remain < 0:
            continue
        lion_arrows[10] += remain  

        lion_score = sum((10 - i) for i in range(11) if lion_arrows[i] > info[i])
        apeach_score = sum((10 - i) for i in range(11) if lion_arrows[i] <= info[i] and info[i] > 0)
        diff = lion_score - apeach_score

        if diff > best_diff:
            best_diff = diff
            best_shot = lion_arrows[:]
        elif diff == best_diff:
            if lion_arrows[::-1] > best_shot[::-1]:
                best_shot = lion_arrows[:]

    return best_shot if best_diff > 0 else [-1]

시간 복잡도 분석 ⏲️

시간 복잡도: O(2^11) (비슷)
- 하지만 itertools.combinations()를 활용하여 가독성을 향상.

공간 복잡도 분석 ️

공간 복잡도: O(11)
- 최적의 배열 best_shot만 저장.

프로그래머스 [이모티콘 할인 행사]

개발하는 장씨 — Wed, 5 Mar 2025 19:29:04 +0900

프로그래머스 [이모티콘 할인 행사]

문제 링크

문제 설명

이모티콘 할인 행사를 진행할 때, 사용자들이 이모티콘을 구매하거나 이모티콘 플러스 서비스에 가입하는 최적의 경우를 찾아야 합니다. 할인율을 다르게 적용했을 때의 결과를 계산하여, 가입자 수가 최대가 되는 경우를 찾고, 같은 가입자 수라면 매출이 최대가 되는 경우를 선택해야 합니다.

문제 접근 방식

할인율(10%, 20%, 30%, 40%)을 이모티콘마다 다르게 적용할 수 있다.
각 사용자는 특정 할인율 이상일 때만 구매하며, 구매 금액이 특정 금액 이상이면 이모티콘 플러스에 가입한다.
완전 탐색(BFS)을 사용하여 모든 할인 조합을 탐색하고 최적의 결과를 찾는다.
bfs() 함수는 현재까지의 구매 금액을 추적하며, 모든 이모티콘에 대해 할인율을 적용한 경우를 탐색한다.
최종적으로 가장 많은 가입자를 확보하고, 같은 가입자 수라면 매출이 최대가 되도록 설정한다.

Solution

def solution(users, emoticons):
    global answer
    answer = [0, 0]

    def bfs(totals, eindex):
        global answer
        if len(emoticons) == eindex:
            plus = 0
            total = 0
            for t in range(len(totals)):
                if totals[t] >= users[t][1]:
                    plus += 1
                else:
                    total += totals[t]

            if answer[0] < plus:
                answer[0] = plus
                answer[1] = total
            elif answer[0] == plus:
                answer[1] = max(total, answer[1])
            return
        else:
            for discount in [10, 20, 30, 40]:
                newTotals = totals[:]
                for i in range(len(users)):
                    if users[i][0] <= discount:
                        newTotals[i] += (emoticons[eindex] * (1 - discount * 0.01))
                bfs(newTotals, eindex + 1)

    bfs([0] * len(users), 0)
    return answer

시간 복잡도 분석 ⏲️

시간 복잡도: O(4^E x U)
- E: 이모티콘 개수
- U : 사용자 수
- 각 이모티콘에 대해 4가지 할인율을 적용하는 경우의 수가 4^E이므로, 이모티콘 개수가 많아지면 계산량이 증가함.

공간 복잡도 분석 ️

공간 복잡도: O(U + E)
- U(사용자 수) 크기의 리스트(totals)와 E(이모티콘 개수) 깊이의 재귀 호출 스택 사용.

리팩토링 ️

from itertools import product

def solution(users, emoticons):
    max_plus, max_sales = 0, 0
    discounts = [10, 20, 30, 40]
    
    for discount_comb in product(discounts, repeat=len(emoticons)):
        plus, sales = 0, 0
        user_spending = [0] * len(users)

        for i, discount in enumerate(discount_comb):
            price = emoticons[i] * (1 - discount * 0.01)
            for j, (min_discount, min_price) in enumerate(users):
                if min_discount <= discount:
                    user_spending[j] += price

        for j, (_, min_price) in enumerate(users):
            if user_spending[j] >= min_price:
                plus += 1
            else:
                sales += user_spending[j]

        if plus > max_plus or (plus == max_plus and sales > max_sales):
            max_plus, max_sales = plus, sales

    return [max_plus, max_sales]

시간 복잡도 분석 ⏲️

시간 복잡도: O(4^E x U) (같음)
- 단, itertools.product()를 활용해 코드 가독성을 높이고, 중복 연산을 최소화.

공간 복잡도 분석 ️

공간 복잡도: O(U)
- 사용자별 구매 금액을 저장하는 리스트 사용.