코딩테스트에서 손에서 바로 나와야 하는 Python 문법/표준 라이브러리/패턴만 모았다. (Python 3.10 기준)

1. 기본 템플릿과 입출력

input()은 느리다... 입력이 1만 줄 넘으면 sys.stdin.readline으로 바꾸고, 재귀를 쓰면 setrecursionlimit을 올린다.

import sys
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, product, accumulate
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from functools import lru_cache, cmp_to_key
import math

input = sys.stdin.readline
sys.setrecursionlimit(10**6)

n, m = map(int, input().split())
arr = list(map(int, input().split()))
grid = [list(map(int, input().split())) for _ in range(n)]
s = input().rstrip()          # readline은 개행 포함 → 문자열은 반드시 rstrip

# 출력 많으면 모아서 한 번에
out = []
for x in arr:
    out.append(str(x))
print("\n".join(out))
# 또는 sys.stdout.write("\n".join(out) + "\n")

과제형(클래스 설계 등)이면 입력 파싱 대신 if __name__ == "__main__": 아래에 테스트 데이터를 만들어 직접 호출하고 print로 보여준다.

2. 문자열

Python 문자열도 불변이다. 반복 +=는 느리니 리스트에 모아 "".join().

# 문자 빈도
from collections import Counter
cnt = Counter("banana")          # {'a': 3, 'n': 2, 'b': 1}
cnt.most_common(2)               # [('a', 3), ('n', 2)]

# 정규식은 간단한 것만
import re
re.sub(r"[^a-z0-9]", "", s)      # 영소문자·숫자만 남기기
re.findall(r"\d+", s)            # 숫자 덩어리 전부
re.split(r"[,;]", s)

3. 리스트·튜플·슬라이싱

리스트는 Java의 ArrayList, 튜플은 불변 리스트(해시 가능 → dict 키, set 원소로 쓸 수 있음).

a = [0] * n                        # 1차원 초기화
grid = [[0] * m for _ in range(n)] # 2차원 — [[0]*m]*n 은 같은 행 참조라 금지
visited = [[False] * m for _ in range(n)]

a.append(x);  a.insert(i, x);  a.pop();  a.pop(i);  a.remove(x)   # remove는 값, O(n)
a.index(x);  a.count(x);  a.reverse();  a.sort();  a.extend(b)
len(a);  sum(a);  max(a);  min(a);  sorted(a);  reversed(a)
a[-1]                              # 마지막
a[a.index(max(a))]                 # 최댓값 위치는 a.index(max(a))
b = a[:]  /  a.copy()  /  list(a)  # 얕은 복사
import copy; c = copy.deepcopy(grid)   # 2차원 복사

# 슬라이스
a[1:4];  a[:3];  a[3:];  a[::-1];  a[::2]
a[2:5] = [9, 9]                    # 구간 교체
del a[2:5]

# 컴프리헨션
sq = [x * x for x in a if x % 2 == 0]
flat = [x for row in grid for x in row]
transposed = list(zip(*grid))      # 전치 (튜플 행)
rotated = [list(r) for r in zip(*grid[::-1])]   # 시계방향 90도 회전

# 자주 쓰는 내장
for i, x in enumerate(a, start=1): ...
for x, y in zip(a, b): ...
any(x > 0 for x in a);  all(x > 0 for x in a)
list(map(str, a));  list(filter(None, a))
max(a, key=len);  max(d, key=d.get)   # 키 지정 최대

a.sort()는 제자리(None 반환), sorted(a)는 새 리스트. 리스트의 in은 O(n)이니 포함 확인이 많으면 set으로.

4. 딕셔너리·집합·collections

카운팅·그룹핑은 defaultdict와 Counter로 끝낸다. dict.get(k)는 없으면 None, d[k]는 KeyError.

# dict
d = {}
d[k] = v;  d.get(k, 0);  k in d;  del d[k];  d.pop(k, None)
d.keys();  d.values();  d.items()
for k, v in d.items(): ...
sorted(d.items(), key=lambda kv: -kv[1])       # 값 내림차순
dict(sorted(d.items()))                        # 키 정렬된 새 dict
d.setdefault(k, []).append(v)                  # 그룹핑 (defaultdict 없이)
# dict는 3.7+ 삽입 순서 유지 → LinkedHashMap 역할

# defaultdict / Counter
from collections import defaultdict, Counter
cnt = defaultdict(int);   cnt[k] += 1
grp = defaultdict(list);  grp[k].append(v)
c = Counter(arr)                               # 빈도
c.most_common(3);  c[x];  c.total()  (3.10+)
Counter(a) - Counter(b);  Counter(a) & Counter(b)   # 차집합·교집합 (빈도 기준)

# set
s = set();  s.add(x);  s.discard(x) (없어도 OK);  s.remove(x) (없으면 에러);  x in s
a | b;  a & b;  a - b;  a ^ b                  # 합·교·차·대칭차
len(set(arr))                                  # 중복 제거 개수
frozenset(...)                                 # 해시 가능한 set (set의 set 만들 때)

# deque (큐·스택·슬라이딩)
from collections import deque
q = deque([1, 2])
q.append(x);  q.appendleft(x);  q.pop();  q.popleft();  q[0];  q[-1]
q.rotate(1)                                    # 오른쪽으로 한 칸
deque(maxlen=k)                                # 고정 길이 윈도우
# 리스트 pop(0)은 O(n) — 큐는 반드시 deque

# heapq (최소 힙)
import heapq
h = [];  heapq.heappush(h, x);  heapq.heappop(h);  h[0]
heapq.heapify(arr)                             # 리스트를 제자리 힙으로 O(n)
heapq.heappush(h, -x)                          # 최대 힙은 부호 뒤집기
heapq.heappush(h, (priority, data))            # 튜플은 첫 원소 기준
heapq.nlargest(3, arr);  heapq.nsmallest(3, arr, key=...)

# 정렬 유지 삽입 / 이분탐색
from bisect import bisect_left, bisect_right, insort
bisect_left(a, x)    # x 이상인 첫 인덱스 (lower bound)
bisect_right(a, x)   # x 초과인 첫 인덱스 (upper bound) → 개수 = right - left
insort(a, x)         # 정렬 유지 삽입 O(n)

Python엔 TreeMap이 없다. 정렬 상태 유지 + 범위 검색이 필요하면 정렬 리스트 + bisect, 또는 힙으로 우회.

5. 정렬과 key

sort/sorted는 안정 정렬(TimSort). 다중 조건은 key에 튜플, 내림차순은 reverse=True 또는 숫자면 부호 반전.

a.sort()                                  # 오름차순 제자리
sorted(a, reverse=True)                   # 내림차순 새 리스트
sorted(words, key=len)                    # 길이 순
sorted(words, key=lambda w: (len(w), w))  # 길이 순, 같으면 사전순
sorted(people, key=lambda p: (-p[1], p[0]))   # 점수 내림, 이름 오름
sorted(d.items(), key=lambda kv: (-kv[1], kv[0]))

# 문자열 내림 + 숫자 오름처럼 부호 반전이 안 되는 경우 → cmp_to_key
from functools import cmp_to_key
def cmp(x, y):
    if x[0] != y[0]: return -1 if x[0] > y[0] else 1      # 문자열 내림
    return x[1] - y[1]                                    # 숫자 오름
sorted(a, key=cmp_to_key(cmp))

# 가장 큰 수 만들기 (문자열 결합 비교)
sorted(nums, key=cmp_to_key(lambda a, b: 1 if a + b < b + a else -1))

# 객체 정렬
sorted(songs, key=lambda s: (-s.plays, s.title))
from operator import itemgetter, attrgetter
sorted(rows, key=itemgetter(1, 0));  sorted(songs, key=attrgetter("plays"))

key 함수는 원소당 한 번만 호출돼서 cmp_to_key보다 빠르다. 가능하면 튜플 key로 해결하고 cmp는 정말 필요할 때만.

6. itertools·functools·math

조합·순열은 직접 짜지 말고 itertools. 메모이제이션은 lru_cache 한 줄.

from itertools import permutations, combinations, product, combinations_with_replacement, accumulate, groupby, chain

list(permutations([1,2,3], 2))     # 순열 (순서 있음) nP2
list(combinations([1,2,3], 2))     # 조합 (순서 없음) nC2
list(product([0,1], repeat=3))     # 중복 순열 / 데카르트 곱 → 비트마스크 대용
list(combinations_with_replacement([1,2,3], 2))   # 중복 조합
list(accumulate([1,2,3]))          # 누적합 [1,3,6]
list(accumulate(a, max))           # 누적 최댓값
list(chain(a, b))                  # 이어붙이기
for k, g in groupby(sorted(a)): print(k, len(list(g)))   # 연속 동일값 묶기 (정렬 먼저)

from functools import lru_cache, reduce
@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)
# 3.9+ 는 @cache 도 가능. 인자는 해시 가능해야 함 (리스트 → 튜플)
reduce(lambda x, y: x * y, a, 1)

import math
math.gcd(a, b);  math.lcm(a, b) (3.9+);  math.gcd(*arr) (3.9+)
math.factorial(n);  math.comb(n, r);  math.perm(n, r)
math.ceil(x);  math.floor(x);  math.sqrt(x);  math.isqrt(n) (정수 제곱근)
math.inf;  -math.inf;  float("inf")
math.log(x, base);  math.log2(x);  math.hypot(dx, dy);  math.dist(p, q)
divmod(a, b)       # (몫, 나머지)
pow(a, b, mod)     # 모듈러 거듭제곱 O(log b)
abs(x);  round(x, 2)   # round는 은행가 반올림 — 0.5는 짝수로

7. 자주 나오는 알고리즘 패턴

완전탐색

# 비트마스크 부분집합
for mask in range(1 << n):
    subset = [a[i] for i in range(n) if mask & (1 << i)]

# 백트래킹 (N-Queen 틀)
def dfs(depth, path):
    if depth == n:
        result.append(path[:])
        return
    for i in range(n):
        if not used[i]:
            used[i] = True;  path.append(i)
            dfs(depth + 1, path)
            path.pop();  used[i] = False

투포인터 / 슬라이딩 윈도우

left = total = 0;  best = float("inf")
for right in range(n):
    total += a[right]
    while total >= target:
        best = min(best, right - left + 1)
        total -= a[left];  left += 1

누적합

pre = [0] + list(accumulate(a))     # pre[i] = a[0..i-1] 합
# [l, r] 구간 합 = pre[r+1] - pre[l]

# 2차원
P = [[0] * (m + 1) for _ in range(n + 1)]
for i in range(n):
    for j in range(m):
        P[i+1][j+1] = grid[i][j] + P[i][j+1] + P[i+1][j] - P[i][j]

BFS (그리드 최단거리)

from collections import deque
dr, dc = [-1, 1, 0, 0], [0, 0, -1, 1]
dist = [[-1] * m for _ in range(n)]
q = deque([(sr, sc)]);  dist[sr][sc] = 0
while q:
    r, c = q.popleft()
    for d in range(4):
        nr, nc = r + dr[d], c + dc[d]
        if not (0 <= nr < n and 0 <= nc < m): continue
        if grid[nr][nc] == 1 or dist[nr][nc] != -1: continue
        dist[nr][nc] = dist[r][c] + 1
        q.append((nr, nc))

DFS (인접 리스트, 재귀 → 스택)

adj = [[] for _ in range(n)]
adj[a].append(b);  adj[b].append(a)

visited = [False] * n
def dfs(u):
    visited[u] = True
    for v in adj[u]:
        if not visited[v]: dfs(v)

# 재귀 깊이 걱정되면 스택으로
stack = [start];  visited[start] = True
while stack:
    u = stack.pop()
    for v in adj[u]:
        if not visited[v]:
            visited[v] = True;  stack.append(v)

다익스트라

import heapq
INF = float("inf")
dist = [INF] * n;  dist[s] = 0
pq = [(0, s)]
while pq:
    d, u = heapq.heappop(pq)
    if d > dist[u]: continue
    for v, w in adj[u]:
        if dist[u] + w < dist[v]:
            dist[v] = dist[u] + w
            heapq.heappush(pq, (dist[v], v))

이분탐색 / 매개변수 탐색

from bisect import bisect_left
idx = bisect_left(a, target)          # 정렬된 a에서 target 이상 첫 위치

# "X가 가능한가"가 단조일 때 최대 X
lo, hi = 1, max_x
while lo < hi:
    mid = (lo + hi + 1) // 2
    if ok(mid): lo = mid
    else: hi = mid - 1
# 최소 X 는 mid = (lo+hi)//2, ok면 hi = mid, 아니면 lo = mid+1

유니온 파인드

parent = list(range(n))
def find(x):
    while parent[x] != x:
        parent[x] = parent[parent[x]];  x = parent[x]
    return x
def union(a, b):
    parent[find(a)] = find(b)

DP 기본 틀

# 1차원
dp = [0] * (n + 1)
for i in range(1, n + 1):
    dp[i] = max(dp[i-1], ...)

# 2차원 (LCS, 격자 경로)
dp = [[0] * (m + 1) for _ in range(n + 1)]

# 탑다운
@lru_cache(None)
def solve(i, j): ...

# 배낭
for w, v in items:
    for cap in range(W, w - 1, -1):      # 0/1은 역순
        dp[cap] = max(dp[cap], dp[cap - w] + v)

8. 자주 하는 실수와 함정

9. 속도 올리는 습관

Python은 느리다. 같은 O(n)이라도 쓰는 방법에 따라 3~10배 차이 난다.

• for 안에서 len(a), a.b.c 같은 속성 접근 반복하지 말고 변수로 빼기
• in 검사는 list 말고 set/dict
• sum, max, min, sorted, "".join, 컴프리헨션은 C로 돌아서 명시적 루프보다 빠름
• 2차원 접근 grid[i][j] 반복이면 row = grid[i] 한 번 꺼내기
• 재귀 DP보다 반복 DP가 2~3배 빠름. 깊이 깊으면 반복으로
• 전역 변수보다 지역 변수가 빠름 → 메인 로직을 def main(): 안에 넣고 호출
• PyPy 선택 가능하면 PyPy (단, 재귀와 큰 dict에서 메모리 주의)
• 문자열 비교 많으면 ord로 정수화

def main():
    input = sys.stdin.readline
    # ... 전체 로직 ...
    print(...)

if __name__ == "__main__":
    main()

10. 과제형 테스트용 클래스 설계

오프라인 IDE 테스트에서 "플레이리스트 관리 기능을 만들어라" 같은 과제가 나오면 이 틀로 간다.

from dataclasses import dataclass, field
from typing import Optional

@dataclass
class Song:
    title: str
    artist: str
    duration: int          # 초
    plays: int = 0

class Playlist:
    def __init__(self, name: str):
        self.name = name
        self._songs: list[Song] = []
        self._titles: set[str] = set()     # 중복 방지 O(1)

    def add(self, song: Song) -> bool:
        if song.title in self._titles:
            return False
        self._songs.append(song)
        self._titles.add(song.title)
        return True

    def remove(self, title: str) -> Optional[Song]:
        for i, s in enumerate(self._songs):
            if s.title == title:
                self._titles.discard(title)
                return self._songs.pop(i)
        return None

    def by_artist(self, artist: str) -> list[Song]:
        return [s for s in self._songs if s.artist == artist]

    def total_duration(self) -> int:
        return sum(s.duration for s in self._songs)

    def top(self, n: int) -> list[Song]:
        return sorted(self._songs, key=lambda s: -s.plays)[:n]

    def __len__(self): return len(self._songs)
    def __repr__(self): return f"Playlist({self.name}, {len(self)} songs)"


if __name__ == "__main__":
    pl = Playlist("드라이브")
    pl.add(Song("A", "IU", 210, 50))
    pl.add(Song("B", "IU", 180, 120))
    print(pl.add(Song("A", "IU", 210)))   # False — 중복
    print(pl.by_artist("IU"))
    print(pl.total_duration())
    print(pl.top(1))

면접에서 받을 질문과 한 줄 답: 왜 set을 따로 뒀나 → 중복 체크를 O(1)로 하려고, 리스트 in은 O(n) 곡이 100만 개면 → 삭제가 O(n)이니 dict로 title→Song 매핑하고 순서가 필요하면 OrderedDict나 인덱스 관리 dataclass 쓴 이유 → __init__, __repr__, __eq__ 자동 생성으로 보일러플레이트 제거 타입 힌트는 → 실행엔 영향 없지만 의도를 읽는 사람에게 보여준다. 변수명은 a, tmp 대신 play_count, songs_by_artist처럼 Python은 snake_case

평소 Python으로 문제를 풀다가 Java로 코딩테스트를 봐야 할 때, 손에서 바로 나와야 하는 것들만 모았다. 알고리즘 이론보다 "Java로 생각을 코드로 옮기는 속도"에 초점을 맞췄다. (Java 17 기준)

1. 기본 템플릿과 입출력

오프라인 IDE 테스트는 채점기가 없으므로 main에서 직접 함수를 호출해 결과를 출력하는 형태가 기본이다. 입력이 주어지는 경우엔 BufferedReader가 안전하다.

import java.util.*;
import java.io.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        int[] arr = Arrays.stream(br.readLine().split(" "))
                          .mapToInt(Integer::parseInt).toArray();

        StringBuilder sb = new StringBuilder();
        for (int x : arr) sb.append(x).append('\n');
        System.out.print(sb);
    }
}

과제형(플레이리스트 만들기 등)이면 입력 파싱 대신 main에 테스트 데이터를 직접 만들어 호출하고, 결과를 println으로 보여주면 된다. 클래스 여러 개는 한 파일에 class Song {}처럼 public 없이 두면 된다.

2. String / StringBuilder / char

String은 불변이라 반복 +=는 O(n²)다. 문자열을 만들거나 바꿀 땐 무조건 StringBuilder.

StringBuilder sb = new StringBuilder();
sb.append("abc").append(1).append('x');
sb.insert(0, "z");        // 앞에 삽입
sb.deleteCharAt(sb.length() - 1);
sb.setCharAt(0, 'q');
sb.reverse();             // 뒤집기 — 팰린드롬 판별에 바로 쓰임
sb.setLength(0);          // 비우기
String result = sb.toString();

문자열 뒤집기는 new StringBuilder(s).reverse().toString(). 문자 정렬은 char[] c = s.toCharArray(); Arrays.sort(c); new String(c). 아스키 연산은 char가 정수로 자동 승격되니 (char)(c + 1)처럼 캐스팅 필요.

3. 배열과 Arrays 유틸

크기가 고정이면 배열, 늘어나면 ArrayList. int[]와 Integer[]는 다른 타입이라 Comparator 정렬은 Integer[]에만 된다.

int[] a = new int[n];                 // 0으로 초기화
int[] b = {3, 1, 2};
int[][] grid = new int[r][c];
boolean[][] visited = new boolean[r][c];
Arrays.fill(a, -1);                   // 전체 채우기
for (int[] row : grid) Arrays.fill(row, Integer.MAX_VALUE);  // 2차원은 행별로

Arrays.sort(a);                       // 오름차순 (기본형은 역순 직접 불가)
Integer[] boxed = {3, 1, 2};
Arrays.sort(boxed, Collections.reverseOrder());
Arrays.sort(a, from, to);             // 구간 정렬

int[] copy = Arrays.copyOf(a, a.length);
int[] part = Arrays.copyOfRange(a, 1, 4);   // [1,4)
int[] c2 = a.clone();

Arrays.toString(a);                   // 디버그 출력 "[1, 2, 3]"
Arrays.deepToString(grid);            // 2차원
Arrays.equals(a, b);
Arrays.stream(a).sum();  .max().getAsInt();  .min().getAsInt();
Arrays.asList(boxed);                 // 고정 크기 List (add 불가)
List<Integer> list = new ArrayList<>(Arrays.asList(boxed));   // 수정 가능
List<Integer> li = Arrays.stream(a).boxed().collect(Collectors.toList());   // int[] → List
int[] back = li.stream().mapToInt(Integer::intValue).toArray();            // List → int[]
int idx = Arrays.binarySearch(a, key);  // 정렬된 배열만, 없으면 음수

2차원 배열 정렬은 Arrays.sort(arr, (x, y) -> x[0] - y[0]) (int[][] 은 객체 배열이라 가능). 방향 배열은 int[] dr = {-1, 1, 0, 0}; int[] dc = {0, 0, -1, 1};로 두고 범위 검사 if (nr < 0 || nr >= R || nc < 0 || nc >= C) continue;를 반드시 먼저.

4. 컬렉션 핵심

과제형 문제의 8할은 ArrayList + HashMap으로 끝난다. 선언은 인터페이스 타입으로, 제네릭은 래퍼 타입(Integer, Long, Character)만 가능.

List

List<Integer> list = new ArrayList<>();
list.add(x);  list.add(0, x);  list.get(i);  list.set(i, x);
list.remove(i);                 // 인덱스로 삭제
list.remove(Integer.valueOf(x)); // 값으로 삭제 (int면 인덱스로 오해함)
list.size();  list.isEmpty();  list.contains(x);  list.indexOf(x);
Collections.sort(list);  list.sort(null);  list.sort(Comparator.reverseOrder());
Collections.reverse(list);  Collections.max(list);  Collections.min(list);
Collections.swap(list, i, j);
list.subList(from, to);         // 뷰(복사 아님)
new ArrayList<>(list);          // 복사
List.of(1, 2, 3);               // 불변

Map

Map<String, Integer> map = new HashMap<>();
map.put(k, v);
map.get(k);                     // 없으면 null → int에 넣으면 NPE
map.getOrDefault(k, 0);
map.put(k, map.getOrDefault(k, 0) + 1);   // 카운팅 기본
map.merge(k, 1, Integer::sum);            // 카운팅 한 줄
map.computeIfAbsent(k, x -> new ArrayList<>()).add(v);   // 그룹핑 한 줄
map.containsKey(k);  map.containsValue(v);  map.remove(k);  map.size();
for (Map.Entry<String, Integer> e : map.entrySet()) { e.getKey(); e.getValue(); }
for (String k : map.keySet()) {}
for (int v : map.values()) {}

TreeMap<Integer, String> tm = new TreeMap<>();   // 키 정렬 유지
tm.firstKey();  tm.lastKey();  tm.floorKey(x);  tm.ceilingKey(x);  tm.headMap(x);  tm.tailMap(x);
LinkedHashMap<>                                  // 삽입 순서 유지

Set

Set<Integer> set = new HashSet<>();
set.add(x);  set.contains(x);  set.remove(x);  set.size();
new HashSet<>(list).size();     // 중복 제거 개수
TreeSet<Integer> ts = new TreeSet<>();   // 정렬 유지
ts.first();  ts.last();  ts.floor(x);  ts.ceiling(x);  ts.pollFirst();

Deque (스택·큐 둘 다)

Deque<Integer> dq = new ArrayDeque<>();
// 큐: offer / poll / peek         (뒤에 넣고 앞에서 뺀다)
// 스택: push / pop / peek        (앞에 넣고 앞에서 뺀다)
dq.offerFirst(x);  dq.offerLast(x);  dq.pollFirst();  dq.pollLast();  dq.peekFirst();  dq.peekLast();
dq.isEmpty();
// Stack 클래스는 느리고 권장 안 함. ArrayDeque는 null 불가.

PriorityQueue

PriorityQueue<Integer> pq = new PriorityQueue<>();                          // 최소 힙
PriorityQueue<Integer> maxPq = new PriorityQueue<>(Collections.reverseOrder());
PriorityQueue<int[]> pq2 = new PriorityQueue<>((a, b) -> a[1] - b[1]);      // 배열 우선순위
pq.offer(x);  pq.poll();  pq.peek();  pq.size();  pq.isEmpty();

5. 정렬과 Comparator

람다 (a, b) -> a - b는 오름차순, b - a는 내림차순. 값이 클 수 있으면 뺄셈 대신 Integer.compare(a, b)를 써야 오버플로우를 피한다.

// 기본
Collections.sort(list);
list.sort(Comparator.reverseOrder());
Arrays.sort(arr2d, (a, b) -> a[0] - b[0]);

// 다중 조건: 점수 내림차순, 같으면 이름 오름차순
list.sort((a, b) -> {
    if (a.score != b.score) return Integer.compare(b.score, a.score);
    return a.name.compareTo(b.name);
});

// 같은 것을 Comparator 체이닝으로 (면접에서 더 좋아 보임)
list.sort(Comparator.comparingInt((Song s) -> s.score).reversed()
                    .thenComparing(s -> s.name));

// 문자열 길이 순, 같으면 사전순
words.sort(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));

// Map을 값 기준으로 정렬해 상위 N개
List<Map.Entry<String, Integer>> entries = new ArrayList<>(map.entrySet());
entries.sort((a, b) -> b.getValue() - a.getValue());

객체가 기본 정렬 기준을 가지게 하려면 Comparable 구현:

class Song implements Comparable<Song> {
    String title; int plays;
    Song(String title, int plays) { this.title = title; this.plays = plays; }
    @Override
    public int compareTo(Song o) { return Integer.compare(o.plays, this.plays); }  // 재생수 내림차순
    @Override
    public String toString() { return title + "(" + plays + ")"; }
}

Collections.sort와 Arrays.sort(객체)는 안정 정렬(TimSort)이라 같은 키는 원래 순서 유지. Arrays.sort(int[])는 듀얼 피벗 퀵소트로 최악 O(n²)가 있으나 실무 테스트에선 신경 안 써도 됨.

6. Stream 핵심 패턴

과제형에서 "필터링해서 정렬해서 상위 N개" 같은 요구는 Stream 한 줄이 가장 읽기 좋다. 다만 성능 질문이 나오면 "반복문과 동일한 O(n), 가독성 때문에 썼다"고 답하면 된다.

import java.util.stream.*;

// 필터 + 변환 + 수집
List<String> titles = songs.stream()
    .filter(s -> s.plays > 100)
    .map(s -> s.title)
    .collect(Collectors.toList());      // Java 16+ 면 .toList()

// 정렬 + 상위 N
List<Song> top3 = songs.stream()
    .sorted(Comparator.comparingInt((Song s) -> s.plays).reversed())
    .limit(3)
    .collect(Collectors.toList());

// 그룹핑: 아티스트별 곡 목록 / 개수 / 합계
Map<String, List<Song>> byArtist = songs.stream().collect(Collectors.groupingBy(s -> s.artist));
Map<String, Long> countByArtist = songs.stream().collect(Collectors.groupingBy(s -> s.artist, Collectors.counting()));
Map<String, Integer> playsByArtist = songs.stream().collect(Collectors.groupingBy(s -> s.artist, Collectors.summingInt(s -> s.plays)));

// 집계
int total = songs.stream().mapToInt(s -> s.plays).sum();
Optional<Song> best = songs.stream().max(Comparator.comparingInt(s -> s.plays));
double avg = songs.stream().mapToInt(s -> s.plays).average().orElse(0);
boolean any = songs.stream().anyMatch(s -> s.plays == 0);   // allMatch, noneMatch
long cnt = songs.stream().filter(s -> s.plays > 0).count();

// 중복 제거, 문자열 합치기
List<String> artists = songs.stream().map(s -> s.artist).distinct().collect(Collectors.toList());
String joined = titles.stream().collect(Collectors.joining(", "));

// 범위 반복, 문자열 문자 순회
IntStream.range(0, n).forEach(i -> ...);          // 0..n-1
IntStream.rangeClosed(1, n).sum();
s.chars().filter(Character::isDigit).count();

// List → Map (키 중복 시 터짐, 세 번째 인자로 병합 규칙)
Map<String, Song> byTitle = songs.stream().collect(Collectors.toMap(s -> s.title, s -> s, (a, b) -> a));

Optional은 .orElse(기본값), .orElseThrow(), .isPresent(), .get()로 꺼낸다. Collectors.toList()로 만든 리스트는 수정 가능, .toList()(Java 16+)는 불변이라 add 하면 예외.

7. 자주 나오는 알고리즘 패턴

1시간 오프라인 테스트에서 실제로 나오는 건 이 여섯 개가 거의 전부다. 각각 손에서 바로 나와야 한다.

완전탐색 (순열·조합·부분집합)

// 조합: n개 중 r개 고르기
static void comb(int[] arr, int start, int r, List<Integer> cur, List<List<Integer>> out) {
    if (cur.size() == r) { out.add(new ArrayList<>(cur)); return; }
    for (int i = start; i < arr.length; i++) {
        cur.add(arr[i]);
        comb(arr, i + 1, r, cur, out);
        cur.remove(cur.size() - 1);
    }
}
// 순열은 start 대신 boolean[] used 로, 부분집합은 비트마스크 for (int mask = 0; mask < (1 << n); mask++)

투포인터 / 슬라이딩 윈도우

// 합이 target 이상인 최소 길이 구간
int left = 0, sum = 0, best = Integer.MAX_VALUE;
for (int right = 0; right < n; right++) {
    sum += arr[right];
    while (sum >= target) {
        best = Math.min(best, right - left + 1);
        sum -= arr[left++];
    }
}

누적합

int[] pre = new int[n + 1];
for (int i = 0; i < n; i++) pre[i + 1] = pre[i] + arr[i];
// [l, r] 구간 합 = pre[r + 1] - pre[l]

BFS (그리드 최단거리)

int[] dr = {-1, 1, 0, 0}, dc = {0, 0, -1, 1};
int[][] dist = new int[R][C];
for (int[] row : dist) Arrays.fill(row, -1);
Deque<int[]> q = new ArrayDeque<>();
q.offer(new int[]{sr, sc}); dist[sr][sc] = 0;
while (!q.isEmpty()) {
    int[] cur = q.poll();
    for (int d = 0; d < 4; d++) {
        int nr = cur[0] + dr[d], nc = cur[1] + dc[d];
        if (nr < 0 || nr >= R || nc < 0 || nc >= C) continue;
        if (grid[nr][nc] == 1 || dist[nr][nc] != -1) continue;
        dist[nr][nc] = dist[cur[0]][cur[1]] + 1;
        q.offer(new int[]{nr, nc});
    }
}

DFS (인접 리스트, 연결 요소)

List<List<Integer>> adj = new ArrayList<>();
for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
adj.get(a).add(b); adj.get(b).add(a);

boolean[] visited = new boolean[n];
static void dfs(int u) {
    visited[u] = true;
    for (int v : adj.get(u)) if (!visited[v]) dfs(v);
}
// 재귀 깊이 1만 넘으면 스택으로 바꿀 것 (Java 기본 스택은 작음)

이분탐색

// 정렬된 배열에서 target 이상인 첫 위치 (lower bound)
int lo = 0, hi = n;
while (lo < hi) {
    int mid = (lo + hi) >>> 1;
    if (arr[mid] < target) lo = mid + 1; else hi = mid;
}
// 매개변수 탐색: "X가 가능한가"가 단조이면 같은 틀로 최대/최소 X를 찾는다

유니온 파인드 (그룹 묶기)

int[] parent;
static int find(int x) { return parent[x] == x ? x : (parent[x] = find(parent[x])); }
static void union(int a, int b) { parent[find(a)] = find(b); }

유틸 함수

Math.max(a, b);  Math.min(a, b);  Math.abs(x);  Math.pow(2, 10);  Math.sqrt(x);  Math.floorMod(a, m);
long gcd(long a, long b) { return b == 0 ? a : gcd(b, a % b); }   // lcm = a / gcd * b
Integer.MAX_VALUE;  Integer.MIN_VALUE;  Long.MAX_VALUE;
Integer.bitCount(n);  1 << k;  (mask & (1 << k)) != 0;

8. Python 유저가 Java에서 자주 하는 실수

이 표의 절반은 컴파일 에러로 바로 잡히지만, 나머지 절반은 조용히 틀린 답을 낸다. 특히 ==, 정수 나눗셈, 오버플로우는 테스트 끝나기 전에 한 번씩 훑어볼 것.

문법 상 자주 막히는 것: 삼항은 a ? b : c, 향상된 for문은 for (int x : arr), static 메서드에서는 인스턴스 필드 접근 불가(헬퍼 메서드를 모두 static으로 통일하거나 객체를 만들어 호출), 예외를 던지는 메서드 쓰면 throws IOException 또는 try-catch. 프로그래머스 스타일은 class Solution { public int solution(int[] arr) {...} }이니 그 형태도 익숙해지기.

9. IntelliJ 필수 단축키와 낯선 환경 대비

회사 장비는 맥북일 수도 윈도우일 수도 있다. 이 열 개만 양쪽으로 외우면 된다. 마우스로 해도 되니 기억 안 나면 그냥 클릭.

라이브 템플릿 (타이핑 후 Tab): main → main 메서드, sout → println, fori → for (int i = 0; ...), iter → 향상된 for, psvm → main, ifn → if null, .var (식 뒤에) → 변수 추출, .for → 반복문 감싸기.

시작 직후 할 일 (2분)

1. 새 프로젝트가 아니라 이미 열려 있는지, Java 버전이 몇인지 확인 (.toList(), var, record는 16+ / 10+ / 16+)
2. Main 클래스에 sout("hi") 하고 실행해서 콘솔 나오는지 확인
3. 한글 입력 전환이 어떻게 되는지 확인 (윈도우면 한/영 키, 맥이면 Caps Lock 또는 Ctrl+Space)
4. 자동완성이 안 뜨면 Ctrl + Space 수동 호출, 그래도 안 되면 외운 대로 친다

테스트 중 전략: 먼저 클래스와 메서드 시그니처만 빈 몸으로 다 만들어 놓고 설명 주석 한 줄씩 달기 → 핵심 로직 구현 → main에서 테스트 데이터로 호출해 출력 → 엣지 케이스 추가. 시간이 끝나도 뼈대가 다 있으면 면접에서 설명할 게 남는다.

10. 면접에서 "왜 이 자료구조를 썼나" 한 줄 답변

코드를 놓고 바로 면접이 이어지므로, 선택마다 이유를 한 문장으로 말할 수 있어야 한다. 답의 형식은 항상 "필요한 연산 + 그 연산에서 이 구조가 빠른 이유 + 대안을 안 고른 이유".

하나 더: 변수명은 a, tmp 대신 playCount, songsByArtist처럼 의미 있게. 코드 스타일을 본다고 했으니 이게 점수에 직접 들어간다.

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다. Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 오버로딩과 오버라이딩입니다. 이름이 비슷해서 헷갈리지만 전혀 다른 개념이고, 면접 단골 질문이기도 합니다. 코테에서는 직접 만든 클래스를 정렬하거나 HashMap 키로 쓸 때 오버라이딩이 꼭 필요합니다.

1. 한눈에 비교

오버로딩은 "새로 추가(load)", 오버라이딩은 "덮어쓰기(ride over)" 로 외우자!

2. 오버로딩

자바: 매개변수가 다르면 같은 이름을 쓸 수 있다

class Calc {
    int add(int a, int b)          { return a + b; }
    int add(int a, int b, int c)   { return a + b + c; }      // 개수가 다름
    double add(double a, double b) { return a + b; }          // 타입이 다름
}

Calc c = new Calc();
c.add(1, 2);        // 3      → 첫 번째
c.add(1, 2, 3);     // 6      → 두 번째
c.add(1.5, 2.5);    // 4.0    → 세 번째

우리가 늘 쓰는 Math.max(int, int), Math.max(long, long), Math.max(double, double)과 System.out.println()도 오버로딩이다.

int add(int a, int b)  { ... }
long add(int a, int b) { ... }   // ❌ 반환 타입만 다른 것은 오버로딩이 아니다 (컴파일 에러)

파이썬: 같은 이름으로 다시 정의하면 덮어쓴다

def add(a, b):
    return a + b

def add(a, b, c):          # 앞의 add를 덮어쓴다
    return a + b + c

add(1, 2)                  # ❌ TypeError: add() missing 1 required positional argument: 'c'

파이썬은 대신 기본값 인자와 가변 인자로 같은 효과를 낸다.

def add(a, b, c=0):        # 기본값 인자
    return a + b + c

add(1, 2)                  # 3
add(1, 2, 3)               # 6

def add_all(*nums):        # 가변 인자 (몇 개든 받는다)
    return sum(nums)

add_all(1, 2, 3, 4)        # 10

생성자 오버로딩

class Point {
    int x, y;
    Point()             { this(0, 0); }        // 다른 생성자를 호출
    Point(int x, int y) { this.x = x; this.y = y; }
}

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

3. 오버라이딩

상속 문법부터

class Animal {
    String name;
    Animal(String name) { this.name = name; }

    void speak() { System.out.println("..."); }
}

class Dog extends Animal {
    Dog(String name) { super(name); }

    @Override
    void speak() {                       // 부모의 speak를 다시 정의
        super.speak();                   // 부모 것도 부르고 싶을 때
        System.out.println("멍멍");
    }
}

Animal a = new Dog("바둑이");
a.speak();   // "..." 다음에 "멍멍"  ← 변수 타입(Animal)이 아니라 실제 객체(Dog) 기준

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("...")

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)

    def speak(self):                     # 같은 이름으로 정의하면 오버라이딩
        super().speak()
        print("멍멍")

Dog("바둑이").speak()   # "..." 다음에 "멍멍"

자바 오버라이딩 규칙

• 메서드 이름과 매개변수가 부모와 똑같아야 한다.
• 접근 범위를 더 좁힐 수 없다 (public → private 불가).
• static, final, private 메서드는 오버라이딩할 수 없다.

4. 코테에서 오버라이딩하는 메서드

직접 만든 클래스를 출력, 비교, 해시, 정렬에 쓰려면 아래 메서드를 다시 정의해야 한다.

class Point implements Comparable<Point> {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Point)) return false;
        Point p = (Point) o;
        return x == p.x && y == p.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public int compareTo(Point o) {           // x 오름차순, 같으면 y 오름차순
        if (x != o.x) return Integer.compare(x, o.x);
        return Integer.compare(y, o.y);
    }
}

Set<Point> set = new HashSet<>();
set.add(new Point(1, 2));
set.contains(new Point(1, 2));   // true  (equals + hashCode 덕분)

PriorityQueue<Point> pq = new PriorityQueue<>();   // compareTo 기준으로 꺼낸다

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"({self.x}, {self.y})"

    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))

    def __lt__(self, other):                 # x 오름차순, 같으면 y 오름차순
        return (self.x, self.y) < (other.x, other.y)

s = {Point(1, 2)}
Point(1, 2) in s                 # True

sorted([Point(2, 1), Point(1, 5)])   # [(1, 5), (2, 1)]

더 짧게 쓰는 방법 (사실 이건 외우기 좀 힘들지도)

from dataclasses import dataclass

@dataclass(frozen=True, order=True)
class Point:
    x: int
    y: int

5. 체크포인트

equals(Point p)는 오버라이딩이 아니라 오버로딩이다

public boolean equals(Point p) {      // ❌ 매개변수 타입이 Object가 아니다
    return x == p.x && y == p.y;
}

부모(Object)의 equals(Object o)와 매개변수 타입이 달라서 오버라이딩이 아니라 오버로딩이 된다. HashSet은 equals(Object)를 부르기 때문에 이 메서드는 쓰이지 않고, 값이 같아도 못 찾는다.

@Override를 항상 붙이자! 위 코드에 @Override를 붙이면 컴파일 에러로 바로 알려 준다.

그 밖에

• equals를 재정의하면 hashCode도 반드시 함께... equals만 하면 HashSet / HashMap에서 값이 같은 객체를 못 찾는다.

• 파이썬에서 __eq__만 정의하면 해시가 불가능해진다. TypeError: unhashable type이 나므로 __hash__도 같이 정의한다.

• 파이썬 리스트를 출력하면 __str__이 아니라 __repr__을 쓴다. 하나만 정의할 거면 __repr__을 정의하자.

• 자바 static 메서드는 오버라이딩되지 않는다. 자식에 같은 이름으로 만들면 가려질(hiding) 뿐, 변수 타입 기준으로 호출된다.

• 파이썬 기본값 인자에 리스트를 쓰지 말자. 기본값은 함수 정의 시 한 번만 만들어져서 호출끼리 공유된다.

  def add(x, lst=[]):          # ❌
      lst.append(x)
      return lst
  
  add(1)   # [1]
  add(2)   # [1, 2]  ← 이전 호출의 리스트가 남아 있다
  
  def add(x, lst=None):        # ⭕
      if lst is None:
          lst = []
      lst.append(x)
      return lst

💡 이것만 기억하자

1. 오버로딩: 같은 이름, 다른 매개변수

오버라이딩: 부모 메서드를 자식이 재정의 2. 파이썬은 오버로딩이 없다. 같은 이름으로 다시 정의하면 덮어쓴다. 기본값 인자와 *args로 대신한다. 3. 부모 호출: 자바: super.메서드() 파이썬: super().메서드() 4. 직접 만든 클래스를 HashSet / HashMap에 넣으려면 equals + hashCode (파이썬은 __eq__ + __hash__) 5. 정렬/우선순위 큐에 넣으려면 compareTo (파이썬은 __lt__) 6. 자바는 @Override를 항상 붙이자! equals(Point p) 같은 실수를 컴파일러가 잡아 준다.

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다. Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 클래스와 static입니다. 자바로 코테를 풀다 보면 static을 일단 붙이고 보자는 식으로 쓰게 되는데, 왜 붙여야 하는지와 파이썬에서는 무엇에 해당하는지를 정리해 봅시다.

1. 클래스 기본

class Point {
    int x, y;                    // 필드 선언

    Point(int x, int y) {        // 생성자
        this.x = x;
        this.y = y;
    }

    int sum() {                  // 인스턴스 메서드
        return x + y;            // this.x에서 this 생략 가능
    }
}

Point p = new Point(1, 2);
p.sum();   // 3

class Point:
    def __init__(self, x, y):    # 생성자
        self.x = x               # 여기서 필드가 만들어진다
        self.y = y

    def sum(self):               # 인스턴스 메서드
        return self.x + self.y   # self 생략 불가

p = Point(1, 2)
p.sum()   # 3

코테에서 좌표나 노드처럼 값 몇 개를 묶기만 할 때는 자바는 int[]나 클래스, 파이썬은 튜플 (x, y)이 가장 간단하다.

2. static: 객체가 아니라 클래스에 속한 것

자바와 파이썬 대응표

class Counter {
    static int count = 0;        // 모든 객체가 공유
    int id;                      // 객체마다 따로

    Counter() {
        count++;
        id = count;
    }

    static int total() {         // 객체 없이 호출 가능
        return count;
    }
}

new Counter(); new Counter();
Counter.total();   // 2

class Counter:
    count = 0                    # 클래스 변수 (모든 객체가 공유)

    def __init__(self):
        Counter.count += 1       # 클래스 이름으로 접근
        self.id = Counter.count  # 인스턴스 변수 (객체마다 따로)

    @staticmethod
    def total():                 # self 없음, 객체 없이 호출 가능
        return Counter.count

Counter(); Counter()
Counter.total()   # 2

3. 코테에서 static이 필요한 이유

main이 static이기 때문!

자바 프로그램은 객체를 만들기 전에 main부터 실행된다. 그래서 main은 static이고, static 메서드 안에서는 static 멤버만 바로 쓸 수 있다.

public class Main {
    int n;                                  // 인스턴스 변수

    void dfs(int x) { }                     // 인스턴스 메서드

    public static void main(String[] args) {
        n = 5;        // ❌ non-static variable n cannot be referenced from a static context
        dfs(0);       // ❌ non-static method dfs(int) cannot be referenced from a static context
    }
}

해결 방법은 두 가지다.

// 방법 1: 전부 static으로 (백준 스타일, 가장 흔함)
static int n;
static void dfs(int x) { }

// 방법 2: 객체를 만들어서 호출
Main m = new Main();
m.dfs(0);

DFS · BFS용 공유 변수

재귀 함수 여러 번의 호출이 같은 배열과 답을 공유해야 할 때, 자바는 static 필드, 파이썬은 전역 변수를 쓴다.

public class Main {
    static int n;
    static boolean[] visited;
    static List<List<Integer>> graph = new ArrayList<>();
    static int answer = 0;

    static void dfs(int cur) {
        visited[cur] = true;
        answer++;
        for (int next : graph.get(cur)) {
            if (!visited[next]) dfs(next);
        }
    }
}

import sys
sys.setrecursionlimit(10**6)      # 파이썬 재귀 깊이 제한(기본 1000) 늘리기, 분할정복 시 필수다...

n = 5
visited = [False] * (n + 1)
graph = [[] for _ in range(n + 1)]
answer = 0

def dfs(cur):
    global answer                 # 전역 변수에 "대입"하려면 global 선언
    visited[cur] = True           # 리스트 원소 수정은 global 없이 가능
    answer += 1
    for nxt in graph[cur]:
        if not visited[nxt]:
            dfs(nxt)

파이썬 global vs nonlocal

def solution(n):
    answer = 0

    def dfs(x):
        nonlocal answer           # solution의 answer를 바꾸겠다는 뜻
        answer += 1

    dfs(0)
    return answer

4. 체크포인트

자바

• static 메서드 안에서는 this와 인스턴스 멤버를 쓸 수 없다. 객체가 없을 수도 있기 때문이다.
• 프로그래머스에서 static 필드는 초기화를 직접 하자. 테스트 케이스가 같은 클래스로 여러 번 실행되면 이전 값이 남아 있을 수 있다. solution() 시작 부분에서 answer = 0;처럼 다시 초기화한다.
• static final 상수는 대문자로! static final int MOD = 1_000_000_007;

파이썬

• self를 빼먹으면 에러가 난다...

  class A:
      def hello():          # self 누락
          print("hi")
  
  A().hello()               # TypeError: A.hello() takes 0 positional arguments but 1 was given

• self.count += 1은 클래스 변수를 바꾸지 않는다. 그 객체에 새 인스턴스 변수를 만들 뿐이다. 클래스 변수는 클래스이름.count += 1로 바꾼다.

  class Counter:
      count = 0
      def inc(self):
          self.count += 1   # 인스턴스 변수 count가 새로 생긴다
  
  a = Counter(); a.inc()
  print(a.count, Counter.count)   # 1 0

• 클래스 변수에 리스트를 두면 모든 객체가 공유한다. 객체마다 따로 가져야 하면 __init__ 안에서 만든다.

  class Bag:
      items = []                    # ❌ 모든 Bag이 같은 리스트를 쓴다
      def __init__(self):
          self.items = []           # ⭕ 객체마다 새 리스트

• global 없이 대입하면 지역 변수가 새로 생긴다. answer += 1은 UnboundLocalError가 난다.

💡 이것만 기억하자

1. static은 "객체 없이 쓸 수 있고, 모두가 공유하는 것" 파이썬에서는 클래스 변수와 @staticmethod
2. main이 static이라서 보조 메서드와 공유 변수도 static, 프로그래머스 solution()은 인스턴스 메서드라 필요 없다.
3. 파이썬 메서드는 첫 매개변수로 self를 적고, 필드는 항상 self.을 붙인다.
4. 파이썬 전역 변수: 읽기와 내용 수정은 그냥, 대입은 global (함수 안의 함수는 nonlocal)
5. 파이썬 클래스 변수는 클래스이름.변수로 바꾼다. self.변수 += 1은 다른 변수를 만든다.
6. 파이썬 DFS는 sys.setrecursionlimit을 잊지 말자.

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다. Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 람다입니다! 람다는 쉽게 말하면 이름 없는 짧은 함수입니다. 코테에서는 주로 정렬 기준, 변환(map)/거르기(filter), 입력 파싱에 씁니다.

1. 기본 문법

// 자바 람다는 반드시 "함수형 인터페이스" 타입에 담아야 한다
Function<Integer, Integer> doubleIt = x -> x * 2;
BinaryOperator<Integer> add = (a, b) -> a + b;

doubleIt.apply(3);   // 6
add.apply(2, 3);     // 5

double_it = lambda x: x * 2
add = lambda a, b: a + b

double_it(3)   # 6
add(2, 3)      # 5

파이썬 람다는 식(expression) 하나만 쓸 수 있다. if문, for문, 대입이 필요하면 def로 함수를 만든다. 자바 람다는 { } 블록을 쓰면 여러 줄도 가능하지만, 이때는 return을 직접 써야 한다.

자바 함수형 인터페이스

자바 람다는 혼자 존재할 수 없고, 어떤 인터페이스의 구현으로 쓰인다. 자주 보는 것만 알아두면 된다.

2. 메서드 참조 vs 함수 그대로 넘기기

람다가 이미 있는 함수를 호출만 할 때는 더 짧게 쓸 수 있다.

map.merge(key, 1, Integer::sum);
words.sort(Comparator.comparing(String::length));

words.sort(key=len)                 # 함수 이름을 그대로 넘긴다
nums = list(map(int, ["1", "2"]))   # int 함수를 그대로 넘긴다

파이썬은 함수 자체가 값이라서 key=len처럼 괄호 없이 이름만 넘기면 된다. key=len()이라고 쓰면 에러 발생!

3. 정렬 기준 (복습)

• 자바는 "두 값을 받아 비교", 파이썬은 "값 하나를 받아 비교할 기준을 반환" 하는 방식이다.
• 자바 Comparator.comparing(...)이 파이썬 key=와 같은 방식이라, 익숙해지면 둘을 똑같이 생각할 수 있다.

// 파이썬 key=lambda x: (x[0], -x[1]) 과 같은 정렬
Arrays.sort(arr, Comparator.comparingInt((int[] x) -> x[0])
                           .thenComparing((int[] x) -> x[1], Comparator.reverseOrder()));

자세한 정렬은 #2 형변환/비교/정렬 편 참고

4. map · filter · reduce

int[] arr = {1, -2, 3, -4, 5};

int[] result = Arrays.stream(arr)
                     .filter(x -> x > 0)     // 1, 3, 5
                     .map(x -> x * 2)        // 2, 6, 10
                     .toArray();

List<String> words = List.of("apple", "kiwi", "banana");
List<Integer> lengths = words.stream()
                             .map(String::length)
                             .collect(Collectors.toList());   // [5, 4, 6]

arr = [1, -2, 3, -4, 5]

result = [x * 2 for x in arr if x > 0]              # [2, 6, 10]  ← 추천
result = list(map(lambda x: x * 2,
                  filter(lambda x: x > 0, arr)))    # 같은 결과

from functools import reduce
total = reduce(lambda a, b: a + b, arr, 0)          # 3

파이썬에서는 map + lambda 조합보다 리스트 컴프리헨션이 더 읽기 쉽고 흔하다. 단, map(int, ...)처럼 이미 있는 함수를 넘길 때는 map이 더 짧다.

5. 코테에서 자주 쓰는 한 줄

6. 체크포인트

[자바] 람다 안에서 바깥 지역변수를 바꿀 수 없다

람다가 쓰는 바깥 지역변수는 사실상 final(한 번도 바뀌지 않는 값)이어야 한다.

int count = 0;
list.forEach(x -> count++);        // ❌ 컴파일 에러

int[] count = {0};
list.forEach(x -> count[0]++);     // ⭕ 배열 원소는 바꿀 수 있다 (꼼수)

int cnt = 0;
for (int x : list) cnt++;          // ⭕ 그냥 for문이 제일 깔끔

[파이썬] 반복문 안에서 만든 람다는 마지막 값을 본다

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]               # [2, 2, 2]  ← 0, 1, 2가 아님!

funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]               # [0, 1, 2]  ← 기본값으로 현재 i를 고정

람다는 i의 값이 아니라 변수 자체를 기억하기 때문에, 호출 시점의 i(마지막 값 2)를 읽는다.

그 밖에

• 파이썬 map / filter는 결과를 바로 만들지 않는다. 이터레이터라서 list()로 감싸야 리스트가 되고, 한 번 순회하면 다시 쓸 수 없다.
• 자바 스트림도 한 번만 쓸 수 있다. 다시 쓰면 IllegalStateException이 난다.
• 자바 스트림은 for문보다 느리다. 반복 횟수가 많은 핵심 로직에서는 for문을 쓰고, 스트림은 입력 파싱처럼 한 번만 실행되는 곳에 쓰자.
• 자바 int[] 스트림은 IntStream이다. mapToInt, boxed()로 Stream<Integer>와 오가야 할 때가 있다 #4 참고
• 자바 람다 + .reversed()는 타입 추론이 안 될 때가 있다. Comparator.comparing((String s) -> s.length()).reversed()처럼 매개변수 타입을 적어 준다.

💡 이것만 기억하자

1. 문법: 자바: (a, b) -> 식 파이썬: lambda a, b: 식, 파이썬은 식 하나만
2. 이미 있는 함수는 그대로 넘기자.

자바: Integer::parseInt 파이썬: int, len 3. 정렬: 자바는 두 값을 비교 파이썬: 기준 값을 반환(key=) 자바: Comparator.comparing이 파이썬 key=와 같은 방식 4. 변환/거르기: 자바: 스트림 map / filter 파이썬: 리스트 컴프리헨션 5. 자바 람다 안에서 바깥 변수 수정 불가! 카운트는 for문으로 6. 파이썬 반복문 안 람다는 lambda i=i:로 값을 고정

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다. Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 HashMap · dict · Set입니다. 개수 세기, 중복 제거, 빠른 존재 여부 확인까지 코테에서 가장 많이 쓰는 자료구조입니다. 웬만한 문제는 풀 수 있어요! 조회·추가·포함 확인이 평균 O(1) 이라서, 리스트로 in / contains를 반복하다 시간 초과가 나면 가장 먼저 떠올려야 합니다.

0. 선언

import java.util.*;

Map<String, Integer> map = new HashMap<>();
Set<Integer> set = new HashSet<>();

from collections import Counter, defaultdict

d = {}          # 빈 딕셔너리
s = set()       # 빈 셋  ← {}는 딕셔너리

1. HashMap · dict 기본 사용

없는 키를 조회하면

Map<String, Integer> map = new HashMap<>();
int n = map.get("a");        // ❌ NullPointerException (null을 int로 언박싱)
int m = map.getOrDefault("a", 0);   // ⭕ 0

d = {}
n = d["a"]           # ❌ KeyError
m = d.get("a", 0)    # ⭕ 0

자바 map.get()은 에러 없이 null을 주지만, int 변수에 담거나 + 1을 하는 순간 NullPointerException 이 난다.

2. 개수 세기 (가장 많이 쓰는 패턴)

["a", "b", "a", "c", "a"] → {a: 3, b: 1, c: 1}

Map<String, Integer> count = new HashMap<>();

for (String x : arr) {
    count.put(x, count.getOrDefault(x, 0) + 1);   // 방법 1
    // count.merge(x, 1, Integer::sum);           // 방법 2 (한 줄)
}

count = {}
for x in arr:
    count[x] = count.get(x, 0) + 1       # 방법 1

from collections import Counter
count = Counter(arr)                      # 방법 2 (한 줄)
count.most_common(2)                      # [('a', 3), ('b', 1)]  빈도 상위 2개

그룹 묶기 (키 하나에 여러 값)

Map<String, List<String>> group = new HashMap<>();
group.computeIfAbsent(key, k -> new ArrayList<>()).add(value);

group = defaultdict(list)
group[key].append(value)     # 키가 없으면 빈 리스트를 자동으로 만든다

defaultdict(int)는 없는 키를 0으로, defaultdict(list)는 []로 자동 생성한다.

3. 순회

for (Map.Entry<String, Integer> e : map.entrySet()) {
    String key = e.getKey();
    int value = e.getValue();
}

for key, value in d.items():
    print(key, value)

파이썬 d.items()는 enumerate처럼 두 값을 한 번에 풀어서 받는다. 자바는 Entry에서 getKey(), getValue()로 꺼낸다.

정렬해서 순회

List<Map.Entry<String, Integer>> entries = new ArrayList<>(map.entrySet());
entries.sort((a, b) -> Integer.compare(b.getValue(), a.getValue()));   // 값 내림차순

순회 체크포인트

• 순회하면서 삭제하면 에러가 난다. 자바는 ConcurrentModificationException, 파이썬은 RuntimeError. 자바는 map.entrySet().removeIf(e -> e.getValue() == 0), 파이썬은 for k in list(d):처럼 키 목록을 복사해서 순회한다.

4. Set: 중복 없는 집합

중복 제거

List<Integer> list = List.of(3, 1, 3, 2, 1);
Set<Integer> set = new HashSet<>(list);            // [1, 2, 3] (순서 보장 X)
Set<Integer> kept = new LinkedHashSet<>(list);     // [3, 1, 2] (넣은 순서 유지)

lst = [3, 1, 3, 2, 1]
s = set(lst)                    # {1, 2, 3} (순서 보장 X)
kept = list(dict.fromkeys(lst)) # [3, 1, 2] (넣은 순서 유지)

이미 본 값인지 확인

자바 add()는 새로 추가되면 true, 이미 있으면 false 를 반환한다. 중복 체크와 추가를 한 번에 할 수 있다.

Set<Integer> seen = new HashSet<>();
for (int x : arr) {
    if (!seen.add(x)) {
        System.out.println(x + " 중복!");
    }
}

seen = set()
for x in arr:
    if x in seen:
        print(x, "중복!")
    seen.add(x)

집합 연산

자바 집합 연산은 원본을 바꾼다. 원본을 남기려면 Set<Integer> c = new HashSet<>(a); c.retainAll(b);처럼 복사 후 연산한다.

5. 키로 쓸 수 있는 것

Set<String> visited = new HashSet<>();
visited.add(x + "," + y);

// int[]를 키로 쓰면 값이 같아도 다른 키로 취급된다
Set<int[]> bad = new HashSet<>();
bad.add(new int[]{1, 2});
bad.contains(new int[]{1, 2});   // false

visited = set()
visited.add((x, y))       # 튜플은 OK
visited.add([x, y])       # ❌ TypeError

💡 이것만 기억하자

1. 없는 키 조회: 자바 null, 파이썬 KeyError 둘 다 getOrDefault / get(k, 0)으로 안전하게 쓰자.
2. 개수 세기: 자바 getOrDefault + 1 또는 merge, 파이썬 get + 1 또는 Counter
3. 키 + 값 순회: 자바 entrySet(), 파이썬 items()
4. 파이썬 빈 셋은 set(), {}는 딕셔너리다.
5. 자바 set.add()는 중복이면 false 중복 체크를 한 줄로!
6. 좌표를 키로 쓸 때: 자바는 문자열, 파이썬은 튜플 배열과 리스트는 키가 될 수 없다.
7. 순서: HashMap / HashSet은 순서 보장 X, 파이썬 dict는 넣은 순서 유지

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다. Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 배열 · 리스트 · 문자열 기초입니다. 길이 구하기, 순회, 복사, 정렬처럼 매 문제마다 쓰는 기본기인데, 자바는 대상마다 문법이 다르고 파이썬은 거의 하나로 통일되어 있어서 자주 헷갈립니다.

1. 길이 · 크기

자바는 배열은 필드(length), 문자열은 메서드(length()), 컬렉션은 size() 로 외우자! 파이썬은 무엇이든 len() 하나면 된다.

int[] arr = {1, 2, 3};
String s = "abc";
List<Integer> list = List.of(1, 2, 3);

arr.length;    // 3  (괄호 없음)
s.length();    // 3  (괄호 있음)
list.size();   // 3

len([1, 2, 3])  # 3
len("abc")      # 3

2. 선언 · 초기화

선언 체크포인트

• 파이썬 2차원 리스트를 [[0] * m] * n으로 만들면 안 된다. 모든 행이 같은 리스트를 가리켜서 한 칸을 바꾸면 모든 행이 같이 바뀐다.

  grid = [[0] * 3] * 2
  grid[0][0] = 1
  print(grid)   # [[1, 0, 0], [1, 0, 0]]  ← 둘 다 바뀜

• 자바 Arrays.asList()와 List.of()는 크기를 바꿀 수 없다. add하면 예외가 난다. 추가하려면 new ArrayList<>(Arrays.asList(...))로 감싼다.

• 자바 int[]는 Arrays.asList()로 리스트가 되지 않는다. List<int[]>가 되어 버린다. 박싱이 필요하다.

  List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());   // int[] → List
  int[] back = list.stream().mapToInt(Integer::intValue).toArray();                // List → int[]

3. 순회

enumerate

파이썬에서 인덱스와 값이 둘 다 필요할 때 쓰는 함수다. 자바에는 없으니 인덱스 for문을 쓴다.

fruits = ["apple", "banana", "cherry"]

for i, fruit in enumerate(fruits):
    print(i, fruit)        # 0 apple / 1 banana / 2 cherry

for i, fruit in enumerate(fruits, start=1):
    print(i, fruit)        # 1 apple / 2 banana / 3 cherry

String[] fruits = {"apple", "banana", "cherry"};

for (int i = 0; i < fruits.length; i++) {
    System.out.println(i + " " + fruits[i]);
}

파이썬에서 for i in range(len(arr)): 안에서 arr[i]를 쓰고 있다면 enumerate로 바꾸는 게 더 파이썬답다.

4. 문자열 다루기

문자열 체크포인트

• 두 언어 모두 문자열은 불변(immutable)이다. s.charAt(0) = 'x', s[0] = 'x' 모두 불가능하다. 문자 배열(리스트)로 바꿔서 수정한 뒤 다시 합친다.

  String s = "hello";
  char[] cs = s.toCharArray();   // ['h', 'e', 'l', 'l', 'o']
  cs[0] = 'j';                   // 배열은 수정 가능
  s = new String(cs);            // "jello"

  // StringBuilder도 가능
  StringBuilder sb = new StringBuilder(s);
  sb.setCharAt(0, 'y');
  s = sb.toString();             // "yello"

  s = "hello"
  chars = list(s)                # ['h', 'e', 'l', 'l', 'o']
  chars[0] = "j"                 # 리스트는 수정 가능
  s = "".join(chars)             # "jello"

  # 한 글자만 바꿀 거면 슬라이싱으로 새로 만들어도 된다
  s = "y" + s[1:]                # "yello"

• 반복문에서 문자열을 +로 이어 붙이지 말자. 매번 새 문자열이 만들어져서 느리다.

  StringBuilder sb = new StringBuilder();
  for (int x : arr) sb.append(x).append(" ");
  String result = sb.toString();

  result = " ".join(map(str, arr))

• split 동작이 다르다. 파이썬 split()(인자 없음)은 연속된 공백도 하나로 보고 앞뒤 공백을 무시한다. 자바 split(" ")는 공백 하나 기준이라 빈 문자열이 섞일 수 있다. 자바에서 연속 공백을 처리하려면 s.trim().split("\\s+")를 쓴다.

5. 복사

int[][] copy = new int[n][];
for (int i = 0; i < n; i++) copy[i] = grid[i].clone();

b = a는 두 언어 모두 복사가 아니라 같은 배열을 가리키는 것이다. b를 바꾸면 a도 바뀐다. 2차원 배열에 clone() / a[:]만 쓰면 행은 여전히 공유된다(얕은 복사).

6. 정렬: 원본을 바꿀까, 복사본을 만들까

sort() vs sorted()

nums = [3, 1, 2]

a = sorted(nums)   # a = [1, 2, 3], nums = [3, 1, 2]  ← 원본 유지
nums.sort()        # nums = [1, 2, 3]                 ← 원본 변경

• lst.sort(): 리스트 원본을 정렬하고 None을 반환한다. 리스트에만 있는 메서드다.
• sorted(x): 원본은 그대로 두고 정렬된 새 리스트를 반환한다. 문자열, 튜플, 딕셔너리 등 순회 가능한 모든 것에 쓸 수 있다.

nums = nums.sort()      # (X) nums가 None이 된다
nums = sorted(nums)     # (O)

sorted("dcba")          # ['a', 'b', 'c', 'd']
sorted({"b": 1, "a": 2})  # ['a', 'b']  (딕셔너리는 키만)

자바의 Arrays.sort(), Collections.sort()는 항상 원본을 바꾼다. 원본을 남겨야 하면 먼저 복사하고 정렬한다.

💡 이것만 기억하자

1. 길이: 자바 배열 length, 문자열 length(), 컬렉션 size(). 파이썬은 전부 len()
2. 파이썬 2차원 리스트는 [[0] * m for _ in range(n)]. [[0] * m] * n은 행이 공유된다.
3. 인덱스와 값이 둘 다 필요하면 파이썬은 enumerate. 자바는 인덱스 for문
4. b = a는 복사가 아니다. 1차원은 clone() / a[:], 2차원은 행마다 복사
5. 파이썬 sort()는 원본 변경 + None 반환, sorted()는 새 리스트 반환. 자바 정렬은 항상 원본 변경
6. 문자열 이어 붙이기는 StringBuilder / join

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다. Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 Math입니다. 자바는 대부분 Math 클래스에 모여 있고, 파이썬은 내장 함수와 math 모듈에 나뉘어 있습니다. 함수 이름은 비슷하지만 반환 타입과 반올림 방식이 달라서 실수하기 쉽습니다.

import math   # 파이썬은 math 모듈을 import 해야 한다 (abs, max, min, pow, round는 내장)

1. 기본 연산

int big = Math.max(a, Math.max(b, c));     // 3개 이상은 중첩
int p = (int) Math.pow(2, 10);             // 1024, double이라 형변환 필요

big = max(a, b, c)
p = 2 ** 10                                # 1024, 결과가 바로 int

2. 반올림/올림/내림

반올림 결과가 다른 거 주의!!

• 자바 Math.round(x)는 floor(x + 0.5) 방식이다. 그래서 -2.5는 -2가 된다.
• 파이썬 round()는 은행가 반올림이라 .5일 때 짝수 쪽으로 간다.
• 사사오입이 필요하면 파이썬은 math.floor(x + 0.5)를 쓰거나 decimal 모듈의 ROUND_HALF_UP을 쓴다.

정수 올림 나눗셈 (코테 단골)

a / b를 올림하고 싶을 때, 실수로 바꾸지 않고 정수만으로 계산하는 방법이다.

int q = (a + b - 1) / b;        // a, b가 양수일 때

q = (a + b - 1) // b            # a, b가 양수일 때
q = -(-a // b)                  # 음수에서도 동작

3. 몫과 나머지

-7 / 2;                  // -3
-7 % 2;                  // -1
Math.floorDiv(-7, 2);    // -4  (파이썬 // 와 같음)
Math.floorMod(-7, 2);    // 1   (파이썬 % 와 같음)

음수 인덱스를 순환시킬 때((i - 1) % n) 자바는 음수가 나올 수 있다. Math.floorMod(i - 1, n) 또는 ((i - 1) % n + n) % n을 쓰자.

4. 큰 수 · 오버플로우

거듭제곱 나머지 (모듈러 거듭제곱)

a^b % mod처럼 결과가 큰 거듭제곱은 Math.pow를 쓰면 안 된다. double이라 정밀도가 깨진다.

// 빠른 거듭제곱 (분할 정복)
static long modPow(long a, long b, long mod) {
    long result = 1;
    a %= mod;
    while (b > 0) {
        if ((b & 1) == 1) result = result * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return result;
}

pow(a, b, mod)   # 내장 함수가 세 번째 인자로 모듈러를 지원한다

5. 정수론 · 조합

static int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

static int lcm(int a, int b) {
    return a / gcd(a, b) * b;   // 곱하기 먼저 하면 오버플로우 위험
}

math.gcd(12, 18)    # 6
math.lcm(12, 18)    # 36
math.comb(5, 2)     # 10

6. 로그 · 기타

7. 배열 집계

자바 스트림은 편하지만 반복 호출하면 느리다. 반복문 안에서는 for문으로 직접 계산하는 게 안전하다.

💡 이것만 기억하자

1. 자바 Math는 대부분 double을 반환한다. pow, sqrt, ceil, floor는 (int)로 형변환하고, round는 long이다. 파이썬 math.ceil / math.floor는 바로 int다.
2. 반올림이 다르다! 2.5는 자바 3, 파이썬 2(은행가 반올림)
3. 음수 몫과 나머지. 파이썬 //, %와 같게 하려면 자바는 Math.floorDiv, Math.floorMod를 쓴다.
4. 큰 거듭제곱에 Math.pow 금지. 자바는 빠른 거듭제곱을 직접 구현하고, 파이썬은 pow(a, b, mod)를 쓴다.
5. 자바는 오버플로우를 조심! 곱셈은 long으로, 최소공배수는 나누기를 먼저!
6. gcd, 조합, 팩토리얼은 파이썬만 내장. 자바는 직접 구현한다.
7. 사실 나도 아직 안 써본 게 많다...언젠가는 쓰겠지 싶어서 정리했다.

알고리즘 Cheat Sheet 시리즈는 코딩 테스트를 풀다가 "이거 자바에선 뭐였지?", "파이썬은 어떻게 했더라?" 싶을 때 바로 펼쳐 보려고 만든 개인 참고용 정리입니다. Java와 Python을 나란히 놓고, 문법 차이 때문에 실수하기 쉬운 부분만 짧게 정리합니다.

이번 주제는 형변환, 비교, 정렬입니다. 입력을 파싱하고, 값을 비교하고, 원하는 기준으로 정렬하는 건 거의 모든 문제에서 반복되는 작업이므로 꼭! 숙지할 필요가 있습니다.

1. 형변환

문자열 ↔ 숫자

int i = Integer.parseInt("123");
double d = Double.parseDouble("3.14");
String s = String.valueOf(123);
int t = (int) 3.99;   // 3 (소수점 버림)

i = int("123")
d = float("3.14")
s = str(123)
t = int(3.99)          # 3 (소수점 버림)

문자 ↔ 숫자 (코테 단골)

형변환 체크포인트

• 소수 문자열을 바로 정수로 바꾸면 에러가 난다. 자바 Integer.parseInt("3.14") → NumberFormatException, 파이썬 int("3.14") → ValueError. 실수로 바꾼 뒤 정수로 변환해야 한다: (int) Double.parseDouble("3.14"), int(float("3.14")).
• (int), int()는 반올림이 아니라 0 방향 버림이다. (int) -3.7과 int(-3.7)은 둘 다 -3이다. 내림이 필요하면 Math.floor() / math.floor(), 반올림은 Math.round() / round()를 쓴다.
• 파이썬 round()는 사사오입이 아니다. 은행가 반올림이라 round(2.5)는 2, round(3.5)는 4다.
• 나눗셈 결과 타입이 다르다.

2. 비교

compare / compareTo의 반환값은 음수(앞이 작음), 0(같음), 양수(앞이 큼) 이다.

비교 체크포인트

• 자바에서 문자열은 ==로 비교하면 안 된다. ==는 값이 아니라 참조(주소)를 비교한다. 반드시 equals()를 쓴다.
• Integer 객체도 ==로 비교하면 안 된다. -128 ~ 127 범위만 캐시되어 있어서 그 밖의 값은 같은 숫자여도 false가 나올 수 있다. equals()나 intValue()로 비교한다.
• 비교 함수에 a - b를 쓰지 말자. 정수는 오버플로우가 날 수 있고(Integer.MIN_VALUE - 1), 실수는 int로 잘리면서 오차가 생긴다. Integer.compare(a, b)를 쓴다.

3. 정렬

기본 정렬

기준을 정해서 정렬

자바는 (a, b) 순서면 오름차순, (b, a)로 뒤집으면 내림차순으로 외우면 된다.

// 2차원 배열: 첫 번째 값 오름차순, 같으면 두 번째 값 내림차순
Arrays.sort(arr, (a, b) -> {
    if (a[0] != b[0]) return Integer.compare(a[0], b[0]);
    return Integer.compare(b[1], a[1]);
});

// Comparator 체이닝으로도 가능
list.sort(Comparator.comparing((int[] a) -> a[0])
                    .thenComparing(a -> a[1], Comparator.reverseOrder()));

arr.sort(key=lambda x: (x[0], -x[1]))

파이썬은 튜플을 key로 주면 앞 원소부터 차례로 비교한다. 숫자 기준 내림차순은 -만 붙이면 된다.

특수 정렬: 이어 붙였을 때 가장 큰 수

["3", "30", "34", "5", "9"] → "9534330" 처럼 두 값을 붙여 보고 더 큰 쪽을 앞에 두는 정렬이다.

String[] strs = {"3", "30", "34", "5", "9"};
Arrays.sort(strs, (a, b) -> (b + a).compareTo(a + b));
String answer = String.join("", strs);   // "9534330"

from functools import cmp_to_key

strs = ["3", "30", "34", "5", "9"]
strs.sort(key=cmp_to_key(lambda a, b: int(b + a) - int(a + b)))
answer = "".join(strs)                   # "9534330"

파이썬은 key만 받기 때문에, 두 값을 직접 비교하는 함수는 cmp_to_key로 감싸야 한다.

정렬 체크포인트

• 자바 int[]는 람다나 reverseOrder()로 정렬할 수 없다. 비교자를 받는 Arrays.sort는 Integer[], String[], int[][] 같은 객체 배열에만 쓸 수 있다. int[]를 내림차순으로 정렬하려면 박싱하거나, 오름차순 정렬 후 뒤에서부터 읽는다.

  Integer[] boxed = Arrays.stream(arr).boxed().toArray(Integer[]::new);
  Arrays.sort(boxed, Collections.reverseOrder());

• 파이썬 list.sort()는 None을 반환한다. arr = arr.sort()라고 쓰면 arr이 None이 된다. 새 리스트가 필요하면 sorted()를 쓴다.

• 두 언어 모두 객체 정렬은 안정 정렬이다. 기준 값이 같으면 원래 순서가 유지되므로, 정렬을 여러 번 나눠서 해도 된다.

💡 이것만 기억하자

1. 소수 문자열 → 정수는 두 단계. 실수로 바꾼 다음 정수로. (int)와 int()는 0 방향 버림이다.
2. 나눗셈이 다르다. 자바 /는 정수끼리면 정수, 파이썬 /는 항상 실수. 음수 몫은 자바 -3, 파이썬 //는 -4.
3. 자바 문자열·Integer 비교는 equals(). ==는 주소 비교다.
4. 비교 함수에서 a - b 대신 Integer.compare(a, b).
5. 정렬 기준: 자바는 (a, b) 오름 / (b, a) 내림, 파이썬은 key=와 튜플, - 붙여서 내림.
6. 자바 int[]는 비교자 정렬 불가. Integer[]로 박싱하자.

0. 선언

// Java
import java.util.ArrayDeque;
import java.util.Deque;

Deque<Integer> stack = new ArrayDeque<>();
Deque<Integer> queue = new ArrayDeque<>();   // Queue<Integer> queue = new ArrayDeque<>(); 도 가능

# Python
from collections import deque

stack = deque()          # 스택은 그냥 list를 써도 된다: stack = []
queue = deque([1, 2, 3]) # 리스트/튜플 등 iterable로 바로 초기화 가능

선언 시 체크포인트

• Deque는 인터페이스라서 new Deque<>()는 불가능하다. 구현체 ArrayDeque 또는 LinkedList를 쓴다.
• 코테에서는 ArrayDeque 를 쓰자. LinkedList보다 빠르고 메모리 효율이 좋다. 레거시 Stack 클래스도 쓸 이유가 없다.
• ArrayDeque에는 null을 넣을 수 없다 (NullPointerException).
• 파이썬 deque는 타입을 명시하지 않으므로 숫자·문자열·튜플 등을 섞어 넣을 수 있다.
• 파이썬에서 큐를 list로 만들고 pop(0)을 쓰면 O(N) 이다. 큐는 반드시 deque의 popleft()(O(1))를 쓴다.

1. 스택 (Stack, LIFO: 후입선출)

자바는 맨 앞(왼쪽), 파이썬은 맨 뒤(오른쪽) 이 입구이자 출구

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1); stack.push(2); stack.push(3);   // [3, 2, 1]
stack.peek();  // 3
stack.pop();   // 3

stack = deque()
stack.append(1); stack.append(2); stack.append(3)  # [1, 2, 3]
stack[-1]      # 3
stack.pop()    # 3

두 코드 모두 마지막에 넣은 3이 먼저 나온다. 내부 저장 순서만 반대일 뿐 동작은 같다.

2. 큐 (Queue, FIFO: 선입선출)

두 언어 모두 맨 뒤로 넣고, 맨 앞에서 꺼낸다.

Deque<Integer> queue = new ArrayDeque<>();
queue.offer(1); queue.offer(2); queue.offer(3);  // [1, 2, 3]
queue.peek();  // 1
queue.poll();  // 1

queue = deque()
queue.append(1); queue.append(2); queue.append(3)  # [1, 2, 3]
queue[0]         # 1
queue.popleft()  # 1

3. 비어 있을 때 동작 (에러 처리)

가장 많이 실수하는 부분이다.

• 자바: poll() / peek() 계열은 null을 돌려주므로 비교적 안전하다. 단, 스택의 pop()은 예외를 던진다. 꺼내기 전에 isEmpty()로 확인하는 습관을 들이자.
• 파이썬: 비어 있으면 무조건 예외가 난다. 실행 전에 if dq: 로 확인한다.

while (!stack.isEmpty()) {
    int top = stack.pop();
}

while dq:
    top = dq.pop()

4. 한눈에 보는 전체 치트시트

💡 이것만 기억하자

1. pop()의 방향이 다르다. 자바 pop()은 맨 앞(왼쪽), 파이썬 pop()은 맨 뒤(오른쪽) 에서 꺼낸다.
2. 큐는 둘 다 뒤로 넣고 앞에서 꺼낸다. 자바 offer / poll, 파이썬 append / popleft.
3. 비어 있을 때가 다르다. 자바 poll() / peek()은 null, 파이썬은 IndexError. 자바 pop()도 예외가 나니 둘 다 꺼내기 전에 비었는지 확인하자.

1편 — 서버 설계: 포럼 채널 2편 — 봇 설계: 명령어는 단순하게 3편 — 삽질 모음: 에러도 안 나는 버그들 4편 — 배포와 회고 ← 지금 글

여태 로컬에서 돌려서 봇은 배포가 아직...인 상태였다. 스펙 정하기도 꽤 걸렸는데, 오늘은 배포 이야기를 해보고자 한다.

왜 오라클 무료 티어인가

선택지를 놓고 봤다.

오라클 Always Free는 기한이 없다. 30일 크레딧이 아니라 계속 무료인 인스턴스를 준다. 램 512MB면 충분한 봇에는 과분한 사양이다.

대신 가입할 때 결제 카드 등록이 필요하다(무료 티어만 쓰면 청구되지는 않는다). 그리고 지역·주소 입력이 꽤 깐깐하다. 리전은 한 번 정하면 못 바꾸니 가까운 곳으로 했다. (한국이 없어서 도쿄로 했다. 회원가입만 30분 걸렸다. 그리고 로그인 할 때마다 전용 앱으로 인증도 해야 한다. 매우 귀찮)

[1] 인스턴스 만들기 — 고난의 시작

문제 ① Out of capacity

Always Free로 받을 수 있는 사양은 둘이다.

• VM.Standard.A1.Flex — ARM(Ampere), 최대 4코어 24GB
• VM.Standard.E2.1.Micro — AMD, 1코어 1GB

당연히 A1을 고르려고 했다. 스펙이 압도적으로 좋다.

API Error: Out of capacity for shape VM.Standard.A1.Flex
in availability domain AD-1

A1은 인기가 많아서 사용이 불가했다.ㅠㅠ 그래서 그냥 E2.1.Micro로 갔다. 1코어 1GB인데, Node 프로세스 하나에 SQLite 한 파일 돌리는 데는 차고 넘친다. (실제로 지금 메모리 95MB 쓴다. 야 호 ~)

문제 ② 공용 IP 토글

인스턴스 생성 화면의 네트워킹 항목에서 "공용 IPv4 주소 할당" 토글이 비활성화돼 있었다. (근데 진짜 클릭이 막혀 있었다...)

아래에 이런 안내가 있었다.

There are additional options available when you use the Networking pages...

원인은 VCN 설정이었다. 공용 IP를 붙이려면 서브넷이 퍼블릭 서브넷이어야 한다. 기존에 잡힌 서브넷이 프라이빗이면 토글 자체가 잠긴다.

해결은 네트워킹 항목에서:

1. Create new virtual cloud network 선택
2. Create new public subnet 선택
3. CIDR은 기본값 10.0.0.0/24 그대로

분명 하라는대로 했는데, 토글 버튼 클릭이 막혀 있었다. 젠장! 그래서 일단 인스턴스를 먼저 만들어버렸다. 만들고 나니 당연하게도 공용 IP가 - 로 비어 있었다.

다행히 나중에 붙일 수 있다!

인스턴스 → Resources → Attached VNICs → (VNIC 클릭)
→ IPv4 Addresses → (주소 옆 ⋮) → Edit
→ Public IP Type: Ephemeral IP 선택 → Update

Ephemeral IP는 인스턴스를 재부팅해도 유지되고, 인스턴스를 완전히 종료(terminate)해야 사라진다. 고정 IP가 필요하면 Reserved IP를 쓰면 되는데, 봇 하나 돌리는 데는 Ephemeral로 충분했다. 뭐 어찌저찌 완료!!

[2] SSH 키

인스턴스를 만들 때 SSH 공개키를 넣어야 한다. 미리 만들어두는 게 편하다.

ssh-keygen -t ed25519 -f ~/.ssh/oracle -C "oracle-seogi"
cat ~/.ssh/oracle.pub    # ← 이 내용을 붙여넣는다

~/.ssh/oracle (확장자 없는 쪽)이 개인키다. 이건 절대 어디에도 올리면 안 된다. 깃허브에도, 블로그에도...

접속:

ssh -i ~/.ssh/oracle ubuntu@<공용IP>

Ubuntu 이미지의 기본 사용자는 ubuntu 다. root 로는 직접 못 들어간다.

[3] 서버 세팅

sudo apt update && sudo apt upgrade -y

# Node 22
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs

# better-sqlite3 를 컴파일하려면 필요
sudo apt install -y build-essential python3

마지막 줄이 없으면 npm install 이 중간에 동작하지 않는다. better-sqlite3 는 네이티브 모듈이라 설치할 때 C++ 컴파일이 돌고, 그러려면 build-essential 과 python3(node-gyp)이 있어야 한다.

미리 깔아두는 게 낫다. 에러 메시지가 gyp ERR! 로 시작하는 긴 로그라서, 처음 보면 원인을 찾는 데 시간이 든다.

[4] 파일 옮기기

rsync로 보냈다.

rsync -avz --delete \
  -e "ssh -i ~/.ssh/oracle" \
  --exclude 'node_modules' \
  --exclude 'data/' \
  --exclude '.DS_Store' \
  ~/Downloads/discord-trpg-setup/seogi/ \
  ubuntu@<공용IP>:~/seogi/

제외 항목마다 이유가 있다.

• node_modules — 네이티브 모듈이 있어서 맥에서 빌드한 걸 리눅스로 보내면 안 된다. 서버에서 npm install 을 다시 해야 한다.
• data/ — 여기에 SQLite 파일이 있다. --delete 를 쓰고 있으므로 이걸 빼지 않으면 서버의 실제 데이터가 로컬 버전으로 덮인다.
• .DS_Store — 맥 부스러기...

--delete 는 로컬에서 지운 파일을 서버에서도 지운다. 편한데, 제외 목록을 잘못 쓰면 데이터가 날아간다. 이 조합은 한 번 확인하고 쓰는 게 좋다.

그리고 .env 와 service-account.json 은 rsync로 보내되, git에는 절대 올리지 않는다. .gitignore 확인.

ssh -i ~/.ssh/oracle ubuntu@<공용IP>
cd ~/seogi
npm install          # 여기서 better-sqlite3 컴파일이 돈다 (1~2분)
npm run deploy       # 슬래시 명령어 등록
node src/index.js    # 일단 손으로 띄워서 확인

▶ Mr. Clerk#1003 로 로그인했습니다. 가 뜨면 성공이다.

[5] pm2 사용하기

node src/index.js 로 띄우면 SSH를 끊는 순간 또 문제가 생긴다. 그리고 봇이 crash하면 그대로 끝이다.

sudo npm install -g pm2

cd ~/seogi
pm2 start src/index.js --name seogi
pm2 save                # 지금 목록을 저장
pm2 startup             # 부팅 시 자동 시작 설정

pm2 startup 을 치면 이런 걸 출력하는데,

sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ubuntu --hp /home/ubuntu

이걸 복사해서 한 번 실행해야 한다. pm2가 대신 실행해주지 않고 명령어만 보여준다. 한 번 실행하면 systemd 서비스가 등록되고, 그 뒤로는 잊어도 된다.

순서가 하나 있다. pm2 save 로 목록을 저장한 다음에 startup 을 해야 한다. 반대로 하면 재부팅 후 빈 목록으로 뜬다.

pm2 status

위의 명령어로 상태를 확인하면, 아래와 같이 정보가 나온다.

1GB 인스턴스에 95MB라니~ 여유가 많다!

자주 쓰는 것들:

pm2 logs seogi          # 실시간 로그
pm2 logs seogi --lines 100
pm2 restart seogi
pm2 monit               # CPU·메모리 실시간

[6] 배포를 한 줄로

코드를 고칠 때마다 rsync 명령어를 다시 치는 건 금방 귀찮아진다. 그래서 스크립트로 만들었다. (클로드 최고)

#!/usr/bin/env bash
set -euo pipefail

HOST="ubuntu@<공용IP>"
KEY="$HOME/.ssh/oracle"
SRC="$(cd "$(dirname "$0")" && pwd)/seogi/"

rsync -avz --delete -e "ssh -i $KEY" \
  --exclude 'node_modules' --exclude 'data/' \
  --exclude '_to_delete' --exclude '.DS_Store' \
  "$SRC" "$HOST:~/seogi/"

# 옵션 처리
for arg in "$@"; do
  case "$arg" in
    --deps) ssh -i "$KEY" "$HOST" "cd ~/seogi && npm install" ;;
    --cmds) ssh -i "$KEY" "$HOST" "cd ~/seogi && npm run deploy" ;;
  esac
done

ssh -i "$KEY" "$HOST" "pm2 restart seogi && pm2 status"

./deploy.sh            # 코드만
./deploy.sh --deps     # 패키지가 바뀐 경우
./deploy.sh --cmds     # 슬래시 명령어가 바뀐 경우

백업도 하나 만들었다. 사실상 지켜야 할 건 SQLite 파일 하나다.

DEST="backups/$(date +%Y%m%d-%H%M)"
mkdir -p "$DEST"
scp -i "$KEY" "$HOST:~/seogi/data/seogi.db" "$DEST/"
scp -i "$KEY" "$HOST:~/seogi/config.json" "$DEST/"

[7] 유지보수 체크리스트

한 달에 한 번쯤 하면 되는 것들:

./backup.sh                              # DB 백업
sudo apt update && sudo apt upgrade -y   # 서버 업데이트
sudo reboot                              # 커널이 올라갔으면

pm2가 자동 시작으로 등록돼 있으니 재부팅해도 봇은 알아서 살아난다.

그리고 오라클 콘솔에 가끔 로그인해야 한다. 무료 티어는 장기간 미사용 시 리소스가 회수될 수 있다고 명시돼 있다...

회고

만들었다가 되돌린 것들

이번 프로젝트에서 제일 배운 게 이쪽이다. 기능을 넣는 것보다 뺀 결정들이 결과를 더 좋게 만들었다.

① 캐릭터 자동완성

"장기 캠페인이면 예전 캐릭터를 다시 쓸 텐데, 등록할 때 이미 있는 애인지 물어보면 좋겠다~"

• 과거 세션의 캐릭터 목록을 선택 메뉴로
• → 25개 한도에 걸림 (디스코드 선택 메뉴 제한)
• → 세션별로 먼저 고르고 그 안에서 캐릭터 고르는 2단계로
• → 구글 시트에 있는 캐릭터도 검색되게 자동완성 추가
• → 시트를 10분마다 읽어서 메모리에 캐싱

기능은 다 동작했지만 문제가 있었다.

2단계 선택은 클릭이 늘어난 만큼 더 헷갈렸고, 자동완성으로 불러온 값이 빈칸으로 오는 경우가 있었다. 한 번 치고 마는 입력을 편하게 하려다 매번 하는 입력을 불편하게 만든 것이다.

전부 걷어내고 [캐릭터 등록] 버튼 → 모달 두 칸으로 돌아갔다.

여기서 하나의 반성 포인트가 있다. 걷어낼 때 services/sheets.js 의 시트 인덱스 코드(refreshSheetIndex, getSheetIndex, startSheetIndexJob)를 호출만 끊고 함수는 안 지웠다. 지금은 아무도 안 부르는 시체 같은 코드만 남아 있다... (언젠가 정리하겠다.)

② 참가자 한정 아카이브

세션 기록을 참가자에게만 보이게 하는 옵션이다. 구현하려면 기록을 포럼 포스트가 아니라 비공개 스레드에 넣어야 했다.

기록보관소를 만드는 이유는 나중에 찾아보기 위해서인데, 접근 제한을 붙이면 찾기가 어려워져서 목적과 수단이 충돌해 버렸다.

그래서 기록은 항상 공개하되, 종료할 때 KP가 비밀을 어디까지 남길지를 고르게 했다.

이쪽이 훨씬 간단하고, 결과적으로 더 잘 맞는다.

③ 스레드 보관 → 삭제

세션이 끝나면 스레드를 보관(archive)하는 게 기본값이었다. 그런데 세션 하나에 스레드가 5~6개씩 생긴다. 몇 달이면 목록이 스레드로 가득 찬다.

로그와 이미지가 기록 글에 다 들어가니 원본 스레드가 남아 있을 이유가 없지 않나? (지금 생각해보면 당연하기도)

기본값을 삭제로 바꾸면서 안전장치를 뒀다. 종료 패널에서 언제든 '보관'으로 바꿀 수 있고, 삭제를 고르면 확인 문구가 하나 더 뜬다. 되돌릴 수 없는 동작은 기본값이더라도 눈에 잘 보이게 설계했다.

그리고 기존 DB의 기본값도 바꿔야 해서 2편에서 얘기한 PRAGMA user_version 일회성 마이그레이션이 여기서 나왔다.

잘한 결정 셋

① [customId에 상태를 다 넣은 것] 처음에 이걸 안 했으면 배포할 때마다 신경 쓸 일이 생겼을 것이다.

② [상태 전이를 한 파일에 몰아넣은 것] 기능을 추가할 때마다 "이건 session.js에 있어야 하나?"를 묻게 되는데, 이 질문 자체가 설계를 지켜줬다. 여러 파일에서 status를 건드리기 시작했으면 지금쯤 엉켰을 것 같다.

③ [스크립트로 서버를 만든 것] 이게 제일 컸다. 구조를 바꾸는 비용이 싸지니까 바꿔볼 마음이 생긴다. 손으로 만들었으면 #시나리오 포럼 신설이나 태그 정리 같은 개편은 "귀찮으니 그냥 두자"로 끝났을 것이다.

아직 안 만든 것

없어도 서버는 완전히 돌아간다.

• /핸드아웃 — KP가 특정 PC의 비밀 스레드로 자료 전송
• /비밀배포 — 비밀 카드 N장을 섞어 각자 1장씩 (인세인용)
• /전적 — 플레이 횟수, KP 횟수, 룰별 통계. 데이터는 이미 DB에 다 쌓여서 쉽게 만들 수 있다.

마지막으로 — 화려함보다는 편리함이 우선이다!

블로그에서는 전반적으로 기술적인 얘기를 다루고 있지만, 사실 제일 중요한 것은 기능보다 이 서비스를 사용하는 사용자이다.

사실 제일 열심히 만든 기능이 제일 먼저 폐기됐다. (캐릭터 자동완성) 25개 한도를 우회하려고 2단계 선택을 설계하고, 구글 시트를 캐싱하고, 검색까지 붙였다. 만들고 나서 좀 뿌듯했던 것 같은데, 몇 번 써보고 없앴다.

반대로 제일 반응이 좋았던 건 제목 자동으로 만들어주는 거랑 하루 전에 DM 한 통 가는 거였다. 코드로 치면 별거 아니지만...

이 둘 차이가 뭐였나 생각해 보면, 하나는 내가 만들고 싶었던 거고 하나는 쓰는 사람이 필요한 기능이었다.

결국 서버의 라이프 사이클이 유지되는 건 봇과 화려한 기능이 아니라 함께 해주는 사람들 덕분인 것 같다. 앞으로도 함께 해줘!!

읽어주셔서 감사합니다. 언제나 GM과 PL의 행복한 플레이를 응원합니다!

1편 — 서버 설계: 포럼 채널 2편 — 봇 설계: 명령어는 단순하게 3편 — 에러도 안 나는 버그들 ← 지금 글 4편 — 배포와 회고: 오라클 무료 티어, 그리고 되돌린 기능들

이번 편은 만들면서 실제로 막혔던 것들이다. 공통점이 하나 있는데, 대부분 에러가 안 났다. ㅠㅠ 스택 트레이스가 찍히는 버그는 오히려 쉽다. 어려운 건 아무 일도 안 일어나거나, 조용히 틀린 결과가 나오는 쪽이다...

[1] 텅 빈 세션 로그

증상

첫 테스트 세션을 마치고 [세션 종료]를 눌렀다. #세션-기록 에 포스트는 잘 만들어졌다. 로그 파일도 첨부됐다. 그런데 열어보니 이랬다.

# [CoC] 테스트 세션

- 룰: CoC
- KP: 오일러
- 참가: 뉴턴, 보일

---

## 플레이 로그

**뉴턴**
**보일**
**뉴턴**

이름만 있고 내용이 없다!!! 메시지 개수와 순서도 맞지만 본문만 빈 문자열로 저장되었다. 에러는 딱히 뜨지 않았고, 종료도 정상적으로 끝났다고 나왔다.

원인

GatewayIntentBits.MessageContent 를 코드에는 선언해뒀다.

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMembers,
    GatewayIntentBits.MessageContent,   // ← 있음
  ],
});

문제는 디스코드 개발자 포털에서도 따로 켜야 한다는 것이었다.

MESSAGE CONTENT INTENT 는 특권 인텐트(Privileged Intent)라서 포털 → Bot 탭에서 토글을 켜야 실제로 부여된다. 코드 선언만으로는 안 된다.

그리고 안 켜져 있을 때는 너무한 게 message.content 가 빈 문자열로 온다. 예외를 던지는 것도 아니고, 권한 오류가 오는 것도 아니라 그냥 빈 값이다.

해결

포털에서 토글을 켰다.

특권 인텐트는 코드와 포털 양쪽에 있어야 한다. 그리고 없을 때 조용히 빈 값이 오므로, 남의 메시지 본문을 읽는 봇이라면 이걸 제일 먼저 확인해야 한다.

[2] 중복 기록

증상

인텐트를 켜고 다시 테스트했다. 이번엔 내용이 들어왔는데, 로그가 이상했다.

비밀 스레드 내용이 두 번씩 나왔다. (1. 플레이 로그, 2. 비밀) 거기에 봇이 쓴 안내 메시지("## 🔓 비밀 공개" 같은 것)까지 로그에 섞여 있었다.

원인

종료 처리 순서를 이렇게 짰던 게 문제였다.

// 처음 (틀림)
await revealSecrets(main, secrets);        // 1. 비밀을 전체 스레드에 공개
const mainMsgs = await fetchAll(main);     // 2. 전체 스레드 로그 추출

비밀을 전체 스레드에 먼저 풀고 나서 그 스레드의 로그를 떴다. 그러니 방금 푼 비밀이 전체 스레드 메시지에 포함돼서 로그에 들어가고, 그 뒤에 '비밀' 절에서 한 번 더 들어간다.

봇 메시지가 섞인 것도 같은 이유다. 봇이 쓴 "🔓 비밀 공개" 헤더가 로그 추출 시점에는 이미 스레드에 존재했다.

해결

순서를 뒤집고, 봇 자신의 메시지를 걸러냈다.

const selfId = client.user.id;

/* 1. 로그를 먼저 뜬다 */
let mainMsgs = [];
if (main) mainMsgs = await fetchAll(main);

const secretSets = [];
for (const p of joined) {
  if (!p.secret_thread_id) continue;
  const t = await client.channels.fetch(p.secret_thread_id);
  secretSets.push({ userId: p.user_id, msgs: await fetchAll(t) });
}

/* 2. 첨부 수집 — 봇 메시지 제외 */
const attachments = [
  ...collectAttachments(mainMsgs.filter((m) => m.author.id !== selfId), 'main'),
  ...secretSets.flatMap((x) =>
    collectAttachments(x.msgs.filter((m) => m.author.id !== selfId), 'secret')),
].sort((a, b) => a.at - b.at);

/* 3. 이제 공개한다 */
if (main && optSecret === 'reveal') { ... }

코드에 주석으로 이유를 박아뒀다. 나중에 누가(혹은 내가) 리팩토링하면서 순서를 바꿀 수 있으니까...

/**
 * 순서가 중요
 *   1) 로그를 먼저 뜬다 (비밀을 뿌린 뒤에 뜨면 중복)
 *   2) 기록 글을 만들고
 *   3) 이미지를 기록 글에 다시 업로드
 */

부수효과가 있는 작업과 읽기 작업이 섞이면 순서가 의미를 갖는다. (당연한 말인데, 기능이 여덟 단계쯤 되면 눈에 잘 안 들어온다.)

[3] DiscordAPIError[10008] Unknown Message

증상

스레드 처리 기본값을 '삭제'로 바꾸고 나서 생긴 문제다. 세션 종료가 정상적으로 다 끝나는데, 마지막에 이게 뜬다.

DiscordAPIError[10008]: Unknown Message

기록 글도 잘 만들어졌고, 시트에도 들어갔고, 스레드도 지워졌는데 말이다.

원인

종료 확인 패널이 지워질 스레드 안에 떠 있었다.

흐름을 다시 보면:

1. KP가 전체 스레드에서 [세션 종료]를 누른다
2. 확인 패널이 나만 보이는(ephemeral) 메시지로 그 스레드에 뜬다
3. [이대로 종료]를 누른다
4. 봇이 일을 하고... 그 스레드를 지운다
5. 봇이 interaction.editReply('종료했습니다') 를 부른다
6. 그 메시지가 있던 스레드가 없다 → Unknown Message

나만 보이는 메시지는 호스트 채널에 종속된다. 채널이 사라지면 같이 사라진다.

해결

결과 보고를 DM으로 떨어지게 했다.

/**
 * 확인 패널은 세션 스레드 안에 떠 있는데, 스레드 삭제를 고르면 그 메시지가 함께 사라짐
 * 그럼 editReply 가 Unknown Message 로 실패하므로 DM 으로
 */
async function report(interaction, content) {
  try {
    await interaction.editReply({ content, components: [] });
  } catch {
    try {
      await interaction.user.send(content);
    } catch {
      console.log('[finish]', content);
    }
  }
}

editReply → 실패하면 DM → 그것도 실패하면(DM 차단) 콘솔 방식으로 3단 폴백이다.

[4] 실패한 /밀담 추가

증상

/밀담 추가 로 사람을 넣으면 "추가했습니다" 는 뜨는데 그 사람이 스레드에 없는 문제가 있었다. 다른 하위 명령(만들기, 제거, 이름)은 다 정상적으로 동작하는데 말이다.

원인 — 두 개였다

첫째, 에러를 코드가 삼키고 있었다.

const ok = await thread.members.add(uid).catch(() => false);   // ← 범인

.catch(() => false) 로 뭉개놓으니 왜 실패했는지 알 방법이 없었다. 실패를 실패로만 알고 이유를 모르는 상태...

이걸 풀었더니 진짜 원인이 나왔다.

둘째, 잘못 설계한 부분이 등장했다. 추가하려던 사람이 그 채널을 볼 권한이 없었다! 디스코드는 채널을 못 보는 사람은 그 채널의 스레드에도 못 넣는다. 당연한 규칙인데 에러 코드(50001 Missing Access)만 보고는 알기 어려웠다... 힝

해결

에러를 사람 말로 풀어서 보여주게 했다.

const results = [];
for (const uid of picked) {
  try {
    await thread.members.add(uid);
    results.push(`✓ <@${uid}>`);
  } catch (e) {
    const why =
      e.code === 50001 ? '그 사람이 이 채널을 볼 권한이 없습니다'
    : e.code === 50013 ? '봇 권한이 부족합니다'
    : e.message;
    results.push(`✗ <@${uid}> — ${why}`);
  }
}

보관된 스레드에 추가하려 할 때도 실패해서, 자동으로 깨우는 것도 넣었다.

if (thread.archived) await thread.setArchived(false).catch(() => {});

교훈은 에러의 출처를 알아내는 것도 정말 중요하다는 것이다. .catch(() => false) 를 쓸 때는 그 자리에서 왜 실패했는지 알 필요가 정말 없는지 한 번 생각하는 게 좋다.

[5] 깨지는 이미지

증상

이건 증상이 발생하기 전에 발견했다. 로그에 이미지를 링크로 넣는 코드를 짜다가 디스코드 첨부 URL을 보고 이상해서 뜯어봤다.

https://cdn.discordapp.com/attachments/.../scene.png?ex=...&is=...&hm=...

ex, is, hm. 만료(expire), 발급(issued), 서명(hmac)이다.

원인

디스코드 CDN 첨부 URL에는 서명된 만료 시간이 붙는다. 대략 하루면 만료된다. 그리고 원본 메시지가 있는 채널이나 스레드가 삭제되면 파일 자체가 사라진다.

기록보관소를 만드는 게 목적인데, 로그에 링크만 적어두면 며칠 뒤에 전부 깨진 이미지가 된다. 심지어 우리는 종료 시 스레드를 지우는 게 기본값이라 고민이 많았다.

해결

파일을 내려받아서 기록 글에 다시 올린다.

export async function rehostAttachments(thread, attachments) {
  const files = [];
  for (const a of attachments) {
    if (a.size > 9 * 1024 * 1024) { skipped.push(a); continue; }   // 9MB 한도
    const buf = await download(a.url);
    files.push({ attachment: buf, name: `${String(a.no).padStart(3, '0')}_${a.name}` });
    if (files.length >= 100) break;
  }
  // 10개씩 나눠서 전송 (메시지당 첨부 10개 한도)
}

그리고 로그 본문에는 번호로 짝을 맞춘다.

## 이미지

아래 번호는 이 기록 글에 함께 올려둔 파일과 짝이 맞습니다.

- `001` scene.png — 김도현
- `002` map.jpg — 이서연 · 🔒 비밀

한도가 있긴 하다. 파일 하나 9MB(무료 서버 8MB 제한을 감안한 값), 한 메시지에 첨부 10개

[6] Carl-bot 역할 버튼 노작동

증상

#역할-알림설정 에 룰별 알림 구독 버튼을 만들려고 Carl-bot 대시보드에서 Reaction Roles를 설정했다. 저장했다. 채널에 아무것도 안 생긴다.

대시보드에는 저장됐다고 나온다. 에러 메시지는 없다.

원인

#역할-알림설정 은 읽기 전용 채널이었다. @everyone 의 SendMessages 를 막아뒀다.

그런데 봇도 @everyone 에 속한다. 글쓰기를 막으면 봇도 같이 막힌다.

사람이 못 쓰게 하려던 건데 봇까지 막힌 것이고, 봇 입장에서는 메시지 전송이 거부된 것이라 대시보드에서는 알 방법이 없다.

해결

봇 역할에만 예외를 여는 스크립트를 만들었다. 봇을 초대하면 자동으로 생기는 역할은 managed 플래그가 붙어 있어서 골라내기 쉽다.

const botRoles = guild.roles.cache.filter((r) => r.managed);

// @everyone 의 글쓰기가 막혀 있는 텍스트 채널만
const locked = guild.channels.cache.filter((c) => {
  if (c.type !== ChannelType.GuildText) return false;
  const ow = c.permissionOverwrites.cache.get(guild.roles.everyone.id);
  return ow?.deny.has(PermissionFlagsBits.SendMessages);
});

for (const ch of locked.values()) {
  for (const role of botRoles.values()) {
    await ch.permissionOverwrites.edit(role, {
      ViewChannel: true, SendMessages: true, EmbedLinks: true,
      AttachFiles: true, ReadMessageHistory: true, AddReactions: true,
      ManageMessages: true, CreatePublicThreads: true,
    });
  }
  await new Promise((r) => setTimeout(r, 400));   // 레이트 리밋 회피
}

사람은 여전히 못 쓰고 봇만 예외다. 봇을 새로 추가할 때마다 한 번씩 돌리면 된다.

읽기 전용 채널을 만들면 봇 예외를 같이 생각해야 한다. 이건 #공지, #세션-일정 에도 똑같이 해당됐다.

[7] 미디어 채널의 부재

증상

#캐릭터-갤러리 를 미디어 채널로 만들려고 했다. 미디어 채널은 포럼과 비슷한데 이미지 위주로 최적화된 채널 타입이다.

✗ 실패: Cannot execute action on this channel type

DiscordAPIError[50024].

원인

ChannelType.GuildMedia 는 discord.js에 정의돼 있고 API 문서에도 있는데, 이 서버에서는 만들 수 없는 타입이었다. 미디어 채널은 서버 조건이나 롤아웃 상태에 따라 가용 여부가 갈린다.

에러 메시지가 "이 채널 타입에는 이 작업을 할 수 없다"라서 처음엔 코드 문제인 줄 알고 파라미터를 계속 바꿔봤다. 그게 아니라 애초에 만들 수 없는 것이었다.

해결

포기하고 포럼 채널 + 갤러리 뷰로 갔다.

const gallery = await guild.channels.create({
  name: '캐릭터-갤러리',
  type: ChannelType.GuildForum,
  defaultForumLayout: ForumLayoutType.GalleryView,   // ← 격자 썸네일
  defaultSortOrder: SortOrderType.LatestActivity,
});

결과적으로 보기에는 거의 같다. 격자로 썸네일이 깔리고 태그도 쓸 수 있다. 오히려 태그를 쓸 수 있어서 나은 면도 있었다.

API 문서에 있다고 이 서버에서 되는 건 아니다. 채널 타입, 기능 플래그 같은 건 서버 상태에 따라 갈린다.

[8] 봇 역할의 한계

이건 겪기 전에 알고 대비한 건데, 그래도 적어둘 만하다.

봇은 자기 역할보다 아래에 있는 역할만 만들고, 지우고, 부여할 수 있다.

@세션-42 같은 임시 역할을 만드는 봇인데, 봇 역할이 역할 목록에서 아래쪽에 있으면 역할 생성이나 부여가 조용히 실패한다. 파티 확정을 눌렀는데 스레드는 생기고 역할만 안 붙는 상태가 된다.

봇을 초대하면 그 역할은 기본적으로 목록 아래쪽에 생긴다. 그래서 서버 설정 → 역할에서 드래그로 올려줘야 한다.

파티 확정 코드에 실패를 수집하는 부분을 둔 것도 이 때문이다.

const report = { role: null, main: null, secrets: [], failed: [] };

for (const uid of memberIds) {
  try {
    const m = await guild.members.fetch(uid);
    await m.roles.add(role, '세션 참가자');
  } catch (e) {
    report.failed.push(`역할 부여 실패: <@${uid}> (${e.message})`);
  }
}

[정리]

여덟 개를 놓고 보니 패턴이 보인다.

디스코드 API를 다루면서 제일 도움이 됐던 습관은 "권한 문제일 수 있다"를 항상 먼저 의심하는 것이었다. 코드가 맞는데 아무 일도 안 일어나면 열에 아홉은 권한이었다.

그리고 .catch(() => {}) 를 쓸 때 잠깐 멈추고 생각을 해보자. 실패를 무시해도 되는 자리와 무시하면 안 되는 자리를 구분해야 한다.

다음 편은 이걸 클라우드에 올린 얘기다. 오라클 무료 티어에서 원하는 사양을 찾고, 공용 IP 토글을 설정해야 한다. 그리고 만들었다가 되돌린 기능들에 대한 회고도 넣었다.

→ 4편 — 배포와 회고: 오라클 무료 티어, 그리고 되돌린 기능들

1편 — 서버 설계: 포럼 채널 2편 — 봇 설계: 명령어는 단순하게 ← 지금 글 3편 — 삽질 모음: 에러도 안 나는 버그들 4편 — 배포와 회고: 오라클 무료 티어, 그리고 되돌린 기능들

1편에서 서버 구조를 짰다. 이제 원칙 04 — 정리는 사람이 하면 반드시 밀린다 — 를 실제로 지킬 차례다. 봇을 만들자!

봇 이름은 서기(書記) 로 정했다. 하는 일이 결국 기록하고, 나눠주고, 보관하는 것이기 때문이다. (이래놓고 보여지는 이름은 Mr. Clerk로 했다...)

[기능보다 급한 것]

기능 목록부터 뽑고 싶은 걸 꾹 참고, 먼저 정한 건 이거였다.

KP가 외워야 하는 명령어는 /모집 하나여야 한다.

이유는 단순하다. 봇을 만든 나만 쓰는 명령어가 아니기 때문이다. 몇 개의 처리를 제외한 나머지는 전부 버튼으로 처리하기로 했다. 실제 사이클은 이렇게 됐다.

명령어 하나와 클릭 네 번으로 세션 모집이 가능하다. 나머지 명령어(/세션수정 /세션취소 /글찾기 /밀담 /이번주)는 몰라도 세션이 돌아갈 수 있다. (근데 그렇게 많은 명령어도 아닌데, 외워줬으면 하는 바람은 있다.)

[상태 몰빵] 상태를 한 파일에 몰아넣기

봇의 거의 모든 버그는 상태 전이가 여기저기 흩어지는 것에서 나온다고 생각했다. /모집 파일에서도 상태를 바꾸고, 버튼 핸들러에서도 바꾸고, 잡(job)에서도 바꾸면, 세 곳이 서로 다른 가정을 하기 시작한다.

그래서 규칙을 하나 세웠다. 상태 전이는 services/session.js 한 파일에만 둔다. 명령어와 버튼은 그 함수를 부르기만 한다.

recruiting  ──[파티 확정]──▶  confirmed  ──[시작]──▶  playing  ──[종료]──▶  done
     │
     └──[/세션취소]──▶ cancelled

각 상태에서 무슨 일이 일어나는지:

recruiting — 포럼 포스트가 있고, 태그는 🟢 모집중 + 룰 + 시간대를 자동으로 설정한다. 아래에 [참가] [취소] 버튼이 살아 있다. 정원이 차면 [파티 확정] 버튼이 나타난다.

confirmed — 여기가 제일 많은 일을 한다.

// 1. 역할
const role = await guild.roles.create({ name: `세션-${s.id}`, mentionable: true });
for (const uid of memberIds) {
  const m = await guild.members.fetch(uid);
  await m.roles.add(role);
}

// 2. 전체 스레드
const main = await progress.threads.create({
  name: `[${s.rule}] ${s.title} — 전체`,
  type: ChannelType.PrivateThread,
  invitable: false,           // 참가자가 남을 못 데려오게
  autoArchiveDuration: 10080,
});

// 3. 사람마다 비밀 스레드
for (const p of joined) {
  const t = await progress.threads.create({
    name: `[${s.rule}] ${s.title} — ${member.displayName} 🔒`,
    type: ChannelType.PrivateThread,
  });
  await t.members.add(p.user_id);   // 본인
  await t.members.add(s.kp_id);     // KP
}

버튼 한 번에 역할 하나, 스레드 N+1개, 리마인드 예약 2건이 생긴다. 손으로 하면 5분씩 걸리던 일이다.

invitable: false 가 작은 포인트다. 기본값은 참가자가 다른 사람을 스레드에 초대할 수 있는데, 세션 스레드에서는 그러면 안 된다.

playing — 태그가 🎬로 바뀐다. 이곳에서 오간 대화가 나중에 로그가 된다.

done — 이게 제일 복잡해서 따로 설명할 예정이다.

[핸들러 설정]

여기가 이 봇에서 제일 중요한 설계 결정이었다고 생각한다. 그런데 왜 중요한지는 디스코드 버튼이 어떻게 생겨먹었는지를 먼저 알아야 한다.

버튼은 메시지에 붙어 있는 데이터다. 그리고 메시지는 디스코드 서버에 영구히 남는다. 내 봇이 켜져 있든 꺼져 있든, 3개월 전 모집 글의 [참가] 버튼은 계속 거기 있고 계속 눌러진다.

버튼이 눌리면 디스코드가 내 봇에게 이벤트를 보내는데, 알려주는 건 딱 이거다.

누가 custom_id 가 xxx 인 버튼을 눌렀다

문자열 하나가 전부다. 그걸 보고 뭘 할지는 봇이 알아서 정해야 하는 것이다.

처음에 떠오른 방식

버튼을 만들 때 "이거 눌리면 이 함수 실행해" 를 같이 등록해두는 게 자연스럽다.

const handlers = new Map();          // ← 그냥 자바스크립트 변수

// 모집 글을 만들 때
const id = crypto.randomUUID();
handlers.set(id, () => {
  session.participants.push(userId);   // session 을 클로저로 붙잡고 있다
});
button.setCustomId(id);

// 눌렸을 때
const fn = handlers.get(interaction.customId);
fn();

동작은 하지만, 문제가... 봇이 켜진 동안만 동작한다는 것이다.

문제는 handlers 가 프로세스 메모리에 있는 변수라는 것이다. 배포하거나, 크래시하거나, 서버가 재부팅되면 프로세스가 죽고 이 Map은 통째로 사라진다.

그런데 디스코드에 있는 메시지는 안 사라진다. 버튼도 그대로 있고, 여전히 눌러진다는 문제가 있다.

해법

카페로 치면 이렇다. 메모리에 콜백을 두는 건 주문을 종이에 안 적고 직원이 머릿속으로만 기억하는 것이다. 그 직원이 퇴근하면 다음 직원은 3번 손님이 뭘 시켰는지 모른다.

대신 진동벨에 주문번호를 새겨서 주면 된다. 손님이 벨을 들고 오면 번호를 보고 주문서를 찾으면 되고, 직원이 몇 번 바뀌든 상관없다.

custom_id 는 최대 100자 문자열이고, 디스코드가 메시지와 함께 보관했다가 누를 때마다 그대로 돌려준다. 이 아이가 진동벨이다. 지이잉

new ButtonBuilder()
  .setCustomId(`sess:join:${s.id}`)     // "참가 버튼 / 42번 세션"
  .setLabel(full ? '대기 등록' : '참가')
  .setStyle(full ? ButtonStyle.Secondary : ButtonStyle.Success)

눌렸을 때는 기억에 의존하지 않고 매번 새로 조회한다.

const [, action, idRaw] = interaction.customId.split(':');
const s = getSession(Number(idRaw));   // SQLite = 디스크 = 재시작해도 살아있음

봇은 버튼에 대해 아무것도 기억하지 않는다. 문자열을 읽고 DB를 조회할 뿐이라 어느 프로세스가 처리하든 결과가 같다. 그래서 몇 번을 재시작하든, 몇 달 전 글의 버튼이든 그대로 동작한다.

같은 이유로 라우팅도 접두사로만 한다.

if (i.isButton() && i.customId.startsWith('sess:'))  return sessionButtons.handle(i);
if (i.customId.startsWith('fin:'))                    return finishPanel.handle(i);
if (i.isUserSelectMenu() && i.customId.startsWith('mildam:')) return 밀담.handleSelect(i);

[3초 규칙]

디스코드는 상호작용에 3초 안에 응답하지 않으면 실패로 처리한다. 그런데 위에서 본 파티 확정은 스레드를 5개 만든다. 3초를 훌쩍 넘는다.

그래서 비용이 큰 일을 하기 전에 무조건 먼저 호출한다.

await interaction.deferReply({ flags: MessageFlags.Ephemeral });
// ← 여기서부터는 시간을 써도 된다
await confirmParty(client, sessionId);
await interaction.editReply('파티를 확정했습니다.');

(deferReply 를 부르면 "생각 중..." 상태로 바뀌고 15분까지 시간을 벌 수 있다.)

[타임존 계산]

일정을 다루는 봇이라 타임존에 시간이 좀 걸릴 줄 알았는데, 디스코드가 해결책을 갖고 있었다.

DB에는 유닉스 초(UTC)로만 저장하고, 출력은 디스코드 타임스탬프 형식으로 던진다.

export const stamp = (unix, style = 'F') => `<t:${unix}:${style}>`;

<t:1788000000:F> 를 메시지에 넣으면 디스코드가 보는 사람의 시간대로 알아서 표시한다. <t:...:R> 을 쓰면 "3일 후" 같은 상대 시간으로 나온다.

이거 하나로 타임존 버그가 통째로 사라졌다. 서버가 도쿄 리전에 있든 UTC로 돌든 상관없어진다.

입력 쪽은 반대로 아주 빡빡하게 잡았다. 한국어 자연어 파싱("다음 주 토요일 8시")을 하고 싶었지만 참았다.

/** 'YYYY-MM-DD HH:mm' (한국 시간) → 유닉스 초. 형식이 틀리면 null */
export function parseKST(text) { ... }

형식이 틀리면 그냥 거절하고 예시를 보여준다. 자연어 파싱은 대체로 맞지만, 가끔 은밀하게 틀린 날짜로 세션을 잡는다. (너무해!)

[일정 리마인드] setTimeout 쓰지 말자

세션 24시간 전, 1시간 전에 참가자에게 DM을 보내야 한다.

가장 쉬운 구현은 이거다.

setTimeout(() => sendReminder(session), msUntil24hBefore);   // ← 하지 말 것

이러면 봇이 한 번만 재시작해도 예약이 전부 증발한다. 배포 한 번에 다음 주 세션 리마인드가 다 사라지는 것이고, 심지어 아무 에러도 안 난다.

그래서 DB에 적어두고 1분마다 확인하는 방식으로 했다.

CREATE TABLE reminders (
  session_id  INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
  kind        TEXT    NOT NULL,   -- 24h | 1h
  fire_at     INTEGER NOT NULL,
  sent_at     INTEGER,
  PRIMARY KEY (session_id, kind)
);

const tick = async () => {
  const due = db.prepare(
    'SELECT * FROM reminders WHERE sent_at IS NULL AND fire_at <= ?').all(now());
  for (const row of due) {
    await fire(client, row);
    db.prepare('UPDATE reminders SET sent_at = ? WHERE session_id = ? AND kind = ?')
      .run(now(), row.session_id, row.kind);
  }
};

tick();                     // 재시작 직후 밀린 것부터 처리
setInterval(tick, 60_000);

소규모 서버에서 1분에 한 번 SQLite 조회는 부하가 생기지 않아서 다행이다. 그리고 재시작 직후에 tick() 을 한 번 부르는 것이 중요하다. 봇이 꺼져 있는 동안 지나간 예약을 그때 처리한다.

[DB] SQLite = 한 파일

동시 접속이 몇 명 안 되는 서버라서 굳이 Postgres를 띄울 이유가 없다. better-sqlite3 는 동기 API라 오히려 코드가 단순해진다.

CREATE TABLE sessions (
  id                INTEGER PRIMARY KEY AUTOINCREMENT,
  rule              TEXT    NOT NULL,
  title             TEXT    NOT NULL,
  kp_id             TEXT    NOT NULL,
  capacity          INTEGER NOT NULL,
  scheduled_at      INTEGER NOT NULL,   -- unix seconds, UTC
  status            TEXT    NOT NULL DEFAULT 'recruiting',
  forum_post_id     TEXT,
  main_thread_id    TEXT,
  role_id           TEXT,
  archive_post_id   TEXT,
  created_at        INTEGER NOT NULL
);

CREATE TABLE participants (
  session_id        INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
  user_id           TEXT    NOT NULL,
  state             TEXT    NOT NULL,   -- joined | waitlist | cancelled
  pc_name           TEXT,
  sheet_url         TEXT,
  secret_thread_id  TEXT,
  PRIMARY KEY (session_id, user_id)
);

캐릭터 테이블은 만들지 않았다. 1편에서 정한 대로 캐릭터 인덱스는 스프레드시트가 맡는다. 봇은 pc_name 과 sheet_url 만 들고 있다가 세션이 끝날 때 시트에 정보를 기입한다.

마이그레이션을 가볍게

기능을 추가하면서 컬럼이 늘었는데, 이미 돌아가는 DB가 있으니 스키마를 갈아엎을 수는 없다. 그래서 실행할 때 조용히 붙이게 했다.

for (const [col, def] of [
  ['opt_secret',  "TEXT DEFAULT 'reveal'"],
  ['opt_threads', "TEXT DEFAULT 'delete'"],
]) {
  const has = db.prepare('PRAGMA table_info(sessions)').all().some((c) => c.name === col);
  if (!has) db.exec(`ALTER TABLE sessions ADD COLUMN ${col} ${def}`);
}

한 번만 돌아야 하는 데이터 변환은 PRAGMA user_version 으로 막는다.

if (db.pragma('user_version', { simple: true }) < 1) {
  db.exec("UPDATE sessions SET opt_threads = 'delete' WHERE opt_threads = 'archive'");
  db.pragma('user_version = 1');
}

[하드코딩 금지] ID는 코드에 넣지 말자

채널 ID, 포럼 태그 ID, 역할 ID를 코드에 하드코딩하면 채널 하나 새로 만드는 순간 전부 고쳐야 한다. 그래서 config.json 으로 뺐다.

{
  "channels": { "모집": "...", "진행": "...", "일정": "...", "기록": "..." },
  "tags":     { "모집중": "...", "마감": "...", "CoC": "...", "평일밤": "..." },
  "roles":    { "kp": "...", "알림": { "CoC": "...", "인세인": "..." } },
  "rules":    ["CoC", "인세인", "D&D 5e", "더블크로스", "파라노이아", "기타룰"]
}

그리고 이 파일을 서버를 읽어서 자동 생성하는 스크립트를 만들었다. (클로드야 고맙다!) 채널 이름과 태그 이름으로 찾아서 ID를 채운다. 구조를 바꿨으면 npm run config 한 번이면 끝이다.

여기에 하나 더 붙였는데, 이게 꽤 도움이 됐다. 기동할 때 config에 적힌 ID가 실제로 존재하는지 검증한다.

const REQUIRED = ['모집', '진행'];      // 없으면 봇이 못 돈다
const OPTIONAL = ['일정', '기록', '다이스'];

필수 채널이 없으면 콘솔에 이름을 찍고 즉시 종료한다.

[종료] 순서의 중요성

세션 종료가 이 봇에서 가장 복잡한 부분이다. [세션 종료]를 누르면 바로 끝나지 않고 확인 패널이 먼저 뜬다.

두 가지를 고른다.

비밀 스레드가 하나도 없으면 비밀 메뉴는 자동으로 잠긴다. 고른 값은 DB에 저장돼서 패널을 다시 열어도 유지된다.

[이대로 종료]를 누르면 이 순서로 실행된다.

1. 로그를 먼저 뜬다 — 전체 + 비밀 스레드 메시지 전부 (봇 자신의 메시지는 제외)
2. 첨부를 시간순으로 모아 번호를 매긴다
3. 비밀을 공개한다 (reveal일 때만)
4. 로그 파일을 마크다운으로 조립
5. #세션-기록 에 포스트 생성 (룰 태그 승계)
6. 이미지를 기록 글에 다시 올린다
7. 마스터 시트에 참가자 수만큼 행 추가
8. 역할 삭제 → 스레드 정리 → 모집 글 [✅ 완결] + 보관

1번과 3번의 순서가 핵심이다. 처음엔 반대로 짰다가 기록이 통째로 중복됐다. (이 얘기는 3편에서 자세히 다룬다...)

6번도 그냥 지나가면 안 되는 부분이다. 디스코드 첨부 URL에는 만료 서명이 붙어 있어서 하루면 만료된다. 링크만 적어두면 기록보관소가 며칠 뒤에 전부 깨진다. 그래서 파일을 내려받아 기록 글에 다시 올리고, 로그 본문에는 번호로 짝을 맞춘다.

## 이미지

아래 번호는 이 기록 글에 함께 올려둔 파일과 짝이 맞습니다.

- `001` scene.png — 김도현
- `002` map.jpg — 이서연 · 🔒 비밀

7번 시트 연동은 try/catch 로 감쌌다. 시트 API가 실패해도 세션 종료는 진행돼야 한다. 구글 API 때문에 기록이 통째로 날아가면 안 되므로, 실패하면 경고만 남긴다.

[부가 기능]

세션 사이클 외의 기능이지만 만들길 잘했다~ 싶은 게 두 개 있다.

/글찾기 — 포럼에 작성자 필터가 없다

"특정 작성자가 올린 시나리오 글만 보고 싶다"는 요구사항 ➡ 충격적이게도 디스코드 포럼 검색에는 작성자 필터가 없다.

태그로 만드는 건 현실적으로 불가능해서, 봇의 명령어를 추가했다. 보관된 글까지 훑어야 하니 지금 생각해 보면... 봇이 하는 게 맞긴 하다.

const active = await forum.threads.fetchActive();
let before;
for (let page = 0; page < 10; page++) {          // 최대 1000개
  const arch = await forum.threads.fetchArchived({ type: 'public', limit: 100, before });
  if (arch.threads.size === 0) break;
  before = arch.threads.last()?.archivedAt;
  if (!arch.hasMore) break;
}
const mine = found.filter((t) => t.ownerId === user.id);

처음엔 채널 목록을 하드코딩했다가, 채널을 하나 추가하니 바로 어긋났다. 지금은 서버의 포럼 채널을 그때그때 읽어서 자동완성으로 띄운다.

export async function autocomplete(interaction) {
  const q = (interaction.options.getFocused() ?? '').toLowerCase();
  const list = forumChannels(interaction.guild)
    .filter((c) => !q || c.name.toLowerCase().includes(q))
    .slice(0, 25)
    .map((c) => ({ name: `#${c.name}`, value: c.name }));
  await interaction.respond(list);
}

/밀담 — 아무 때나 여는 임시 스레드

원래는 세션 중 PC끼리 몰래 이야기하는 용도로 구상했는데, 만들다 보니 "세션이 아니어도 아무나 쓸 수 있으면 좋겠다"로 범위가 넓어졌다.

사람 고르는 건 UserSelectMenuBuilder 를 쓴다. 텍스트로 멘션을 받는 것보다 훨씬 낫다.

const menu = new UserSelectMenuBuilder()
  .setCustomId(`mildam:create:${s?.id ?? 0}:${withoutKp ? '1' : '0'}:${parent.id}`)
  .setPlaceholder('사람 고르기')
  .setMinValues(1)
  .setMaxValues(10);

customId에 상태를 전부 밀어넣는 패턴이 여기서도 쓰인다. 세션 id, KP 제외 여부, 부모 채널 id까지 다 문자열에 담는다.

세션 스레드 안에서 실행하면 그 세션에 묶이고 KP가 자동으로 들어간다. PC끼리만 몰래 하면 KP가 상황을 놓치기 때문이다. 정 빼고 싶으면 kp제외 옵션이 있는데, 그때는 경고를 띄운다.

여기까지가 설계다. 명령어 하나 원칙, 상태 기계 한 파일, customId에 상태 인코딩, 타임존은 디스코드에 위임, 리마인드는 DB 폴링...

그런데 설계가 맞아도 에러 메시지도 없이 조용히 꼬이는 것들이 있었다. 다음 편은 그 얘기다.

→ 3편 — 삽질 모음: 에러도 안 나는 버그들

TRPG 동아리용 디스코드 서버를 설계하고, 세션 진행 전체를 자동화하는 봇을 만들어 클라우드에 올린 과정을 4편으로 나눠 보았다.

1편 — 서버 설계: 포럼 채널 ← 지금 글 2편 — 봇 설계: 명령어는 단순하게 3편 — 삽질 모음: 에러도 안 나는 버그들 4편 — 배포와 회고: 오라클 무료 티어, 그리고 되돌린 기능들

[문제점] 파티가 매번 바뀐다!

(기존 디스코드 서버가 너무 더러워서) TRPG 동아리 서버를 만들기로 했다. 규모는 작고, 룰은 다섯 개를 돌아가면서 하고, 세션은 종종 음성으로 한다. 여기까지는 흔한 조건인데, 하나가 걸렸다...

바로 파티가 매번 바뀐다는 것이다.

장기 캠페인을 고정 멤버로 도는 서버가 아니라, 단편 위주로 그때그때 사람을 모아서 한 판 돌리고 흩어지는 구조다. 이 부분이 서버 설계의 거의 결정에 영향을 미쳤다.

처음에 자연스럽게 떠올린 건 이런 구조였다.

📁 CoC
  └ #coc-공지  #coc-자료  #coc-세션1  #coc-세션2
📁 인세인
  └ #인세인-공지  #인세인-자료  ...

세션마다 채널을 하나 파고, 룰마다 카테고리를 파는 것이 처음엔 깔끔해 보였다.

그런데... 대충 계산해보니 답이 없는 구조라는 걸 알 수 있었다. 한 달에 세션 두 번만 해도 1년이면 채널 24개다. 솔직히 끝난 세션 채널은 아무도 안 들어가는데 사이드바만 차지한다. (그리고 반년에 한 번 돌리는 룰은 카테고리 자체가 짐이 되는 느낌이 들었다.)

[해결법] 포럼 채널

레퍼런스로 다른 디스코드 서버 스크린샷을 보다가 게시판처럼 생긴 화면을 발견했다. 처음엔 봇으로 만든 건 줄 알았는데, 알고 보니 디스코드 기본 기능인 포럼 채널(Forum Channel) 이었다.

포럼 채널의 특징:

• 포스트 하나하나가 그대로 스레드다
• 포스트마다 태그를 붙이고, 태그로 필터링할 수 있다
• 갤러리 뷰로 두면 썸네일이 격자로 깔린다
• 오래된 포스트는 자동으로 보관된다 (사라지지는 않는다)

여기서 이 서버의 설계 원칙이 하나로 정리됐다!

파티가 매번 바뀌는 소규모 서버는 '채널을 파는 서버'가 아니라 '포스트를 파는 서버'가 되어야 한다.

세션마다 채널을 파면 반년 뒤 안 쓰는 채널 20개가 남는다. 세션마다 포스트를 파면 그건 그대로 기록보관소가 된다. 같은 행위인데 결과물이 정반대다.

3번은 부연 설명이 필요하다. 단편의 경우, 캐릭터가 시나리오와 함께 태어나고 시나리오와 함께 끝난다. #캐릭터-시트 포럼을 파서 캐릭터마다 포스트를 만들면, 한 번 쓰고 버려지는 포스트가 계속 쌓인다. 그래서 캐릭터는 구글 스프레드시트 한 장에 행으로 쌓기로 했다. (이건 나중에 봇이 자동으로 채우게 설계했다.)

[최종 채널 구조]

카테고리 6개로 끝났다. 처음 설계안보다 확실히 줄었다.

📌 시작
  #공지            
  #규칙과-매너      
  #역할-알림설정

🎲 세션
  #세션-모집 [포럼]
  #세션-일정 [봇 전용]         
  #세션-진행 [확정된 세션마다 비공개 스레드가 열림]

📚 자료실
  #자료실 [포럼]  룰 요약·핸드아웃·BGM·맵
  #시나리오 [포럼]

🏛 기록보관소
  #세션-기록 [포럼]  완결 세션 로그. 봇이 자동 생성
  #캐릭터-갤러리 [포럼]
  #명장면 [스타보드 자동 수집]

💬 라운지
  #잡담  #trpg-소식  #다이스  #봇-테스트

🔊 음성
  ➕ 세션방 만들기 [들어가면 방이 생기고, 다 나가면 사라짐]
  🔒 밀담방
  대기실  잡담방

주요 채널 다섯 개가 포럼이다. 그리고 여기서 설계상 제일 고민했던 지점이 하나 있다.

왜 #세션-진행만 포럼이 아닌가

확정된 세션의 참가자들만 쓰는 공간이 필요했다. 핸드아웃을 주고받고, 비밀 정보를 주고 받으며 정보를 확인하는 곳 말이다.

처음엔 이것도 포럼으로 만들려고 했다. 그런데 문제가 생겼다!

디스코드는 "포럼 포스트 하나만 특정 인원에게 보이게" 하는 걸 지원하지 않는다. 포스트 권한은 부모 채널 권한을 그대로 따라간다. 채널이 보이면 모든 포스트가 보이고, 안 보이면 다 안 보인다. 포스트 단위 권한이라는 개념 자체가 없는 것이다. ㅠㅠ

반면 비공개 스레드(Private Thread) 는 참가자를 한 명씩 넣는 방식이다. 세션마다 딱 맞는 공간이 된다.

그런데 비공개 스레드는 일반 텍스트 채널에서만 만들 수 있었다. 포럼 안에서는 못 만든다.

그래서 #세션-진행 만 텍스트 채널로 남겼다. 나중에 만들 봇의 /밀담 명령어가 텍스트 채널에서만 동작하는 것도 같은 제약 때문이다.

태그를 '예산'처럼 배분하기

포럼 채널의 태그에는 두 가지 한도가 있다.

• 채널당 최대 20개
• 포스트당 최대 5개

20개는 생각보다 금방 찬다. 아무 생각 없이 만들다 보면 룰 6개 + 상태 4개만 해도 절반이 날아간다. 그래서 태그를 예산처럼 미리 배분해두는 게 이 설계의 핵심이었다.

#세션-모집 은 20칸을 꽉 채워 썼다.

상태 4개와 시간대 4개는 봇이 자동으로 붙인다. 상태는 세션이 진행되면서 교체되고, 시간대는 입력된 일시에서 계산한다. 사람이 직접 고르는 건 '대상' 3개뿐이다.

[역할 설계] '임시 역할'이라는 트릭

파티가 매번 바뀌는 서버에서 권한을 수동으로 관리하면 무조건 사고가 난다는 확신에 기반했다. "아! 저번 사람들 역할 빼는 거 깜빡했다.."

해법은 세션마다 태어나고 세션이 끝나면 사라지는 임시 역할이다.

@운영진          채널·역할·봇 관리
@KP / GM        세션 개설
@플레이어         온보딩 통과 후 기본 역할
@알림-CoC ...    룰별 알림 구독 (버튼으로 자율)
@세션-{ID}       ← 봇이 만들고 봇이 지우도록 설계

@세션-42 같은 역할이 파티 확정 순간에 생겨서 참가자에게 붙고, 세션이 끝나면 사라진다. 그 세션의 공간 접근권이 이 역할 하나로 결정된다. 사람이 손댈 일이 없다.

발견한 권한 구멍

설계하다가 하나 발견했는데, 이건 꽤 중요하다.

디스코드에서 '스레드 관리(Manage Threads)' 권한이 있으면, 초대받지 않은 비공개 스레드도 열어볼 수 있다.

@운영진 과 @KP / GM 역할에 관례적으로 이 권한을 주기 쉬운데, 그러면 KP가 여러 명이 됐을 때 서로의 세션 비밀 스레드가 전부 보인다. 인세인 비밀이나 CoC 개별 핸드아웃이 다른 KP에게 노출된다는 뜻이다.

그래서 #세션-진행 채널에서만 그 권한을 뺐다.

await jinhaeng.permissionOverwrites.edit(kp, {
  ViewChannel: true,
  SendMessages: true,
  CreatePrivateThreads: true,   // 만들 수는 있고
  CreatePublicThreads: true,
  ManageThreads: false,          // 남의 것은 못 보게
});

스레드를 만들 수는 있지만 남의 것을 열어볼 수는 없는 상태. 정리는 봇이 하니까 사람에게 관리 권한이 필요 없다.

다만 정직하게 고백하자면, 서버 소유자는 권한과 무관하게 모든 비공개 스레드를 볼 수 있다. 디스코드 사양이라 못 막는다. 하하!

채널 제작은 클로드와 함께

카테고리 6개, 채널 15개, 포럼 태그 60여 개, 역할 10개. 상상만 해도 오래 걸리기에, 클로드와 함께 작업했다. 그래서 discord.js로 구축 스크립트를 짰다.

const guild = await client.guilds.fetch(process.env.GUILD_ID);

const forum = await guild.channels.create({
  name: '세션-모집',
  type: ChannelType.GuildForum,
  parent: category.id,
  defaultForumLayout: ForumLayoutType.ListView,
  defaultSortOrder: SortOrderType.LatestActivity,
  availableTags: TAGS.map((t) => ({
    name: t.name,
    moderated: false,
    ...(t.emoji ? { emoji: { id: null, name: t.emoji } } : {}),
  })),
});

--dry-run 플래그를 붙이면 디스코드에 붙지 않고 무엇을 만들지만 출력하게 해뒀다. 이게 생각보다 유용했다. 태그 개수가 20을 넘는지, 이름에 오타가 없는지를 API 호출 없이 확인할 수 있다.

스크립트로 만들면 좋은 점이 하나 더 있다. 구조를 바꾸는 게 편해진다. 나중에 #시나리오 포럼을 새로 만들고 #자료실 에서 태그 하나를 빼는 개편을 했는데, 이것도 스크립트(revamp.js)로 처리했다. 손으로 했으면 "귀찮으니 그냥 두자" 로 끝났을 일이다.

다만 코드로 안 되는 것들도 있다

전부 자동화되지는 않았다. ** 서버 설정 화면에서 직접 설정해야 했던 것들**:

• 커뮤니티 활성화 — 이걸 켜야 온보딩과 공지 채널을 쓸 수 있다
• 온보딩 — 규칙 동의 + 관심 룰 선택
• 온보딩 '기본 채널' — 가장 헷갈렸던 부분이라 따로 쓴다
• 역할 순서 — 봇 역할을 @세션-* 위로 드래그

세 번째가 유독 헷갈렸다. 보통 온보딩의 기본 채널 목록에 등록된 채널만 신입에게 기본으로 보인다. 사용자가 '모든 채널 보기'를 꺼두고 있으면 이 목록이 곧 그 사람이 보는 서버 전부다.

이걸 모르고 있다가, GM 역할 계정으로 서버를 보니 카테고리가 이상하게 갈라져 보이고 음성 채널이 안 보이는 현상을 겪었다. 원인은 그 계정의 '모든 채널 보기' 가 꺼져 있었고 기본 채널 목록에 음성 채널이 빠져 있던 것이다.

이건 API로 채울 수 있어서 스크립트를 하나 더 만들었다.

const onboarding = await guild.fetchOnboarding();
await guild.editOnboarding({
  defaultChannels: [...allChannelIds],   // 음성 채널까지 전부
  mode: onboarding.mode,
  enabled: true,
});

여기까지가 서버 구조다. 채널을 파지 않고 포스트를 파는 것, 태그를 예산처럼 배분하는 것, 임시 역할로 권한을 자동화하는 것...

다음 편은 그 봇을 어떻게 설계했는지다. 사실 제일 중요했던 결정은 기능이 아니라 "KP가 외워야 하는 명령어를 몇 개로 할 것인가" 였다.

→ 2편 — 봇 설계: 명령어를 외우게 하지 않기

: 소프트웨어 개발, 유지보수 등에 필요한 수행 방법과 각종 기법 및 도구를 체계적으로 정리하여 표준화한 것

• 주요 방법론
  • 구조적 방법론 : 사용자 요구사항 파악하여 문서화하는 처리 중심의 방법론
  • 정보공학 방법론 : 정형화된 기법들을 상호 연관성 있게 통합 및 적용하는 자료 중심의 방법론
  • 객체지향 방법론 : 객체들을 조립해서 소프트웨어 구현하는 방법론
  • 컴포넌트 기반 방법론 : 컴포넌트를 조합하여 새로운 애플리케이션을 만드는 방법론
  • 제품 개열 방법론 : 제품에 적용하고 싶은 공통된 기능을 정의하여 개발하는 방법론
  • 애자일 방법론

소프트웨어 재사용(Software Reuse)

: 이미 개발되어 인정받은 소프트웨어를 다른 소프트웨어 개발이나 유지에 사용하는 것 / 품질과 생산성 향상

• 방법
  • 합성 중심(Composition-Based): 블록을 만들어서 끼워 맞춰 소프트웨어를 완성, 블록 구성 방법
  • 생성 중심(Generation-Based): 추상화 형태로 써진 명세를 구체화하여 프로그램 완성, 패턴 구성 방법

소프트웨어 재공학(Software Reengineering)

: 기존 시스템을 이용하여 보다 나은 시스템을 구축하고, 새로운 기능을 추가하여 소프트웨어 성능을 향상시키는 것

• 이점: 품질 향상, 생산성 증가, 수명 연장, 오류 감소

CASE(Computer Aided Software Engineering)

: 소프트웨어 개발 과정 전체 또는 일부를 컴퓨터와 전용 소프트웨어 도구를 사용하여 자동화하는 것 = 자동화 도구

비용 산정 기법

하향식

: 과거의 유사한 경험을 바탕으로 전문 지식이 많은 개발자들이 참여한 회의를 통해 비용을 산정하는 비과학적인 방법

• 기법
  • 전문가 감정 기법
  • 델파이 기법(주관적 편견 보완)

상향식

: 세부적인 작업 단위별로 비용을 산정한 후 집계하여 전체 비용을 산정하는 방법

• 기법
  • LOC(원시 코드 라인 수) 기법: 비관치(가장 많이 측정), 낙관치(가장 적게), 기대치(측정된 모든 코드 라인 수)
  • 개발 단계별 인월수(Effort Per Task) 기법: LOC 기법 보완
  • 수학적 산정 기법

수학적 산정 기법

: 상향식 비용 산정 기법, 경험적 추정 모형, 실험적 추정 모형 / 개발 비용 산정의 자동화를 목표

• 기법

• COCOMO 모형

• Putnam 모형 : 소프트웨어 생명 주기의 전 과정 동안에 사용될 노력의 분포를 예상하는 모형, 생명 주기 예측 모형 / Rayleigh-Norden 곡선의 노력 분포도를 기초

• 기능 점수(FP) 모형 : 소프트웨어의 기능을 증대시키는 요인별로 가중치 부여

• 비용 산정 자동화 추정 도구

  • SLIM: Rayleigh-Norden 곡선과 Putnam 예측 모델을 기초로 하여 개발된 자동화 추정 도구
  • ESTIMACS

COCOMO(Constructive COst MOdel) 모형

: 원시 프로그램 규모인 LOC(원시 코드 라인 수)에 의한 비용 산정 기법 / 비용 산정 결과는 프로젝트를 완성하는 데 필요한 노력으로 나타남 / 보헴이 제안

• 개발 유형 : '조반내'
  • 조직형(Organic Mode)
  • 반분리형(Semi-Detached Mode)
  • 내장형(Embedded Mode)
• 모형 종류
  • 기본형 COCOMO
  • 중간형 COCOMO
  • 발전형 COCOMO

프로젝트 일정 계획

: 프로젝트의 프로세스를 이루는 소작업을 파악하고 예측된 노력을 각 소작업에 분배하여 소작업의 순서와 일정을 정하는 것

• 기능: WBS, PERT/CPM, 간트 차트

소프트웨어 개발 방법론

• 프로젝트 관리: '일비인위품' 일정, 비용, 인력, 위험, 품질 관리

소프트웨어 개발 표준

: 소프트웨어 개발 단계에서 수행하는 품질 관리에 사용되는 국제 표준

ISO/IEC 12207

: ISO에서 만든 표준 소프트웨어 생명 주기 프로세스

• 기본 생명 주기 프로세스
• 지원 생명 주기 프로세스
• 조직 생명 주기 프로세스

CMMI

: 소프트웨어 개발 조직의 업무 능력 및 조직의 성숙도를 평가하는 모델 / SEI 개발

• 프로세스 성숙도: '초관정,정관최' 초기, 관리, 정의, 정량적 관리, 최적화

SPICE = ISO/IEC 15504

: 소프트웨어의 품질 및 생산성 향상을 위한 소프트웨어 프로세스를 평가 및 개선

• 수행 능력 단계: 불완전, 수행, 관리, 확립, 예측, 최적화

소프트웨어 개발 방법론 테일러링

: 소프트웨어 개발 방법론의 절차, 사용기법 등을 수정 및 보완하는 작업

• 내부적 기준: 목표 환경, 요구사항, 프로젝트 규모, 보유 기술
• 외부적 기준: 법적 제약사항, 표준 품질 기준

소프트웨어 개발 프레임워크

: 소프트웨어 개발에 공통적으로 사용되는 구성 요소와 아키텍처를 일반화하여 여러 가지 기능들을 제공해주는 반제품 형태의 소프트웨어 시스템

스프링 프레임워크(Spring Framework)

: 자바 플랫폼을 위한 오픈 소스 경량형 애플리케이션 프레임워크

전자정부 프레임워크

: 대한민국의 공공부문 정보화 사업 시, 정보 시스템의 구축을 지원하기 위해 필요한 기능 및 아키텍처를 제공하는 프레임워크

닷넷 프레임워크(.NET Framework)

: Windows 프로그램의 개발 및 실행 환경을 제공하는 프레임워크 / CLR(공용 언어 런타임) 가상머신 상에서 작동

소프트웨어 개발 프레임워크의 특성

• 모듈화 : 캡슐화로 모듈화 강화 --> 유지보수 용이 : 설계 및 구현 변경에 따른 영향 최소화 --> 소프트웨어 품질 향상
• 재사용성 : 재사용 가능한 모듈 제공 --> 예산 절감, 생산성 향상, 품질 보증
• 확장성 : 다형성을 통한 인터페이스 확장 가능 --> 다양한 형태와 기능을 가진 애플리케이션 개발 가능
• 제어의 역흐름 : 관리하고 통제해야 하는 객체들의 제어를 프레임워크에 넘김 --> 생산성 향상

: 시스템 개발 과정에서 의사소통이 원활하게 이루어지도록 표준화한 대표적인 객체지향 모델링 언어

• 구성 요소: '사관다'
  • 사물(Things)
  • 관계(Relationships)
  • 다이어그램(Diagram)

사물(Things)

: 다이어그램 안에서 관계가 형성될 수 있는 대상

• 종류: '구행그주'
• 구조 사물(Structural Things) : 시스템의 개념적 물리적 요소 --> 클래스, 유스케이스, 컴포넌트, 인터페이스, 노드
• 행동 사물(Behavioral Things) : 시간과 공간에 따른 요소들의 행위 표현 --> 상호 작용, 상태 머신
• 그룹 사물(Grouping Things) : 요소들을 그룹으로 묶어서 표현 --> 패키지
• 주해 사물(Annotation Things) : 부가적인 설명이나 제약조건 등을 표현 --> 노트

관계(Relationships)

: 사물과 사물 사이의 연관성을 표현하는 것

• 종류: '연집포일의실' 연관, 집합, 포함, 일반화, 의존, 실체화 관계

연관(Association) 관계

: 2개 이상의 사물이 서로 관련

• 실선 방향성은 화살표, 양뱡향의 경우 생략 가능, 다중도는 선 위에 표기

집합(Aggregation) 관계

: 하나의 사물이 다른 사물에 포함되어 있는 관계

• 전체(Whole)와 부분(Part)는 서로 독립적

포함(Composition) 관계

: 집합 관계의 특수한 형태, 포함하는 사물의 변화가 포함되는 사물에게 영향을 미치는 관계

• 전체와 부분은 서로 독립될 수 없고, 생명주기를 함께 함

일반화(Generalization) 관계

: 하나의 사물이 다른 사물에 비해 더 일반적이거나 구체적인 관계

• 구제적(하위), 일반적(상위)

의존(Dependency) 관계

: 서로 연관은 있으나, 필요에 의해 서로에게 영향을 주는 짧은 시간 동안만 연관을 유지하는 관계

• 소유 관계는 아니지만 사물의 변화가 다른 사물에도 영향을 미침

실체화(Realization) 관계

: 할 수 있거나 해야 하는 기능으로, 서로를 그룹화 할 수 있는 관계

• 사물에서 기능으로 연결

다이어그램(Diagram)

: 사물과 관계를 도형으로 표현한 것 / 여러 관점에서 시스템을 가시화한 뷰(View)를 제공함으로써 의사소통에 도움을 줌

• 정적 모델링: 구조적 다이어그램
• 동적 모델링: 행위 다이어그램

구조적(Structural) 다이어그램 종류: '클객컴배복패'

• 클래스 다이어그램: 클래스 속성
• 객체 다이어그램: 인스턴스와 럼바우
• 컴포넌트 다이어그램: 실제 구현 모듈인 컴포넌트, 구현 단계
• 배치 다이어그램: 물리적 요소 위치, 구현 단계
• 복합체 구조 다이어그램: 복합 구조
• 패키지 다이어그램: 그룹화

행위(Behavioral) 다이어그램 종류: '유순커상활상타'

• 유스케이스 다이어그램: 사용자 + 사용 사례
• 순차 다이어그램: 메시지
• 커뮤니케이션 다이어그램: 연관 관계
• 상태 다이어그램: 상태 변화, 럼바우, 동적 모델링
• 활동 다이어그램: 수행, 처리 로직
• 상호작용 개요 다이어그램: 제어
• 타이밍 다이어그램: 시간 제약

스테레오 타입(Stereotype)

: UML에서 표현하는 기본 기능 외에 추가적인 기능을 표현하는 것

• 길러멧(Guilemet): ≪ ≫ 사이에 형태 기술
  • ≪include≫: 포함 관계
  • ≪extends≫: 확장 관계
  • ≪interface≫: 인터페이스 정의
  • ≪exception≫: 예외 정의
  • ≪constructor≫: 생성자 역할

유스케이스(Use Case) 다이어그램

: 개발될 시스템을 이용해 수행할 수 있는 기능을 사용자의 관점에서 표현한 것

• 기능 모델링: 개발될 시스템이 갖춰야 할 기능을 정리한 후, 사용자와 공유하기 위해 그림으로 표현하는 것
• 종류: 유스케이스 다이어그램, 액티비티 다이어그램
• 구성 요소: 시스템, 액터, 유스케이스, 관계

활동(Activity) 다이어그램

: 사용자의 관점에서 시스템이 수행하는 기능을 처리 흐름에 따라 순서대로 표현한 것

• 구성 요소: 액션(단일 작업), 액티비티(액션으로 분리 가능), (시작, 종료, 조건, 병합, 포크, 조인) 노드, 스윔레인

클래스(Class) 다이어그램

: 클래스와 클래스가 가지는 속성, 클래스 사이의 관계를 표현한 것

• 정적 모델링: 사용자가 요구한 기능을 구현하는데 필요한 자료들의 논리적인 구조를 표현한 것
• 구성 요소: 클래스, 제약조건, 관계
• 연관 클래스: 연관 관계에 있는 두 클래스에 추가적으로 표현해야 할 속성이나 오퍼레이션이 있는 경우 생성하는 클래스

순차(Sequence) 다이어그램

: 시스템이나 객체들이 메시지를 주고 받으며 상호 작용하는 과정을 그림으로 표현한 것

• 동적 모델링: 시스템의 내부 구성 요소들의 상태 변화 과정과 과정에서 발생하는 상호 작용을 표현한 것

: 소프트웨어가 어떤 문제를 해결하기 위해 제공하는 서비스에 대한 설명과 운영되는데 필요한 제약조건 / 기준과 근거 제공 / 이해관계자들 간의 의사소통을 원활

• 요구사항의 유형: '기비사시'
  • 기능 요구사항(Functional Requirements) : 시스템의 기능이나 수행과 관련된 요구사항
  • 비기능 요구사항(Non-functional requirements) : 품질이나 제약사항과 관련된 요구사항 (품질 요구사항: 가용성, 정합성, 상호 환성, 대응성, 이식성, 확장성, 보안성 등)
  • 사용자 요구사항(User requirements) : 사용자 관점에서 본 시스템이 제공해야 할 요구사항
  • 시스템 요구사항(System requirements) : 개발자 관점에서 본 시스템 전체가 사용자와 다른 시스템에 제공해야 할 요구사항 = 소프트웨어 요구사항

요구사항 개발 프로세스: '도분명확'

: 개발 대상에 대한 요구사항을 체계적으로 도출하고 분석한 후 명세서에 정리한 다음 확인 및 검증하는 일련의 구조화된 활동 = 요구 공학의 한 요소 / 진행되기 전에 타당성 조사(Feasibility Study)가 선행

도출(Elicitation) --> 분석(Analysis) --> 명세(Specification) --> 확인(Validation)

1. 요구사항 도출(Requirement Elicitation, 요구사항 수집)

: 시스템 개발에 관련된 사람들이 서로 의견을 교환하여 요구사항을 식별하고 이해하는 과정 / 이해관계자(Stakeholder)가 식별 --> 소프르웨어 개발 생명 주기(SDLC) 동안 지속적으로 반복

• 주요 기법: 청취와 인터뷰, 설문, 브레인스토밍, 워크샵, 프로토타이핑, 유스케이스

2. 요구사항 분석(Requirement Analysis)

: 요구사항 중 명확하지 않거나 이해되지 않는 부분을 발견하고 이를 걸러내기 위한 과정 / 서로 상충되는 요구사항이 있으면 이를 중재하는 과정

• 대표 도구: 자료 흐름도(DFD), 자료 사전(DD)

3. 요구사항 명세(Requirement Specification)

: 분석된 요구사항을 바탕으로 모델을 작성하고 문서화하는 것 / 기능은 전부, 비기능은 필요한 것만 기술

• 소단위 명세서(Mini-Spec)

4. 요구사항 확인(Requirement Validation, 요구사항 검증)

: 요구사항 명세서가 정확하고 완전하게 작성되었는지 검토하는 활동

• 관리 도구를 이용하여 형상 관리(SCM; Software Configuration Management)를 수행

요구공학(Requirements Engineering)

: 요구사항을 정의하고, 분석 및 관리하는 프로세스를 연구하는 학문 --> 요구사항 변경의 원인과 처리 방법을 이해하고, 프로세스 품질을 개선하여 소프트웨어 프로젝트 실패를 최소화하는 것을 목표

요구사항 명세 기법

• 정형 명세 기법
• 비정형 명세 기법

요구사항 분석

: SW 개발의 실질적인 첫 단계, 개발 대상에 대한 사용자의 요구사항을 이해하고 문서화하는 활동 (타당성 조사, 제약 및 목표 설정)

구조적 분석 기법

: 자료 흐름과 처리 중심의 요구사항 분석 기법 / 하향식 방법으로 시스템 세분화 / 분석의 중복 배제 가능

• 주요 도구: 자료 흐름도(DFD), 자료 사전(DD), 소단위 명세서(Mini-Spec), 개체 관계도(ERD), 상태 전이도(STD), 제어 명세서

자료 흐름도(DFD; Data Flow Diagram)

: 자료의 흐름 및 변환 과정과 기능을 도형 중심으로 기술하는 방법 = 자료 흐름 그래프, 버블 차트

• 기본 기호 (Yourdon/DeMacro 표기법)

자료 사전(DD; Data Dictionary)

: 자료 흐름도에 있는 자료를 더 자세히 정의하고 기록한 것 --> 메타 데이터(Meta Data) = 데이터를 위한 데이터

• 표기 기호

요구사항 분석 CASE와 HIPO

요구사항 분석용 CASE(자동화 도구)

: 요구사항을 자동으로 분석하고, 요구사항 분석 명세서를 기술하도록 개발된 도구

• 대표 CASE
  • SADT: SoftTech 사에서 개발
  • SREM = RSL/REVS : TRW 사에서 개발, 실시간 처리용
  • PSL/PSA: 미시간 대학에서 개발
  • TAGS: 자동 접근 방법, 통합 자동화

HIPO(Hierarchy Input Process Output)

: 시스템 실행 과정인 입력, 처리, 출력의 기능을 표현한 것 / 하향식 소프트웨어 개발을 위한 문서화 도구

• HIPO Chart : 시스템의 기능을 여러 개의 고유 모듈로 분할하여 이들 간의 인터페이스를 계층 구조로 표현한 것
  • 가시적 도표
  • 총체적 도표
  • 세부적 도표

: 소프트웨어를 개발하기 위한 설계, 운용, 유지보수 등의 과정을 각 단계별로 나눈 것 --> 단계별 주요 활동 + 산출물

1. 폭포수 모형(Waterfall Model)

: 이전 단계로 돌아갈 수 없다는 전제, 각 단계를 확실히 매듭짓고 그 결과를 철저하게 검토하여 승인 과정을 거친 후에 다음 단계를 진행하는 개발 방법론

• 고전적 생명 주기 모형
• 단계 끝에 다음 단계를 수행하기 위한 결과물이 명확하게 산출되어야 함

2. 프로토타입 모형(Prototype Model, 원형 모형)

: 사용자의 요구사항을 파악하기 위해 실제 개발될 소프트웨어에 대한 견본품(prototype)을 만들어 최종 결과물을 예측하는 모형

3. 나선형 모형(Spiral Model, 점진적 모형)

: 나선을 따라 돌듯이 여러 번의 소프트웨어 개발 과정을 거쳐 점진적으로 완벽한 최종 소프트웨어를 개발하는 모형

• 4가지 주요 활동: '계분개평'
• 계*획 수립 --> 위험 분석 --> 개발 및 검증 --> 고객 평가 (다시 계획 수립으로 돌아감)
• 보헴(Boehm)이 제안
• 누락되거나 추가된 요구사항을 첨가할 수 있음
• 유지보수 과정이 필요 없음

4. 애자일 모형(Agile Model) -> 시험에서는 모형 빼고, 애자일(Agile)로 쓰는 듯

: 애자일은 '민첩한', '기민한'이라는 의미, 고객의 요구사항 변화에 유연하게 대응할 수 있도록 일정한 주기를 반복하면서 개발하는 모형

• 고객과의 소통에 초점을 맞춘 방법론을 통칭
• 폭포수 모형과 대조적
• 대표적인 개발 모형 : 스크럼(Scrum), XP(eXtreme Programming), 기능 중심 개발(FDD; Feature Driven Development), 칸반(Kanban), Lean
• 4가지 핵심 가치
  • 방대한 문서보다는 실행되는 SW에 더 가치를 둔다
  • 프로세스와 도구보다는 개인과 상호작용에 더 가치를 둔다
  • 방대한 문서보다는 실행되는 SW에 더 가치를 둔다
  • 계약 협상보다는 고객과의 협업에 더 가치를 둔다
  • 계획을 따르기 보다는 변화에 반응하는 것에 더 가치를 둔다

5. 소프트웨어 공학(SE; Software Engineering)

: 소프트웨어의 위기를 극복하기 위한 방안으로 연구된 학문 / 여러 가지 방법론과 도구, 관리 기법들을 통하여 소프트웨어의 품질과 생산성 향상을 목적

• 소프트웨어 공학의 기본 원칙
  • 현대적인 프로그래밍 기술을 계속적으로 적용해야 한다
  • 개발된 소프트웨어의 품질이 유지되도록 지속적으로 검증해야 한다
  • 소프트웨어 개발 관련 사항 및 결과에 대한 명확한 기록을 유지해야 한다

스크럼(Scrum) 기법

: 팀이 중심이 되어 개발의 효율성을 높이는 기법 / 팀원 스스로가 스크럼 팀을 구성하고 개발 작업에 관한 모든 것을 스스로 해결할 수 있어야 함

스크럼 팀

• 제품 책임자(PO; Product Owner) : 요구사항이 담긴 백로그(Backlog)를 작성하는 주체, 이해관계자들 중 개발될 제품에 대한 이해도가 높고, 요구사항을 책임지고 의사를 결정할 사람으로 선정
  • 백로그: 제품 개발에 필요한 요구사항을 모두 모아 우선순위를 부여한 목록
• 스크럼 마스터(SM; Scrum Master) : 스크럼 팀이 스크럼을 잘 수행하도록 가이드 역할
• 개발팀(DT; Development Team) : 제품 책임자와 스크럼 마스터를 제외한 모든 팀원으로 제품 개발 수행

스크럼 개발 프로세스: '계진회검회'

계획 --> 진행(스프린트) --> 회의 --> 검토 --> 회고

• 스프린트 계획 회의(Sprint Planning Meeting): 제품 백로그 중 이번 스프린트에서 수행할 작업을 대상으로 단기 일정을 수립하는 회의
• 스프린트(Sprint): 실제 개발 작업 진행, 보통 2~4주
• 일일 스크럼 회의(Daily Scrum Meeting): 모든 팀원 매일 약 15분 동안 진행 상황 점검, 남은 작업 시간은 소멸 차트(Burn-down Chart)에 표시
• 스프린트 검토 회의(Review): 부분 또는 전체 완성 제품이 요구사항에 잘 부합하는지 테스팅
• 스프린트 회고(Sprint Retrospective): 규칙 준수 여부 및 개선점 확인 후 기록

XP(eXtreme Programming) 기법

: 수시로 발생하는 고객의 요구사항에 유연하게 대응하기 위해 고객 참여와 개발 과정의 반복을 극대화하여 개발 생산성을 향상시키는 방법

• 짧고 반복적인 개발 주기, 단순한 설계, 고객의 적극적인 참여를 통해 소프트웨어를 빠르게 개발하는 것이 목적
• 릴리즈 기간을 짧게 반복하며 고객의 요구사항 반영에 대한 가시성을 높임
• XP의 핵심 가치: '의단용존피'
  • 의사소통(Communication)
  • 단순성(Simplicity)
  • 용기(Courage)
  • 존중(Respect)
  • 피드백(Feedback)

XP 개발 프로세스: '계진검출'

계획 --> 진행(이터레이션) --> 검사 --> 출시(릴리즈)

• 릴리즈 계획 수립(Release Planning)
• 이터레이션(Iteration)
• 승인 검사(Acceptance Test, 인수 테스트)
• 소규모 릴리즈(Small Release)

XP의 주요 실천 방법(Practice)

• Pair Programming(짝 프로그래밍)
• Collective Ownership(공동 코드 소유)
• Test-Driven Development(테스트 주도 개발)
• Whole Team(전체 팀)
• Continuous Integration(계속적인 통합)
• Refactoring(리팩토링): 프로그램 기능 변경 없이 시스템을 재구성
• Small Releases(소규모 릴리즈)

개발 기술 환경 파악

• 운영체제(OS; Operating System) : 컴퓨터 시스템의 자원을 효율적으로 관리 / 사용자에게 편리한 환경을 제공하는 소프트웨어 고려사항: 가용성, 성능, 기술 지원, 주변 기기, 구축 비용

• 데이터베이스 관리 시스템(DBMS; DataBase Management System) : 사용자와 데이터베이스 사이에서 사용자의 요구에 따라 정보를 생성, 데이터베이스를 관리해 주는 소프트웨어 / 기존 파일 시스템이 갖는 데이터의 종속성과 중복성의 문제 고려사항: 가용성, 성능, 기술 지원, 상호 호환성, 구축 비용

• 웹 어플리케이션 서버(WAS; Web Application Server) : 사용자의 요구에 따라 변하는 동적인 콘텐츠를 처리하기 위해 사용되는 미들웨어 / 라이브러리 제공 고려사항: 가용성, 성능, 기술 지원, 구축 비용

• 오픈 소스(Open Source) : 누구나 별다은 제한 없이 사용할 수 있도록 소스 코드를 공개한 소프트웨어 / 오픈 소스 라이선스를 만족 고려사항: 라이선스의 종류, 사용자 수, 기술의 지속 가능성

평소에는 템플릿을 가져올 때도 있고, 아이콘 리소스가 많은 사이트도 자주 이용한다. 그러나 손맛이 필요할 때, 나는 Procreate를 이용하는 편이다.

그래서 오늘은 픽셀 아트 그리는 방법을 준비했다.

[Step 1]_브러시 제작

우선 어떤 귀인께서 올려주신 유튜브 링크를 참고하여 픽셀을 그릴 수 있는 브러시를 만들어야 한다. 참고로 귀찮은 사람은 브러시 공유 구글 드라이브에 들어가서 내가 만들어 둔 브러시를 사용하기 바란다.

다운로드 한 다음, 프로크리에이트로 내보내기하면 된다. 참고로 메뉴 들어가서 Imported에 들어가면 다운받은 것을 확인할 수 있다. 이름은 Pixel이다.

[Step 2]_New Canvas

커스텀에 들어가서 그리기 쉬운 사이즈로 설정해야 한다. 작게 그리고 싶으면 10 x 10이나20 x 20 정도를 추천한다. 크게 그리고 싶으면 50이나 100 이상도 좋다.

일단 나는 10 px로 했다.

[Step 3]_Drawing Guide

그리기 전에 Actions에 들어가서 Drawing Guide를 켜준다. 그러면 아래에 편집하기 옵션이 뜨는데 눌러준다.

그리드 사이즈는 0이 되게 만들어 준다. 그럼 None으로 뜰 것이다. 브러시를 가장 작은 사이즈로 했을 때, 한 번의 터치마다 한 칸이 채워진다. (만약 캔버스의 크기를 크게 생성했다면 라인의 크기를 적당히 조절해야 한다.)

상단의 색상 바를 통해서 가이드 라인의 색상을 지정할 수 있다.

[Step 4]_Resize Settings

Procreate의 사용법은 이미 알고 있으리라 생각한다. (보통 그림은 레이어를 나눠서 그린다. 이번 그림은 단순해서 한 레이어에 색칠까지 다 했다.)

그림을 알아서 잘 그렸다면 위처럼 완성된 이미지가 있을 것이다. 그럼 다시 Actions에 들어가서 이번에는 사이즈 조절을 해준다. 이걸 안하면 완성된 이미지를 내보내기할 때 해상도가 처참하게 박살나는 것을 볼 수 있다. 궁금하면 그대로 내보내기 추천!

내가 필요한 사이즈로 조절해준다. 일반적인 앱 아이콘은 1024 x 1024가 권장 사이즈이다.

[Step 5]_Fit to Canvas

사이즈 조절이 끝난 직후의 그림은... 되게 웃긴 상태일 것이다. 코딱지만하다.

여기서부터 중요하다! 마우스 버튼 같은 선택 도구, Selections에 들어가서 유니폼하게 사이즈를 조절할 수 있도록 수정하고, 특히!! Interpolation(보간법)을 Nearest Neighbour(최근접 이웃)로 설정한다.

픽셀 아트의 경우에 꼭 필요한데, 평균이나 보간을 안 하기 때문에 색이 섞이지 않아서 이미지 리사이즈(확대) 시, 값 왜곡이 발생하지 않는다. 더불어 블러 효과가 생기지 않아서 경계가 또렷하게 유지된다는 장점이 있다.

다 따라했으면 Fit to Canvas를 클릭한다.

[Step 6]_Share Layers

Fit to Canvas 직후에는 흐려 보이지만, Selection 버튼 클릭을 해제하면 이미지가 잘 확대된 것을 확인할 수 있다.

드디어 마지막!! 이제 내보내기만 남았다. 레이어를 모두 보이게 표시하고, 배경색을 숨김 처리한다.

다시 Actions에 들어가서 Share Image 말고, Share Layers의 PNg Files로 내보내기 하면 각각의 레이어들이 한 번에 내보내진다.

[마치며]

픽셀 아트는 단순해 보이지만, 작은 점들이 모여 하나의 그림이 되는 과정에서 생각보다 많은 섬세함이 필요하다. 제한된 해상도 안에서 표현해야 하기 때문에 오히려 더 창의적으로 고민하게 되는 부분도 많았다.

지금 블로그에 예시로 그린 그림들은 앱 개발에 사용할 에셋들이다. 어떻게 사용될지는 추후 블로그에 올릴 예정이다.

• 출처 및 난이도: 백준 골드5
• 링크: https://www.acmicpc.net/problem/31423
• 분류: 문자열, 그래프 이론, DFS, 연결 리스트, 자료구조

문제 요약

• N개 대학교 이름이 주어질 때, N-1번의 합치기 연산 (i, j) 를 순서대로 수행
• s_i 뒤에 s_j를 이어 붙이고 s_j를 빈 문자열로 만든 뒤, 최종 이름을 출력하는 문제.

풀이 접근

시도 1 - LinkedList<String>

• 직관적으로 연결 리스트 사용
• 합치기 연산마다 리스트 탐색이 필요해 시간 초과

시도 2 - ArrayList<StringBuilder>

• list.get(i).append(list.get(j))로 문자열 직접 합치기
• N이 최대 100,000이고 이름 길이도 길어서 합칠 때마다 문자열 복사 발생 → O(N²) 시간 초과

최종 - next[] + tail[] 배열로 연결 리스트 구현

1. next[i]: i번 대학 다음에 연결된 대학 번호 (초기값 -1)
2. tail[i]: i번 체인의 마지막 노드 번호 (초기값 자기 자신 i)
3. 합치기 (i, j) 시:
   • next[tail[i]] = j → i 체인 끝에 j 체인 연결
   • tail[i] = tail[j] → i 체인의 꼬리 갱신
4. 마지막 answer(=i)부터 next 따라가며 이름 출력

연결 리스트?

연결 리스트(Linked List)는 데이터를 저장할 때 하나의 데이터와 그 다음 데이터로의 위치를 함께 저장하여 논리적으로 연결(link)하는 방식으로 자료를 저장한다.

데이터는 논리적으로 연결되어 있으므로 배열과 달리 데이터의 삽입 삭제가 자유로워지면서 자연스럽게 전체 크기를 늘리고 줄이는 것 또한 가능해진다.

보통 node로 저장을 하고, 그 안에 데이터(data)와 다음 노드의 주소나 참조(next)를 담는다. 즉, node: data + next

Java에서는 LinkedList 클래스를 기본으로 제공한다.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();

// 삽입
list.add("A");          // 맨 뒤
list.addFirst("B");     // 맨 앞
list.addLast("C");      // 맨 뒤

// 조회
list.get(0);            // 인덱스로 접근
list.getFirst();        // 첫 번째 요소
list.getLast();         // 마지막 요소

// 삭제
list.remove(0);         // 인덱스로 삭제
list.removeFirst();     // 첫 번째 삭제
list.removeLast();      // 마지막 삭제

// 크기
list.size();

이중 연결 리스트(Doubly Linked List) 구조로 구현되어 있다. 심지어 List와 Deque 인터페이스를 모두 구현하므로, 리스트뿐 아니라 스택/큐/덱으로도 활용 가능하다.

핵심 아이디어

• 실제로 문자열을 합치지 않고 포인터만 연결 → 합치기 연산이 O(1)
• tail[] 배열이 핵심: 리스트 끝을 항상 O(1)에 알 수 있어서 이어붙이기가 빠름
• 출력할 때만 next를 따라가며 StringBuilder에 append → 전체 O(N)

코드

<시도 1>

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;

class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        LinkedList<String> list = new LinkedList<>();
        // 이 문제는 인덱스 1부터 시작
        list.add("");

        int N = Integer.parseInt(br.readLine());
        for (int temp = 0; temp < N; temp++) list.add(br.readLine());

        String s = "";
        for (int temp = 0; temp < N-1; temp++) {
            String[] nums = br.readLine().split(" ");
            int i = Integer.parseInt(nums[0]);
            int j = Integer.parseInt(nums[1]);
            list.set(i, list.get(i) + list.get(j));
            if (temp == N - 2) s = list.get(i);
        }

        System.out.println(s);
    }
}

<시도 2>

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        ArrayList<StringBuilder> list = new ArrayList<>();
        // 이 문제는 인덱스 1부터 시작
        list.add(new StringBuilder());

        int N = Integer.parseInt(br.readLine());
        for (int temp = 0; temp < N; temp++) list.add(new StringBuilder(br.readLine()));

        int answer = 0;
        for (int temp = 0; temp < N-1; temp++) {
            String[] nums = br.readLine().split(" ");
            int i = Integer.parseInt(nums[0]);
            int j = Integer.parseInt(nums[1]);
            list.get(i).append(list.get(j));
            list.get(j).setLength(0);
            answer = i;
        }

        System.out.println(list.get(answer));
    }
}

<최종>

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());

        String[] unis = new String[N + 1];
        int[] next = new int[N + 1];
        int[] tail = new int[N + 1];

        for (int i = 1; i <= N; i++) {
            unis[i] = br.readLine();
            next[i] = -1;
            tail[i] = i;
        }

        int answer = 0;
        for (int temp = 0; temp < N - 1; temp++) {
            String[] nums = br.readLine().split(" ");
            int i = Integer.parseInt(nums[0]);
            int j = Integer.parseInt(nums[1]);

            next[tail[i]] = j;
            tail[i] = tail[j];
            answer = i;
        }
        StringBuilder sb = new StringBuilder();
        int next_num = answer;
        while (next_num != -1) {
            sb.append(unis[next_num]);
            next_num = next[next_num];
        }
        System.out.print(sb);
    }
}

<초기 배열 상태> unis: 0 1 2 3 4 5 next: -1 -1 -1 -1 -1 -1 tail: 0 1 2 3 4 5

<최종 배열 상태> unis: 0 1 2 3 4 5 next: -1 2 3 4 5 -1 tail: 0 5 3 3 5 5

배운 점 / 회고

드디어 풀었다! 복병 해결

• 문자열을 실제로 합치면 무조건 시간 초과가 발생한다.
• 핵심은 "합치는 척만 하고 포인터만 연결"하는 것. 실제 합치기는 출력할 때 딱 한 번만 하는 것이다.
• LinkedList → StringBuilder → 포인터 배열 구현 순서로 최적화해가는 과정 자체가 좋은 공부였다고 생각한다.