isekaipudding 님의 블로그

[수학 - 제곱근]백준 제곱 수?(34027번) 풀이 (C++/Python)

isekaipudding — Fri, 1 May 2026 11:00:27 +0900

사칙연산에서 덧셈, 뺄셈, 곱셈, 나눗셈에 대해 간단하게 알아봤습니다.

이 중에 곱셈에 대해 좀 더 깊게 공부할려고 합니다.

우선 2를 몇 번 곱하면 값이 각각 어떻게 나올까요?

먼저 1번만 곱하면 값은 2가 나옵니다.(1 * 2 = 2)

그 다음 2번 곱하면 값은 4가 나옵니다.(1 * 2 * 2 = 4)

그러면 2를 n번 곱하면 뭐라고 부를까요? 2^n이라고 부릅니다.

만약 2가 아닌 3으로 바꾸면 3^n이 되며 예시로 n=4이면 3^4 = 81이 됩니다.

이것을 일반화하면 다음과 같은 식이 나옵니다.

$$y = x^n$$

같은 수를 여러 번 곱하는 것을 거듭제곱이라고 부릅니다.

그리고 여기서 x를 밑(base), n을 지수(exponent)라고 부릅니다.

예시로 x = 5, n = 3이면 y = 125가 됩니다.

보통 주변에서 불리는 제곱은 n이 2일 때의 경우이며 n이 3이면 세제곱, n이 4이면 네제곱으로 부릅니다.

예시로 2^3이면 2의 세제곱이라고 부릅니다.

C++로 x, n을 입력할 때 x^n을 구하는 소스 코드를 구현합니다.

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    long long y, x, n;
    cin >> x >> n;

    y = 1;
    while(n--) y *= x;
    cout << y;

    return 0;
}

x = 3, n = 5로 입력하면 출력은 아래와 같이 나옵니다.

이렇게 해서 y = 3^5 = 243로 출력하게 됩니다.

그러면 그 반대도 가능할까요?

네 가능합니다. x, n이 주어지는 대신 y, n이 주어질 때 x를 구하는 수학 공식이 있습니다.

이것을 수식으로 표현하면 다음과 같습니다.

x = \sqrt[n]{y}

n=2인 경우 제곱근, n=3인 경우 세제곱근, n=4인 경우 네제곱근이라고 부릅니다.

예시로 9의 제곱근은 3, 8의 세제곱근은 2, 625의 제곱근은 5라고 부릅니다.

(3^2 = 9, 2^3 = 8, 5^4 = 625)

또한 n=2인 경우 다음과 같이 표현할 수 있습니다.

x = \sqrt{y}

n=2인 경우 숫자 2를 없애고 표현할 수 있으며 y의 제곱근 대신 루트 y라고 읽기도 합니다.

그리고 오늘 게시글 주제는 루트 값을 구하는 소스 코드를 구현하는 것입니다.

C++ 및 Python으로 구현할 수 있을까요?

결론부터 말하자면 그냥 sqrt() 함수를 호출해서 사용하세요.

왜냐면 실수 기초에서 보면 알겠지만 실수 연산 자체가 원래 많이 복잡합니다.

거기에 제곱근을 구하는 과정은 하드웨어 레벨에서 어셈블리어(SQRTSD)까지 이해해야 하고

소프트웨어 레벨에서도 뉴턴-랩슨 방법 수학 공식을 사용해야 할 정도로 많이 어려운 편입니다.

아래는 sqrt() 없이 루트 529를 구하는 Python 소스 코드입니다.

import sys
from decimal import Decimal, getcontext

input = sys.stdin.readline

getcontext().prec = 50

LIMIT = 100

dp:list = [Decimal('0') for _ in range(LIMIT + 1)]

# 529의 제곱근 구하기 위해 입력값을 529으로 설정합니다.
target:Decimal = Decimal('529')

# 초기값
dp[0] = (1 + target) / 2

# 점화식
for i in range(1, LIMIT + 1, 1) :
    dp[i] = Decimal('0.5') * (dp[i-1] + target / dp[i-1])

print(dp[-1])

이것을 실행하면 다음과 같습니다.

이렇게 이해하기 어려운 소스 코드를 통해 루트 529 = 23이라는 결과를 알게 됩니다.

그러면 부동 소수점 고려하면서 수학 공식까지 사용하면서 직접 제곱근을 구현해야 할까요?

다행히 C++ 및 Python에서 이미 천재 개발자 및 연구원들이 sqrt() 함수로 이미 내부에서 최적화된 코드로 구현해 놓았기 때문에 우리는 sqrt() 함수를 사용하기만 하면 됩니다.

먼저 C++로 루트 529 구하는 과정을 구현하면 다음과 같습니다.

#include <cmath>로 불러들어서 std::sqrt() 함수를 사용할 수 있습니다.

그러나 using namespace std;에 의해 sqrt()만 사용해도 됩니다.

이렇게 해서 C++에서는 루트 529를 아주 쉽게 구현할 수 있습니다.

Python으로 구현하면 어떻게 될까요?

import math를 통해 sqrt()를 호출할 수 있으며 math.sqrt()로 루트 529를 구할 수 있습니다.

그런데 매번마다 math.sqrt() 붙이기엔 귀찮죠?

그래서 저는 2가지 방법을 알려드립니다.

[1. C++의 #define처럼 사용하기]

import sys
import math

input = sys.stdin.readline
sqrt = math.sqrt

Y:float = float(input().rstrip())
print(sqrt(Y))

sqrt = math.sqrt로 C++의 별칭(alias) 혹은 매크로(macro)처럼 사용해서 더 간단하게 구현할 수 있습니다.

애초에 input = sys.stdin.readline도 같은 원리입니다.

[2. Java의 import static처럼 사용하기]

import sys
from math import sqrt

input = sys.stdin.readline

Y:float = float(input().rstrip())
print(sqrt(Y))

Java로 비유하면 import static java.lang.Math.sqrt;입니다.

from (모듈명) import (객체 목록) 형식으로 해서 특정 도구만 사용합니다.

math.sqrt처럼 모듈명.객체명 형식이면 from math import sqrt가 정석입니다.

하지만 input = sys.stdin.readline는 from sys import stdin까지 가능하나

그 안에 있는 메서드 readline까지는 표현할 수 없어 오히려 input = sys.stdin.readline가 정석입니다.

이제 제곱근을 구하는 방법을 알게 되었으니 이제부터 백준 문제를 해결하도록 하겠습니다.

문제 : 제곱 수?(34027번)(Bronze III)

문제 링크 : https://www.acmicpc.net/problem/34027

출처 : Baekjoon Online Judge

각 테스트 케이스마다 해당 자연수가 완전 제곱수인지 확인하면 되는 문제입니다.

완전 제곱수는 어떤 자연수의 제곱이 되는 수입니다.

1, 4, 9, 16, 25, 36, ...이 완전 제곱수입니다.

주어진 자연수가 완전 제곱수인지 확인할려면 그 자연수의 제곱근을 구해서 정수로 나오면 됩니다.

제가 따로 1부터 16까지 제곱근 값을 구하면 다음과 같습니다.

root 1 -> 1.0
root 2 -> 1.4142135623730951
root 3 -> 1.7320508075688772
root 4 -> 2.0
root 5 -> 2.23606797749979
root 6 -> 2.449489742783178
root 7 -> 2.6457513110645907
root 8 -> 2.8284271247461903
root 9 -> 3.0
root 10 -> 3.1622776601683795
root 11 -> 3.3166247903554
root 12 -> 3.4641016151377544
root 13 -> 3.605551275463989
root 14 -> 3.7416573867739413
root 15 -> 3.872983346207417
root 16 -> 4.0

우선 정수 부분만 확인합니다.

예시로 9이면 정수 부분은 3이며 3 * 3 == 9이므로 9는 완전 제곱수입니다.

반면 12는 정수 부분이 3이며 3 * 3 != 12이므로 12는 완전 제곱수가 아닙니다.

이 때 정수 부분을 구하는 방법은 sqrt(n)으로 루트 값을 구한 다음 실수 -> 정수 변환 과정에서 정수 부분 빼고 나머지 데이터가 모두 소실되는데 이 점을 역이용해서 int로 강제 형변환을 합니다.

이것을 C++로 구현하면 다음과 같습니다.

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    while(t--) {
        int n, m;
        cin >> n;
        m = (int)(sqrt(n));
        if(m * m == n) cout << 1;
        else cout << 0;
        cout << '\n';
    }

    return 0;
}

여기서 m은 루트 n의 정수 부분이며 m * m == n이면 n은 완전 제곱수입니다.

이 때 마지막에 cout << '\n'; 추가해주세요.

안 그러면 출력이 잘못 나와서 오답 처리 됩니다.

Python도 동일하게 구현하면 됩니다.

import sys
from math import sqrt

input = sys.stdin.readline

T:int = int(input().rstrip())

for _ in range(T) :
    N:int = int(input().rstrip())
    M:int = int(sqrt(N))
    
    if M * M == N :
        print(1)
    else :
        print(0)

[class 2]백준 직각삼각형(4153번) 풀이 (C++/Python)

isekaipudding — Thu, 30 Apr 2026 13:59:36 +0900

문제 : 직각삼각형(4153번)(Bronze III)

문제 링크 : https://www.acmicpc.net/problem/4153
출처 : Baekjoon Online Judge

while문으로 입력 받아서 세 개의 변을 입력 받아 직각삼각형 여부를 판정하고 세 개의 변 모두 0으로 나오면 while문을 탈출하는 문제입니다.

직각삼각형인지 판별할려면 저번에 나온 피타고라스 정리 공식을 활용하면 되겠죠?

$$a^2 + b^2 = c^2$$

해당 공식이 나온 게시글에 나온 소스 코드를 그대로 활용하면 됩니다.

[C++]

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    while(true) {
        int a, b, c;
        cin >> a >> b >> c;

        if(a == 0 && b == 0 && c == 0) break;

        int z = a;
        z = (b > z) ? b : z;
        z = (c > z) ? c : z;

        int x = a;
        x = (b < x) ? b : x;
        x = (c < x) ? c : x;

        int y = (a + b + c) - z - x;

        if(x * x + y * y == z * z) cout << "right" << '\n';
        else cout << "wrong" << '\n';
    }

    return 0;
}

[Python]

import sys

input = sys.stdin.readline

while True :
    a, b, c = map(int, input().split())

    if a == b == c == 0 :
        break
        
    x, y, z = 0, 0, 0
    x = min([a, b, c])
    z = max([a, b, c])
    y = sum([a, b, c]) - x - z

    if x ** 2 + y ** 2 == z ** 2 :
        print("right")
    else :
        print("wrong")

[수학 - 피타고라스 정리(기하학)]백준 Patyki(8723번) 풀이 (C++/Python)

isekaipudding — Thu, 30 Apr 2026 12:37:22 +0900

우리가 중학교 2학년 때 "밑변의 제곱과 높이의 제곱의 합은 빗변의 제곱이다"라는 말을 들어본 적 있을 것입니다.

오늘은 피타고라스의 정리에 대해 간단하게 알아보고 그 공식을 활용하여 백준 문제를 해결하도록 하겠습니다.

밑변 a, 높이 b, 빗변 c인 직각삼각형이 있습니다.

피타고라스의 정리에 의하면 직각삼각형일 때 다음과 같은 공식이 성립됩니다.

$$a^2 + b^2 = c^2$$

피타고라스의 정리를 증명하는 방법은 수백 가지 발견되었습니다.

그 중 가장 대중적인 증명 과정 하나를 소개하도록 하겠습니다.

정사각형 ABCD와 정사각형 EFGH가 존재합니다.

이들은 각각 길이가 (a+b), c이며 여기서 밑변이 a, 높이가 b인 직각삼각형 4개가 붙어있는 상태입니다.

수식 전개해서 피타고라스의 정리를 증명하도록 하겠습니다.

\begin{aligned} (a + b)^2 &= 4 \times \frac{1}{2}ab + c^2 \\ a^2 + 2ab + b^2 &= 2ab + c^2 \\ \therefore a^2 + b^2 &= c^2 \end{aligned}

이렇게 해서 피타고라스의 정리를 간단하게 증명했습니다.

이제 이 공식을 활용하여 백준 문제를 해결하도록 하겠습니다.

문제 : Patyki(8723번)(Bronze IV)

문제 링크 : https://www.acmicpc.net/problem/8723

출처 : Baekjoon Online Judge

이 문제는 정말로 간단합니다.

1. 만약 정삼각형이면 2 출력

2. 그게 아니라 직각삼각형이면 1 출력

3. 그 외의 경우는 0 출력

우선 가장 먼저 정삼각형인 경우를 확인하겠습니다.

정삼각형의 조건은 딱 하나입니다.
"모든 변의 길이가 같을 것"

즉, a와 b가 같고 b와 c가 같으면 됩니다.(그러면 나머지 a와 c는 자동으로 성립됩니다.)

그러므로 C++에서는 아래와 같이 작성해주시면 됩니다.

if(a == b && b == c) cout << 2;

그런데 만약 정삼각형이 아니라면 직각삼각형인지 확인해야 합니다.

하지만 여기서 한 가지 사소한 문제가 발생했습니다.

바로 a, b, c가 문제에서 무작위로 입력되어서 어느 변이 빗변인지 모른다는 것입니다.

원래라면 정렬(sorting)을 사용해서 간단하게 해결할 수 있으나 아직 정렬에 배우지 않았고 삼각형이라는 특수한 경우이니 다음과 같은 소스 코드로 구현할 수 있습니다.

int a, b, c;
cin >> a >> b >> c;

// 1. 최댓값(빗변) 구하기
int z = a;
z = (b > z) ? b : z;
z = (c > z) ? c : z;

// 2. 최솟값(밑변 혹은 높이) 구하기
int x = a;
x = (b < x) ? b : x;
x = (c < x) ? c : x;

// 3. 중간값(나머지 한 변) 구하기
// 전체 합에서 가장 큰 놈과 가장 작은 놈을 빼면 중간 놈만 남음
int y = (a + b + c) - z - x;

이렇게 하면 빗변을 구하면서 밑변과 높이를 구할 수 있게 됩니다.

이제부터 피타고라스의 정리를 적용해서 이 문제를 해결하도록 하겠습니다.

if(x * x + y * y == z * z) cout << 1;
else cout << 0;

피타고라스의 정리를 이용하여 해당 삼각형이 직각삼각형인지 알 수 있게 됩니다.

예를 들어 a = 4, b = 5, c = 3인 경우 x = 3, y = 4, z = 5가 되고 3*3 + 4*4 = 5*5가 성립되므로 해당 삼각형은 직각삼각형으로 판정됩니다.

지금까지 했던 과정을 C++로 전체 구현하겠습니다.

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int a, b, c;
    cin >> a >> b >> c;

    if(a == b && b == c) {
        cout << 2;
        return 0;
    }

    int z = a;
    z = (b > z) ? b : z;
    z = (c > z) ? c : z;

    int x = a;
    x = (b < x) ? b : x;
    x = (c < x) ? c : x;

    int y = (a + b + c) - z - x;

    if(x * x + y * y == z * z) cout << 1;
    else cout << 0;

    return 0;
}

이 때 조심해야 하는 것은 정삼각형으로 판정된 후 return 0;으로 프로그램 종료해야 합니다.

그렇지 않으면 아래에 0도 함께 출력되어 결과값이 "20"으로 출력되는 반례가 발생합니다.

참고로 Python에서는 max, min, sum을 이용하여 다음과 같이 해결할 수 있습니다.

import sys

input = sys.stdin.readline

a, b, c = map(int, input().split())

if a == b == c :
    print(2)
    sys.exit(0)
    
x, y, z = 0, 0, 0
x = min([a, b, c])
z = max([a, b, c])
y = sum([a, b, c]) - x - z

if x ** 2 + y ** 2 == z ** 2 :
    print(1)
else :
    print(0)

피타고라스의 정리는 2차원 혹은 3차원 도형에서 어떤 선분의 길이를 구할 때 굉장히 큰 도움이 되는 공식입니다.

그러므로 이 공식은 꼭 숙지하셔야 합니다.

이상, 피타고라스의 정리에 대해 간단하게 알아봤습니다.

[class 1]백준 알파벳 찾기(10809번) 풀이 (C++/Python)

isekaipudding — Wed, 29 Apr 2026 13:48:49 +0900

문제 : 알파벳 찾기(10809번)(Bronze II)

문제 링크 : https://www.acmicpc.net/problem/10809
출처 : Baekjoon Online Judge

이 문제는 문자열 하나 입력 받고 index 0부터 순차 탐색(sequential search)을 해서 해당 글자가 처음으로 등장하는 위치(index)를 출력하는 문제입니다.

이 때 해당 글자가 들어가지 않으면 -1로 출력하게 됩니다.

우선 비어 있는 문자열(size = 0)이라고 가정하면 모든 글자가 출력되지 않으니 초기 배열은 크기가 26이고 모두 -1로 초기화합니다.

int alphabet[26];
for(int i = 0; i < 26; i++) alphabet[i] = -1;

그 다음 문자열 s를 입력 받고 문자열의 크기를 저장합니다.

string s;
cin >> s;

int size = s.size();

이 다음이 핵심입니다.

for문 돌려서 순차 탐색을 진행합니다.

이 때 해당 글자를 0, 1, 2, 3, ..., 25로 index 형식으로 바꿀려면 아래와 같이 작성해주세요.

char ch = s[i] - 'a';

만약 s[i]가 'a'라고 가정합니다.

그러면 'a'와 'a'의 거리가 0이므로 ch는 0이 됩니다.

이번엔 s[i]가 'd'라고 가정해볼까요?

a에서 d로 옮길려면 총 3칸 정도 움직여야 하므로 ch는 3이 됩니다.

이렇게 index 형식으로 변경하고 그 다음 유효성 검사를 진행합니다.

if(alphabet[ch] == -1) alphabet[ch] = i;

-1이면 아직 갱신되지 않았다는 뜻이니 해당 글자의 위치 번호로 저장합니다.

그런데 만약 -1이 아니라면 이미 한 번 기록했다는 뜻이니 두 번 기록하지 않습니다.

마지막으로 각 알파벳이 처음 나오는 위치를 하나씩 출력하면 됩니다.

for(int i = 0; i < 26; i++) cout << alphabet[i] << " ";

이렇게 모두 다 출력하면 백준 문제 해결입니다.

이 모든 과정을 아래에 전체 소스 코드로 정리합니다.

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int alphabet[26];
    for(int i = 0; i < 26; i++) alphabet[i] = -1;


    string s;
    cin >> s;

    int size = s.size();

    for(int i = 0; i < size; i++) {
        char ch = s[i] - 'a';
        // warning: array subscript has type ‘char’ <- 이 경고 없애기 위해 정수형으로 변환
        int index = ch;

        if(alphabet[index] == -1) alphabet[index] = i;
    }

    for(int i = 0; i < 26; i++) cout << alphabet[i] << " ";

    return 0;
}

Python으로 구현하면 다음과 같습니다.

import sys

input = sys.stdin.readline

alphabet:list = [-1 for _ in range(26)]

S:str = input().rstrip()

for i in range(len(S)) :
    ch:int = ord(S[i]) - ord("a")
    if alphabet[ch] == -1 :
        alphabet[ch] = i

print(*alphabet)

ord()로 해당 문자를 아스키 코드(정수)로 변환하고 두 아스키 코드의 차를 구해서 이를 index로 활용합니다.

여기까지 왔다면 수고 많았습니다!

class 1 모든 문제를 해결했습니다.

[class 1]백준 OX퀴즈(8958번) 풀이 (C++/Python)

isekaipudding — Tue, 28 Apr 2026 16:43:04 +0900

문제 : OX퀴즈(8958번)(Bronze II)

문제 링크 : https://www.acmicpc.net/problem/8958
출처 : Baekjoon Online Judge

O이면 1점 획득인데 O가 2연속이면 1+2 = 3점을 획득합니다.

그리고 O가 3연속이면 1+2+3 = 6점 획득하는 방식입니다.

하지만 단 한 번이라도 X로 만나서 연속이 깨지면 그 즉시 0점 획득이고 그 다음에 다시 O가 오면 1점 획득하는 방식입니다.

OOXXOXXOOO

예시 입력이 다음과 같습니다.

우선 index 0부터 시작합니다.

(0번째 원소)

초기 count는 0입니다.

O이니 count는 1이 되고 점수(result)를 count만큼 더해서 1점이 됩니다.

(1번째 원소)

O이므로 count++ 되고 count는 2가 됩니다.

이 때 O이니 result += count를 통해 총 3점이 됩니다.

(2번째 원소)

X이므로 count = 0이 되고 별도의 연산을 하지 않습니다.

(3번째 원소)

X이므로 count = 0이 되고 별도의 연산을 하지 않습니다.

...

이렇게 해서 1 + 2 + 0 + 0 + 1 + 0 + 0 + 1 + 2 + 3 = 10점이 됩니다.

이것을 통해 O인 경우와 X인 경우는 다음과 같은 작업을 진행합니다.

[O인 경우]

count++;

result += count;

[X인 경우]

count = 0;

이제 이것을 C++로 구현하겠습니다.

#include <bits/stdc++.h>
 
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    while(t--) {
        string ox;
        cin >> ox;

        int count = 0;
        int size = ox.size();

        int result = 0;

        for(int i = 0; i < size; i++) {
            if(ox[i] == 'O') {
                count++;
                result += count;
            } else count = 0;
        }

        cout << result << '\n';
    }

    return 0;
}

같은 논리를 Python으로도 구현할 수 있습니다.

import sys

input = sys.stdin.readline

T:int = int(input().rstrip())

for i in range(T) :
    OX:str = input().rstrip()
    
    count:int = 0
    result:int = 0
    
    for j in range(len(OX)) :
        if OX[j] == "O" :
            count += 1
            result += count
        elif OX[j] == "X" :
            count = 0
            
    print(result)

추가로 Python은 split() 하나로 문자열을 리스트로 만들 수 있습니다.

예시로 OOXXOXXOOO일 때 "X" 기준으로 파싱한다면 ['OO', '', 'O', '', 'OOO']가 됩니다.

이 때 1부터 N까지의 합(시그마 공식)을 활용하면 수학적으로 해결할 수 있습니다.

import sys

input = sys.stdin.readline

def sigma(N:int) -> int :
    return N * (N + 1) // 2

T:int = int(input().rstrip())
for _ in range(T) :
    OX:str = input().rstrip()
    
    L:list = list(map(str, OX.split("X")))
    
    result:int = 0
    
    for item in L :
        result += sigma(len(item))
        
    print(result)

이렇게 해도 계산을 빠르게 할 수 있습니다.

[class 1]백준 나머지(3052번) 풀이 (C++/Python)

isekaipudding — Mon, 27 Apr 2026 11:28:00 +0900

문제 : 나머지(3052번)(Bronze II)

문제 링크 : https://www.acmicpc.net/problem/3052
출처 : Baekjoon Online Judge

이 문제는 원래 HashSet 혹은 HashMap을 사용해서 해결해야 하는 문제입니다.

하지만 이 문제는 class 2가 아닌 class 1이며 해당 문제를 곰곰히 생각해보니 굳이 HashSet 혹은 HashMap을 사용할 이유가 없습니다.

왜냐면 결국 나누기 42 해서 나오는 나머지 경우의 수가 42개 뿐이며 이것은 배열만으로 구현할 수 있거든요.

bool check[42];

예시로 나머지가 1, 2, 3, 4, 5, 6, 7, 8, 9, 1이라고 가정합니다.

그러면 check[1]부터 check[9]까지 모두 true로 바뀌게 되며 1이 한 번 더 등장해도 이미 true 처리되어 중복 연산을 방지할 수 있습니다.

이건 사실 내부적으로 보면 LinkedList에서 이미 존재한 원소가 있으면 원소 추가를 진행하지 않는 것과 같습니다.

(실제 Hash Table은 ArrayList + LinkedList 조합이거든요.)

그래서 사실상 이 문제는 본격적인 집합과 맵 들어가기 전 손풀기 문제입니다.

집합과 맵은 class 2에서 다루도록 하겠습니다.

이제 배열만으로 해당 문제를 해결하도록 하겠습니다.

[C++]

#include <bits/stdc++.h>
 
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    bool check[42];
    for(int i = 0; i < 42; i++) check[i] = false;

    for(int i = 0; i < 10; i++) {
        int n;
        cin >> n;
        check[n % 42] = true;
    }

    int result = 0;
    for(int i = 0; i < 42; i++) {
        if(check[i]) result++;
    }

    cout << result;

    return 0;
}

이미 true가 된 곳에 중복 원소가 오면 result++ 되지 않고 그냥 무시됩니다.

조심해야 할 것은 반드시 check[n % 42] = true;로 해주세요.

제가 check[n] = true;로 하다가 오답 받았습니다.

[Python]

import sys

input = sys.stdin.readline

check:list = [False for _ in range(42)]

for _ in range(10) :
    check[int(input().rstrip()) % 42] = True
    
print(sum(check))

JavaScript와 Python는 truthy한 값들을 1로 취급해서 sum(check)에서 true -> 1 취급하여 true의 개수를 출력하는 방식을 채택했습니다.

[자료구조 기초 - 연결 리스트(LinkedList)]백준 에디터(1406번) 풀이 (C++/Python)

isekaipudding — Sun, 26 Apr 2026 10:48:18 +0900

저번에는 ArrayList에 대해 알아봤습니다.

이번에는 LinkedList에 대해 알아보겠습니다.

ArrayList는 1-2-3-4-5-6처럼 주소값이 연속적으로 이어지는 동적 배열입니다.

그리고 조회 및 수정할 때 연속적인 index 기반이라서 O(1)의 시간 복잡도를 가지고 있습니다.

하지만 여기서 한계점이 있습니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
0xA2	0xA8	1	2	3	4	5	6

현재 다음과 같이 저장되어 있습니다.

만약 맨 끝의 원소만 삭제한다고 하면 포인터 한 칸만 움직이면 되거든요.

그런데 만약 딱 중간에 있는 0xA4의 원소값을 없앨려고 하면 어떻게 해야 할까요?

그러면 매우 귀찮아지는 일이 벌어집니다.

*(0xA4) = *(0xA5);

*(0xA5) = *(0xA6);

*(0xA6) = *(0xA7);

이렇게 0xA4 뒤에 있는 모든 원소들의 값을 왼쪽으로 전부 다 옮겨야 하고 그 다음에 포인터를 옮겨야 하는 귀찮은 작업을 해야 합니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
0xA2	0xA7	1	2	4	5	6	6

이렇게 바뀌어집니다.

이게 만약 리스트의 크기가 100000개이고 삭제되어야 하는 원소의 index가 0이라면?

그러면 99999개의 원소들을 모두 왼쪽으로 옮겨야 하는 O(N)의 시간 복잡도를 가지게 됩니다.

원소의 개수가 많아질 수록 비효율적입니다.

만약 조회/수정보다 추가/삭제가 압도적으로 많은 작업이라면 ArrayList는 오히려 독입니다.

이럴 때 나오는 것이 바로 LinkedList입니다.

			0xBC	---	0x3F
			12		24

ㅡ는 서로 연결되었다는 것을 의미합니다.

현재 두 원소가 서로 연결되어 있습니다.

0xBC의 오른쪽 간선은 0x3F와 연결되어 있고 0x3F의 왼쪽 간선은 0xBC와 연결되어 있습니다.

그리고 0xBC의 왼쪽 지점과 0x3F의 오른쪽 지점은 연결되지 않는 상태입니다.

여기서 두 지점 사이에 0x90(value는 18)를 넣고 싶습니다.

이럴 때 다음과 같은 과정을 거치면 됩니다.

			0xBC		0x3F
			12		24

먼저 두 지점의 연결을 해제해주세요.

			0xBC		0x90		0x3F
			12		18		24

그 다음 0x90을 불러옵니다.

			0xBC	ㅡ	0x90		0x3F
			12		18		24

그 다음 0xBC의 오른쪽 간선을 0x90에 연결하고 0x90의 왼쪽 간선을 0xBC와 연결합니다.

			0xBC	ㅡ	0x90	ㅡ	0x3F
			12		18		24

그 다음 0x90의 오른쪽 간선을 0x3F와 연결하고 0x3F의 왼쪽 간선을 0x90과 연결합니다.

이렇게 하면 12-24에서 18이 중간에 들어와서 12-18-24가 됩니다.

그러면 이번엔 반대로 원소 18을 제거할려면 어떻게 해야 할까요?

간단합니다. 추가 과정에서 역순으로 진행하면 됩니다.

그러면 바로 연결 해제됩니다.

자매품으로 아래와 같이 원형으로 만들 수도 있습니다.


0xAB	ㅡ	0x7A	ㅡ	0x40
1		2		3
ㅣ				ㅣ
0xF1				0x0E
8				4
ㅣ				ㅣ
0x71	ㅡ	0x54	ㅡ	0xEE
7		6		5

이렇게 해서 추가/삭제할 때 그 원소의 주소값이 무엇이든 O(1)의 시간 복잡도로 빠르게 가능합니다.

그런데 여기서 ArrayList는 조회/수정 대신 추가/삭제에서 느리다는 단점이 있잖아요?

LinkedList는 추가/삭제가 빠르지만 주소값이 불연속적이라 탐색하는 과정에서 느리다는 단점이 있습니다.

이로 인해 조회 및 수정하는 과정에서 O(N)의 시간 복잡도를 가집니다.

이제 아까 전에 했던 12, 24 사이에 18 원소를 추가하고 삭제하는 과정을 C언어로 구현해보겠습니다.

#include <stdio.h>
#include <stdlib.h>

// 노드 구조체 정의
typedef struct Node {
    int data;
    struct Node* prev; // 왼쪽 사람의 손
    struct Node* next; // 오른쪽 사람의 손
} Node;

// 원형 이중 연결 리스트 구조체
typedef struct {
    Node* head; // 강강술래의 시작점 (기준점)
} CircularDoublyLinkedList;

// 1. 리스트 초기화
void initList(CircularDoublyLinkedList* list) {
    list->head = NULL;
}

// 2. 맨 뒤에 추가 (append) - 생성된 노드의 주소를 반환!
Node* insertEnd(CircularDoublyLinkedList* list, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;

    if (list->head == NULL) {
        // 첫 번째 노드일 경우: 혼자서 강강술래 (자기 자신을 가리킴)
        newNode->next = newNode;
        newNode->prev = newNode;
        list->head = newNode;
    } else {
        // 이미 사람이 있을 경우: 맨 마지막 사람(tail)을 찾아서 연결
        Node* tail = list->head->prev; // 원형이므로 head의 이전은 항상 tail!

        tail->next = newNode;       // 기존 마지막 사람의 오른손을 새 사람에게
        newNode->prev = tail;       // 새 사람의 왼손을 기존 마지막 사람에게
        newNode->next = list->head; // 새 사람의 오른손을 첫 사람(head)에게
        list->head->prev = newNode; // 첫 사람의 왼손을 새 사람에게
    }
    return newNode; // ★ 중요: 생성된 노드의 '주소값(GPS)'을 반환합니다.
}

// 3. 특정 노드의 '바로 뒤'에 추가 (O(1) 삽입)
Node* insertAfter(Node* target, int value) {
    if (target == NULL) return NULL;
    
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;

    Node* nextNode = target->next; // target의 원래 오른쪽 사람

    // 새 사람(18)과 양옆 사람(12, 24)의 손을 연결합니다.
    newNode->prev = target;
    newNode->next = nextNode;
    
    target->next = newNode;
    nextNode->prev = newNode;

    return newNode; // 캐싱을 위해 주소값 반환
}

// 4. 주소값을 이용한 즉시 삭제 (O(1) 삭제)
void deleteNode(CircularDoublyLinkedList* list, Node* target) {
    if (list->head == NULL || target == NULL) return;

    // 만약 지우려는 노드가 리스트의 유일한 노드라면?
    if (target->next == target) {
        list->head = NULL;
    } else {
        Node* leftPerson = target->prev;
        Node* rightPerson = target->next;

        // 타겟을 왕따(?)시키고 양옆 사람끼리 손을 잡게 합니다.
        leftPerson->next = rightPerson;
        rightPerson->prev = leftPerson;

        // 만약 지운 노드가 head였다면, 다음 사람에게 head 자리를 물려줍니다.
        if (list->head == target) {
            list->head = rightPerson;
        }
    }
    // 다 쓴 노드의 메모리 반환
    free(target);
}

// 전체 출력 함수
void printList(CircularDoublyLinkedList* list) {
    if (list->head == NULL) {
        printf("현재 리스트: []\n");
        return;
    }
    
    Node* current = list->head;
    printf("현재 리스트: [ ");
    do {
        printf("%d ", current->data);
        current = current->next;
    } while (current != list->head); // 다시 head로 돌아올 때까지 반복
    printf("]\n");
}

int main() {
    CircularDoublyLinkedList list;
    initList(&list);

    printf("=== 1단계 : 12 삽입 ===\n");
    Node* node12 = insertEnd(&list, 12); // 나중에 쓰기 위해 주소를 저장(캐싱)
    printList(&list);

    printf("\n=== 2단계 : 24 삽입 ===\n");
    insertEnd(&list, 24);
    printList(&list);

    printf("\n=== 3단계 : 12와 24 사이에 18 삽입 ===\n");
    // 처음부터 찾을 필요 없이, 아까 저장한 node12의 '바로 뒤'에 삽입!
    // 동시에 18의 주소값도 캐싱해둡니다.
    Node* cached_node_18 = insertAfter(node12, 18);
    printList(&list);

    printf("\n=== 4단계 : 캐시를 활용한 18 삭제 (탐색 시간 O(1)) ===\n");
    // 반복문(for/while)으로 18을 찾는 과정이 전혀 없습니다!
    deleteNode(&list, cached_node_18);
    printList(&list);

    return 0;
}

네... 이해 못 해도 됩니다.

출력 결과는 다음과 같이 나옵니다.

더 빠른 탐색을 위해 캐시 기능을 사용했지만 ArrayList이면 캐시 기능 없이도 빠른 조회가 가능합니다.

이것을 통해 LinkedList는 엄청 빠른 추가/삭제를 해서 "일단 데이터를 무작정 많이 집어넣자!"라고 할 때 큰 도움이 됩니다.

ArrayList로 할 때 메모리를 연속적으로 할당해야 해서 정말 많은 데이터를 추가해야 할 때 메모리가 부족해지는 문제점이 발생합니다.

예시로 남은 메모리 부분이 o이고 이미 할당된 부분이 x라고 가정합니다.

그리고 현재 데이터 3개를 넣어야 합니다.

메모리가 만약 xoxoxoxoxoxoxoxo 상태이면 분명히 메모리 남은 칸이 8칸인데도 불구하고 ArrayList이면 할당할 수 없는 문제점이 발생합니다.

하지만 LinkedList라면 xoxoxoxoxoxoxoxo라도 데이터를 구겨넣을 수 있어 메모리 효율이 좀 더 좋아집니다.

물론 탐색을 빨리 할려면 LinkedList가 아닌 ArrayList로 해야 합니다.

그래서 보통 데이터를 다음과 같이 처리합니다.

1. 초반에 데이터를 추가할 때 LinkedList로 합니다. 그러면 최대한 많이 채워 넣을 수 있습니다.

2. LinkedList로 순차 탐색을 딱 1번만 합니다. 거기서 불필요한 데이터를 순식간에 제거합니다.

3. 1번 과정과 2번 과정을 반복하여 메모리 안에 품질 좋은 데이터를 최대한 많이 채워 넣을 수 있습니다.

4. 이제 더 큰 용량의 메모리로 옮겨서 각 데이터 별로 ArrayList를 통해 구분 및 정리해서 조회 및 탐색하기 딱 좋게 만듭니다.

이렇게 해서 대용량 데이터를 효율적으로 관리할 수 있습니다.

이제 백준 문제로 넘어갈까요???

문제 : 에디터(1406번)(Silver II)

문제 링크 : https://www.acmicpc.net/problem/1406
출처 : Baekjoon Online Judge

실버 2티어 수준이면 코딩 테스트에 나올 정도로 좀 어려운 문제입니다.

거기에 LinkedList로 추가/삭제는 그렇다 쳐도 마지막에 O(1) 시간 복잡도의 조회까지 필요해서 정말 막막할 것입니다.

하지만 걱정마십시오. 이 문제는 편법을 사용해서 해결할 수 있습니다.

ArrayList 2개이면 이 문제를 정말 쉽게 해결할 수 있거든요.

이름이 left, right인 ArrayList로 어떻게 해결할 수 있을까요?

각 테스트 케이스들을 하나씩 뜯어보면서 이 문제를 해결해보겠습니다.

[테스트 케이스 1]

문자열 "abcd"가 나왔습니다.

가장 1번째로 "abcd"를 문자로 쪼개고 모두 다 left에 넣는 것입니다.

left = [a, b, c, d], right = []

그 다음 명령어 수가 3개이며 각각 "P x", "L", "P y"가 나왔습니다.

각 명령어들을 순서대로 진행합니다.

(1번째 명령어)

현재 커서는 abcd_이며 여기서 _는 커서입니다.

커서 왼쪽에 x를 추가합니다. 즉, abcd(x_) -> abcdx_가 됩니다.

left 리스트에 x를 추가합니다.

left = [a, b, c, d, x], right = []

(2번째 명령어)

커서를 왼쪽으로 옮깁니다.

그러면 abcd_x가 됩니다.

이 때 x는 left에서 빼고 right로 옮깁니다.

left = [a, b, c, d], right = [x]

(3번째 명령어)

커서 왼쪽에 y를 추가합니다.

이러면 abcd(y_)x -> abcdy_x가 됩니다.

이 때 left에 y를 추가합니다.

left = [a, b, c, d, y], right = [x]

(결과)

abcdyx가 됩니다.

[테스트 케이스 2]

문자열 "abc"가 나왔습니다.

그러므로 left = [a, b, c]가 되며 현재 커서는 abc_입니다.

각 명령어들을 수행하겠습니다.

(1번째 명령어)

커서를 왼쪽으로 옮깁니다.

그러면 ab_c가 되며 left = [a, b], right = [c]가 됩니다.

(2번째 명령어)

커서를 왼쪽으로 옮깁니다.

그러면 a_bc가 되며 left = [a], right = [c, b]가 됩니다.

(3번째 명령어)

커서를 왼쪽으로 옮깁니다.

그러면 _abc가 되며 left = [], right = [c, b, a]가 됩니다.

(4번째 명령어)

커서를 왼쪽으로 옮깁니다.

그런데 커서 왼쪽에는 문자가 더이상 없습니다.

그러므로 아무런 변화가 없으며 left = [], right = [c, b, a]입니다.

(5번째 명령어)

커서를 왼쪽으로 옮깁니다.

그런데 커서 왼쪽에는 문자가 더이상 없습니다.

그러므로 아무런 변화가 없으며 left = [], right = [c, b, a]입니다.

(6번째 명령어)

커서 왼쪽에 x를 추가합니다.

그러므로 x_abc가 되며 left = [x], right = [c, b, a]가 됩니다.

(7번째 명령어)

커서를 왼쪽으로 옮깁니다.

그러면 _xabc가 되며 left = [], right = [c, b, a, x]가 됩니다.

(8번째 명령어)

커서 왼쪽에 있는 문자 1개를 삭제합니다.

그런데 커서 왼쪽에는 문자가 없습니다.

그러므로 아무런 변화가 없으며 left = [], right = [c, b, a, x]입니다.

(9번째 명령어)

커서 왼쪽에 y를 추가합니다.

그러므로 y_xabc가 되며 left = [y], right = [c, b, a, x]가 됩니다.

(결과)

최종적으로 left에서는 순서대로 읽어서 y, right에서는 역순으로 읽어서 xabc가 나와서 yxabc가 됩니다.

[테스트 케이스 3]

문자열 "dmih"가 나왔습니다.

초기 상태는 dmih_이며 left = [d, m, i, h]입니다.

(1번째 명령어)

커서 왼쪽에 있는 문자 1개를 삭제합니다.

dmi_

left = [d, m, i], right = []

(2번째 명령어)

커서 왼쪽에 있는 문자 1개를 삭제합니다.

dm_

left = [d, m], right = []

(3번째 명령어)

커서 왼쪽에 x를 추가합니다.

dmx_

left = [d, m, x], right = []

(4번째 명령어)

커서를 왼쪽으로 옮깁니다.

dm_x

left = [d, m], right = [x]

(5번째 명령어)

커서 왼쪽에 있는 문자 1개를 삭제합니다.

d_x

left = [d], right = [x]

(6번째 명령어)

커서 왼쪽에 있는 문자 1개를 삭제합니다.

left = [], right = [x]

(7번째 명령어)

커서 왼쪽에 있는 문자 1개를 삭제합니다.

하지만 커서 왼쪽에 문자가 없어서 아무런 변화가 없습니다.

left = [], right = [x]

(8번째 명령어)

커서 왼쪽에 y를 추가합니다.

y_x

left = [y], right = [x]

(9번째 명령어)

커서를 오른쪽으로 옮깁니다.

yx_

left = [y, x], right = []

(10번째 명령어)

커서를 오른쪽으로 옮깁니다.

하지만 커서 오른쪽에 문자가 없어서 아무런 변화가 없습니다.

yx_

left = [y, x], right = []

(11번째 명령어)

커서 왼쪽에 z를 추가합니다.

yxz_

left = [y, x, z], right = []

(결과)

yxz가 됩니다.

자, 이제 이것을 C++로 구현하겠습니다.

#include <bits/stdc++.h>
 
using namespace std;

vector<char> L;
vector<char> R;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string s;
    cin >> s;

    int size = s.size();

    for(int i = 0; i < size; i++) L.push_back(s[i]);

    int n;
    cin >> n;

    for(int i = 0; i < n; i++) {
        char cmd;
        cin >> cmd;

        switch(cmd) {
            case 'L' :
                if(!L.empty()) {
                    char ch = L.back();
                    L.pop_back();
                    R.push_back(ch);
                }
                break;
            case 'D' :
                if(!R.empty()) {
                    char ch = R.back();
                    R.pop_back();
                    L.push_back(ch);
                }
                break;
            case 'B' :
                if(!L.empty()) L.pop_back();
                break;
            case 'P' :
                char ch;
                cin >> ch;
                L.push_back(ch);
                break;
            default :
                break;
        }
    }

    int L_size = L.size();
    int R_size = R.size();

    for(int i = 0; i < L_size; i++) cout << L[i];
    for(int i = R_size - 1; i > -1; i--) cout << R[i];

    return 0;
}

back()으로 맨 마지막 원소를 저장하고 pop_back()을 합니다.

왜냐면 C++에서 pop_back()의 반환값이 void라서 삭제 전 값을 따로 저장해야 합니다.

이제 같은 논리를 바탕으로 Python으로 구현해보겠습니다.

import sys

input = sys.stdin.readline

left:list = list(input().rstrip())
right:list = []

N:int = int(input().rstrip())

for _ in range(N) :
    L:list = list(map(str, input().split()))
    command:list = L[0]
    if command == "L" :
        if left :
            right.append(left.pop())
    if command == "D" :
        if right :
            left.append(right.pop())
    if command == "B" :
        if left :
            left.pop()
    if command == "P" :
        left.append(L[1])
        
result:str = ''.join(map(str, left)) + ''.join(map(str, right[::-1]))
print(result)

[자료구조 기초 - 배열 리스트(ArrayList)]백준 제로(10773번) 풀이 (C++/Python)

isekaipudding — Sat, 25 Apr 2026 12:24:11 +0900

데이터를 저장할 때 다양한 자료구조를 활용합니다.

이 중 저번에 정적 배열(Array)을 간단하게 확인해봤습니다.

로우 레벨에서 봐도 정적 배열은 메모리 내부에서 임의의 주소값에 정해진 크기대로 메모리 할당해서 그 안에 값 조회 및 수정을 할 수 있었습니다.

그런데 정적 배열의 단점은 추가 및 삭제가 안 됩니다.

그래서 이번엔 다른 자료 구조를 들고 왔습니다.

리스트(List)는 기존 정적 배열에서 메모리 재할당을 통해 추가 및 삭제할 수 있는 자료 구조입니다.

리스트는 ArrayList와 LinkedList가 있는데 여기서는 ArrayList만 설명하겠습니다.

왜냐면 LinkedList 이것도 결국 ArrayList 2개로 비슷하게 구현할 수 있거든요.

물론 로우 레벨로 보면 LinkedList와 ArrayList는 엄연히 다르며 상황에 따라 LinkedList로 구현해야 하나

요즘 메모리 자체가 워낙 용량이 커서 그냥 깡으로 ArrayList 2개만으로도 LinkedList를 비슷하게 구현할 수 있습니다.

표를 통해 ArrayList를 직접 확인해보시죠!

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
				5

1번째 행은 주소값(address), 2번째 행은 원소값(value)입니다.

메모리 내부는 대충 이렇게 되어 있다고 가정합니다.(실제 메모리 구조와 다릅니다. 편의상 이렇게 만든 것입니다.)

여기서 제가 정적 배열 하나를 선언합니다, 그 배열명의 이름은 list라고 가정하겠습니다.

그리고 0xA4 부분은 "int a = 5;"로 되어 있는 부분입니다.

이미 할당된 부분이라서 여기에 배열 list를 할당하면 안 됩니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
				5

해당 배열의 초기 주소값은 0xA2이며 초기 배열의 크기는 2로 할당했습니다.

그리고 초기 포인터는 0xA2입니다.

포인터는 정말 쉽게 말하자면 "현재 주소값을 가리키는 마우스 커서"라고 생각하시면 그나마 이해하기 쉬울 것입니다.

여기에 값을 적어야겠죠?

처음에는 3을 넣어주세요.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
		3		5

짜잔! 주소값 0xA2에 원소값 3이 추가되었습니다.

추가되고 나면 다음 작업을 하기 전에 포인터를 오른쪽으로 옮겨야 합니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
		3		5

현재 포인터는 0xA3입니다.

이렇게 해서 현재 리스트의 크기는 1이 됩니다.

이제 해당 포인터가 가리키는 부분에 6을 대입해보겠습니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
		3	6	5

자, 주소값 0xA3의 value에 6을 대입하는데 성공했습니다.

추가 작업 완료할려면 포인터를 옮겨줘야 합니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
		3	6	5

이것을 코드로 표현하면 int list = {3, 6};입니다.

리스트의 크기가 2가 되었습니다.

그러면 현재 포인터(0xA4) 부분에 값을 대입할 수 있을까요?

저는 이 자리에 9를 대입하고 싶거든요.

로우 레벨에서 대입은 가능합니다.

하지만 만약 int a의 주소값이 0xA4이고 이미 a = 5인 상태로 되어 9로 바꾸면 나중에 printf("%d", a);에서 5가 아닌 9가 출력되는 문제가 발생합니다.

이것은 실제로 C/C++에서 껶고 있는 메모리 보안 문제와 연결됩니다.

이게 왜 메모리 보안 문제로 바뀌냐고요?

만약 0xA4 부분에 "int important_price = 100000000;"이 저장되어 있습니다.

"나중에 받아야 할 돈이 1억원이다"인데 어떤 악질적인 해커가 이 부분을 건들여서 "int important_price = 9;"으로 만든다면?

그러면 나중에 받아야 할 돈이 9원이 되는 진짜 큰일난 결과가 나옵니다.

그래서 C/C++ 말고 Java나 Python 등 자동으로 메모리 할당해주는 프로그래밍 언어에서는 index 범위를 체크해서 만약 범위를 넘어서면 컴파일 과정에서 Exception 혹은 Error를 발생시켜 메모리 보안 문제를 어느 정도 해결해줍니다.

그러면 로우 레벨에서는 이것을 어떻게 해결해야 할까요?

바로 메모리 재할당을 통해 이미 저장된 a의 주소값을 임의의 장소로 변경하고 그 자리에 list 배열의 메모리를 해제하고 크기 4의 list 배열로 재할당합니다.

그런데 재할당하는 과정을 보면 이미 0xA4 부분에 int a = 5;가 자리 잡고 있네요?

그러면 list의 주소값 자체를 바꿔서 다른 곳에 할당해야 합니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
				5	3	6

바로 이렇게 말이죠.

기존 list 주소값이 0xA2인데 이것을 통째로 메모리 해제하고 0xA5 자리에 새롭게 재할당합니다.

재할당 하기 전 리스트의 크기가 2이므로 현재 포인터는 0xA7입니다.

여기서 한 칸 움직이면 안전하게 배열 안에서 값을 넣을 수 있어요.

그 자리에 9를 넣어볼게요.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
				5	3	6	9

이제 리스트의 크기는 3이 되었습니다.

그러면 이번엔 원소 삭제를 어떻게 해야 할까요?

메모리 내부에는 0xA7 부분이 반드시 있어야 해서 0xA7 부분을 물리적으로 못 없애는데 말이죠.

여기서 "인간은 컴퓨터 내부를 볼 수 없다"를 활용하여 속임수(?)를 하나 부릴 것입니다.

그냥 포인터를 왼쪽으로 옮기면 그만입니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
				5	3	6	9

바로 이렇게 말이죠.

이렇게 해서 만약 나머지 원소들을 모두 제거하면 포인터는 어떻게 될까요?

그러면 포인터는 0xA5가 되겠죠.

이러면 리스트의 크기는 0xA5 - 0xA5 = 0이 되어서 리스트 크기를 측정하기도 편안합니다.

하지만 여기서는 9 원소만 삭제 작업(실제 컴퓨터 내부에서는 그저 포인터 하나만 옮김)을 진행하여

현재 리스트의 크기는 0xA7 - 0xA5 = 2가 됩니다.

이제 다음으로 {3, 6} 부분에 2를 추가해볼까요?

0xA7 부분에 9를 2로 수정해서 포인터를 한 칸 옮기면 마치 사람 입장에서 보면 "{3, 6}에서 {3, 6, 2}로 추가되었구나!"라고 느끼지만 실제 컴퓨터 내부에서는 그저 9에서 2로 수정하고 포인터 한 칸 옮겼을 뿐입니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
				5	3	6	2

그런데 어떻게 리스트의 크기를 구할 수 있을까요?

0xA0 부분에 list의 주소값, 0xA1 부분에 현재 포인터 주소값을 저장해서 *(0xA1) - *(0xA0) 연산하면 되거든요.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
0xA5	0xA8			5	3	6	2

이렇게 말이죠. 그러면 (주소값 0xA1의 value) - (주소값 0xA0의 value) = 0xA8 - 0xA5 = 3으로 리스트의 크기가 나와요!

만약 현재 포인터가 0xA8 -> 0xA6로 바뀐다면 리스트의 크기는 1이 되겠죠?

아 맞다. 가장 중요한 것을 빼먹을 뻔했네요.

지금 value 부분에 비어있는 칸들 있잖아요?

사실 진짜 비어있는 것이 아닌 임의의 값(쓰레기 값)들이 들어있는 상태입니다.

그래서 printf("%d", 0xA8); 형식으로 하면 102937460 등으로 쓰레기 값이 출력됩니다.

이 부분은 이전에 정적 배열(Array)에서 이미 다루었으니 복습 개념에서 한 번 더 알려드립니다.

어쨋거나 {3, 6, 2}에 이번에는 4를 넣겠습니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
0xA5	0xA9			5	3	6	2	4

이렇게 해서 리스트는 {3, 6, 2, 4}가 됩니다.

크기는 0xA9 - 0xA5 = 4가 되고요.

마지막으로 0xA7 부분(index 2)에 있는 값을 수정할려고 합니다.

이 때 다른 포인터가 등장하게 됩니다.

우선 다른 포인터 부분을 보라색으로 표시합니다.

이 때 포인터 계산 과정은 *(0xA0) + index = 0xA5 + 2 = 0xA7이 됩니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
0xA5	0xA9			5	3	6	2	4

해당 포인터의 value를 1로 수정하겠습니다.

0xA0	0xA1	0xA2	0xA3	0xA4	0xA5	0xA6	0xA7	0xA8	0xA9
0xA5	0xA9			5	3	6	1	4

수정이 끝나고 하면 해당 포인터는 없어지고 *(0xA0)과 *(0xA1) 값은 변경되지 않았으므로 여전히 리스트의 크기는 4입니다.

이제 이것을 C언어로 구현해보겠습니다.

#include <stdio.h>
#include <stdlib.h>

// ArrayList 구조체 정의
typedef struct {
    int* data;
    int size;     // 현재 저장된 데이터의 개수 (논리적 크기)
    int capacity; // 할당된 전체 메모리 용량 (물리적 크기)
} ArrayList;

// 1. 초기화
void initList(ArrayList* list, int initCapacity) {
    list->data = (int*)malloc(initCapacity * sizeof(int));
    list->size = 0; // 데이터가 하나도 없으므로 0부터 시작합니다.
    list->capacity = initCapacity;
}

// 2. 맨 뒤에 추가 (append)
void append(ArrayList* list, int value) {
    // 현재 개수가 용량과 같아지면, 집을 2배로 넓힙니다.
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->data = (int*)realloc(list->data, list->capacity * sizeof(int));
    }
    // size는 현재 개수이자, 다음에 들어갈 'index' 번호와 같습니다.
    list->data[list->size] = value;
    list->size++; // 데이터를 넣었으니 개수를 하나 늘립니다.
}

// 3. 맨 뒤 데이터 삭제 (pop)
void pop(ArrayList* list) {
    // 실제로 메모리를 지울 필요 없이, "여기까지만 데이터야"라고
    // 경계선(size)만 한 칸 안으로 당기면 됩니다.
    if (list->size > 0) list->size--;
}

// 4. 조회 (get)
int get(ArrayList* list, int index) {
    // (보통 여기서 index < list->size 인지 체크하는 안전장치를 둡니다)
    return list->data[index];
}

// 5. 수정 (set)
void set(ArrayList* list, int index, int value) {
    list->data[index] = value;
}

// 전체 출력 함수
void printList(ArrayList* list) {
    printf("현재 리스트: [");
    for (int i = 0; i < list->size; i++) {
        printf("%d", get(list, i));
        if (i < list->size - 1) printf(", ");
    }
    printf("]\n");
}

int main() {
    int a = 5; // 이미 자리 잡은 변수
    
    ArrayList list;
    initList(&list, 2);
    
    printf("=== 1단계 : 3, 6, 9 삽입 ===\n");
    append(&list, 3);
    append(&list, 6);
    append(&list, 9);
    printList(&list);
    
    printf("\n=== 2단계 : 맨 뒤(9) 제거 ===\n");
    pop(&list);
    printList(&list);
    
    printf("\n=== 3단계 : 2, 4 삽입 ===\n");
    append(&list, 2);
    append(&list, 4);
    printList(&list);
    
    printf("\n=== 4단계 : 인덱스 2의 값을 1로 수정 ===\n");
    set(&list, 2, 1);
    printList(&list);
    
    // 다 쓴 메모리는 반드시 반환!
    free(list.data);
    return 0;
}

뭔가 좀 많이 어려워 보이죠?

하지만 이건 사실 지금까지 했던 과정을 C언어 소스 코드로 구현한 것입니다.

출력 결과를 확인해볼까요?

아주 잘 나옵니다.

이것이 바로 C언어로 ArrayList를 구현하는 방법입니다.

"그러면 ArrayList를 일일히 구현해야 하나요?"라고 물어볼 수 있는데 걱정 마십시오.

C++에서는 <vector> 혹은 <list>라는 STL(표준 탬플릿 라이브러리)가 있어서 굳이 일일히 구현할 필요 없이 바로 구할 수 있거든요.

여기서는 간단하게 <vector>로 위 C언어와 동일한 논리를 가진 C++ 소스 코드를 만들어 보겠습니다.

#include <iostream>
#include <vector>

using namespace std;

// 편의를 위한 전체 출력 함수 (get 메서드 대신 인덱스 [] 직접 사용)
void printList(const vector<int>& list) {
    cout << "현재 리스트: [";
    for (int i = 0; i < list.size(); i++) {
        cout << list[i];
        if (i < list.size() - 1) cout << ", ";
    }
    cout << "]\n";
}

int main() {
    int a = 5; // 이미 자리 잡은 변수 (C++ vector는 알아서 안전하게 피해갑니다!)
    
    // 1. 초기화 
    // C언어의 구조체 생성 및 malloc(initCapacity)이 단 한 줄로 끝납니다.
    vector<int> list;
    list.reserve(2); // 초기 용량(capacity)을 2로 설정 (생략해도 무방함)
    
    // 2. 3, 6, 9 삽입 후 출력
    cout << "=== 1단계 : 3, 6, 9 삽입 ===\n";
    list.push_back(3); // C언어의 append() 역할 + 메모리가 꽉 차면 알아서 realloc!
    list.push_back(6);
    list.push_back(9);
    printList(list);
    
    // 3. 맨 뒤 9 제거 후 출력
    cout << "\n=== 2단계 : 맨 뒤(9) 제거 ===\n";
    list.pop_back(); // C언어의 pop() 역할 (알아서 size를 1 줄여줍니다)
    printList(list);
    
    // 4. 2, 4 삽입 후 출력
    cout << "\n=== 3단계 : 2, 4 삽입 ===\n";
    list.push_back(2);
    list.push_back(4);
    printList(list);
    
    // 5. 인덱스 2의 값을 1로 수정 후 출력
    cout << "\n=== 4단계 : 인덱스 2의 값을 1로 수정 ===\n";
    list[2] = 1; // C언어의 set() 역할 (배열처럼 직관적으로 접근 가능)
    printList(list);
    
    // 메모리 해제(free)는 어디 갔냐고요?
    // main 함수가 끝날 때 vector가 알아서 쓰레기통(Destructor)에 버려줍니다!
    
    return 0;
}

복잡한 포인터와 구조체가 사라졌습니다!

사실 list.reserve()는 생략해도 됩니다. 어차피 C++의 <vector> 라이브러리는 메모리 할당을 알아서 해주기 때문입니다.

C++에서 원소를 삽입할려면 push_back(), 원소를 제거할려면 pop_back()을 사용하면 됩니다.

그리고 C++에서는 조회 및 수정을 할려면 그냥 정적 배열처럼 list[index] 형식으로 간편하게 조회 및 수정할 수 있어요.

그리고 Python으로 넘어가면 훨씬 더 쉬워집니다.

# 파이썬은 배열 선언, 초기 용량 설정, 메모리 관리가 전혀 필요 없습니다.
# 심지어 전체 출력을 위한 별도의 함수(printList)를 만들 필요도 없습니다!

L:list = []

# 1. 3, 6, 9 삽입 후 출력
print("=== 1단계 : 3, 6, 9 삽입 ===")
L.append(3)
L.append(6)
L.append(9)
print(f"현재 리스트: {L}")

# 2. 맨 뒤 9 제거 후 출력
print("\n=== 2단계 : 맨 뒤(9) 제거 ===")
L.pop()
print(f"현재 리스트: {L}")

# 3. 2, 4 삽입 후 출력
print("\n=== 3단계 : 2, 4 삽입 ===")
L.append(2)
L.append(4)
print(f"현재 리스트: {L}")

# 4. 인덱스 2의 값을 1로 수정 후 출력
print("\n=== 4단계 : 인덱스 2의 값을 1로 수정 ===")
L[2] = 1
print(f"현재 리스트: {L}")

# 프로그램이 종료되면 파이썬의 가비지 컬렉터(Garbage Collector)가
# 알아서 메모리를 청소해주므로 free() 같은 작업도 필요 없습니다.

ArrayList는 정말 자주 사용하는 자료 구조입니다.

수많은 자료들을 ArrayList에 다 저장해서 훗날 나올 수많은 알고리즘을 사용하는데 ArrayList가 무조건 들어갑니다.

특히 Python에서는 ArrayList가 기본 자료형으로 채택되어 있어 더더욱 중요합니다.

이제 ArrayList를 활용하여 백준 문제를 해결해보겠습니다.

문제 : 제로(10773번)(Silver IV)

문제 링크 : https://www.acmicpc.net/problem/10773
출처 : Baekjoon Online Judge

이 때까지 브론즈 문제들만 해결하다가 갑자기 실버 문제가 나와서 당황했죠?

하지만 겁 먹을 필요는 없습니다. 지금까지 게시글을 끝까지 읽었다면 이 문제는 별거 아니라는 것을 알 수 있습니다.

항상 크기가 0인 리스트(= 비어 있는 상태)로 시작해서 만약 입력한 숫자가 0이면 원소 제거, 0이 아니면 해당 숫자를 맨 끝에 추가하는 문제입니다.

그 뒤 모든 원소들을 조회해서 모든 원소들의 합을 구하면 됩니다. 참 쉽죠?

이제 C++와 Python으로 이 문제를 간단하게 해결하겠습니다.

[C++]

#include <bits/stdc++.h>
 
using namespace std;

vector<int> L;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    for(int i = 0; i < n; i++) {
        int a;
        cin >> a;

        if(a != 0) L.push_back(a);
        else L.pop_back();
    }

    int result = 0;

    int size = L.size();

    for(int i = 0; i < size; i++) result += L[i];

    cout << result;

    return 0;
}

[Python]

import sys

input = sys.stdin.readline

N:int = int(input().rstrip())

L:list = []

for _ in range(N) :
    K:int = int(input().rstrip())
    if K != 0 :
        L.append(K)
    else :
        L.pop()

print(sum(L))

[class 1]백준 음계(2920번) 풀이 (C++/Python)

isekaipudding — Fri, 24 Apr 2026 12:01:20 +0900

문제 : 음계(2920번)(Bronze II)

문제 링크 : https://www.acmicpc.net/problem/2920
출처 : Baekjoon Online Judge

1,2,3,4,5,6,7,8 순서로 연주하면 ascending, 8,7,6,5,4,3,2,1 순서로 연주하면 descending, 둘 다 아니라면 mixed로 출력된다고 합니다.

그런데 문제를 잘 읽어보면 "1부터 8까지 숫자가 한 번씩 등장한다."가 있습니다.

즉, ascending으로 나오는 경우는 12345678이 유일하며 descending으로 나오는 경우는 87654321가 유일하고 나머지는 모두 mixed입니다.

이것을 C++로 구현하면 다음과 같이 나옵니다.

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    char ch[8];
    for(int i = 0; i < 8; i++) {
        char c;
        cin >> c;
        ch[i] = c;
    }

    string s = "";
    for(int i = 0; i < 8; i++) s += ch[i];

    if(s == "12345678") cout << "ascending";
    else if(s == "87654321") cout << "descending";
    else cout << "mixed";

    return 0;
}

"1부터 8까지 숫자가 한 번씩 등장한다." 조건 덕분에 문제를 좀 더 쉽게 해결할 수 있었습니다.

Python은 이것보다 더 쉽게 구현할 수 있습니다.

import sys

input = sys.stdin.readline

S:str = input().rstrip()

if S == "1 2 3 4 5 6 7 8" :
    print("ascending")
elif S == "8 7 6 5 4 3 2 1" :
    print("descending")
else :
    print("mixed")

[class 1]백준 문자열 반복(2675번) 풀이 (C++/Python)

isekaipudding — Thu, 23 Apr 2026 13:45:43 +0900

문제 : 문자열 반복(2675번)(Bronze II)

문제 링크 : https://www.acmicpc.net/problem/2675
출처 : Baekjoon Online Judge

이 문제는 정말 간단합니다.

테스트 케이스 수 입력하고 그 다음 반복 횟수 int r과 문자열 string s를 입력 받아

s의 각 글자들을 r번 반복 출력하면 되는 문제입니다.

그러니 바로 소스 코드를 올리겠습니다.

#include <bits/stdc++.h>
 
using namespace std;
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    while(t--) {
        int r;
        cin >> r;
        string s;
        cin >> s;

        int size = s.size();

        for(int i = 0; i < size; i++) {
            char ch = s[i];
            for(int j = 0; j < r; j++) cout << ch;
        }

        cout << '\n';
    }

    return 0;
}

코딩에 익숙할 쯤 되면 이 문제가 쉽게 느껴질 것입니다.

Python은 구현 과정이 조금 특이합니다.

테스트 케이스 수 입력하는 것까지는 동일하나 L:list = list(map(str, input().split()))로 해서 R, S = int(L[0]), L[1]으로 해야 합니다.

왜냐면 Python은 한 줄의 문자열로 입력 받기 때문에 파싱 과정이 따로 필요합니다.

import sys

input = sys.stdin.readline

T:int = int(input().rstrip())

for _ in range(T) :
    L:list = list(map(str, input().split()))
    R, S = int(L[0]), L[1]
    
    result:str = ""
    
    for ch in S :
        result += R * ch
        
    print(result)