회고록

[개인 프로젝트] ProjectA - 인터페이스, 클래스

RꞮbble — Mon, 8 Jun 2026 22:28:53 +0900

IState

public interface IState
{
    public void Enter();
    public void Update();
    public void Exit();
}

모든 상태들의 인터페이스
모든 상태는 진입 시점과 탈출 시점이 있으므로, Enter()와 Exit()를 추가했다.
모든 상태는 매 프레임마다 체크할 로직이 필요할 수 있으므로, Update()를 추가했다.

BaseState

public class BaseState : IState

{

// 공통 기능 컴포넌트

protected AnimationController animationController;

public virtual void Enter() { }

public virtual void Update() { }

public virtual void Exit() { }

}

모든 상태들의 최상위 부모가 되는 클래스
IState 인터페이스를 상속받아 Enter(), Update(), Exit()를 강제로 구현하도록 했다.
모든 상태들의 최상위 부모이므로, 공통적으로 사용되는 컴포넌트를 가지고 있으면 되겠다.

PlayerState

public class PlayerState : BaseState

{

// 플레이어 공통 기능 컴포넌트

protected InputReader inputReader;

protected PlayerMovement playerMovement;

protected VerticalVelocity verticalVelocity;

public override void Enter()

{

base.Enter();

}

public override void Update()

{

base.Update();

}

public override void Exit()

{

base.Exit();

}

플레이어 상태들의 부모 상태 클래스
BaseState를 상속받아 Enter(), Update(), Exit()를 재정의 하도록 했고,
플레이어 상태들의 부모이므로, 플레이어 상태들에서 공통적으로 사용되는 컴포넌트를 가지고 있으면 되겠다.

PlayerGroundState

public class PlayerGroundState : PlayerState

{

// 플레이어가 땅에 있을 때 사용되는 기능 컴포넌트

public override void Enter()

{

base.Enter();

}

public override void Update()

{

base.Update();

}

public override void Exit()

{

base.Exit();

}

플레이어가 땅에 있을 때 상태 클래스
PlayerState를 상속받아 Enter(), Update(), Exit()를 재정의 하도록 했다.
대기/걷기/뛰기 상태들의 부모이므로, 땅에 있을 때 공통적으로 사용되는 컴포넌트를 가지고 있으면 되겠다.

PlayerAirState

public class PlayerAirState : PlayerState

{

// 플레이어가 공중에 있을 때 사용되는 기능 컴포넌트

public override void Enter()

{

base.Enter();

}

public override void Update()

{

base.Update();

}

public override void Exit()

{

base.Exit();

}

플레이어가 공중에 있을 때 상태 클래스
PlayerState를 상속받아 Enter(), Update(), Exit()를 재정의 하도록 했다.
점프 시작/중/착지 상태들의 부모이므로, 공중에 있을 때 공통적으로 사용되는 컴포넌트를 가지고 있으면 되겠다.

[코딩테스트] Programmers - H Index (실패)

RꞮbble — Mon, 8 Jun 2026 21:12:54 +0900

코딩테스트 연습 - H-Index | 프로그래머스 스쿨

프로그래머스

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

programmers.co.kr

풀이

[문제]
H-Index는 과학자의 생산성과 영향력을 나타내는 지표
어느 과학자의 H_Index를 나타내는 값인 h를 구해야 한다.

H_index 구하는 방법
논문 n편 중, h번 이상 인용된 논문이 h편 이상이고
나머지 논문이 h번 이하 인용되었다.
이때 h의 최댓값이 H_index이다.

[입력]
- 논문의 인용 횟수 배열 citations

[출력]
- 과학자의 H_index 반환

[제한사항]
- 1편 <= 발표한 논문의 수 <= 1,000편
- 0회 <= 논문별 인용 횟수 <= 10,000회

[입출력 예]
citations = [3, 0, 6, 1, 5]]

논문의 수 = 5
3번 이상 인용된 논문이 3편 (h번 이상 인용된 논문이 h편 이상)
나머지 논문은 3번 이하 인용되었다. (나머지 논문은 h번 이하 인용)
H-Index = 3

[풀이]
1
i번째 논문이 citations[i]번 이상 인용된 논문이 citations[i]편이고
나머지 논문은 citations[i]번 이하 인용되었는지 확인.
이 과정을 citations 길이만큼 반복
조건을 만족하면 H-index를 반환

코드1 - 오답

using System;

public class Solution {
    public int solution(int[] citations) 
    {
        int count1 = 0; 
        int count2 = 0; 
        int max = -1;
        
        for(int i = 0; i < citations.Length; i++)
        {
            for(int j = 0; j < citations.Length; j++)
            {
                if(citations[j] >= citations[i])
                    count1++;
                
                else
                    count2++;
            }
            
            if(count1 >= citations[i] && count2 <= citations[i])
                max = citations[i] > max ? citations[i] : max;
                
            count1 = 0; 
            count2 = 0; 
            
        }
        
        return max;
    }
}

뭐 때문에 틀렸는지 전혀 감이 오지 않아서 llm을 사용해서 내 코드에 대한 피드백을 받아봤다.

이 문제에서 h는 citations[i]이어야 한다는 말은 없다.

나는 h가 citations[i]라고 보고 문제를 풀었다. h의 후보군을 citations 원소값으로 줄이니 오답이 나왔던 것이다.

h는 범위가 딱히 정해져 있지 않으므로, h는 0부터 검사하면 된다.

코드 2 - 정답

using System;

public class Solution {
    public int solution(int[] citations) 
    {
        int count1 = 0; 
        int count2 = 0; 
        int max = 0; 

        for(int h = 0; h <= citations.Length; h++)
        {
            for(int j = 0; j < citations.Length; j++)
            {
                if(citations[j] >= h)
                    count1++;
                
                if(citations[j] <= h)
                    count2++;
            }

            if(count1 >= h && count2 <= h) 
            {
                max = h > max ? h : max;
            }

            count1 = 0; 
            count2 = 0; 
        }

        return max;
    }
}

[개인 프로젝트] ProjectA - 이동 구현 설계

RꞮbble — Sun, 7 Jun 2026 23:28:30 +0900

하나의 스크립트에 이동 관련 코드를 모두 넣으면, 가독성과 유지보수성이 떨어진다.

이동 상태들을 여러 스크립트로 분리하고, 상태머신으로 각각의 상태들을 관리한다면, 추후 새로운 상태를 넣을 때 상태 스크립트를 작성하고 상태머신에 등록만 하면 된다.

이동은 상태패턴으로 구현하겠다.

상태패턴으로 상태 흐름을 관리하고, 실제 기능 수행은 기능 컴포넌트로 구현하겠다.

인터페이스/클래스 구조

인터페이스/클래스별 역할 정리

IState

상태가 기본적으로 가져야 할 기능 정의

BaseState

IState를 구현
모든 상태가 가져야 할 기능 컴포넌트를 가진다.

PlayerGroundState

BaseState를 상속받는 클래스
땅에서 공통적으로 처리해야 하는 기능 컴포넌트를 가진다.

PlayerAirState

BaseState를 상속받는 클래스
공중에서 공통적으로 처리해야 하는 기능 컴포넌트를 가진다.

PlayerIdleState, PlayerWalkState, PlayerRunState

PlayerGroundState를 상속받는 클래스
대기, 걷기, 뛰기 처리에 필요한 기능 컴포넌트를 가진다.

PlayerJumpStartState, PlayerJumpLoopState, PlayerJumpLandState

PlayerAirState를 상속받는 클래스
점프 시작/중/착지에 필요한 기능 컴포넌트를 가진다.

기능 컴포넌트

유지보수를 위해 "이동하기", "점프하기", "애니메이션 재생하기"와 같이 특정 기능을 수행하는 것을 클래스로 분리시켜 봤다.

PlayerMovement

플레이어 (수평) 이동 처리 클래스
- 플레이어 이동 = 대기, 걷기, 뛰기

VerticalVelocity

플레이어 수직 이동 처리 클래스
- 수직 이동 = 중력 이동, 점프 이동

AnimationController

애니메이션 처리 클래스
- 애니메이션 처리 = 애니메이션 재생, 애니메이션 재생 완료 여부 판단

InputReader

플레이어 입력 처리 클래스
- 플레이어 입력 = w, a, s, d, 마우스 좌클릭, 마우스 우클릭

[코딩테스트] Programmers - 주식가격 (실패)

RꞮbble — Sun, 7 Jun 2026 17:52:25 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42584?language=csharp

프로그래머스

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

programmers.co.kr

풀이

[문제]
초 단위로 기록된 주식가격 배열 prices가 주어진다.
가격이 떨어지지 않은 기간은 몇 초인지 return 하라.

문제는 무슨 말인지 알겠는데, 입출력 예시가 이해가 안 간다.

[풀이]
간단한 방법은 prices[i] 뒤에 있는 숫자가 prices [i]보다 작지 않은 경우를 헤아리기.
그 개수가 가격이 떨어지지 않은 시간이다.
이중 for문을 사용하니, O(N^2) = 100,000 제곱 = 10,000,000,000 == 100억 = 1초 넘어간다.
O(N^2) 풀이로 못 푼다.

문제 유형이 스택/큐다. 스택/큐 풀이를 생각해야 한다.
그런데 전혀 감이 안 온다.

다른 사람 코드

using System;
using System.Collections.Generic;

public class Solution {
    public int[] solution(int[] prices) 
    {
        int[] answer = new int[prices.Length];
        
        Stack<int> stack = new Stack<int>();
        
        for(int i = 0; i < prices.Length; i++)
        {
            // 가격이 내려가면 
            while(stack.Count > 0 && prices[stack.Peek()] > prices[i])
            {
                int index = stack.Pop();
                answer[index] =  i - index;
            }
            
            stack.Push(i);
        }
        
        while(stack.Count > 0)
        {
            int index = stack.Pop();
            answer[index] = (prices.Length - 1) - index;
        }
        
        return answer;
    }
}

스택을 활용한 풀이다.
스택에 주식의 인덱스를 넣는다. 그러다가 주식 가격이 내려가는 순간, 스택에 있던 원소들을 꺼내면서, 꺼낸 주식의 가격이 현재 주식 가격보다 큰 경우, 가격이 떨어지지 않은 기간을 계산한다.

스택에 여전히 주식 가격 인덱스가 남아 있다는 건 해당 주식은 가격이 내려가지 않았다는 것이다.
그러니 이들은 자기들 기준으로 가격이 떨어지지 않는 기간을 계산해 주면 된다.

배운점

난 스택을 단순히 탑처럼 쌓고, 마지막 넣은 것부터 빼내는 자료구조로만 이해하고 있었다.
이 문제를 푸니, 스택은 단순 데이터를 넣고 빼는 자료구조가 아니라, Pop을 이용해서 이전 원소들을 비교할 수 있다는 것을 알게 된 것 같다.

해결해야 할 문제를 한 가지로 보지 않고, 쪼개서 보는 것 또한 중요한 것 같다.
이 문제의 경우 주식 가격이 내려가는 순간의 주식의 시간을 계산하는 것, 주식 가격이 오르는 순간의 주식의 시간을 계산하는 것. 이렇게 두 가지로 문제를 나누었다.
꼭 해결해야 할 문제를 한 가지로 볼 필요는 없다. 쪼갤 수 있다면 쪼개서 문제를 해결하는 것도 좋은 방법인 것 같다.

[자료구조] 힙 삭제

RꞮbble — Sun, 7 Jun 2026 12:18:22 +0900

힙 삭제

힙에 있는 데이터를 삭제하는 것
O(log N)
최소 힙(Min Heap) 삭제, 최대 힙(Max Heap) 삭제가 있다.

최소 힙(Min Heap) 삭제

그래프가 최소 힙인지 아닌지 확인
1. 완전 이진 트리인지 확인
2. 각 노드의 값이 자식 노드의 값보다 작거나 같은지 확인
힙의 가장 아래에 있는 리프 노드값을 루트 노드에 덮어씌운다.
힙 가장 아래에 있는 리프 노드값을 삭제한다.
수정된 루트 노드가 최소 힙 조건을 만족하는지 확인한다.
1. 루트 노드가 최소 힙 조건을 만족하지 않으면, 자식 노드와 위치를 바꾼다.
2. 바뀐 위치에서 최소 힙 조건을 만족하는지 확인한다.
  1. 바뀐 위치에서 최소 힙 조건을 만족하지 않으면, 자식 노드와 위치를 바꾼다.
최소 힙 조건을 만족하면 종료한다.

루트노드 값을 10으로 덮어씌우기.

리프 노드 삭제

루트 노드 값과 자식 노드 값 바꾸기.

최대 힙(Max Heap) 삭제

그래프가 최대 힙인지 확인
1. 완전 이진 트리인지 확인
2. 각 노드의 값이 자식 노드의 값보다 크거나 같은지 확인
힙 가장 아래에 있는 리프 노드 값을 루트 노드에 덮어씌운다.
힙 가장 아래에 있는 리프 노드 값을 삭제한다.
수정된 루트 노드가 최대 힙 조건을 만족하는지 확인한다.
1. 루트 노드가 최대 힙 조건을 만족하지 않으면, 자식 노드와 위치를 바꾼다.
2. 바뀐 위치에서 최대 힙 조건을 만족하는지 확인한다.
  1. 바뀐 위치에서 최대 힙 조건을 만족하지 않으면, 자식 노드와 위치를 바꾼다.
최대 힙 조건을 만족하면 종료한다.

루트노드 값을 4으로 덮어씌우기.

리프 노드 삭제

루트 노드 값과 자식 노드 값 바꾸기.

[코딩테스트] Programmers - 다리를 지나는 트럭 (실패)

RꞮbble — Sat, 6 Jun 2026 21:20:12 +0900

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

프로그래머스

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

programmers.co.kr

풀이

이번 문제는 문제를 이해하는데 엄청 오래 걸렸다. 2시간 넘게 풀었지만 통과하지 못했다.

코드 1 - 오답

public class 다리를_지나는_트럭
{
    public int solution(int bridge_length, int weight, int[] truck_weights)  {
        int answer = 0;
        Queue<int> queue = new Queue<int>(bridge_length);
        
        for(int i = 0; i < truck_weights.Length; i++)
        {
            if(truck_weights[i] + queue.Sum() <= weight && queue.Count < bridge_length) 
            {
                queue.Enqueue(truck_weights[i]);
                answer += (bridge_length); // 건너는 시간 
            }
            else
            {
                // answer += ((queue.Count * bridge_length) + queue.Count);
                // answer += ((queue.Count * 1) + queue.Count);
                // answer += ((queue.Count * 1) + 1);
                // answer += ((weight / queue.Count) + 1);
                queue.Clear();
                // answer += 1; // 지나는 시간 

                queue.Enqueue(truck_weights[i]);
                answer += (bridge_length); // 건너는 시간 
            }
        }
        
        // if(queue.Count > 0)
        //     answer += ((queue.Count * bridge_length) + queue.Count);
            // answer += ((queue.Count * 1) + queue.Count);
            // answer += ((queue.Count * 1) + 1);
            // answer += ((weight / queue.Count) + 1);
        
        return answer;
    }

    static void Main(string[] args)
    {
        다리를_지나는_트럭 p = new 다리를_지나는_트럭();

        int bridge_length = 100;
        int weight = 100;
        int[] truck_weights = {10,10,10,10,10,10,10,10,10,10};

        Console.WriteLine(p.solution(bridge_length, weight, truck_weights));
    }
}

시간을 한번에 계산하는 식이 문제인 것 같다.

코드 2 - 정답

using System;
using System.Collections.Generic;
using System.Linq;

public class 다리를_지나는_트럭
{
    public int solution(int bridge_length, int weight, int[] truck_weights) 
    {
        int answer = 0;
        Queue<int> bridge = new Queue<int>();
        
        // 처음에는 다리 길이만큼 빈 공간(0)을 채워 넣습니다. (컨베이어 벨트 세팅)
        for (int i = 0; i < bridge_length; i++)
        {
            bridge.Enqueue(0);
        }
        
        int current_weight = 0; // 현재 다리 위의 총 무게를 실시간으로 추적
        int truck_idx = 0;      // 출발할 트럭의 인덱스
        
        // 모든 트럭이 다리를 통과할 때까지 반복
        while (truck_idx < truck_weights.Length)
        {
            answer++; // 1초가 흐릅니다.
            
            // 1. 다리의 맨 끝에서 트럭(또는 0)이 나갑니다.
            current_weight -= bridge.Dequeue();
            
            // 2. 새 트럭이 들어올 수 있는지 검사합니다.
            if (current_weight + truck_weights[truck_idx] <= weight)
            {
                // 들어올 수 있다면 트럭을 진입시키고, 무게를 더해줍니다.
                bridge.Enqueue(truck_weights[truck_idx]);
                current_weight += truck_weights[truck_idx];
                truck_idx++; // 다음 트럭을 대기시킵니다.
            }
            else
            {
                // 무게 초과로 못 들어온다면, 다리를 전진시키기 위해 빈 공간(0)을 넣습니다.
                bridge.Enqueue(0);
            }
        }
        
        // 마지막 트럭이 다리에 '진입'하면서 while문이 끝납니다. 
        // 그 마지막 트럭이 다리를 완전히 '통과'하는 데 걸리는 시간(다리 길이)을 더해줍니다.
        return answer + bridge_length;
    }
}

시간에 대한 정보가 없어서 어떻게 풀지도 잘 모르겠고 도저히 혼자서 못 풀 것 같아 llm에게 물어봤다.

길이가 bridge_length인 큐를 만들고, 이 큐에 트럭을 넣으면서 시간을 계산하는 것 같다.

[자료구조] 힙 삽입

RꞮbble — Sat, 6 Jun 2026 15:39:03 +0900

우선순위 큐 구현에서 힙 자료구조의 시간복잡도가 O(log N)이므로, 힙으로 우선순위 큐를 구현해야 한다고 배웠다.

배열, 연결리스트에 삽입, 삭제, 탐색, 순회가 있듯 힙에도 삽입 기능이 있다.

힙 삽입

힙에 데이터를 추가하는 것
O(log N)
최소 힙(min heap) 삽입, 최대 힙(max heap) 삽입이 있다.

최소 힙(min heap) 삽입

그래프가 최소 힙인지 아닌지 확인
1. 완전 이진 트리인지 확인
2. 각 노드의 값이 자식 노드의 값보다 작거나 같은지 확인
힙에 원소 삽입 (완전 이진 트리를 만족하도록 삽입)
1. 부모노드와 비교해서 최소 힙 조건을 만족하는지 확인
2. 최소 힙 조건을 만족하지 않으면 부모 노드와 스왑

우선 위 그래프가 최소 힙인지 아닌지 확인해야 한다.

최소 힙은 다음 조건을 만족해야 한다.

완전 이진 트리
각 노드의 값은 자식 노드의 값보다 작거나 같아야 한다.

각 노드는 자식 노드를 0 ~ 2개를 가지고, 3층 노드들은 왼쪽 노드부터 채워져 있으므로, 완전 이진 트리가 맞다.

각 노드의 값은 자식 노드의 값보다 작은 값을 가지므로, 최소 힙이 맞다.

최소 힙이 맞으므로, 이제 삽입을 할 수 있다.

5를 삽입해보자.

완전 이진 트리를 만족해야 하므로, 5는 9의 왼쪽 자식 노드로 들어간다.

최소힙은 노드의 값이 자식 노드의 값보다 작거나 같아야 한다.

9는 5보다 크므로, 최소힙 조건을 만족하지 않는다.

따라서 둘의 위치를 바꿔야 한다.

3은 5보다 작으므로, 최소힙 조건을 만족한다.

최소 힙 삽입이 끝났다.

최대 힙(max heap) 삽입

그래프가 최대 힙인지 아닌지 확인
1. 완전 이진 트리인지 확인
2. 각 노드의 값이 자식 노드의 값보다 크거나 같은지 확인
힙에 원소 삽입 (완전 이진 트리를 만족하도록 삽입)
1. 부모노드와 비교해서 최대 힙 조건을 만족하는지 확인
2. 최대 힙 조건을 만족하지 않으면 부모 노드와 스왑

위 그래프가 최대 힙인지 아닌지 확인해야 한다.

최대 힙은 다음 조건을 만족해야 한다.

완전 이진 트리
각 노드의 값은 자식 노드의 값보다 크거나 같아야 한다.

각 노드는 자식 노드를 0 ~ 2개를 가지고, 3층 노드들은 왼쪽 노드부터 채워져 있으므로, 완전 이진 트리가 맞다.

각 노드의 값은 자식 노드의 값보다 큰 값을 가지므로, 최대 힙이 맞다.

15를 삽입해보자.

완전 이진 트리를 만족해야 하므로, 15는 5의 오른쪽 자식 노드로 들어간다.

최대 힙은 노드의 값이 자식 노드의 값보다 크거나 같아야 한다.

5는 15보다 작으므로, 최대힙 조건을 만족하지 않는다.

따라서 둘의 위치를 바꿔야 한다.

10은 15보다 작으므로, 최대 힙 조건을 만족하지 않는다.

둘의 위치를 바꿔야 한다.

최대 힙의 삽입이 끝났다.

[코딩테스트] Programmers - 모의고사 (실패)

RꞮbble — Thu, 4 Jun 2026 20:57:24 +0900

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

풀이

문제 = 1번 ~ 마지막 문제까지 정답이 들은 배열 answer가 주어졌을 때, 가장 많은 문제를 맞힌 사람을 배열에 담아 반환

제한 조건

answer 배열 길이는 최대 10,000
문제 정답은 1 ~ 5 중 하나
가장 높은 점수 받은 사람이 여럿일 경우, return 값을 오름차순 정렬하기.

풀이

1번 수포자 = (1 2 3 4 5) (1 2 3 4 5) ... = 1 ~ 5번까지 순서대로 찍기.
2번 수포자 = (2 1 2 3) (2 4 2 5) (2 1 2 3) (2 4 2 5) ... = (2 1 2 3), (2 4 2 5) ... 순서대로 찍기.
3번 수포자 = (3 3) (1 1) (2 2) (4 4) (5 5) / (3 3) (1 1) (2 2) (4 4) (5 5) ... = (3 3) (1 1) (2 2) (4 4) (5 5) ... 순서대로 찍기.

1~3번 수포자의 정답지를 배열에 저장하기. (arr1, arr2, arr3)
answer배열에서 하나씩 읽으며 1~3번 정답지 배열과 비교하며 맞춘 횟수를
(int index, int count) answer1, (int index, int count) answer2, (int index, int count) answer3에 저장
answer1 ~ answer3을 오름차순 정렬
최댓값이 여러개이면 순서대로 answer배열에 넣기.
최댓값이 하나이면 하나만 answer배열에 넣기.
answer배열 출력

코드1 - 오답

using System;
using System.Linq;
using System.Collections.Generic;

public class Solution {
    public int[] solution(int[] answers) 
    {
        int[] arr1 = {1, 2, 3, 4, 5};
        int index1 = 0; 
        int answer1 = 0; 
        
        int[] arr2 = {2, 1, 2, 3, 2, 4, 2, 5};
        int index2 = 0; 
        int answer2 = 0; 
        
        int[] arr3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        int index3 = 0; 
        int answer3 = 0; 
        
        for(int i = 0; i < answers.Length; i++)
        {
            if(answers[i] == arr1[index1++])
            {
                answer1++;
                if(index1 >= arr1.Length)
                    index1 = 0; 
            }
            
            if(answers[i] == arr2[index2++])
            {
                answer2++;
                if(index2 >= arr2.Length)
                    index2 = 0; 
            }
            
            if(answers[i] == arr3[index3++])
            {
                answer3++;
                if(index3 >= arr3.Length)
                    index3 = 0; 
            }
        }
        
        (int index, int count) a1;
        a1.index = 1; 
        a1.count = answer1;
        
        (int index, int count) a2;
        a2.index = 2;
        a2.count = answer2;
        
        (int index, int count) a3;
        a3.index = 3;
        a3.count = answer3; 
        
        List<(int index, int count)> list = new List<(int index, int count)>();
        list.Add(a1);
        list.Add(a2);
        list.Add(a3); 
        
        int max = list.Max(x => x.count); 
        
        return list.Where(a => a.count == max).OrderBy(a => a.index).Select(a => a.index).ToArray();
    }
}

LINQ를 사용해서 풀어봤다.

인덱스 범위에서 벗어나면 인덱스를 0으로 만들어주는 부분이 정답을 맞추었을 때만 처리가 된다.

정답을 맞추지 않으면 인덱스는 계속 늘어나기만 하고 배열 크기보다 더 큰 인덱스로 배열에 접근하니 에러가 발생한다.

코드2 - 정답

using System;
using System.Linq;
using System.Collections.Generic;

public class Solution {
    public int[] solution(int[] answers) 
    {
        int[] arr1 = {1, 2, 3, 4, 5};
        int index1 = 0; 
        int answer1 = 0; 
        
        int[] arr2 = {2, 1, 2, 3, 2, 4, 2, 5};
        int index2 = 0; 
        int answer2 = 0; 
        
        int[] arr3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        int index3 = 0; 
        int answer3 = 0; 
        
        for(int i = 0; i < answers.Length; i++)
        {
            if(answers[i] == arr1[index1++])
                answer1++;
            if(index1 >= arr1.Length)
                    index1 = 0; 
            
            if(answers[i] == arr2[index2++])
                answer2++;
            if(index2 >= arr2.Length)
                    index2 = 0; 
            
            if(answers[i] == arr3[index3++])
                answer3++;
            if(index3 >= arr3.Length)
                    index3 = 0; 
        }
        
        (int index, int count) a1;
        a1.index = 1; 
        a1.count = answer1;
        
        (int index, int count) a2;
        a2.index = 2;
        a2.count = answer2;
        
        (int index, int count) a3;
        a3.index = 3;
        a3.count = answer3; 
        
        List<(int index, int count)> list = new List<(int index, int count)>();
        list.Add(a1);
        list.Add(a2);
        list.Add(a3); 
        
        int max = list.Max(x => x.count); 
        
        return list.Where(a => a.count == max).OrderBy(a => a.index).Select(a => a.index).ToArray();
    }
}

정답을 맞추든 맞추지 못하든 인덱스 범위 체크를 해주도록 코드를 수정해주니 통과했다.

[자료구조] 힙(Heap)이란

RꞮbble — Thu, 4 Jun 2026 19:52:46 +0900

힙(Heap)을 배우기 전에 우선순위 큐를 알아둬야 한다.

우선순위 큐(Priority Queue)

추상 데이터 타입
우선순위가 부여되며, 우선순위가 높은 요소가 먼저 처리된다.
예시 = 우선순위가 높은 작업부터 처리하기

우선순위 큐 구현 방식

배열이나 연결리스트로 구현
- 삽입, 삭제 연산
  - 배열 = 삽입, 삭제하고 옆에 있는 데이터들을 옮겨주는 연산 -> O(N)
  - 연결리스트 = 헤드 노드부터 삽입, 삭제할 위치까지 탐색하는 연산 -> O(N)
힙으로 구현
- 삽입, 삭제 연산 -> O(log N)

배열과 연결리스트로 우선순위 큐를 구현하면 O(N)이 나올 수 있다.

힙으로 우선순위 큐를 구현하면 O(log N)이 나온다.

따라서 우선순위 큐는 힙으로 구현하는 것이 적합하다.

힙(Heap)

이진 완전 트리(Complete Binary Tree)
각 노드의 값은 자식 노드의 값보다 크지 않거나, 작지 않다.

힙 시간복잡도

삽입 = O(log N)
삭제 = O(log N)
최대/최소값 찾기 = O(1)

힙 종류

Max Heap
- 각 노드의 값은 자식 노드의 값보다 작지 않다. (크다)
- 루트 노드가 가장 큰 값을 가진다.

Max Heap

Min Heap
- 각 노드의 값은 자식 노드의 값보다 크지 않다. (작다)
- 루트 노드가 가장 작은 값을 가진다.

Min Heap

[코딩테스트] Programmers - 전화번호 목록 (실패)

RꞮbble — Sun, 31 May 2026 18:04:14 +0900

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

프로그래머스

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

programmers.co.kr

풀이 1

문제 = 한 번호가 다른 번호의 접두어인 경우가 있는지 확인
ex)
구조대 = 119
박준영 = 97 674 223
지영석 = 11 9552 4421
-> 구조대의 번호가 지영석의 번호의 접두사이다.

입력
- 전화번호 담은 배열 phone_book

출력
- 어떤 번호가 다른 번호의 접우어인 경우가 있다 = false 반환
- 없다 = true 반환

제한 사항
- 1 <= phone_book 길이 <= 1,000,000
    - 1 <= 전화번호 길이 <= 20
    - 같은 전화번호 중복 없다.

풀이 1
- 119가 다른 전화번호에 포함되어 있는지 확인하려면
    다른 전화번호를 하나씩 탐색해서 그 번호에 119가 포함되어 있는지 확인하면 된다.
- 그걸 어떻게 구현할까인데
- A번호에 B번호가 있는지 확인.

가장 쉬운 방법은 이중 for문을 써서
i번째 번호가 i+1~n번째 번호에 포함되어 있는지 확인하는 방법
시간복잡도는 O(N^2) = O(100만 제곱) = 1,000,000,000,000 = 1초 넘는다.
이중 for문 방법 사용하면 안 된다.

문제 유형이 해시이니 Dictionary로 풀어야 하는데.
일단 phone_book 원소들을 딕셔너리에 다 넣어보자. 그리고.. 어떻게 풀지 전혀 모르겠다.

다른 사람 풀이를 보자.

풀이 2

문자열 배열을 사전순으로 정렬하고, 문자열 배열에서 인접한 원소끼리 비교해서 풀면 된다.

❓크기 순서대로 정렬을 하더라도 i번째와 i+1번째, i번째와 i+2번째를 비교해야 할 텐데, 왜 인접한 원소끼리 비교해서 풀어도 될까?

문자열 배열을 사전순으로 정렬하면
A가 C의 접두어라면, A바로 옆에 있는 B도 A를 접두어로 가진다. 따라서 A는 바로 옆에 있는 문자열과 비교해도 A가 누군가의 접두어가 되는 것을 검사할 수 있다.

코드 1 - 정답 (C#)

public bool solution(string[] phone_book)
{
    Array.Sort(phone_book); // 사전 순 정렬

    // 인접한 원소끼리 비교 
    for(int i = 0; i < phone_book.Length - 1; i++)
        // phone_book[i]가 phone_book[i+1]에 포함되어 있으면
        if(phone_book[i+1].StartsWith(phone_book[i])) 
            return false;

    // 여기까지 왔다는 건 한 번호가 다른 번호의 접두사인 경우가 없다는 것 
    return true; 
}

코드1 - 정답 (Java)

import java.util.Arrays;

class Solution {
    public boolean solution(String[] phone_book) 
    {
        Arrays.sort(phone_book);
        
        for(int i = 0; i < phone_book.length - 1; i++)
            if(phone_book[i + 1].startsWith(phone_book[i]))
                return false;
        
        return true;
    }
}

효율성 테스트에서 시간이 꽤 걸린다.

풀이 3

해시 문제이니 딕셔너리로 풀 수도 있다.

딕셔너리에 phone_book 문자열들을 넣고, 딕셔너리 키값을 하나씩 뽑아서 이 키값의 접두사를 전화번호로 하는 것이 딕셔너리에 있는지 확인하고 있으면 false를 없으면 true를 반환하면 된다.

코드 2 - 정답 (C#)

public bool solution2(string[] phone_book)
{
    // 딕셔너리 사용
    Dictionary<string, int> dict = new Dictionary<string, int>();

    // 딕셔너리에 phone_book 저장  
    foreach(string key in phone_book)
        dict[key] = 1;

    // phone_book[i]의 접두사를 번호로 하는 얘가 딕셔너리에 있는가 
    foreach(string key in phone_book)
        for(int i = 1; i < key.Length; i++)
            if(dict.ContainsKey(key.Substring(0, i)))
                return false;

    return true;
}

코드2 - 정답 (Java)

import java.util.*;

class Solution {
    public boolean solution(String[] phone_book) 
    {
        HashMap<String, Integer> map = new HashMap<>();
        for(int i = 0; i < phone_book.length; i++)
            map.put(phone_book[i], 1);
        
        for(int i = 0; i < phone_book.length; i++)
            for(int j = 1; j < phone_book[i].length(); j++)
                if(map.containsKey(phone_book[i].substring(0, j)))
                    return false;
        return true;
    }
}

효율성 테스트는 배열을 사용한 방법보다 시간이 덜 걸린다.

cf)

복습 1 풀이 (6/7)

[문제]
한 번호가 다른 번호의 접두어인 경우가 있는지 확인하기.
전화번호 담은 배열 phone_book이 주어진다.
어떤 번호가 다른 번호의 접두어가 있으면 false
어떤 번호가 다른 번호의 접두어가 없으면 true를 반환하라.

[제한 사항]
- 1 <= phone_book 길이 <= 1,000,000
- 1 <= 전화번호 길이 <= 20
- 같은 전화번호는 중복 저장 X

[풀이]
당장 떠오르는 풀이는 phone_book[i]가 phone_book[i+1], phone_book[i+2], ... 과 비교했을 때
접두어가 있는지 확인하기.
이중 for문 > O(N^2)
N은 최대 1,000,000. > O(100만 제곱) = 1,000,000,000,000 = 1초 넘는다 > 시간 초과

다른 풀이 생각해야 한다.

방법1
- 문자열 배열을 정렬한다.
- 문자열 배열을 정렬하면, 앞 문자가 작은 순서대로 정렬이 된다.
- 그러면 phone_book에서 바로 가까이 있는 문자열들은 접두어 관계에 있을 수 있다.
- 뒤에 문자열들은 볼 필요가 없다. 이미 문자열 정렬이 되었으므로, 가까운 문자열끼리 비교하면 된다.

방법2
해시 문제인 만큼 해시로 풀어보자.
- 일단 phone_book 원소들을 딕셔너리(dict)에 넣자.
- 전화번호는 중복되지 않는다고 했으니, value는 1로 넣으면 된다.
- phone_book[i]를 하나씩 검사해서 phone_book[i]의 접두사가 전화번호인 것을 dict에서 찾으면 된다.

코드 1 - 정답

public bool solution(string[] phone_book)
{
    Array.Sort(phone_book); 
    for(int i = 0; i < phone_book.Length - 1; i++)
    {
        // phone_book[i]가 phohe_book[i+1]에 포함되어 있는가? 
        if(phone_book[i+1].StartsWith(phone_book[i]))
            return false;
    }

    return true;
}

코드 2 - 정답

public bool solution(string[] phone_book)
{
    Dictionary<string, int> dict = new Dictionary<string, int>();
    foreach(string key in phone_book)
    {
        if(!dict.ContainsKey(key))
            dict.Add(key, 1);
    }

    foreach(string key in phone_book)
    {
        for(int i = 1; i < key.Length; i++)
        {
            if(dict.ContainsKey(key.Substring(0, i)))
            return false;
        }
    }
    return true;
}