tjdgus123 님의 블로그

<프로그래머스 C++> H-Index 풀이 ( 정렬 )

tjdgus123 — Fri, 26 Jun 2026 11:18:41 +0900

문제

논문 n편 중 h번 이상 인용된 논문이 h편 이상이고, 나머지 논문이 h번 이하 인용되었을 때 h의 최댓값이 H-Index이다.

이 H-Index를 구하는 문제이다.

풀이 아이디어

내림차순 정렬

H-Index의 조건은 "h번 이상 인용된 논문이 h편 이상" 이다.

이 조건을 효율적으로 체크하기 위해선 인용 횟수가 많은 순서대로 논문을 나열하고 현재 인덱스와 인용 횟수를 비교하면 된다.

내림차순 정렬 후 i+1번째까지 봤을 때 citations[ i ] >= i + 1이면, "i+1편의 논문이 모두 i+1회 인용됐다" 라는 의미가 된다.

[3, 0, 6, 1, 5] → 내림차순 정렬 → [6, 5, 3, 1, 0]

i=0: citations[0]=6 >= 1    (1편 이상이 1회 이상 인용)
i=1: citations[1]=5 >= 2    (2편 이상이 2회 이상 인용)
i=2: citations[2]=3 >= 3    (3편 이상이 3회 이상 인용)
i=3: citations[3]=1 >= 4  x  → 멈춤

조건이 깨지는 순간, 이전까지의 개수가 H-Index이다.

문제풀이

#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int solution(vector<int> citations) {
    int answer = 0;
    sort(citations.begin(), citations.end(), greater<int>());

    for(int i = 0; i < citations.size(); ++i)
    {
        if(citations[i] >= i+1)
            answer++;
        else
            break;
    }
    return answer;
}

코드 흐름

1. 내림차순 정렬

sort(citations.begin(), citations.end(), greater<int>());

인용 횟수가 많은 논문부터 순서대로 나열한다.

greater<int>()를 이용해서 내림차순 정렬한다.

2. 조건 체크

if(citations[i] >= i+1)
    answer++;
else
    break;

i + 1은 현재까지 확인한 논문 수이다.

citations[ i ] >= i + 1이면 i + 1편의 논문이 모두 i + 1회 이상 인용됐다는 의미이므로 answer를 증가시킨다.

조건이 깨지는 상황부터는 확인할 필요가 없으니 바로 break한다.

핵심 포인트

내림차순 정렬하면 citations[i] >= i+1 조건 하나로 H-Index를 구할 수 있다.
조건이 깨지는 순간 break해서 불필요한 탐색을 줄인다.

<프로그래머스 C++> 원형 수열의 연속 부분 수열 합 풀이 (set)

tjdgus123 — Wed, 24 Jun 2026 12:32:41 +0900

문제

원형 수열에서 연속하는 부분 수열의 합으로 만들 수 있는 수가 몇 가지인지 구하는 문제이다.

원형 수열은 처음과 끝이 연결된 형태이다. (n번째 다음이 바로 0번째로)

풀이 아이디어

각 시작점에서 1, 2, 3개 ... n개까지 늘려가면서 합을 전부 구해 set에 넣는다.

i=0 (7이 시작점)
  7
  7+9
  7+9+1
  7+9+1+1
  7+9+1+1+4

i=1 (9가 시작점)
  9
  9+1
  9+1+1
  9+1+1+4
  9+1+1+4+7  ← 원형으로 7까지
  ...

원형 배열에서 끝을 넘어 처음으로 돌아오는건 %(element.size())로 처리한다.

i=3, len=3: (3+2) % 5 = 0 → elements[0] = 7  ← 원형으로 돌아옴

set이 중복을 자동으로 제거해주기 때문에 마지막에 sums.size()만 반환하면 된다.

문제 풀이

#include <string>
#include <vector>
#include <set>
using namespace std;

int solution(vector<int> elements) {
    int n = elements.size();
    set<int> sums;

    for(int i = 0; i < n; ++i)
    {
        int sum = 0;
        for(int len = 1; len <= n; ++len)
        {
            sum += elements[(i + len - 1) % n];
            sums.insert(sum);
        }
    }
    return sums.size();
}

코드 흐름

1. 시작점 순회

for(int i = 0; i < n; ++i)
{
    int sum = 0;

i는 부분 수열의 시작점을 의미한다. i가 바뀔때마다 sum을 0으로 초기화한다.

2. 길이별 합을 누적

for(int len = 1; len <= n; ++len)
{
    sum += elements[(i + len - 1) % n];
    sums.insert(sum);
}

len이 늘어날수록 sum에 다음 원소를 누적한다.

i=0 기준
len=1: sum = 7           → 1개짜리 합
len=2: sum = 7+9 = 16    → 2개짜리 합
len=3: sum = 16+1 = 17   → 3개짜리 합
len=4: sum = 17+1 = 18   → 4개짜리 합
len=5: sum = 18+4 = 22   → 5개짜리 합

매 단계마다 sums.insert(sum)으로 각 자릿수별 경우의 수 합을 set에 넣는다.

3. 원형 인덱스 처리

elements[(i + len - 1) % n]

배열 끝을 넘어가면 % n으로 자동으로 처음 항으로 넘어가도록 한다.

i=3 기준
len=1: (3+0)%5 = 3 → elements[3] = 1
len=2: (3+1)%5 = 4 → elements[4] = 4
len=3: (3+2)%5 = 0 → elements[0] = 7  ← 원형!
len=4: (3+3)%5 = 1 → elements[1] = 9
len=5: (3+4)%5 = 2 → elements[2] = 1

4. 결과 반환

return sums.size();

set이 중복을 자동으로 제거해주기 때문에 sums의 크기를 반환하면 이것이 서로 다른 합의 개수이다.

핵심 포인트

각 시작점에서 길이를 1씩 늘려가며 합을 누적하면 모든 연속 부분 수열 합을 구할 수 있다.
(i + len - 1) % n으로 원형 배열에서 끝을 넘어 처음으로 돌아오는 것을 처리한다.
set이 중복을 자동 제거하므로 별도의 중복 처리 없이 size()만 반환하면 된다.

<Unreal> 모듈 & 플러그인 만들기

tjdgus123 — Tue, 23 Jun 2026 21:13:05 +0900

모듈과 플러그인

언리얼 엔진은 기능을 모듈 단위로 나눠서 관리한다.

우리가 만드는 게임 프로젝트도 사실 하나의 모듈이다. 이번엔 프로젝트 안에서 새 모듈을 직접 추가하고, 재사용 가능한 플러그인 구조까지 손으로 만들어보려고 한다.

1. 프로젝트 생성

언리얼 에디터에서 아래 순서대로 프로젝트를 생성했다.

Game -> Third Person -> C++ -> Scalable

프로젝트 이름 : HW10

2. Test 모듈 생성

source 폴더 안에 Test 폴더를 새로 만들어 모듈 파일을 여기 안에서 생성했다.

Source/
├── HW10/          ← 기존 주 모듈
└── Test/          ← 새로 만든 모듈
    ├── Test.Build.cs
    ├── Test.h
    └── Test.cpp

Test.Build.cs

모듈의 의존성을 정의하는 파일이다.

이 파일이 없으면 언리얼 빌드 시스템이 이 폴더를 모듈로 인식하지 못한다.

using UnrealBuildTool;

public class Test : ModuleRules
{
    public Test(ReadOnlyTargetRules Target) : base(Target)
    {
        PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;

        PublicDependencyModuleNames.AddRange(new string[]
        {
            "Core",
            "CoreUObject",
            "Engine"
        });
    }
}

Test.h / Test.cpp

// Test.h
#pragma once
#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"

class FTestModule : public IModuleInterface
{
public:
    virtual void StartupModule() override;
    virtual void ShutdownModule() override;
};

// Test.cpp
#include "Test.h"

void FTestModule::StartupModule()
{
    UE_LOG(LogTemp, Warning, TEXT("=== Test Module Started! ==="));
}

void FTestModule::ShutdownModule()
{
    UE_LOG(LogTemp, Warning, TEXT("=== Test Module Shutdown! ==="));
}

IMPLEMENT_MODULE(FTestModule, Test);

IMPLEMENT_MODULE 매크로가 없으면 모듈로 등록할 수 없다.

처음에 cpp파일을 만들고 실행했을 때 오류가 발생했는데, 이 부분이 없어서 그런 것이었다.

언리얼이 모듈을 로드할 때 이 매크로가 진입점 역할을 한다.

모듈 등록

파일을 만들고 빌드 시스템과 프로젝트 파일에 알려야한다.

Target.cs 수정

source 폴더에 있는

이 두 파일을 수정해준다.

// 변경 전
ExtraModuleNames.AddRange(new string[] { "HW10" });

// 변경 후
ExtraModuleNames.AddRange(new string[] { "HW10", "Test" });

.uproject 수정

HW10.uproject 파일의 내부를 수정해준다.

모듈 배열에 "Test" 모듈을 추가해준다.

LoadingPhase를 PreDefault로 설정한 이유는 주 모듈(HW10)보다 Test모듈이 먼저 로드되어야 주 모듈에서 Test모듈의 클래스를 사용할 수 있기 때문이다.

TestActor 생성

모듈의 동작을 확인하기 위해서 Test모듈 안에 Actor를 만들었다.

// TestActor.cpp
#include "TestActor.h"

ATestActor::ATestActor()
{
    PrimaryActorTick.bCanEverTick = false;
}

void ATestActor::BeginPlay()
{
    Super::BeginPlay();

    UE_LOG(LogTemp, Warning, TEXT("=== TestActor BeginPlay! Test Module Working! ==="));

    if (GEngine)
    {
        GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green,
            TEXT("Test Module Working!"));
    }
}

이렇게 이 모듈에서 Actor의 BeginPlay가 실행되면 로그가 찍히도록 했다.

주 모듈에서 TestActor 스폰

HW10.Build.cs에 Test 의존성을 추가해준다.

PublicDependencyModuleNames.AddRange(new string[]
{
    "Core", "CoreUObject", "Engine", "InputCore",
    "EnhancedInput",
    "Test"  // 추가
});

HW10Character.cpp BeginPlay에서 스폰

#include "TestActor.h"

void AHW10Character::BeginPlay()
{
    Super::BeginPlay();

    FActorSpawnParameters SpawnParams;
    GetWorld()->SpawnActor<ATestActor>(
        ATestActor::StaticClass(),
        GetActorLocation(),
        FRotator::ZeroRotator,
        SpawnParams
    );
}

모듈 결과 확인

여기까지 하면 에디터를 처음 열었을 때, 모듈의 시작로그, 에디터의 실행을 했을 때, 액터의 BeginPlay 로그가 찍혀야 한다.

정상적으로 로그가 나오는 모습을 확인할 수 있다.

Temporary 플러그인 만들기

모듈과 플러그인의 차이에는 재사용성에 있다.

모듈은 프로젝트 안에 종속되지만, 플러그인은 독립적인 구조를 가져서 다른 프로젝트에서도 쓸 수 있다.

이번엔 플러그인 폴더를 만들어 본다.

플러그인 폴더 구조 생성

프로젝트 폴더에 Plugins폴더를 만들고 내부를 다음과 같이 구성한다.

Plugins/
└── Temporary/
    ├── Content/
    ├── Source/
    │   └── Temporary/
    │       ├── Temporary.Build.cs
    │       ├── Temporary.h
    │       └── Temporary.cpp
    └── Temporary.uplugin

Temporary.uplugin 작성

플러그인의 메타데이터를 JSON형식으로 기입하는 파일이다.

이 파일이 있어야 언리얼이 폴더를 플러그인으로 인식한다.

CanContatinContent 를 true로 설정해야 콘텐츠 브라우저에서 플러그인 폴더가 보인다.

플러그인 모듈 파일 작성

모듈 구조는 Test모듈과 동일하다.

Temporary.Build.cs

PublcIncludePaths.Add(ModuleDirectory); 는 이후에 나올 include 경로의 문제때문에 이를 해결하면서 추가했다.

Temporary.h

Temporary.cpp

.uproject에 플러그인 등록

기존 uproject 파일에서 Plugins 항목에 Temporary를 추가했다.

플러그인 활용 - CharacterData클래스

Temporary 플러그인 안에 UCharacterData 클래스를 만들어 캐릭터의 데이터를 저장하게 하고, 주 모듈의 캐릭터에서 해당 데이터를 출력해보려고 한다.

UCharacterData.h

UCharacterData.cpp

UObject를 상속받는 이유는 가비지컬렉터가 메모리를 자동 관리하고, UPROPERTY 매크로를 사용할 수 있기 때문이다.

단순 struct나 일반 class로는 이런 기능을 사용할 수 없다.

캐릭터에서 Data 사용

// HW10Character.h
#include "CharacterData.h"

// 클래스 안에 변수 선언
UPROPERTY()
TObjectPtr<UCharacterData> CharacterData;

// HW10Character.cpp BeginPlay
void AHW10Character::BeginPlay()
{
    Super::BeginPlay();

    CharacterData = NewObject<UCharacterData>(this);

    if (IsValid(CharacterData))
    {
        FString Message = FString::Printf(
            TEXT("=== CharacterData: Name: %s | HP: %.0f | Speed: %.0f | Level: %d ==="),
            *CharacterData->CharacterName,
            CharacterData->MaxHealth,
            CharacterData->MoveSpeed,
            CharacterData->Level
        );

        GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Yellow, Message);
        UE_LOG(LogTemp, Warning, TEXT("%s"), *Message);
    }
}

이렇게 하고 실행하면 정확히 로그가 출력되어야 한다.

트러블슈팅 - include 경로를 찾지 못하는 문제

HW10Character.cpp 부분에서 에러가 발생했다.

Error C1083: Cannot open include file: 'CharacterData.h': No such file or directory

이 오류의 원인은 HW10 모듈이 Temporary 플러그인의 헤더 파일 경로를 알지 못해서 나오는 오류이다.

다음 두 가지를 수정해서 해결했다.

Temporary.Build.cs에 include 경로 추가

using System.IO;  // 추가

// Build.cs 생성자 안에 추가
PublicIncludePaths.Add(ModuleDirectory);

아까 Build.cs 부분에서 잠깐 나왔던 부분이다.

ModuleDirectory는 Build.cs가 있는 폴더의 절대 경로를 자동으로 반환하는 내장변수이다.

이렇게 하면 이 모듈에 의존하는 다른 모듈들도 해당 경로를 include 경로로 사용할 수 있다.

HW10.Build.cs에 Temporary 의존성 추가

PublicDependencyModuleNames.AddRange(new string[]
{
    "Core", "CoreUObject", "Engine", "InputCore",
    "EnhancedInput", "Test",
    "Temporary"  // 추가
});

최종 결과

모든 설정이 완료된 후 에디터를 켜고, PIE를 실행했을 때의 Output Log이다. 문제없이 잘 출력되는 모습을 확인할 수 있다.

핵심 포인트 정리

언리얼 모듈은 Build.cs, 헤더, cpp 세 파일이 최소 구성이다.
모듈을 추가하면 Target.cs와 .uproject 두 곳에 등록해야 빌드 대상이 된다.
LoadingPhase: PreDefault는 주 모듈보다 먼저 로드되어야 하는 모듈에 사용한다.
StartupModule()은 에디터 시작 시 실행된다.
플러그인은 .uplugin 파일이 있어야 언리얼이 플러그인으로 인식한다.
API매크로는 파일이 속한 모듈의 것을 사용해야 한다.
다른 모듈의 헤더를 include 하려면 PublicIncludePaths와 PublicDependencyModuleNames 두 곳에 등록해야 한다.
UObject를 상속받아야 NewObject<> , UPROPERTY(), 가비지컬렉션 자동 관리를 사용할 수 있다.

<프로그래머스 C++> 괄호 회전하기 풀이 (stack)

tjdgus123 — Tue, 23 Jun 2026 11:35:40 +0900

문제

대괄호, 중괄호, 소괄호로 이루어진 문자열 s를 왼쪽으로 x칸 회전했을 때 올바른 괄호 문자열이 되는 x의 개수를 return하는 문제이다.

풀이 아이디어

이 문제의 핵심 포인트는 두 가지이다.

1. 문자열 회전

x칸을 회전하는 것은 왼쪽 앞부분을 잘라 뒤에 붙이면 된다.

"[](){}" 를 2칸 회전
뒷부분: s.substr(2)    = "(){}"
앞부분: s.substr(0, 2) = "[]"
회전 결과 = "(){}" + "[]" = "(){}[]"

string rotated = s.substr(x) + s.substr(0, x);

2. 올바른 괄호 판별 (스택 사용)

여는 괄호를 stack에 push, 닫는 괄호는 스택의 top과 짝이 맞는지 확인한다.

모든 문자를 처리한 후, 스택이 0이 되면 올바른 괄호라고 판단한다.

닫는 괄호가 나왔는데 스택이 비어있다면 false이다.

스택 top이 대응하는 여는 괄호가 아니여도 false이다.

"([)]" 경우
( → push
[ → push
) → top이 [ → 짝 불일치 

")(" 경우
) → 스택 비어있음 → 즉시

문제 풀이

#include <string>
#include <vector>
#include <stack>
using namespace std;

bool IsValid(string s)
{
    stack<char> st;
    for(char c : s)
    {
        if(c == '(' || c == '[' || c == '{')
            st.push(c);
        else
        {
            if(st.empty()) return false;
            char top = st.top();
            st.pop();
            if(c == ')' && top != '(') return false;
            if(c == ']' && top != '[') return false;
            if(c == '}' && top != '{') return false;
        }
    }
    return st.empty();
}

int solution(string s) {
    int answer = 0;

    for(int i = 0; i < s.size(); ++i)
    {
        string rotated = s.substr(i) + s.substr(0, i);
        if(IsValid(rotated))
            answer++;
    }
    return answer;
}

코드 흐름

1. 문자열 회전

string rotated = s.substr(i) + s.substr(0, i);

i칸 회전한 문자열을 만든다.

s.substr(i)는 i번째부터 끝까지, s.substr(0, i)는 앞에서부터 i까지이다. 두 개를 합치면 i칸 왼쪽으로 회전한 결과가 나온다.

2. 여는 괄호 push

if(c == '(' || c == '[' || c == '{')
    st.push(c);

여는 괄호를 stack에 push한다.

3. 닫는 괄호 체크

if(st.empty()) return false;
char top = st.top();
st.pop();
if(c == ')' && top != '(') return false;
if(c == ']' && top != '[') return false;
if(c == '}' && top != '{') return false;

닫는 괄호가 나오면 두 가지를 체크한다.

1. 스택이 비어있는가?

→ 스택이 비어있으면 짝이 없는 괄호이다.

2. 스택 top이 대응하는 여는 괄호가 아닌가?

→ 이 경우에는 괄호가 일치하지 않는 것.

4. 최종 판별

return st.empty();

모든 문자를 처리한 후 스택이 비어있으면 올바른 괄호이다. 이 경우에 IsValid()함수에서 true를 반환한다.

핵심포인트

x칸 회전은 s.substr(x) + s.substr(0, x)로 구현한다.
괄호 판별은 스택으로한다. 여는 괄호는 push, 닫는 괄호는 top과 짝 확인 후 pop한다.
닫는 괄호 체크 시 스택이 비어있는 경우도 반드시 처리해야 한다.

<프로그래머스 C++> 귤 고르기 풀이 (unordered_map, greedy)

tjdgus123 — Mon, 22 Jun 2026 12:16:18 +0900

문제

귤 k개를 골라 상자에 담을 때 크기 종류의 수를 최소화하는 문제이다.

귤의 크기별 개수를 세고, 개수가 많은 순서대로 담아 종류를 최소화할 수 있다.

풀이 아이디어

종류 수를 최소화하려면 개수가 많은 크기부터 먼저 담으면 된다.

[1, 3, 2, 5, 4, 5, 2, 3]에서 크기별로 개수를 세면 다음과 같다.

2 → 2개
3 → 2개
5 → 2개
1 → 1개
4 → 1개

개수 많은 순으로 정렬하면 [2, 2, 2, 1, 1,]

k = 6이면 2 + 2 + 2 = 6으로 세 종류를 담을 수 있다.

문제 해결 흐름

unordered_map으로 크기별 개수를 센다.
개수만 꺼내 내림차순으로 정렬한다.
개수가 많은 순서대로 k에서 빼며 종류 수를 센다.
k가 0이하가 되는 순간 종료한다.

문제 풀이

#include <string>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

int solution(int k, vector<int> tangerine) {
    int answer = 0;
    unordered_map<int, int> ans;

    for(int fruit : tangerine)
        ans[fruit]++;

    vector<int> count;
    for(auto const& pair : ans)
        count.push_back(pair.second);

    sort(count.begin(), count.end(), greater<int>());

    for(int cnt : count)
    {
        k -= cnt;
        answer++;
        if(k <= 0) break;
    }
    return answer;
}

unordered_map VS map

개수를 세는 자료구조로 map과 unordered_map을 고민한 끝에 unordered_map을 사용했다.

두 자료구조의 차이는 다음과 같다.

	map	unordered_map
내부 구조	레드 - 블랙 트리	해시 테이블
삽입 / 탐색	O(log N)	O(1) 평균
키 정렬	자동 정렬	정렬 없음

이 문제에선 귤 크기(key) 기준 정렬이 필요 없고 단순히 개수만 세면 된다.

map을 써도 정답 처리는 되겠지만 키를 자동 정렬하는 과정이 들어가 O(N log N)이 소요된다.

unordered_map을 사용하면 개수를 세는 과정을 O(N)으로 최적화할 수 있어 훨씬 빠르다.

코드 흐름

1. 크기별 개수 세기

unordered_map<int, int> ans;
for(int fruit : tangerine)
    ans[fruit]++;

귤 크기를 키, 개수를 값으로 저장한다.

unordered_map을 이용해서 O(N)으로 처리할 수 있다.

2. 개수만 추출해서 내림차순 정렬

vector<int> count;
for(auto const& pair : ans)
    count.push_back(pair.second);

sort(count.begin(), count.end(), greater<int>());

크기는 상관없이 종류만 계산하면 되므로 pair.second만 꺼내 사용한다.

greater<int>()를 이용하면 내림차순 정렬이 가능하다.

3. 그리디 방식으로 담기

for(int cnt : count)
{
    k -= cnt;
    answer++;
    if(k <= 0) break;
}

개수가 많은 순서대로 k에서 빼면서 종류 수를 센다.

k가 0이하가 되는 순간 k개를 다 채운 것이므로 종료한다.

핵심 포인트

종류 수를 최소화하려면 개수가 많은 크기부터 담는 그리디 전략을 사용한다.
단순 개수 세기에는 map보다 unordered_map이 O(N)으로 더 효율적이다.
크기(키)는 필요 없으므로 개수(값)만 꺼내 정렬한다.

<프로그래머스 C++> 멀리 뛰기 풀이 (피보나치)

tjdgus123 — Thu, 18 Jun 2026 10:32:28 +0900

문제

한 번에 1칸 또는 2칸을 뛸 수 있을 때, n칸을 이동하는 방법의 수를 1234567로 나눈 나머지를 return하는 문제이다.

풀이 아이디어

n칸에 도달하는 방법을 생각해보면, 마지막 점프가 1칸이었거나 2칸이었거나 둘 중 하나이다.

f(n) = f(n-1) + f(n-2)

이 문제를 보자마자 피보나치 수열의 점화식이 바로 떠올랐다.

초기값은

f(1) = 1  →  (1칸)
f(2) = 2  →  (1+1칸), (2칸)

이렇게 설정한다.

https://tjdgus123.tistory.com/95

<프로그래머스 C++> 피보나치 수 풀이(재귀 함수)

문제F(0) = 0F(1) = 1 일때 F(n) = F(n-1) + (n-2)인 피보나치 수열에서 n번째 수를 1234567로 나눈 나머지를 return하는 문제이다.풀이 아이디어처음엔 재귀함수로 접근했다.int Fib(int n) { if(n 재귀 방식은 구현

tjdgus123.tistory.com

이 문제에서 푼 것 것처럼 반복문으로 해결한다.

재귀로 구현하면 직관적이지만 n이 최대 2000이므로 중복 계산이 폭발적으로 늘어나 시간 초과가 발생한다.

문제 풀이

#include <string>
#include <vector>
using namespace std;

long long solution(int n) {
    if(n <= 1) return n;

    long long a = 1, b = 1;
    for(int i = 2; i <= n; ++i)
    {
        long long c = (a + b) % 1234567;
        a = b;
        b = c;
    }
    return b;
}

코드 흐름

1. 초기값 설정

if(n <= 1) return n;
long long a = 1, b = 1;

a = f(1)

b = f(2)

루프 시작전, f(1)과 f(2)를 각각 담아둔다.

2. 반복문으로 피보나치 계산

for(int i = 2; i <= n; ++i)
{
    long long c = (a + b) % 1234567;
    a = b;
    b = c;
}

매 반복마다 세 변수가 한 칸씩 앞으로 당겨진다.

n = 4일때,

초기: a=1(f1), b=1(f2)

i=2: c=(1+1)%1234567=2  →  a=1, b=2   f(2)=2
i=3: c=(1+2)%1234567=3  →  a=2, b=3   f(3)=3
i=4: c=(2+3)%1234567=5  →  a=3, b=5   f(4)=5

루프가 i=n에서 끝날 때 b에 f(n)이 담겨있는 모습이다.

3. 결과

return b;

따라서 b를 리턴한다.

% 1234567을 매번 하는 이유

n이 최대 2000일 때, 피보나치 수는 천문학적으로 커져 long long으로도 표현이 불가능할 정도이다.

수학적으로도 (a + b) % m - ((a % m) + (b % m)) % m 이 성립하므로, 매번 나눠줘도 최종 결과가 같다.

그렇기 때문에 중간에 나눠주는 것이 overflow를 방지할 수도 있어 계속 나눠주는 것이다.

마지막에 한 번만 나누면
f(2000) = 천문학적으로 큰 수 → overflow → 틀린 답

매번 나누면
c = (a + b) % 1234567  // 항상 1234567 미만으로 유지 → 정확한 답

핵심 포인트

멀리 뛰기 경우의 수는 피보나치 수열과 동일한 점화식 f(n) = f(n-1) + f(n-2)을 따른다.
재귀 대신 반복문으로 O(n)에 해결한다.
overflow 방지를 위해 매 반복마다 % 1234567을 적용한다.

<프로그래머스 C++> n개의 최소공배수 (유클리스 호제법)

tjdgus123 — Wed, 17 Jun 2026 11:52:31 +0900

문제

n개의 수들의 배수 중 공통이 되는 가장 작은 최소공배수를 구하는 문제이다.

풀이 아이디어

두 수의 최소공배수는 아래 공식으로 구할 수 있다.

LCM(a, b) = a * b / GCD(a, b)

GCD는 최대공약수, LCM은 최소공배수이다.

이 공식을 이용해서 구해볼 것이다.

GCD와 LCM

GCD(최대공약수)

두 수를 모두 나눌 수 있어야 하므로 공통 인수 중에서 작은 것을 택한다.

12 = 2² × 3
 8 = 2³

공통 인수: 2
2²로 나누면 → 12/4=3, 8/4=2 (true)
2³으로 나누면 → 12/8=1.5 (false)

GCD = 2² = 4

LCM(최소공배수)

두 수를 모두 담을 수 있어야 하므로 공통 인수 중에서 큰 것을 택한다.

12 = 2² × 3
 8 = 2³

2³ × 3 = 24
24 / 12 = 2 (true)
24 / 8  = 3 (true)

LCM = 2³ × 3 = 24

문제 풀이

#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int Gcd(int a, int b) {
    while(b) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int Lcm(int a, int b)
{
    return a / Gcd(a, b) * b;
}

int solution(vector<int> arr) {
    int answer = arr[0];

    for(int i = 1; i < arr.size(); ++i)
        answer = Lcm(answer, arr[i]);

    return answer;
}

코드 흐름

1. GCD - 유클리드 호제법

int Gcd(int a, int b) {
    while(b) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

GCD(a, b) = GCD(b, a%b) 원리를 반복문으로 구현했다.

b가 0이 되는 순간의 a가 최대공약수이다.

예시로 a = 12, b = 8일 때의 코드의 흐름을 표현하면 다음과 같다.

a=12, b=8  →  temp=8, b=12%8=4, a=8
a=8,  b=4  →  temp=4, b=8%4=0,  a=4
a=4,  b=0  →  종료
return 4

2. LCM()

int Lcm(int a, int b)
{
    return a / Gcd(a, b) * b;
}

a * b / GCD 의 공식을 사용한다.

a * b를 먼저 계산하면 Overflow가 발생할 수 있으므로 먼저 나누고 곱하는 순서로 작성했다.

3. n개의 LCM 계산

int answer = arr[0];
for(int i = 1; i < arr.size(); ++i)
    answer = Lcm(answer, arr[i]);

첫 번째 원소를 초기값으로 설정하고, 두 수씩 순서대로 LCM을 적용한다.

핵심 포인트

GCD는 유클리드 호제법 GCD(a, b) = GCD(b, a % b)으로 구한다.
LCM 공식은 a * b / GCD(a, b)이며, overflow 방지를 위해 a / GCD * b 순서로 계산한다.
n개의 LCM은 두 수씩 순서대로 LCM을 적용한다.

<프로그래머스 C++> 예상 대진표 풀이 ( ceil() )

tjdgus123 — Tue, 16 Jun 2026 11:20:15 +0900

문제

토너먼트 대회에서 N명이 참가하고, 매 라운드마다 인접한 번호끼리 대결한다. 그리고 이기는 사람이 다음 라운드에 올라간다.

A번 참가자와 B번 참가자가 몇 번째 라운드에서 만나는지 return하는 문제이다.

단, 두 참가자는 만나기 전까지 항상 이긴다고 가정한다.

풀이 아이디어

매 라운드마다 참가자 번호가 절반으로 줄어든다.

A와 B의 번호를 매 라운드마다 갱신하면서 두 번호가 갈라지는 순간이 만나는 라운드이다.

다음 라운드에서의 번호는 ceil(번호 / 2.0)으로 갱신한다.

1번↔2번 → 이긴 사람은 다음 라운드 1번  →  ceil(1/2.0)=1, ceil(2/2.0)=1
3번↔4번 → 이긴 사람은 다음 라운드 2번  →  ceil(3/2.0)=2, ceil(4/2.0)=2

A = 4, B = 7을 예시로 들어보면

1라운드: a=ceil(4/2.0)=2,  b=ceil(7/2.0)=4  →  2 ≠ 4
2라운드: a=ceil(2/2.0)=1,  b=ceil(4/2.0)=2  →  1 ≠ 2
3라운드: a=ceil(1/2.0)=1,  b=ceil(2/2.0)=1  →  1 == 1 (true) → 3라운드에서 만남

문제 풀이

#include <iostream>
#include <cmath>
using namespace std;

int solution(int n, int a, int b)
{
    int round = 0;
    while(1)
    {
        round++;
        a = ceil(a / 2.0);
        b = ceil(b / 2.0);
        if(a == b) break;
    }
    return round;
}

Ceil()을 쓰는 이유

Ceil()은 <cmath> 헤더에 정의된 함수로 올림 연산을 수행한다.

올림 연산 말고도 다음과 같은 함수들이 있다.

함수	설명	예시
ceil(x)	올림	ceil(3.5) = 4
floor(x)	내림	floor(3.5) = 3
round(x)	반올림	round(3.5) = 4

이 중에서 Ceil() 함수를 쓴 이유는 토너먼트에서 홀수 번호는 승리해서 다음 라운드로 넘어가게 되면 올림된 번호를 받게 된다.

7번 → ceil(7/2.0) = ceil(3.5) = 4번

이를 2.0으로 나누는 이유는 int / int 나눗셈은 정수 나눗셈이 되어 소수점이 버려지기 때문이다.

7 / 2   = 3   (정수 나눗셈 — 내림)
7 / 2.0 = 3.5 (실수 나눗셈 — ceil 적용 가능)

소수점이 버려지게 되면 올림 연산이 불가능해져 2.0으로 나누는 것이다.

코드 흐름

1. 라운드 반복

while(1)
{
    round++;
    a = ceil(a / 2.0);
    b = ceil(b / 2.0);
    if(a == b) break;
}

매 라운드마다 a와 b를 다음 라운드 번호로 갱신한다.

두 번호가 같아지면 그 라운드에서 만나는 것이다. 따라서 번호가 같아질 때 break로 반복문을 빠져나간다.

2. 두 사람이 만나는 조건

if(a == b) break;

위 설명과 같이 같은 번호가 되었다는 것은 같은 조에 배정되었다는 의미이기 때문에 이 시점의 round를 return하면 그게 정답이 된다.

트러블슈팅

a와 b의 갱신 방식을 잘못 선택함

처음엔 a와 b를 이런식으로 갱신했다.

float A;
A = ceil(a / 2.0);  
a /= 2;          //정수 나눗셈으로

ceil로 계산한 값과 정수 나눗셈으로 갱신한 값이 달라서 일부는 맞고 일부는 틀린 결과가 나왔다.

그래서 매개변수를 ceil로 갱신하는 방법으로 통일해서 이 오류를 수정했다.

// 수정한 부분
a = ceil(a / 2.0);
b = ceil(b / 2.0);

핵심포인트

다음 라운드 번호는 ceil(번호 / 2.0)으로 구한다.
int / int는 정수 나눗셈이므로 반드시 2.0으로 나눠야 한다.
a == b가 되는 순간이 매칭되는 라운드이므로 그 때의 round를 리턴한다.

<프로그래머스 C++> 카펫 풀이 (브루트포스)

tjdgus123 — Mon, 15 Jun 2026 13:08:43 +0900

문제

중앙은 "노란색", 테두리 1줄은 "갈색"인 격자 모양 카펫에서 갈색 격자 수 brown과 노랜삭 격자 수 yellow가 주어질 때, 카펫의 가로/세로 크기를 return하는 문제이다.

단, 가로 길이는 세로 길이보다 크거나 같다.

풀이 아이디어

가로를 w, 세로를 h라고 하면 두 가지 관계식을 세울 수 있다.

1. 전체 크기

w * h = brown + yellow

2. 갈색 테두리 수

테두리는 위 / 아래 / 좌 / 우 한 줄씩인데, 네 모서리는 중복으로 계산되기 때문에 4를 뺀다.

■ ■ ■ ■
■ □ □ ■
■ ■ ■ ■

위쪽:   w개
아래쪽: w개
왼쪽:   h개
오른쪽: h개
→ 2*w + 2*h - 4 (모서리 4개 중복 제거)

2*w + 2*h - 4 = brown

브루트포스

이 두 식을 연립해서 풀어도 가능하지만, 브루트포스 방식으로 접근하면 더 간단해진다.

w * h = total이므로, w와 h는 total의 약수의 쌍과 같다.

h를 1부터 늘려가면서 total % == 0인 경우에 brown 조건을 체크하면 된다.

total = 12 (brown=10, yellow=2)

약수 쌍 탐색:
h=1: w=12  →  2*12+2*1-4=22  ≠ 10
h=2: w=6   →  2*6+2*2-4=12   ≠ 10
h=3: w=4   →  2*4+2*3-4=10   == 10  → [4, 3]

가로가 세로보다 크거나 같아야 하므로 w < h가 되는 순간 더 이상 탐색할 필요가 없다.

문제 풀이

#include <string>
#include <vector>
using namespace std;

vector<int> solution(int brown, int yellow) {
    vector<int> answer;
    int total = brown + yellow;

    for(int h = 1; h <= total; ++h)
    {
        if(total % h == 0)
        {
            int w = total / h;
            if(w < h) break;

            if(2*w + 2*h - 4 == brown)
            {
                answer = {w, h};
                break;
            }
        }
    }
    return answer;
}

코드 흐름

1. 전체 크기 계산

int total = brown + yellow;

전체 격자 수를 구한다.

w*h = total이므로 w와 h는 total의 약수의 쌍이다.

2. 약수 쌍 탐색

for(int h = 1; h <= total; ++h)
{
    if(total % h == 0)
    {
        int w = total / h;

h를 1부터 늘려가면서 total을 나누어 떨어지는 경우에만 처리한다(약수인 경우).

나머지가 0이면 h가 약수이고, w = total / h로 가로길이를 구한다.

3. 가로 세로 조건

if(w < h) break;

문제 조건에서 가로가 세로보다 크거나 같아야 한다는 조건이 있었다. h가 커질수록 w는 작아지므로 w < h가 되는 순간 이후 약수 쌍은 모두 세로가 길어져 조건을 만족하지 않는다.

그 이후부터는 break로 탐색을 종료한다.

4. brown 조건 체크

if(2*w + 2*h - 4 == brown)
{
    answer = {w, h};
    break;
}

테두리 공식 2 * w + 2 * h - 4가 brown과 일치하게 되면 정답이다. {w, h} 순서로 반환한다.

핵심 포인트

테두리 갈색 수는 2 * w + 2 * h - 4로 표현된다
w * h = total이므로 h의 약수 쌍을 브루트포스로 탐색한다
w < h가 되는 순간 break해서 불필요한 탐색을 줄인다

<프로그래머스 C++> 피보나치 수 풀이(재귀 함수)

tjdgus123 — Fri, 12 Jun 2026 11:29:44 +0900

문제

F(0) = 0

F(1) = 1 일때 F(n) = F(n-1) + (n-2)인 피보나치 수열에서 n번째 수를 1234567로 나눈 나머지를 return하는 문제이다.

풀이 아이디어

처음엔 재귀함수로 접근했다.

int Fib(int n) {
    if(n < 2) return n;
    return Fib(n-1) + Fib(n-2);
}

재귀 방식은 구현이 직관적이라서 사용하기 좋지만 시간복잡도가 O(2^n)이라 n이 커질수록 급격히 느려진다.

Fib(5)만 호출해도 Fib(3)이 2번 Fib(2)가 3번이 중복 호출되어 매우 비효율적이다.

Fib(5)
├── Fib(4)
│   ├── Fib(3)  ← 중복
│   └── Fib(2)  ← 중복
└── Fib(3)      ← 중복
    └── Fib(2)  ← 중복

n이 최대 100,000인 이 문제에서 재귀함수를 쓰면 시간 초과가 발생할 수 있다.

그래서 반복문으로 바꿔 O(n)으로 해결하려고 한다.

문제 풀이

#include <string>
#include <vector>
using namespace std;

int Fib(int n)
{
    if(n < 2) return n;
    int a = 0, b = 1;
    for(int i = 2; i <= n; ++i)
    {
        int c = (a + b) % 1234567;
        a = b;
        b = c;
    }
    return b % 1234567;
}

int solution(int n) {
    return Fib(n);
}

나머지를 매번 나누는 이유?

문제에서는 "n번째 피보나치 수를 1234567로 나눈 나머지를 return" 하라고 했다.

그래서 처음엔 n번째 수까지 피보나치를 적용한 후 마지막에 나눈 수를 return했다.

하지만 이렇게 되면 오버플로우가 발생하게 된다.

n = 100,000일 때 피보나치수는 천문학적으로 커져 int는 물론, long long으로도 표현이 불가능한 숫자가 된다.

중간 계산 값이 범위를 넘어버리면 이미 틀린 값이 되어버려 오답이 된다.

수학적으로

(a + b) % m = ((a % m) + (b % m)) % m

이 성립하기 때문에 매번 나눠도 최종 결과가 동일하다.

// 마지막에 한 번만 나누면
Fib(100000) = 천문학적으로 큰 수 → overflow → 오답

// 매번 나누면
c = (a + b) % 1234567  // 매 반복시 1234567 미만으로 유지 → 정답

코드 흐름

1. 초기값 설정

int a = 0, b = 1;

재귀함수 기준 a는 F(n-2), b는 F(n-1)을 의미한다.

재귀 함수의 조건 중 하나인 명확한 이탈 조건을 명시해야 하기 때문에 시작값인 F(0) = 0과 F(1) = 1로 초기화해준다.

2. 반복문으로 피보나치 계산

for(int i = 2; i <= n; ++i)
{
    int c = (a + b) % 1234567;
    a = b;
    b = c;
}

매 반복마다 세 변수가 한 칸씩 앞으로 당겨진다.

변수	역할
a	F(n-2)
b	F(n-1)
c	F(n) = a + b

예시로 Fib(5)라고 했을 때,

초기: a=0(F0), b=1(F1)

i=2: c = a+b = 0+1 = 1           → a=b=1,  b=c=1   // a=F(1), b=F(2)
i=3: c = a+b = 1+1 = 2           → a=b=1,  b=c=2   // a=F(2), b=F(3)
i=4: c = a+b = 1+2 = 3           → a=b=2,  b=c=3   // a=F(3), b=F(4)
i=5: c = a+b = 2+3 = 5           → a=b=3,  b=c=5   // a=F(4), b=F(5)

return b = 5

매 반복마다 a → b → c 순서로 한 칸씩 앞으로 당겨지는 구조이다.

c를 먼저 계산한 뒤 a=b, b=c 순서로 대입해야 한다. 순서가 바뀌면 a가 덮어씌워져서 c계산이 틀어진다.

3. 결과 반환

return b % 1234567;

최종 결과도 한 번 더 나눠서 반환한다.

트러블슈팅

나머지 연산을 조건부로만 적용해서 몇 개의 케이스에서 오류가 났다.

처음 코드

if(a > 1234567)
{
    a %= 1234567;
    b %= 1234567;
}
int c = a + b;

여기서 두 가지 문제가 있었다.

문제 1 - 조건이 틀림

a > 1234567 일 때만 나머지 연산을 하게 되면, a가 1234566, b가 그보다 더 큰 수이면 더했을 때 범위를 벗어나게 되어 매번 나눠주는 것이 좋다.

문제 2 - 나누는 시점이 늦다.

// a와 b를 먼저 나누고
a %= 1234567;
b %= 1234567;
// 그 다음 더함
int c = a + b;  // 여기서도 overflow 가능

a와 b를 따로따로 나눠도 더하는 순간 다시 범위를 넘을 수 있었다.

덧셈과 나머지 연산을 동시에 처리해야 한다.

int c = (a + b) % 1234567;

핵심포인트

재귀 방식은 O(2^n)으로 n이 클 때 시간 초과가 발생한다. 반복문으로 O(n)으로 줄인다
(a + b) % m = ((a % m) + (b % m)) % m이 성립하므로 매번 나눠도 최종 결과가 동일하다
매번 나머지 연산을 적용해 overflow를 방지한다