28차(5/13)와 29차(5/14)에 구름EDU 기출 4회차와 6회차를 풀타임 모의고사로 풀었고, 두 번 모두 추정 800점+ 안정으로 합격선 600을 한참 위에서 통과했다. 함수 작성 6세션 연속 자력 정답, "테스트 통과 but 식 버그" 패턴에 대한 자가 의심도 자발적으로 발동되는 단계까지 진입했다. 모의고사 컨디션이 충분히 올라온 상태였다.

오늘 수업 계획

새 문제 풀이로 머리를 더 쓰는 대신, 이미 아는 공식을 인덱싱하는 정리 모드로 전환했다. 5차 기출 중 스터디에서 미해결로 남은 3문제(5번 몬스터 잡기 / 6번 진법 변환 / 9번 연산 횟수)를 빠르게 분석해서 외울 가치를 분류하고, 학습 전체 이력에서 시험 직전 마지막 한 번 훑기에 적합한 공식을 한 페이지로 압축했다.

COS Pro 1급 Python / Phase 4: 마무리

5차 미해결 3문제 빠른 분석

5번 — 몬스터 잡기 (두 배열 매칭 그리디)

스스로 떠올린 아이디어는 "두 배열을 정렬한 뒤 큰 값부터 비교, 이기면 카운트"였고 방향은 정확했다. 누락된 디테일은 "못 이겼을 때 어떻게 할지" 한 가지였다.

def solution(enemies, armies):
    enemies = sorted(enemies)
    armies = sorted(armies)
    count = 0
    while enemies and armies:
        if armies[-1] >= enemies[-1]:
            armies.pop()
            enemies.pop()
            count += 1
        else:
            enemies.pop()   # 가장 강한 캐릭터도 못 이기는 몬스터 → 영구 포기
    return count

가장 강한 캐릭터로도 못 이기는 몬스터는 약한 캐릭터들도 못 이기니까 그 몬스터만 버리고 캐릭터는 남긴다. 이 문제에서 외울 공식은 없고, 외워야 할 한 줄 패턴만 남는다: "두 묶음을 짝지어야 하는 문제는 둘 다 정렬부터, 못 매칭되는 쪽만 한 칸씩 버린다."

6번 — p진법 → q진법 변환

처음 떠올린 직관은 "각 자릿수별로 더해서 n 이상이면 다음 자리에 +1"이었다. 같은 진법끼리 더하는 받아올림 알고리즘은 맞지만 p≠q일 때 안 통한다. 이 문제는 무조건 10진법을 거쳐가는 게 정석이다.

def solution(s1, s2, p, q):
    total = int(s1, p) + int(s2, p)        # ① p진법 → 10진법
    if total == 0:
        return "0"
    digits = []
    while total > 0:
        digits.append(str(total % q))      # ② 10진법 → q진법
        total //= q
    return ''.join(reversed(digits))

수업 중 질문: digit 문자열 생성할 때 문자열을 붙이지 않고 리스트로 만든 후 join하는 이유가 있어?

Python 문자열은 immutable(불변)이라서 result += str(...)로 반복해서 붙이면 매번 새 문자열 객체를 통째로 새로 만든다. 자릿수가 많으면 O(n²)로 느려진다. 리스트는 mutable이라 append가 O(1)이고, 마지막에 ''.join()으로 한 번만 합치니까 전체가 O(n)이다. 이 문제 크기에서는 체감 차이가 없어서 세 방식 모두 정답으로 인정되지만, 시험 빈칸/디버깅 답안은 보통 출제자 스타일인 리스트 + join 패턴에 맞추는 게 안전하다.

수업 중 질문: reversed() 파라미터로 리스트 말고 가능한 거 뭐 있어? q_digit[::-1]과 비교하면 원본 리스트를 반대로 뒤집는 건가?

reversed()는 len()과 인덱스 접근([i])이 되는 시퀀스 타입에 다 쓸 수 있다. list, tuple, str, range, dict(Python 3.8+) 모두 가능하지만 set, zip, map, filter 같이 한 방향으로만 흐르는 iterator는 불가능하다. 그리고 reversed()도 [::-1]도 원본은 그대로 둔다. 원본을 진짜 뒤집는 건 lst.reverse() 메서드(in-place, 반환값 None)이다.

16차에 정착시킨 "원본 보존" 의식의 연장선상에서 보면, reverse()/sort()처럼 반환값이 None인 메서드는 함정용 디버깅으로 자주 등장한다.

9번 — number를 target으로 만드는 최소 연산 횟수

+1, -1, ×2 세 연산으로 number를 target으로 만드는 최소 횟수를 구한다. 그리디로는 불가능하고 BFS(너비 우선 탐색) 최단 거리로만 풀린다. 학습 초기에 합격 기댓값(부분형 7 + 완성형 1 = 600점+) 기준으로 BFS/DFS는 의도적으로 제외 결정한 영역이라, 시험에서 함수 작성으로 나오면 손절이 정답이다.

다만 빈칸 채우기로 나올 때를 대비해 BFS 골격을 알아보는 키워드만 인지하면 된다.

from collections import deque

def solution(number, target):
    visited = {number}
    queue = deque([(number, 0)])     # (현재값, 횟수)
    while queue:
        cur, cnt = queue.popleft()   # ← popleft가 보이면 BFS
        if cur == target:
            return cnt
        for nxt in (cur + 1, cur - 1, cur * 2):
            if nxt not in visited:
                visited.add(nxt)
                queue.append((nxt, cnt + 1))

deque / popleft() / visited set / (상태, 횟수) 튜플 — 이 네 개가 보이면 BFS 유형이라고 즉시 판단하면 된다.

시험 전날 공식 총정리 — 마지막 한 번 훑기용

🔥 무조건 외울 공식 (그 자리에서 못 만드는 것)

1. 진법 변환

int(s, p)                                  # p진법 문자열 → 10진법 정수
# 10진법 → q진법
digits = []
while n > 0:
    digits.append(str(n % q))
    n //= q
return ''.join(reversed(digits))

2. 자릿수 분해 — 진법 변환의 q=10 특수 케이스

while n > 0:
    digit = n % 10            # 마지막 자리
    n //= 10                  # 한 자리 떨구기

3. 시계 각도 — 외워야 풀린다

hour_angle = h * 30 + m * 0.5    # 시침 (분 기여도 +0.5도/분)
min_angle  = m * 6               # 분침 (6도/분)
diff = abs(hour_angle - min_angle)
answer = min(diff, 360 - diff)   # 큰 각도 처리

4. 소수 판별 √n 최적화

def is_prime(n):
    if n < 2: return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

5. GCD / LCM

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    return a // gcd(a, b) * b    # 오버플로우 안전 형태

6. 90도 회전

# 시계방향 90도
rotated[i][j] = arr[n-1-j][i]                    # 인덱스 공식
rotated = list(map(list, zip(*arr[::-1])))       # zip 패턴 (먼저 뒤집고 전치)

# 반시계방향 90도
rotated[i][j] = arr[j][n-1-i]                    # 인덱스 공식
rotated = list(map(list, zip(*arr)))[::-1]       # zip 패턴 (전치 후 행 뒤집기)

7. dx/dy 좌표 이동

dx = [-1, 1, 0, 0]    # 상 하 좌 우 (행 기준)
dy = [0, 0, -1, 1]
if 0 <= nx < n and 0 <= ny < m:    # 양쪽 차원 다 체크
    ...

8. 이진 탐색 템플릿

left, right = 0, len(arr) - 1
while left <= right:
    mid = (left + right) // 2      # ← // 정수 나눗셈 (디버깅 빈출)
    if arr[mid] == target: return mid
    elif arr[mid] < target: left = mid + 1
    else: right = mid - 1
return -1

⚡ 반사 신경 패턴 (보면 바로 떠올라야)

🚨 함정 체크리스트 (시험 직전 환기)

1. reverse() vs reversed() vs [::-1] — 반환값 / 원본 변경 여부 다름
2. 내장함수명 변수 사용 금지 — sum, dict, type, str, list, map, filter
3. / vs // — 인덱스 / 정수 계산엔 무조건 //
4. 빈 컨테이너 체크 누락 — while stack / if not arr
5. 값 기반 중복 체크 함정 — 좌표 / 인덱스 기반 visited로 전환
6. 데이터 변환 후 원본 소실 — 변환용 따로, 반환용 원본
7. "테스트 통과 but 식 버그" — 풀이 후 극단 입력 상상(빈 입력, 한 개짜리, 한쪽만)

🎯 시험장 판단 매뉴얼

오늘의 결과

5차 미해결 3문제 모두 분석 완료, 그중 5번은 누락 디테일 한 줄 보강만으로 자력 가능, 6번은 진법 변환 공식 두 개로 압축, 9번은 손절 영역으로 분류했다. 학습 이력 전체에서 외울 가치 있는 공식 8개와 반사 신경 패턴 10개, 함정 체크리스트 7개, 시험장 판단 매뉴얼 6개를 한 페이지로 정리했다. 다음은 시험 당일 — 이 글 한 장만 시험 직전에 다시 훑고 들어가는 것으로 마무리한다.

27차(5/13)에서 구름EDU 기출 4회차를 73분에 풀어 8/10 통과했고, 통과한 답에서도 식 버그가 2건 발견된 "테스트 통과 but 식 버그" 패턴을 확인했다. 재귀 멘탈 모델·시계 각도 공식·자릿수 분해 패턴·itertools.permutations·max(default=-1) 다섯 가지를 신규 학습했다. 함수 작성 6세션 연속 자력 정답 추세를 유지한 상태였다.

오늘 수업 계획

구름EDU 기출 6회차를 90분 풀타임 모의고사로 진행한 뒤, 자력으로 통과한 문제까지 포함해 7문제를 검산 모드로 복기했다. 어제 발견한 "테스트 통과 but 식 버그" 패턴을 한 번 더 의식하면서 본인이 통과처럼 보이는 답에 자가 의심을 끼워 넣는 흐름으로 진행했다.

COS Pro 1급 Python / Phase 3: 실전 대비

모의고사 결과

자력 통과 5문제(4·5·8·9·10), 자가 의심 후 자력 수정 3문제(2·3·7), 힌트 후 자력 해결 2문제(1·6)로 정리됐다. 막힌 1번에 시간을 더 끌지 않고 8·9·10번을 자력으로 마무리한 시험장 판단력은 4회차와 일관됐다.

학습 내용 정리

1번: 꽃피는 봄 — 시뮬레이션 동기성 함정

n×n 격자에서 핀 꽃(1)이 매일 상하좌우 4방향으로 한 칸씩 퍼진다. 모든 칸이 필 때까지 며칠이 걸리는지 구한다.

처음 작성한 코드:

def solution(n, garden):
    answer = 0
    bloom = garden[::]                    # 얕은 복사
    dr = [-1, 0, 1, 0]
    dc = [0, 1, 0, -1]

    while any(any(v == 0 for v in row) for row in bloom):
        for i in range(n):
            for j in range(n):
                if bloom[i][j]:
                    for d in range(4):
                        ni, nj = i + dr[d], j + dc[d]
                        if 0 <= ni < n and 0 <= nj < n:
                            bloom[ni][nj] = 1     # 같은 bloom을 읽으면서 수정
        answer += 1
    return answer

핵심 버그: bloom을 읽으면서 같은 bloom을 수정하기 때문에, 같은 날 안에서 갓 핀 꽃이 또 다음 칸을 피우는 연쇄가 일어난다. 예시 1을 한 번 따라가보면 다음과 같다.

초기:        1일째 끝나야 할 모습:
0 0 0        0 1 0
0 1 0   →    1 1 1
0 0 0        0 1 0

(1,1)만 1이니 4방향 4칸만 1로 바뀌어야 한다. 그런데 위 코드는 루프가 (1,1)을 처리한 뒤 (1,2)에 도착했을 때 방금 1로 바뀐 (1,2)를 또 보고 (0,2), (2,2)까지 1로 만들어버린다. 결국 한 번의 while 반복으로 거의 모든 칸이 피어버린다.

해결 — 오늘 시점 스냅샷과 내일 결과를 쓸 곳을 분리한다.

def solution(n, garden):
    answer = 0
    bloom = [row[:] for row in garden]      # 2차원 깊은 복사
    dr = [-1, 0, 1, 0]
    dc = [0, 1, 0, -1]

    while any(any(v == 0 for v in row) for row in bloom):
        today = [row[:] for row in bloom]   # 오늘의 스냅샷
        for i in range(n):
            for j in range(n):
                if today[i][j]:             # 읽기는 today
                    for d in range(4):
                        ni, nj = i + dr[d], j + dc[d]
                        if 0 <= ni < n and 0 <= nj < n:
                            bloom[ni][nj] = 1   # 쓰기는 bloom
        answer += 1
    return answer

2차원 깊은 복사 패턴

2차원 배열을 안전하게 복사하려면 무조건 행 단위 컴프리헨션 패턴을 써야 한다. 시뮬레이션 문제에서 매우 자주 나오니 외워두면 좋다.

슬림화 포인트

처음에 if all(all(v == 1 for v in row) for row in garden): return 0 같은 초기 분기를 넣어뒀었는데, 아래의 while any(any(v == 0 ...))가 이미 이 케이스를 처리한다. 전부 1이면 while 진입을 안 하고 answer = 0 그대로 반환한다.

"이 분기, 빼도 답 같지 않은가?"

23차에 짚었던 슬림화 자기 점검 질문이다. 이번엔 피드백 1회 후 곧장 자력 삭제로 정리됐다.

2번: 단어 순서대로 적기 — 공백을 두 번 세지 않기

한 줄에 K자를 적을 수 있는 메모장에 영어 단어를 순서대로 적는다. 단어 사이는 공백 1칸으로 구분하며, 줄 끝에 단어가 잘리지 않도록 다음 줄로 넘긴다. 단어 배열을 모두 적었을 때 몇 줄이 되는지 구한다.

처음 작성한 코드:

def solution(K, words):
    answer = 0
    current = 0
    for word in words:
        if (current + len(word) + 1) // K > 0:    # 줄바꿈 판단
            answer += 1
            current = len(word)
        else:
            current += len(word) + 1
    return answer

수업 중 질문: 글자 사이 공백을 잘 고려했는지 모르겠다고 했다.

자가 의심이 정확했다. 통과 답에 식 버그가 있다.

버그 1 — 마지막 줄 카운트 누락

answer는 줄바꿈이 일어날 때만 증가한다. 마지막 단어가 같은 줄에 들어가면(else) 그 줄은 세지 않고 끝난다.

solution(10, ["nice"])
# 정답: 1줄, 코드 결과: 0

버그 2 — 공백을 두 번 카운트

첫 단어 nice를 처리할 때 current = 0 + 4 + 1 = 5로 저장한다. nice 뒤에 공백 한 칸을 미리 붙인 형태다. 그런데 다음 단어 c를 추가할 때 또 current + len(word) + 1로 공백을 더한다.

K=5, ["ab", "c", "d"]로 따라가보면:

정답은 2줄 (ab_c 4칸 한 줄, d 한 줄)인데 코드는 1을 반환한다. 공백이 한 번 들어가야 할 자리에 두 번 카운트돼서 발생한 어긋남이다.

수정 코드

def solution(K, words):
    answer = 1
    current = 0
    for word in words:
        if current == 0:                              # 첫 단어
            current = len(word)
        elif current + len(word) + 1 > K:             # 줄바꿈 필요
            answer += 1
            current = len(word)
        else:
            current += len(word) + 1                  # 같은 줄에 공백 + 단어
    return answer

세 가지가 동시에 해결된다.

1. answer = 1로 시작 — 단어가 있으면 줄은 무조건 1개 이상
2. 첫 단어 분기 — 공백 없이 단어만 더함
3. <= K 대신 > K로 명시적 비교 — // 같은 트릭 없이 직관적

3번: 큰수와 작은수의 차이 — combinations은 함정이다

자연수 배열 arr에서 K개를 골라 (가장 큰 수 - 가장 작은 수) 차이가 최소가 되도록 한다. 처음 작성한 코드:

from itertools import combinations

def solution(arr, K):
    coms = set(combinations(arr, K))
    diff = 9999
    for tp in coms:
        diff = min(max(tp) - min(tp), diff)
    return diff

수업 중 질문: 숫자 4개를 순서 상관없이 뽑아야 해서 combinations을 떠올렸는데, arr_len이 최대 1000까지 될 수 있다는 제약을 보고 시간복잡도가 괜찮을지 걱정된다고 했다.

자가 의심이 정확했다. C(1000, 50) ≈ 9 × 10⁸⁵는 우주의 원자 수(약 10⁸⁰)보다 많다. 메모리도, 시간도 절대 못 버틴다.

핵심 인사이트 — 정렬된 배열에서 K개 뽑을 때 차이 최소화는 무조건 연속된 K개다

예: 정렬된 [4, 6, 9, 9, 11, 19]에서 K=4

비연속으로 뽑으면 어딘가 더 먼 수가 끼게 되니 차이가 같거나 더 커진다. 그래서 정렬 + 슬라이딩 윈도우로 풀면 된다.

수정 코드

def solution(arr, K):
    arr_tmp = sorted(arr)                                 # 원본 보존
    answer = arr_tmp[K-1] - arr_tmp[0]                    # 첫 윈도우 초기값
    for i in range(1, len(arr_tmp) - K + 1):              # 둘째 윈도우부터
        diff = arr_tmp[i + K - 1] - arr_tmp[i]
        answer = min(answer, diff)
    return answer

시간복잡도 O(n log n). 정렬 비용이 전부다.

한 코드에 세 가지 정착 패턴이 동시 발현

4번: 카드 섞기 — 인덱스 디버깅 한 줄

1부터 n까지 적힌 카드 뭉치를 반으로 나눠 교대로 섞는 과정을 mix번 반복한 뒤, 아래에서 k번째 카드를 구한다. 디버깅 유형(한 줄 수정)이고 본인이 자력으로 정답을 찾았다.

원본 버그:

card_a, card_b = [0 for _ in range(n//2)], [0 for _ in range(n//2)]
for i in range(0, n):
    if i < n//2:
        card_a[i] = card[i]
    else:
        card_b[i] = card[i]   # 버그: card_b 크기는 n//2인데 i가 n//2~n-1 들어감

본인 진단: "후반 1/2를 저장하는 배열 b에 인덱스를 원본 배열 그대로 넣어서 에러가 나는 것으로 보임."

card_b의 크기는 n//2(=3)인데 i가 3, 4, 5일 때 card_b[i]로 접근하면 IndexError가 난다.

수정: card_b[i - (n//2)] = card[i]

i=3 → card_b[0], i=4 → card_b[1], i=5 → card_b[2]로 후반부를 0부터 다시 채운다. 한 라인 안에서 두 토큰(i와 괄호 보정)을 동시에 바꾼 디버깅이지만 "한 줄 수정" 제약은 코드 라인 단위라 그대로 통과한다.

5번: 코인 획득 — DP 자력 발현

4×4 격자의 가장 왼쪽 위에서 가장 오른쪽 아래까지 오른쪽 또는 아래로만 이동하면서 코인을 최대로 모은다. 디버깅 한 줄 유형이고 본인이 자력 정답을 찾았다.

원본 버그:

else:
    coins[i][j] = board[i][j] + max(coins[i][j], coins[i-1][j-1])
    # max 안: 자기 자신(0) vs 대각선(도달 불가)

수정: max(coins[i-1][j], coins[i][j-1])

오른쪽 또는 아래로만 이동하니까 (i, j)에 도달하기 직전 위치는 위 (i-1, j) 또는 왼쪽 (i, j-1)이다. 그중 큰 누적값을 골라 현재 칸 값에 더한다.

coins[0]: [6, 13, 14, 16]
coins[1]: [9, 18, 21, 30]
coins[2]: [15, 22, 27, 32]
coins[3]: [22, 25, 29, 38]   ← 정답 38

26차에 학습한 DP 마지막 동작 패턴이 자력 발동한 형태다. 26차에선 힌트가 필요했는데 이번엔 디버깅 문제에서 의도를 스스로 짚어냈다.

6번: 만남 최대 — 한 라인 안 인덱스 4토큰 보정

4×4 종이를 가로 또는 세로축에 평행한 격자선을 따라 한 번 접었을 때, 만나는 두 칸의 합이 최대가 되도록 한다. 디버깅 한 줄 유형이다.

원본 코드:

for i in range(4):
    for j in range(4):
        for k in range(j + 1, 4, 2):    # step 2
            answer = max(answer,
                         max(grid[i][j] + grid[j][k],
                             grid[i][j] + grid[k][i]))   # 9번 라인

수업 중 질문: 맨 안쪽 for의 step 2가 처음엔 이해되지 않아 숫자를 대입해보면서 의미를 파악하려고 했다고 했다.

step 2의 의미 — (j, k) 쌍은 한 번 접으면 만날 수 있는 두 인덱스 쌍을 만든다. 합이 홀수일 때만 가능하다.

j+k가 짝수이면 접는 선이 칸 한가운데에 떨어져 물리적으로 접을 수 없다. step 2가 이 제약을 자동으로 걸러낸다.

9번 라인의 진짜 버그 — 인덱스가 어긋남

(j, k) 쌍을 받은 다음, 어떻게 활용해야 만나는 두 칸이 되는지 정리하면 다음 두 경우다.

원본 코드는:

• grid[i][j] + grid[j][k] — (i, j)와 (j, k)는 같은 행도 같은 열도 아니다. 행이 어긋남
• grid[i][j] + grid[k][i] — (i, j)와 (k, i)도 마찬가지로 열이 어긋남

수정: grid[i][j] + grid[i][k], grid[j][i] + grid[k][i]

한 라인 안에서 4개 토큰(j→i, j→i, i→j, i→j)을 동시에 바꿔야 한다. 4번 카드 섞기에 이어 한 라인 안 다중 토큰 보정이 2회 연속 성공한 형태다.

7번: UP AND DOWN — "처음 가설과 max를 합쳤어야 했다"

출제자가 1~K 중 하나의 자연수를 정한다. 참가자가 수를 부르면 출제자는 자기 수보다 작을 때 "UP", 클 때 "DOWN", 같을 때 "RIGHT"이라고 한다. 주어진 게임 진행에서 현재 정답이 될 수 있는 숫자가 몇 개인지 구하는 빈칸 채우기 문제다.

본인이 채운 풀이:

def solution(K, numbers, up_down):
    left = 1
    right = K
    for num, word in zip(numbers, up_down):
        if word == "UP":
            left = max(num, left)
        elif word == "DOWN":
            right = min(num, right)
        elif word == "RIGHT":
            return 1
    return right - left - 1

본인의 풀이 흐름 — 처음엔 left = num + 1, right = num - 1로 정확히 1씩 보정하려 했다. 그런데 예시 2번이 "2 UP" 다음 "1 UP"으로 들어와서 단순 대입을 했더니 left가 3에서 2로 회귀하면서 망가졌다고 했다. 그래서 +1을 빼고 max(num, left)로 바꾼 뒤, 마지막에 right - left - 1로 양 끝을 빼는 방식으로 우회했다고 했다.

자가 분석이 정확한 방향이었지만 검증 시 한 가지가 더 어긋난다.

반례

K = 10
numbers = [5]
up_down = ["DOWN"]
# 정답: 1, 2, 3, 4 → 4개
# 코드: right = 5, left = 1 → 5 - 1 - 1 = 3 (틀림)

right - left - 1은 left와 right가 둘 다 후보 바깥 경계값이어야 의미가 맞는 공식인데, 초기값 left=1, right=K는 본인이 후보가 될 수 있는 값들이다. left가 한 번도 안 바뀌면 1이, right가 한 번도 안 바뀌면 K가 후보에서 빠져버린다.

해법 — 빈칸 채우기라 초기값을 못 바꾸므로 max에 +1을 다시 끼워 넣는다

if word == "UP":
    left = max(num + 1, left)            # +1 다시 추가
elif word == "DOWN":
    right = min(num - 1, right)          # -1 다시 추가
elif word == "RIGHT":
    return 1
return right - left + 1                  # 양 끝 포함

max(num + 1, left)로 감싸면 "2 UP 다음 1 UP" 같은 약한 정보도 자연히 무시된다. left가 3에서 1+1=2로 후퇴할 일이 없다 (max로 보호되니까).

검산:

solution(10, [5], ["DOWN"])
# right = min(4, 10) = 4
# left = 1
# 4 - 1 + 1 = 4  ✓

수업 중 메타 정리 (본인 발화): "처음 생각한 거랑 max 아이디어 합쳤어야 했네."

이게 시험장 디버깅의 핵심 사고다. 첫 가설 +1/-1이 틀린 게 아니라 단순 대입 때문에 깨졌던 것이고, max 도입이 그 깨짐의 보호막이었다. 가설을 통째로 버릴 게 아니라 깨진 원인만 찾아 합치면 답이 나온다.

"테스트 통과 but 식 버그" 누적 3건

27차에 2건(시계, 소수), 오늘 7번 UP/DOWN으로 누적 3건이 됐다. 모두 본인이 통과 처리받은 답에 식 자체의 버그가 숨어있던 케이스다.

오늘 의미 있게 달라진 건, 2번·3번·7번에서 본인이 통과한 답에 자가 의심을 자발적으로 발화했다는 점이다.

• 2번: "공백을 잘 고려했는지 모르겠음"
• 3번: "arr_len 1000인데 시간복잡도 괜찮을까?"
• 7번: 풀이 흐름 메타 정리

자가 의심이 자발적으로 작동하기 시작하면, 같은 함정이 시험장에서도 잡힌다. 풀이 후 한 박자만 두고 극단 입력 하나만 상상하는 습관이 D-2 환기 포인트다.

오늘의 결과

구름EDU 6회차 풀타임 모의고사 77분에 9문제 자력 풀이, 추정 800점대 안정으로 합격선 한참 위였다. 시뮬레이션 동기성 패턴(2차원 깊은 복사 포함)을 신규 학습했고, 슬라이딩 윈도우·DP·슬림화·한 라인 다중 토큰 보정 4가지의 자력 발현/정착을 확인했다. 내일은 5차 기출 미해결 구현 3개와 구현 집중 연습을 진행할 예정이다.

26차(5/12)에서 5차 기출 7문제 스터디 풀이를 복습하고 오답 총복습을 진행했다. DP 마지막 동작 패턴과 range 역순 3가지 방식을 정리했고, 90도 회전·스택·값 기반 중복 체크 함정의 정착을 재확인했다. D-4 기준 주요 약점 없이 90분 풀타임 모의고사 단계로 진입한 상태였다.

오늘 수업 계획

구름EDU 기출 4회차를 90분 풀타임 모의고사로 진행한 뒤, 통과했지만 찝찝한 문제와 못 푼 2문제를 검산 모드로 복기했다. 시험 환경을 흉내내기 위해 검색·AI 도움 없이 90분 안에 풀어내는 형태로 진행했다.

COS Pro 1급 Python / Phase 3: 실전 대비

모의고사 결과

못 푼 2개에 시간을 더 매달리지 않고 마무리한 것이 시험장 판단력 측면에서 의미가 있었다. 실제 시험에서도 모르는 문제에 30분 매달리는 것보다 손절하고 다른 문제로 넘어가는 것이 합격선 확보에 유리하다.

학습 내용 정리

1번: 재귀 — 함수가 자기 자신을 호출하는 형태

A, E, I, O, U 다섯 알파벳으로 만들 수 있는 길이 1~5의 모든 단어를 사전 순으로 나열했을 때, 주어진 word의 위치를 return하는 문제다. 한 줄을 수정하는 디버깅 유형이다.

def create_words(lev, s):
    global words
    VOWELS = ['A', 'E', 'I', 'O', 'U']
    words.append(s)
    for i in range(0, 5):
        if lev < 5:
            create_words(lev, s + VOWELS[i])   # 버그: lev 그대로 0

버그: lev가 계속 0이라 lev < 5가 영원히 True → 무한 재귀가 발생한다.

수정: create_words(lev + 1, s + VOWELS[i]) — 다음 호출에 깊이 한 단계 더한 값을 인자로 넘긴다.

수업 중 질문: 함수 안에서 자기 자신을 호출하는 형태 자체가 어렵다고 했다. lev += 1을 다른 줄에 넣어봤더니 결과가 달라서 이해되지 않았다고 했다.

재귀의 핵심 멘탈 모델

각 호출은 자기만의 독립된 lev, s를 가진다. create_words(lev+1, ...)은 새로운 호출에 새 값을 인자로 넘기는 것이지, 위쪽 호출의 lev를 바꾸는 게 아니다.

create_words(0, '')        ← 이 호출의 lev는 0, 영원히 0
   ↓ 새 호출 만듦
   create_words(1, 'A')    ← 이 호출의 lev는 1, 위의 0과 별개
      ↓
      create_words(2, 'AA') ← lev=2, 또 별개

Java로 비유하면 return sum(n-1) + n 같이 새 값을 인자로 넘기는 형태와 같다. 위쪽 호출의 n을 바꾸는 게 아니다.

lev += 1을 다른 줄에 넣으면 어떻게 되는가

def create_words(lev, s):
    words.append(s)
    lev += 1                    # 여기 넣으면 길이 5짜리가 누락된다
    for i in range(0, 5):
        if lev < 5:
            create_words(lev, s + VOWELS[i])

lev=4로 진입(s='AAAA')하면 lev += 1로 lev=5가 되고 if lev < 5가 False가 된다. 자식 호출이 0번이라 'AAAAA' ~ 'AAAAU' 다섯 단어가 누락된다. 그래서 결과가 달랐던 것이다.

재귀 빈칸/디버깅 체크리스트

1. 종료 조건이 있는가 — 여기선 if lev < 5
2. 호출할 때 값이 진행하는가 — lev+1, s + 글자처럼 뭔가 한 칸 나아가야 한다. 안 그러면 무한 루프다
3. 각 호출은 독립 — 인자 새로 넘기는 거지 바깥 호출 변수를 바꾸는 게 아니다

9번: 시계 시침과 분침의 각도 — 외우는 공식

hour:minute일 때 아날로그 시계의 시침과 분침이 이루는 각도를 구하는 문제다. 본인이 제출한 답:

def solution(hour, minute):
    h_angle = hour / 12 * 360 % 360
    m_angle = (60-minute) / 60 * 360 % 360
    answer = max(h_angle, m_angle) - min(h_angle, m_angle)
    return "{:.1f}".format(answer)

제출은 통과했지만 식에 버그가 3개 있다. 테스트가 약해서 우연히 통과한 케이스다.

버그 1: 시침의 분 기여도 누락

3:30일 때 시침은 3을 정확히 안 가리키고 3과 4 사이에 있다. 분침이 한 바퀴 돌 때마다 시침도 30° 움직이므로, 시침에 minute * 0.5를 더해야 한다.

버그 2: 분침이 반대로 돈다

(60-minute)/60 * 360은 분침을 반시계 방향으로 돌린다.

m=0과 m=30에서만 우연 일치한다. 4회차 테스트가 이 두 케이스만 있어서 통과한 것으로 보인다.

버그 3: 큰 각도 처리 누락

9:00일 때 시침 270°, 분침 0°. 보통 "이루는 각"은 작은 쪽(90°)을 답한다. 본인 식은 270을 반환한다. min(diff, 360 - diff)로 마무리해야 안전하다.

정답 코드와 외울 공식

def solution(hour, minute):
    h_angle = hour * 30 + minute * 0.5
    m_angle = minute * 6
    diff = abs(h_angle - m_angle)
    answer = min(diff, 360 - diff)
    return "{:.1f}".format(answer)

이 유형은 공식을 모르면 풀 수 없다. 외워두는 게 답이다.

6번: 자아도취 수 — 자릿수 분해 패턴

세 자리 자아도취 수: 153 = 1³ + 5³ + 3³. 각 자릿수를 k 제곱해서 더한 값이 원래 수와 같은 자연수다. 빈칸 2개를 채우는 문제였는데 풀지 못했다.

while current != 0:
    calculated += power(current % 10, k)   # 빈칸 1
    current //= 10                          # 빈칸 2

핵심 패턴 — % 10 + // 10 한 쌍

이 두 개가 짝지어 돌아가야 자릿수 분해가 된다. 153 추적:

수업 중 질문: while 조건이 current > 0이 아니고 != 0이라서 빈칸에 탈출 조건을 만들어야 하는데 어떻게 만들어야 할지 모르겠다고 했다.

이게 가장 중요한 오해 지점이었다. 탈출 조건을 빈칸에 넣는 게 아니다. current //= 10이라는 데이터 변형이 매 반복마다 current를 줄여 결국 0에 도달하게 만들고, 그 결과로 current != 0이 자연히 False가 되는 것이다. 탈출은 데이터 변형의 부산물이지 빈칸의 목적이 아니다.

100부터 시작해도 → 10 → 1 → 0이 되니까 3번 만에 탈출한다. 999부터 시작해도 → 99 → 9 → 0이라 마찬가지로 3번이다.

또 current % 100을 끝 두 자리(53)로 가져온다는 점도 함께 짚었다. 한 자리만 뽑으려면 무조건 % 10이다.

자주 나오는 응용:

• 자릿수 합 구하기
• 자릿수 뒤집기 (12345 → 54321)
• 한수, 자아도취 수, 회문수
• 진수 변환 (10진 → 2진 등)

# 외워둘 자릿수 분해 템플릿
while n != 0:
    digit = n % 10
    # digit으로 뭔가 처리
    n //= 10

8번: n번째로 작은 수 — itertools.permutations

숫자 카드 배열로 만들 수 있는 모든 수를 작은 순으로 정렬했을 때, n이 몇 번째인지 구하는 문제다.

본인 시도는 Counter로 카드와 n의 자릿수를 비교해 다르면 -1을 반환하는 부분까지 진행했고, 그 뒤가 막혔다. 핵심 도구는 itertools.permutations다.

from itertools import permutations
from collections import Counter

def solution(card, n):
    digits = [int(c) for c in str(n)]
    if Counter(card) != Counter(digits):
        return -1
    perms = sorted(set(permutations(card)))
    target = tuple(digits)
    return perms.index(target) + 1

combinations vs permutations

10차에서 배운 combinations의 동생격이다.

set이 필요한 이유: permutations는 위치(인덱스) 기반이라 [1,2,1,3]처럼 같은 숫자가 있으면 동일한 순열이 여러 번 나온다. 첫 번째 1(card[0])과 두 번째 1(card[2])을 다른 카드로 취급하기 때문이다. 값으로 봤을 땐 같은 순열이니 set()으로 묶어야 정확한 등수가 나온다.

응용 연습: 가장 큰 짝수 만들기

permutations를 손에 익히기 위해 출제된 응용 문제다.

from itertools import permutations

def solution(cards):
    digits = []
    for perm in set(permutations(cards)):
        num = int(''.join(map(str, perm)))
        if num % 2 == 0:
            digits.append(num)
    return max(digits, default=-1)

7개 테스트 케이스 모두 통과했다. 첫 학습 직후 응용 문제를 자력으로 푼 경우다.

튜플 → 정수 변환: int(''.join(map(str, perm))) 패턴이다. (3, 1, 2)를 312로 만든다.

max(default=-1): max는 빈 리스트에서 에러를 내는데, default 인자로 빈 시퀀스일 때 반환할 값을 지정할 수 있다.

수업 중 슬림화 포인트: 처음에 sorted(set(permutations(cards)))로 정렬했지만, max()로 최댓값만 뽑을 거면 정렬이 필요 없다. 정렬은 O(n log n) 비용이 들지만 결과엔 영향이 없다.

"이 연산 정말 필요한가? 빼도 결과 같지 않은가?"

함수 작성 후 자기 점검 단계로 들어가야 할 메타 질문이다. 23차에 짚었던 슬림화 의식 영역으로, 27차에 1회 재발했다.

10번: 소수의 세제곱 — "통과해도 식 버그" 패턴

a 이상 b 이하 자연수 중 소수의 제곱수와 세제곱수의 개수의 합을 구하는 문제다. 본인이 제출한 답:

def solution(a, b):
    answer = 0
    nums = [2]                            # 소수 2를 미리 넣음
    for n in range(3, b+1):
        i = 2
        for j in range(i, n):
            if n % j == 0:
                break
            if j == n-1:
                if a<=n*n<=b:
                    nums.append(n)
                if a<=n*n*n<=b:
                    nums.append(n)
    answer = len(nums)
    return answer

수업 중 질문: 소수 2를 미리 넣고 3부터 보기 시작하는 방식이 괜찮은지 물어봤다.

답은 "버그다. 테스트가 약해서 통과한 것"이다. nums = [2]로 2를 무조건 카운트에 포함하지만, 2² (=4) 또는 2³ (=8)이 [a,b] 범위에 있는지 확인하지 않는다.

근본 원인은 소수 판별 루프가 range(2, n)이라 n=2에선 inner loop가 비어버려 일반 루프에 못 넣은 것이다. 소수 판별을 함수로 분리하면 자연 처리된다.

수업 중 잘한 부분: 처음에 13라인과 15라인을 or로 연결했다가 답이 달라서 예시(3은 제곱과 세제곱 모두 범위 안)를 보고 분리한 부분이다. or로 묶으면 한 번만 카운트되지만 별도 if로 분리하면 둘 다 만족할 때 두 번 카운트된다. 직접 예시를 추적해서 검증한 것은 24차에 정착된 검증 습관이 지속되고 있는 신호다.

추가 이슈 — 시간복잡도

b는 최대 10⁹까지 가능한데 for n in range(3, b+1)로 루프를 돌면 절대 끝나지 않는다.

n² ≤ b이려면 n ≤ √b면 충분하니까 루프 상한을 √b로 줄일 수 있다.

b=10⁹여도 √b ≈ 31,623으로 한순간이다. 23차에 배운 √n 최적화를 소수 판별 자체에도 적용해야 한다.

정답 코드:

def is_prime(n):
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

def solution(a, b):
    answer = 0
    limit = int(b ** 0.5) + 1
    for n in range(2, limit + 1):
        if is_prime(n):
            if a <= n * n <= b:
                answer += 1
            if a <= n * n * n <= b:
                answer += 1
    return answer

메타: "테스트 통과해도 식 자체는 틀릴 수 있다"는 패턴

오늘 4회차에서 두 건 발견했다.

• 9번 시계: m=0, m=30 케이스에서만 우연 일치
• 10번 소수: a ≤ 8 또는 작은 b에서만 우연 일치

19차에서 짚었던 "주어진 테스트 전부 통과지만 반례에서 깨짐" 패턴이 이번엔 본인이 통과 처리받은 답에서 재발한 형태다. 실제 시험은 테스트가 더 엄격할 수 있으니, 풀이 후 반례를 직접 상상해보는 습관이 필요하다.

10번 nums=[2]에 대해 "이래도 되는걸까?"라고 자가 의심한 것 자체는 좋은 시작이다. 통과한 답에도 의심 가능한 메타인지가 발현된 것이다. 시험장에서는 시간 제약 때문에 모든 답을 의심할 순 없지만, 핵심 식만큼은 "반례 한 개 떠올려보기"를 의식적으로 끼워 넣자.

오늘의 결과

구름EDU 4회차 풀타임 모의고사 73분에 8/10 통과, 추정 800점대로 합격선 한참 위였다. 신규 학습 5건(재귀 멘탈 모델, 시계 각도 공식, 자릿수 분해 패턴, itertools.permutations, max default 인자)을 정리했다. 내일 6회차 풀타임 모의고사 예정이다.

25차(5/8)에서 10일 공백 후 전 영역 워밍업 11문제를 진행했고 11/11 1차 정답으로 컨디션 회복을 확인했다. 90도 회전 공식, 스택 패턴, 이진 탐색, 소수 판별 등 전 영역이 공백에도 안정적으로 유지됐다. 90분 타이머 모의고사 진입 가능 신호가 확정된 상태로 실전 대비를 이어가고 있다.

오늘 수업 계획

20260511 파이썬 스터디에서 구름EDU 5차 기출 7문제(구현형 제외)를 풀었다. 오늘은 전날 풀이를 함께 복습하고 부족한 개념을 보충했으며, 이후 D-4 기준 오답 총복습을 진행했다.

COS Pro 1급 Python / Phase 3: 실전 대비

학습 내용 정리

5차 기출 7문제 복습

1번: DP — 마지막 동작으로 경우 나누기

계단을 1칸, 2칸, 3칸씩 오를 수 있을 때, n번째 계단에 오르는 경우의 수를 구하는 문제다.

def solution(n):
    steps = [0 for _ in range(n+1)]
    steps[1] = 1
    steps[2] = 2
    steps[3] = 4
    for i in range(4, n+1):
        steps[i] = steps[i-1] + steps[i-2] + steps[i-3]
    return steps[n]

핵심 사고방식: "n번째에 어떻게 도착했는가"로 경우를 나눈다.

n번째 계단에 도달하는 방법:
  1. (n-1)번째에서 1칸 → steps[n-1]가지
  2. (n-2)번째에서 2칸 → steps[n-2]가지
  3. (n-3)번째에서 3칸 → steps[n-3]가지
→ steps[n] = steps[n-1] + steps[n-2] + steps[n-3]

수업 중 질문: 타일 채우기 연습 문제를 요청함.

# 타일 채우기 연습 — 1×n 타일을 1칸/2칸으로 채우는 방법의 수
def solution(n):
    tile = [0] * (n + 1)
    tile[1] = 1
    tile[2] = 2
    for i in range(3, n + 1):
        tile[i] = tile[i-1] + tile[i-2]  # 마지막 타일이 1칸/2칸
    return tile[n]

2번: 디버깅 — 부등호 방향

두 벽 사이에 담을 수 있는 물의 양은 낮은 벽 기준으로 계산해야 한다.

# 버그: walls[i][1] > walls[j][1] → i가 높으면 i 기준 (높은 쪽으로 계산)
# 수정: walls[i][1] < walls[j][1] → i가 낮으면 i 기준 (낮은 쪽으로 계산)
if walls[i][1] < walls[j][1]:
    area = walls[i][1] * (walls[j][0] - walls[i][0])

부등호 방향 실수는 디버깅 문제에서 자주 나오는 패턴이다.

3번: 디버깅 — right 범위

배열을 앞쪽은 오름차순, 뒤쪽은 내림차순으로 정렬하는 문제다. 중앙(mid)에 최대값을 배치하고 뒤쪽을 뒤집는 방식이다.

mid = (len(numbers) - 1) // 2
numbers[mid], numbers[len(numbers)-1] = numbers[len(numbers)-1], numbers[mid]
left = mid + 1
right = len(numbers) - 2  # 버그 수정: -1이 아닌 -2 (이미 swap된 마지막 인덱스 제외)

8번 줄에서 numbers[-1]이 이미 mid와 swap됐기 때문에 right는 len-2부터 시작해야 한다.

4번: 디버깅 — range 역순

숫자를 큰 자릿수부터 읽기 위해 역순으로 순회해야 한다.

# 버그: range(10) → 0,1,...9 순서 → "122134" 출력
# 수정: range(9, -1, -1) → 9,8,...0 순서 → "413221" 출력
for i in range(9, -1, -1):
    if number_count[i] != 0:
        answer += (str(i) + str(number_count[i]))

수업 중 질문: range 역순 말고 다른 방법이 있냐고 질문했다.

# 방법 1: range(9, -1, -1)
# 방법 2: reversed(range(10))  ← 인덱스 역순에 가장 가독성 좋음
# 방법 3: my_list[::-1]         ← 리스트 자체를 뒤집을 때

# reversed()는 이터레이터를 반환
result = reversed([1, 2, 3])
print(list(result))  # [3, 2, 1] — list()로 변환해야 리스트

7번: Union-Find (그래프 사이클 탐지)

그래프에서 두 노드를 연결할 때 이미 같은 그룹이면 사이클이 생긴다.

def find(parent, u):        # u의 최상위 대표(루트) 찾기
    if u == parent[u]:
        return u
    parent[u] = find(parent, parent[u])  # 경로 압축
    return parent[u]

def merge(parent, u, v):    # 두 노드를 같은 그룹으로 합치기
    u = find(parent, u)
    v = find(parent, v)
    if u == v:
        return True         # 이미 같은 그룹 → 사이클!
    parent[u] = v
    return False

def solution(n, connections):
    parent = list(range(n + 1))  # [0,1,2,...,n]: 처음엔 자기가 자기 대표
    for i, connection in enumerate(connections):
        if merge(parent, connection[0], connection[1]):
            return i + 1
    return answer

수업 중 질문: parent가 왜 n+1개인지 질문했다.

노드 번호가 1,2,3이면 인덱스도 1,2,3으로 맞추기 위해 n+1 크기로 만든다.
parent[0]은 사용하지 않고 버린다. 그래야 노드 번호 = 인덱스가 돼서 직관적이다.

parent = list(range(n+1))       # 간결한 표현
parent = [i for i in range(n+1)]  # 같은 결과지만 변환이 없으면 list(range())가 더 명확

시험 전략: Union-Find는 코드 전체가 주어지고 빈칸 2개를 채우는 형태로 나온다. "사이클 = 이미 같은 그룹"과 빈칸 패턴(find(parent, parent[u]), parent[u] = v)만 기억해두면 충분하다.

8번: 공약수 구하기 — 함수 역할 파악 전략

세 함수의 역할을 각각의 return을 보고 먼저 파악한 뒤 solution을 채웠다.

# func_a: GCD (유클리드 호제법)
# func_b: 약수 개수 세기
# func_c: p가 q의 약수인지 여부

def solution(a, b, c):
    gcd = func_a(func_a(a, b), c)  # 세 수의 GCD: 두 번 연쇄 적용
    answer = func_b(gcd)            # gcd의 약수 개수
    return answer

23차에서 배운 LCM 누적 패턴(lcm(lcm(a,b), c))과 완전히 같은 구조다.

10번: 클래스 상속 — 계산기 만들기

클래스 구조도를 보고 상속 관계를 파악해 빈칸을 채웠다.

class PartTimeJob(Job):    # Job 상속
    def get_salary(self):  # 오버라이드

class SalesJob(Job):       # Job 상속
    def get_salary(self):  # 오버라이드

오답 총복습

값 기반 중복 체크 함정 (20차 약점)

경계 순회에서 arr[x][y] not in result로 중복을 체크하면 테두리에 같은 값이 여러 번 나올 때 누락이 생긴다.

# 값 기반 (위험)
if arr[0][j] not in result:
    result.append(arr[0][j])

# 좌표 기반 (안전)
if (0, j) not in visited:
    result.append(arr[0][j])
    visited.add((0, j))

경계 순회 → 무조건 좌표 기반 visited로 전환.

수업 중 질문: visited set에 좌표를 저장하는 방법을 물어봤다.

visited.add(0, j)    # ❌ TypeError: add()는 인자 하나만 받음
visited.add((0, j))  # ✅ 튜플을 하나의 인자로 전달

90도 회전 공식

rotated[i][j] = arr[n-1-j][i]

즉시 정답. 정착 재확인.

스택 괄호 매칭

def is_valid(s):
    stack = []
    for ch in s:
        if ch == '(':
            stack.append(ch)
        else:
            if not stack:      # 빈 스택 = 짝 없는 )
                return False
            stack.pop()        # 짝 맞추고 제거
    return len(stack) == 0     # 남은 게 없어야 완전 매칭

즉시 정답. 정착 재확인.

내장함수명 변수 사용 주의

str = ""    # ❌ 내장함수 str()이 덮어씌워짐
str(num)    # → TypeError 발생

# 변수명 블랙리스트: str, sum, list, dict, type, len, max, min
# 대체: result, total, items, data ...

오늘의 결과

5차 기출 7문제(스터디 풀이) 복습 완료, 부족했던 DP 패턴과 range 역순 개념 보충했다. 오답 총복습에서 90도 회전, 스택, 중복 체크 패턴 전 항목 정착 재확인했다. D-4 기준 주요 약점 없음. 내일부터 90분 풀타임 모의고사 2회 예정.

지난 세션(4/28)에서는 90도 회전 공식과 약수 함수 슬림화로 3문제 전부 1차 정답을 받았다. 8일 공백에도 arr[n-1-j][i] 공식을 정확히 떠올리며 정착 신호 확인. 함수 작성 4세션 연속 자력 정답으로 추세를 굳혔다.

오늘 수업 계획

시험까지 일주일 남은 시점에서 약 10일 만에 다시 책상 앞에 앉았다. 바로 90분 타이머 모의고사로 들어가는 건 무리라 판단해, 전 영역을 한 문제씩 가볍게 노출하는 워밍업 트랙을 짰다. 총 11문제. 자료형/조건/반복 → 리스트/문자열/딕셔너리/집합 → 정렬/함수/예외 → 스택/이진탐색/수학/구현 순서로, 지금까지 배운 모든 개념을 자연스럽게 한 번씩 점검한다. 컨디션 회복이 1차 목표, 90분 타이머 진입 가능 여부 진단이 2차 목표.

학습 내용 정리

1. 반복문 + 조건 (sum_multiples_of_3)

a부터 b까지(둘 다 포함) 정수 중 3의 배수의 합을 반환. 음수 입력도 처리해야 한다.

def sum_multiples_of_3(a, b):
    total = 0
    for i in range(a, b+1):
        if i % 3 == 0:
            total += i
    return total

한 줄 컴프리헨션 형태도 익혀두자 — 시험 빈칸으로 자주 나오는 형태.

return sum(i for i in range(a, b+1) if i % 3 == 0)

수업 중 질문: 테스트케이스 (-5, 5)의 기대값이 왜 3이지? -3 + 0 + 3이면 0 아닌가?

학습자가 첫 문제부터 출제자 검산을 시작했다. 정확한 지적이고 내 계산 실수였다. 정정: -3 + 0 + 3 = 0이 맞다. 참고로 Python에서 -3 % 3 == 0, 0 % 3 == 0 둘 다 성립하므로 n % 3 == 0 조건 하나로 음수까지 잘 잡힌다. 검증 습관이 10일 공백에도 살아있다는 좋은 신호.

2. 리스트 슬라이싱 + 컴프리헨션 (filter_reverse)

리스트를 뒤집은 후 k 이상인 값만 필터링.

def filter_reverse(nums, k):
    return [i for i in nums if i >= k][::-1]

인사이트: filter와 reverse는 교환 가능

문제는 "뒤집은 후 필터"였는데 풀이는 "필터한 후 뒤집기"다. 결과는 같다 — 둘 다 상대 순서를 보존하는 연산이라 교환 법칙이 성립하기 때문. 그리고 필터로 먼저 줄인 뒤 뒤집는 게 작업량이 더 적어서 살짝 효율적이기까지 하다.

[i for i in nums if i >= k][::-1]   # 효율적
[i for i in nums[::-1] if i >= k]   # 문제 그대로

→ 메모해둘 패턴: 두 연산의 순서를 바꿔도 결과가 같은지 자문하는 습관. 시험에서 빈칸 답이 두 형태 모두 정답인 경우가 종종 있다.

3. 문자열 회문 판별 (is_palindrome)

대소문자와 공백을 무시하고 회문 판별.

def is_palindrome(s):
    word = s.replace(" ", "").lower()
    return word == word[::-1]

2단계 공식: (1) 정규화(공백 제거 + 소문자), (2) word == word[::-1] 비교 한 줄. 회문 패턴은 손에 박힌 상태.

사이드 노트: 만약 숫자나 구두점도 무시해야 하는 강한 회문 문제라면 re.sub(r'[^a-z0-9]', '', word) 패턴이 필요하다. 오늘은 워밍업이라 안 갔지만 응용 문제에서 떠올릴 수 있게 익혀둔다.

4. 딕셔너리 / Counter — 가장 많이 등장한 글자 (most_char)

가장 많이 등장한 글자와 횟수를 튜플로. 동률이면 먼저 나온 글자 우선.

풀이 A — Counter 한 줄

from collections import Counter

def most_char(s):
    return Counter(s).most_common(1)[0]

동률 처리가 자동으로 되는 이유

• Counter는 dict 상속이라 삽입 순서를 보존 (Python 3.7+)
• most_common(n)은 내부적으로 heapq.nlargest를 쓰는데, 이건 동률일 때 입력 순서를 유지하는 안정 정렬
• 그래서 "먼저 등장한 글자"가 자동으로 앞에 옴

→ most_common(1)[0]은 거의 공식처럼 외워도 된다.

수업 중 질문: dict.get() 방식으로도 풀어보다가 막혔다. 이 코드는 왜 에러나?

tmp_dict = {}
for c in s:
    tmp_dict[c] = tmp_dict.get(c, 0) + 1
return max(tmp_dict, key=lambda x: x[1])   # IndexError 발생

원인은 max(tmp_dict, ...)가 딕셔너리에서 key만 꺼낸다는 것. 그래서 lambda x: x[1]의 x는 글자 한 개('a', 'p' 등)가 되고, 한 글자짜리 문자열에 x[1]을 하면 IndexError가 난다.

수정: .items()를 넘긴다.

return max(tmp_dict.items(), key=lambda x: x[1])

이렇게 하면 x가 ('a', 1) 같은 튜플이 되고 x[1]이 횟수가 된다. 그리고 동률 처리는 Counter 버전과 동일 — dict.items()가 삽입 순서로 순회하고 max는 먼저 본 max를 반환하므로 "먼저 등장한 글자"가 자동으로 우선된다.

자료구조와 순회 패턴 정리

max / min / sorted / for 모두 같은 규칙. 한 번 의식해두면 비슷한 에러 다시 안 난다.

5. 집합(set) 교집합 (common_chars)

두 문자열에 모두 등장하는 글자를 알파벳순으로.

def common_chars(a, b):
    return sorted(set(a) & set(b))

집합 연산자 4가지 (시험 빈출)

슬림화 체크 — 신규 약점 자연 노출

처음 작성한 풀이는 sorted(list(set(a) & set(b))) 였다. list() 호출이 불필요하다. sorted()는 어떤 iterable이든 받아서 항상 list를 반환하기 때문.

이게 4/27에 새로 잡힌 약점인 "불필요 변환/분기 추가" 패턴이다. 자연 노출에서 1회 발생. 의식하면 다음번엔 안 나올 가능성 높음.

함수 작성 후 자기 점검 한 마디:

"이 변환/분기 정말 필요한가? 자료구조나 호출 결과를 그대로 넘기면 사라지지 않나?"

6. 다중 정렬 (sort_students)

(이름, 점수) 튜플 리스트를 점수 내림차순, 동점이면 이름 오름차순으로 정렬.

def sort_students(students):
    return sorted(students, key=lambda x: (-x[1], x[0]))

튜플 key의 동작 원리

key=lambda x: (-x[1], x[0])
        ┌─────┐  ┌────┐
        점수    이름
        내림    오름

1. 첫 원소 -x[1]로 먼저 비교 → 음수로 만들어서 큰 점수가 앞에
2. 첫 원소가 같으면 둘째 원소 x[0](이름)으로 오름차순 비교
3. 튜플은 lexicographic 비교라 자동으로 1차 → 2차 정렬이 작동

→ 음수 트릭으로 내림차순 + 두 번째 키로 동률 처리. COS Pro 빈출 1순위 패턴.

7. 함수 (기본값) + 예외 처리 (safe_get)

nums[idx]를 안전하게 반환. 범위를 벗어나면 default 반환.

def safe_get(nums, idx, default=None):
    try:
        return nums[idx]
    except IndexError:
        return default

수업 중 질문: try/except 구문이 바로 안 떠올라서 옛날 자료를 찾아봤다. 나도 모르게 try-catch로 생각하고 있더라.

Java 출신이라 자연스러운 슬립이고, 7차 학습 이후 한 달 반 만의 자연 노출이라 더 그렇다. 로직은 완전히 손에 있는데 문법 키워드만 슬쩍 미끄러진 상태. 다시 굳히는 차원에서 매핑 정리.

Java → Python try/except 매핑

try:
    risky()
except IndexError as e:    # catch → except, (X) → as
    handle(e)
except (KeyError, ValueError):   # 여러 개 잡기 (튜플)
    handle()
else:                       # try가 예외 없이 끝났을 때만 (Java엔 없음)
    print("성공")
finally:
    cleanup()

시험 함정 포인트:

• return이 try에 있어도 finally는 반드시 실행된다
• else는 try가 예외 없이 끝났을 때만, except보다 먼저 위치

음수 인덱스가 자동 처리되는 점

nums[-1]은 마지막 원소를 정상 반환하고, 범위를 벗어난 음수(nums[-10] for len=3)에서만 IndexError를 던진다. C/Java라면 음수 인덱스 자체에서 별도 분기를 짜야 했을 텐데 Python은 한 줄에 처리됨.

8. 스택 — 다종 괄호 매칭 (is_balanced)

( ) [ ] { } 6가지 괄호의 짝과 순서를 모두 검사.

def is_balanced(s):
    pairs = {")": "(", "]": "[", "}": "{"}
    stack = []
    for c in s:
        if c in pairs.values():
            stack.append(c)
        elif c in pairs:
            if not stack or stack[-1] != pairs[c]:
                return False
            stack.pop()
    return not stack

정착 약점 두 개가 자연스럽게 등장

19차에서 학습한 두 가지가 다시 자연 재노출에서 안정적으로 나왔다.

• ✅ 무엇 저장: 여는 괄호를 스택에 쌓는다
• ✅ 빈 스택 체크: not stack 단락평가로 stack[-1] 호출을 보호

3가지 False 조건도 모두 처리:

1. 빈 스택에서 닫는 괄호 등장 (not stack)
2. 짝이 안 맞음 (stack[-1] != pairs[c])
3. 끝났는데 스택에 남은 여는 괄호 (return not stack)

마이크로 최적화 (시험엔 영향 없음)

c in pairs.values()는 매번 values 순회라 O(n)이고, c in pairs는 dict 해시라 O(1). 문자열 상수로 꺼내두면 더 빠르고 시험 답안 같은 느낌:

opens = "([{"
pairs = {")": "(", "]": "[", "}": "{"}
for c in s:
    if c in opens:
        stack.append(c)
    elif c in pairs:
        if not stack or stack[-1] != pairs[c]:
            return False
        stack.pop()

9. 이진 탐색 — 기본 템플릿 (binary_search)

정렬된 리스트에서 target 인덱스 반환. 없으면 -1.

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

디테일 4가지 — 시험 빈출 함정 포인트

• while left <= right (등호 포함, 원소 1개 케이스 처리)
• (left + right) // 2 (정수 나눗셈, /면 float이 되어 인덱싱 에러)
• mid + 1 / mid - 1 (무한루프 방지)
• 빈 리스트 자동 처리 (right = -1이라 루프 안 들어감)

/ vs // 디버깅 함정은 22차에서 직접 잡아본 문제. 그 경험이 자산이 됐다.

10. 수학 — 소수 판별 √n 최적화 (is_prime)

def is_prime(n):
    if n <= 1:
        return False
    i = 2
    while i * i <= n:
        if n % i == 0:
            return False
        i += 1
    return True

수업 중 질문: range(2, int(n**0.5) + 1) 이 형태는 뭐지?

while 형태와 완전히 같은 범위를 도는 for 형태다. 메커니즘만 다르다.

두 형태 비교

# 정수 연산만 사용 (안전)
i = 2
while i * i <= n:
    ...
    i += 1

# 동등한 for 형태 (sqrt 직접 계산)
for i in range(2, int(n**0.5) + 1):
    ...

조각조각 뜯어보면 (n=25 기준):

어느 쪽이 좋은가

→ COS Pro 입력 크기에서는 둘 다 정답. 빈칸으로 어느 쪽이 나와도 헷갈리지 않게 둘 다 알아둔다.

11. 구현 — 90도 시계방향 회전 (rotate)

N×N 행렬을 시계방향으로 90도 돌린 새 리스트를 반환.

def rotate(arr):
    n = len(arr)
    rotated = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            rotated[j][n - 1 - i] = arr[i][j]
    return rotated

두 가지 매핑 스타일 (둘 다 정답)

rotated[j][n-1-i] = arr[i][j]   # 원본 → 회전 매핑 (이번 풀이)
rotated[i][j] = arr[n-1-j][i]   # 회전 → 원본 매핑 (4/28 학습)

루프를 도는 관점이 다를 뿐, 결과는 동일.

수업 중 질문: 이건 시계방향이지? 만약 반대로(반시계) 돌린다면?

회전 4종 매핑 정리

시각적 기억법 — 외우는 것보다 안 까먹음

    원본            CW (시계)       CCW (반시계)
   1 2 3            7 4 1           3 6 9
   4 5 6     →      8 5 2           2 5 8
   7 8 9            9 6 3           1 4 7

• CW: 첫 행(1,2,3)이 → 마지막 열로 (왼쪽 위 → 오른쪽 위)
• CCW: 첫 행(1,2,3)이 → 첫 열을 거꾸로 (왼쪽 위 → 왼쪽 아래)

보너스 — 회전 패밀리 4종

• 시계 90도: arr[n-1-j][i]
• 반시계 90도: arr[j][n-1-i]
• 180도: rotated[i][j] = arr[n-1-i][n-1-j] (양쪽 다 뒤집힘)
• 전치(transpose, 대각선 대칭): rotated[i][j] = arr[j][i] 또는 zip(*arr)

CW 두 번 = 180도 = CCW 두 번. 회전 패밀리는 이 4가지가 전부다.

오늘의 결과

11문제 1차 정답률 11/11 (100%) — 약 10일 공백 후 컨디션 회복용 워밍업 완료. 자연 노출 약점 1건(불필요한 list() 변환)만 발생, 의식 후 다음 노출 정착 판정 예정. 90분 타이머 모의고사 진입 가능 신호 확인 — 다음 세션은 구름EDU 기출 4회차 풀타임 풀이.

지난 세션(4/27)에서는 수학 파트(소수 판별, 약수, GCD, LCM)를 한 번에 정리하며 4문제 전부 1차 정답으로 끝냈다. 다만 함수 작성에서 같은 값을 가진 변수 2개, 불필요한 엣지 분기 같은 비-슬림한 패턴이 나와서 "코드 슬림화 체크리스트 3가지"를 신규 약점으로 정리했다. 함수 작성 자력 정답은 21차 → 22차 → 23차로 3세션 연속 진행 중.

오늘 수업 계획

오늘은 가벼운 보강 세션. 두 가지 트랙으로 갔다. 먼저 4/20에 학습한 90도 회전 공식이 이번엔 8일 공백이라 망각 점검 — 인덱스 직접 / zip 패턴 두 형태로 빈칸과 디버깅 한 문제씩. 그다음 어제 신규 약점인 슬림화 의식을 보강하기 위해 약수 함수 작성 후 직접 작성한 풀이를 슬림화 체크리스트로 자기 점검.

학습 내용 정리

1. 90도 시계방향 회전 — 인덱스 직접 매핑

n × n 2차원 배열을 시계 방향으로 90도 돌리는 가장 직관적인 풀이. 핵심 공식 한 줄을 외우면 끝난다.

rotated[i][j] = arr[n-1-j][i]

왜 이렇게 매핑되는가?

회전 후 i행은 원본 i열을 아래에서 위로 읽은 값으로 채워진다. 3×3 예시로 추적해보면 명확해진다.

원본:

[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

시계 방향 90도 회전 후 (기대):

[7, 4, 1]
[8, 5, 2]
[9, 6, 3]

회전 후 0행 [7, 4, 1]은 원본의 0열 [1, 4, 7]을 거꾸로 읽은 값이다. 그래서:

→ 행 인덱스에는 n-1-j(거꾸로), 열 인덱스에는 i(원본 열) 가 들어간다.

빈칸 풀이

def rotate_90(arr):
    n = len(arr)
    rotated = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            rotated[i][j] = arr[n - 1 - j][i]   # ← 핵심
    return rotated

⚠️ 함정 후보: arr[n-1-i][j]로 쓰면 반시계 방향이 된다. 시험 디버깅 문제로 충분히 등장 가능. i와 j 자리 바뀌는 거 항상 주의.

2. 90도 회전 — zip 패턴 (뒤집기 + 전치)

같은 회전을 Python 답게 한 줄로 쓰는 방법도 있다. 이게 시험 디버깅에 자주 등장.

[list(row) for row in zip(*arr[::-1])]

이 한 줄을 두 단계로 분해해서 이해하면 외우기 쉬워진다.

단계 1: arr[::-1] — 행 순서 뒤집기

원본:           뒤집기 후:
[1, 2, 3]      [7, 8, 9]
[4, 5, 6]  →   [4, 5, 6]
[7, 8, 9]      [1, 2, 3]

단계 2: zip(*뒤집힌_배열) — 전치(transpose)

zip은 여러 시퀀스에서 i번째 원소를 묶어주는 함수. * 언패킹으로 각 행을 인자로 펼쳐 넣으면 열 단위로 묶이는 효과가 난다.

zip([7,8,9], [4,5,6], [1,2,3])
→ (7,4,1), (8,5,2), (9,6,3)

list로 감싸면 회전 결과 완성. 인덱스를 직접 쓰지 않고 끝낸다.

디버깅 문제 — 어디가 버그?

def rotate_90(arr):
    flipped = arr[::]                              # ⓐ
    return [list(row) for row in zip(*flipped)]    # ⓑ

ⓐ에 버그가 있다. arr[::]은 단순 복사(슬라이싱으로 새 리스트 만들기)일 뿐, 순서를 뒤집지 않는다. 그래서 zip만 호출되면 그냥 전치(transpose)가 되어버려 회전이 아닌 전혀 다른 결과가 나온다.

한 줄 수정:

flipped = arr[::-1]

디버깅 풀이 흐름 (직접 설명)

"zip 부분이 마지막 행에서부터 하나씩 뽑아야 되니 마지막 행이 처음 오도록 뒤집어야 함"

zip의 동작이 첫 행부터 차례로 열 단위로 묶는 거라는 점을 이해하면, 시계 방향 회전 결과의 0행이 "원본 마지막 행의 0번째 값들"이 되려면 마지막 행이 맨 앞에 와야 한다는 게 자연스럽게 따라온다. 4/20에 학습한 "뒤집기 + 전치" 분해가 도구로 자리잡은 형태.

3. 약수 구하기 — 직접 작성 + 슬림화 비교

어제(4/27)에 √n 최적화 패턴으로 약수 짝꿍 구조를 다뤘다면, 오늘은 그걸 함수 작성으로 응용하면서 슬림화 의식을 점검.

문제

자연수 n의 모든 약수를 오름차순 리스트로 반환. 시간 복잡도 O(√n).

divisors(12)  # [1, 2, 3, 4, 6, 12]
divisors(36)  # [1, 2, 3, 4, 6, 9, 12, 18, 36]   ← 제곱수
divisors(7)   # [1, 7]                            ← 소수
divisors(1)   # [1]                               ← 엣지

직접 작성한 풀이

def divisors(n):
    small = []
    large = []
    i = 1
    while i * i <= n:
        if n % i == 0:                  # 나누어떨어짐(약수)
            small.append(i)
            if n // i != i:              # i로 n 나눈 수가 i 아니면 두 번째도 추가
                large.append(n // i)
        i += 1
    return small + large[::-1]           # large는 큰 수부터 들어가있으니 역순

1차 정답 — 5개 테스트 전부 통과.

이 풀이의 좋은 점:

• 제곱수 함정(if n // i != i)을 정확히 처리
• n == 1 같은 안전망 엣지 분기를 추가하지 않음 (메인 while 루프가 자연 처리)
• 같은 값 변수 중복 없음

→ 어제(23차) 신규 약점이던 "안전망 분기 추가" 패턴이 1회 노출에서 발생하지 않음. 어제 학습한 슬림화 체크리스트 3가지가 자기 점검으로 작동한 신호.

슬림화 체크 — 한 발 더 짧게 가는 길

학습자 풀이는 시간 복잡도 측면에서 살짝 우위다 (reverse는 O(d), sorted는 O(d log d)). 의식적인 성능 선택이라면 그대로 둬도 좋다. 다만 코드 길이/가독성 관점에서 보면 더 짧은 형태가 있다.

대안 1: 한 리스트 + sorted

def divisors(n):
    result = []
    i = 1
    while i * i <= n:
        if n % i == 0:
            result.append(i)
            if i != n // i:
                result.append(n // i)
        i += 1
    return sorted(result)

리스트 분리 없이 한곳에 다 넣고 마지막에 정렬. 코드 짧아짐.

대안 2: set + sorted (가장 슬림)

def divisors(n):
    result = set()
    i = 1
    while i * i <= n:
        if n % i == 0:
            result.add(i)
            result.add(n // i)
        i += 1
    return sorted(result)

여기선 제곱수 분기(if i != n // i) 자체가 사라진다. set이 중복을 자동으로 제거해주니까. 메인 자료구조를 바꾸는 것만으로 분기 한 줄이 통째로 없어지는 패턴.

메타 포인트 — 자료구조 선택을 통한 슬림화

세 가지 모두 정답이고 trade-off가 있다. 다만 어제 학습한 슬림화 체크리스트에 항목 하나가 추가된다.

💡 슬림화 자기 점검 — 추가 메타 질문 4. 이 분기 정말 필요한가? 자료구조 바꾸면 사라지지 않나?

"리스트 + 중복 체크 분기" 자리에 "set으로 자동 중복 제거"가 거의 항상 한 번 더 짧게 만들어준다. 약수 문제뿐 아니라 경계 순회(20차 좌표 visited), 부분합 중복 등에도 동일.

Java vs Python — 자료구조 선택의 무게

Java에서는 자료구조 바꾸는 게 선언/변환 비용 때문에 약간의 결심이 필요한 행동인데, Python은 그 비용이 거의 없다. 그래서 Python에선 "분기를 자료구조로 흡수"하는 게 더 자연스러운 선택지가 된다.

4. 공식 재노출 주기 관리 — 8일 공백 결과

4/20(20차)에서 90도 회전 공식을 5일 공백으로 망각했던 적이 있어, 그 후 재노출 주기를 의식하고 있었다. 오늘은 4/20 이후 8일 공백 상태에서 첫 재노출.

8일 공백에도 두 형태 모두 안정 → 4/20 망각 사례 이후 첫 재노출에서 정착 신호. 다음 자연 재노출은 5/12 전후 오답 총복습 기간으로 예정.

📌 공백 주기 관리 메타 — "공식은 망각 사이클을 의식하고 다시 만지기"라는 학습 운영이 한 번 검증됨. 새 공식을 외울 때마다 다음 재노출 시점을 머릿속에 한 번 박아두는 게 효과적.

오늘의 결과

오늘 푼 문제는 3문제(빈칸 1 + 디버깅 1 + 함수 작성 1), 1차 정답률 3/3 (100%). 함수 작성 자력 정답이 21차 → 22차 → 23차 → 24차로 4세션 연속, 어제 신규 약점이던 슬림화 의식도 1회 노출에서 안전망 분기 추가 없이 통과. 다음 학습은 4/29(수)부터 BFS/DFS 시작 — 그래프 탐색 본격 진입.

지난 세션(4/24)에서는 이진 탐색을 처음 학습하며 빈칸/디버깅/함수 작성 4문제 전부 1차 정답으로 끝냈다. 코드 추적 습관이 강화돼 print(f"left=... mid=...")로 실행을 시뮬레이션하며 풀이하는 흐름이 자리잡았다. bisect 라이브러리는 완성형에서만 쓰고 빈칸은 직접 구현이 정석이라는 실전 전략도 같이 정리.

오늘 수업 계획

시험 출제 범위 중 자주 등장하는 수학 파트를 한 번에 정리한다. 소수 판별의 √n 최적화부터 시작해서, 같은 원리로 풀리는 약수 구하기, 그리고 외우면 끝나는 공식 두 개(유클리드 호제법, LCM 공식)까지. 마지막은 GCD를 이용해 N개 수의 LCM을 구하는 함수 작성 문제로 마무리.

학습 내용 정리

1. 소수 판별 — √n 최적화

소수는 1과 자기 자신만으로 나누어떨어지는 자연수(1 제외). 가장 단순한 풀이는 2부터 n-1까지 다 나눠보는 것이다.

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

문제는 n이 1,000,000 같은 큰 수면 백만 번 다 돌아야 한다는 점. 그래서 √n까지만 보면 충분하다는 최적화가 핵심이다.

왜 √n까지면 충분한가? (시각적 설명)

36의 약수 쌍을 적어보면 √36 = 6을 기준으로 거울처럼 대칭이다.

1 × 36 = 36
2 × 18 = 36
3 × 12 = 36
4 × 9  = 36
6 × 6  = 36   ← √36 (중간점)
9 × 4  = 36   ← 위와 대칭
12 × 3 = 36
...

즉 √n 이하에서 약수를 못 찾으면 √n 초과에서도 못 찾는다(대칭이니까). 그래서 검사 범위를 √n까지로 줄이면 시간복잡도가 O(n) → O(√n)으로 떨어진다.

def is_prime(n):
    if n < 2:
        return False
    i = 2
    while i * i <= n:        # i*i <= n 은 i <= √n 과 같음
        if n % i == 0:
            return False
        i += 1
    return True

⚠️ 포인트: i * i <= n은 제곱근 함수(math.sqrt)를 쓰지 않고도 같은 효과를 낸다. 실수 오차도 없고 정수 연산이라 빠르다. 이 패턴은 시험에 그대로 등장한다.

Java vs Python — 정수 연산 비교

Java에서 int / int = int 로 자동 정수화되는 게, Python에서는 명시적으로 //로 적어줘야 한다. 22차 이진 탐색에서도 이 함정이 디버깅 문제로 나왔는데, 오늘 LCM 공식에서도 같은 패턴이 또 등장. 정수 결과가 필요한 곳에선 무조건 // — 외우자.

2. 약수 구하기 — 짝꿍 패턴

약수 구하기도 √n 트릭을 그대로 쓴다. 다만 핵심 아이디어가 하나 더 추가된다.

i가 약수면 n // i도 자동으로 약수다. 두 개를 동시에 수집하면 √n까지만 돌면 된다.

def get_divisors(n):
    small = []
    large = []
    i = 1
    while i * i <= n:
        if n % i == 0:
            small.append(i)
            if i != n // i:           # 제곱수 함정 처리
                large.append(n // i)
        i += 1
    return small + large[::-1]

⚠️ 제곱수 함정

36의 경우 i=6일 때 짝꿍 n//i = 6 — 같은 수다. 이 체크를 빼먹으면 6이 두 번 들어가 [1,2,3,4,6,6,9,...]이 된다. 이게 시험 디버깅 문제의 단골 함정.

디버깅 문제

def count_divisors(n):
    count = 0
    i = 1
    while i * i <= n:
        if n % i == 0:
            count += 2          # 버그: 제곱수에서 2번 셈
        i += 1
    return count

# count_divisors(36) → 기대 9, 실제 10 (i=6에서 2번 셈)
# count_divisors(49) → 기대 3, 실제 4

한 줄 수정:

count += 1 if i == n // i else 2

수업 중 질문: i == n // i 이 조건 i * i == n 이렇게 써도 되지 않나? 저렇게 쓴 이유가 있나해서

좋은 질문이다. 둘 다 정답이고 우리 맥락에선 결과가 같다. 다만 미묘한 차이가 있다.

왜 차이가 생기나? 만약 if n % i == 0: 조건이 없는 곳에서 비교한다고 하면:

n = 10, i = 3
i * i == n   →  9 == 10  →  False  ✅ (정확)
i == n // i  →  3 == 10 // 3 → 3 == 3 → True  ❌ (잘못된 판정!)

정수 나눗셈 //은 나머지를 버려버리니까 i가 약수가 아닌데도 결과가 맞아떨어진 것처럼 보일 수 있다. 우리 코드는 if n % i == 0: 안에서 쓰니까 둘 다 안전하지만, 습관적으로는 i * i == n이 robust한 디폴트. 의도 표현 면에서는 짝꿍 변수와 같이 쓸 때 i == n // i가 가독성이 좋다 — 상황에 맞게 쓰면 된다.

3. 최대공약수 (GCD, Greatest Common Divisor) — 유클리드 호제법

두 수의 공통 약수 중 가장 큰 수. 외우면 끝나는 공식 1개:

gcd(a, b) = gcd(b, a % b) 를 반복. b가 0이 되면 a가 답.

추적해보기

gcd(48, 18)
= gcd(18, 48 % 18) = gcd(18, 12)
= gcd(12, 18 % 12) = gcd(12, 6)
= gcd(6,  12 % 6)  = gcd(6, 0)
                              ↑ b=0 → a=6이 정답

코드 (반복문 — 시험에 더 흔함)

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

🐍 Python 튜플 언패킹: a, b = b, a % b는 오른쪽 전체를 먼저 계산한 다음 왼쪽에 동시 대입한다. Java라면 임시변수가 필요한 패턴인데 Python은 한 줄에 끝.

// Java
int temp = a;
a = b;
b = temp % b;

# Python
a, b = b, a % b

수업 중 질문: a, b 파라미터 조건 있어? 둘 중에 작은 수를 기준값으로 해야할 것 같은데 그런 설명이 없더라고

핵심 질문이다. a < b여도 자동으로 작동한다. 추적해보면 보인다:

gcd(5, 12) — 작은 수를 a에 넣어봤다.

왜 자동 swap이 되냐면, a < b이면 a % b = a가 항상 성립한다(5를 12로 나눈 나머지는 5 그대로). 그래서 첫 줄 a, b = b, a % b가 → a, b = b, a로 변신. 한 번 헛돌고 큰 수가 자연스럽게 앞으로 온다.

→ 매개변수 조건 따로 없다. 어느 쪽이 크든 알아서 됨. 그래서 시험에서 빈칸/디버깅 문제에 if a < b: a, b = b, a 같은 줄이 있다면 그건 있어도 없어도 결과 같은 줄(함정 후보).

4. 최소공배수 (LCM, Least Common Multiple) — 황금 공식

두 수의 공통 배수 중 가장 작은 수. 공식 한 줄.

$$ \text{lcm}(a, b) = \frac{a \times b}{\gcd(a, b)} $$

lcm = (a * b) // gcd(a, b)
# 또는 (오버플로우 안전 버전)
lcm = a // gcd(a, b) * b

왜 성립? 직관적으로:

• a × b는 공통 배수 중 하나(최소는 아닐 수 있음)
• 거기서 공통으로 겹치는 부분(GCD)만큼 한 번 빼주면 최소가 됨

확인:

lcm(4, 6) = (4 * 6) // gcd(4, 6) = 24 // 2 = 12 ✅
lcm(12, 18) = (12 * 18) // gcd(12, 18) = 216 // 6 = 36 ✅

⚠️ / vs // 함정 재등장: 22차 이진 탐색에서도 나왔던 함정. 정수 결과 필요한 곳에선 무조건 //. (4*6) / gcd(4,6)은 12.0(실수)가 나와서 시험 답으로 오답 처리 가능.

5. N개 수의 LCM — 누적 패턴 함수 작성

세 수 이상의 LCM은 어떻게? lcm(a, b, c) = lcm(lcm(a, b), c) — 둘씩 누적해서 합쳐가면 된다.

수업 중 질문: 빈 리스트가 들어올 수도 있어?

엣지케이스 사고력 좋은 질문. 이번 문제는 len(numbers) >= 1 가정. COS Pro는 보통 입력 제약이 명시되고, 빈 리스트가 들어오는 경우는 드물다. 다만 실전 코딩테스트에서 입력 제약을 먼저 확인하는 습관은 함정 회피에 직접적으로 도움이 된다 — 계속 유지할 것.

직접 작성한 풀이

def lcm_all(numbers):
    if len(numbers) == 1:
        return numbers[0]

    a = numbers[0]
    lcm = numbers[0]

    for i in range(1, len(numbers)):
        b = numbers[i]
        lcm = a // gcd(a, b) * b
        a = lcm

    return lcm

테스트 5개 전부 통과. 1차 정답.

피드백: 코드 슬림화 체크리스트

잘 동작하지만 a와 lcm 두 변수가 항상 같은 값이다. 추적해보면:

i=1 직후:  a = lcm = 12
i=2 직후:  a = lcm = 24

또 if len == 1 분기도 불필요하다 — 리스트가 1개면 for 루프가 한 번도 안 돌고 lcm = numbers[0] 그대로 반환된다.

슬림화된 형태:

def lcm_all(numbers):
    lcm = numbers[0]
    for n in numbers[1:]:                    # 첫 번째 빼고 값 순회
        lcm = lcm // gcd(lcm, n) * n
    return lcm

💡 코드 슬림화 체크리스트 (앞으로 함수 작성 후 한 번씩 자기 점검)

1. 같은 값을 가진 변수 2개가 있나? → 하나로 합치기
2. 불필요한 엣지 분기가 있나? → 메인 로직이 자연스럽게 처리하면 제거
3. 인덱스가 꼭 필요한가? → 값 자체로 충분하면 for x in arr

for n in numbers[1:]는 첫 번째 원소 빼고 값으로 순회하는 Python 패턴이다. 인덱스 안 쓰고 값 자체로 도는 게 더 깔끔. 누적 패턴에선 슬라이싱 + 값 순회가 더 흔하다.

오늘의 결과

오늘 푼 문제는 4문제(빈칸 2 + 디버깅 1 + 함수 작성 1), 1차 정답률 4/4 (100%). 함수 작성 자력 정답이 21차→22차→23차로 3세션 연속 이어지며 과거 약점이 강점으로 전환되는 추세. 다음 학습은 4/29(수)부터 BFS/DFS 시작.

4/23 21차 세션에서는 20차 자기 진단에서 나온 두 약점(초기값 세팅 누락 / 인덱스+값 병렬 처리 미숙)을 겨냥해 enumerate → zip → 튜플 정렬 세 빈칸을 가볍게 풀었다. zip 문제에서 top_score = scores[0], top_name = names[0] 초기값 세팅을 힌트 없이 스스로 써서 개선 신호를 확인했고, 부호 뒤집기 트릭의 경계 질문에서 stable sort 기반 2단계 정렬까지 확장했다. 세션 마지막에는 이미 풀어본 프린터 우선순위 문제를 매개로 그리디 알고리즘 개념을 명시적으로 정립했다.

오늘 수업 계획

오늘은 이진 탐색(Binary Search) 을 처음부터 배운다. 개념 설명 → 기본 템플릿 빈칸 → lower bound 변형 빈칸 → 디버깅 → 함수 작성(개수 세기 응용) 순서로 진행한다. COS Pro 1급에 빈출되는 유형이자 아직 안 배운 영역이라 기초를 탄탄히 쌓는 데 집중한다. 마지막에 학습자가 제기한 "시험에서 bisect 써도 되나?" 질문에서 완성형/부분형별 활용 전략까지 정리한다.

학습 내용 정리

1) 이진 탐색 — 언제, 왜 쓰는가?

전제 조건: 리스트가 정렬되어 있어야 한다. 정렬되지 않은 데이터에는 못 쓴다.

속도 비교:

절반씩 버려가며 탐색하기 때문에, 데이터가 커질수록 격차가 기하급수적으로 벌어진다.

동작 원리: [1, 3, 5, 7, 9, 11, 13] 에서 11 찾기

1. 가운데(인덱스 3) 값은 7. 찾는 값 11보다 작으니 왼쪽 반 전부 버림 → left = mid + 1
2. 남은 [9, 11, 13] 의 가운데(인덱스 5) 값은 11. 찾음, 반환 5

핵심 3줄로 요약하면:

mid = (left + right) // 2
if arr[mid] == target: 찾음
elif arr[mid] < target: left = mid + 1   # target은 오른쪽에 있음
else: right = mid - 1                     # target은 왼쪽에 있음

2) 기본 이진 탐색 템플릿 (빈칸 1)

문제: 정렬된 arr 에서 target 의 인덱스를 반환, 없으면 -1. ㉠, ㉡ 을 채우시오.

def solution(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target: # 7 < 11
            left = mid + 1      # ㉠
        else:
            right = mid - 1     # ㉡
    return -1

왜 +1, -1 을 붙이나?

arr[mid] 는 이미 target이 아닌 걸 확인했으니 mid 자체는 다시 볼 필요가 없다. 그래서 ±1 로 mid를 제외하고 범위를 줄여야 한다.

만약 left = mid 로 쓰면? [1, 3] 에서 3 찾을 때 left=0, right=1 → mid=0 → arr[0]=1 < 3 → left=0 그대로 → 무한 루프 💥

while 조건 <= 에 등호가 꼭 필요한 이유: 원소가 한 개 남았을 때(left == right) 그 한 개도 검사해야 하기 때문. 등호를 빼면 마지막 남은 원소를 놓친다.

3) lower bound 패턴 — "target 이상 첫 위치" (빈칸 2)

기본 이진 탐색만으로는 부족한 경우가 많다. 예: "6 이상의 값이 처음 나오는 위치" 같은 경계값 찾기. COS Pro에서도 종종 이 변형으로 출제된다.

# 정렬된 arr에서 target 이상인 값이 처음 등장하는 위치를 반환
# 모든 값이 target보다 작으면 len(arr) 반환
def solution(arr, target):
    left, right = 0, len(arr)     # ← right가 len-1이 아닌 len
    while left < right:            # ← 등호 없음
        mid = (left + right) // 2
        if arr[mid] >= target:
            right = mid            # ← mid도 답 후보이므로 제외하지 않음
        else:
            left = mid + 1
    return left

# 테스트
print(solution([1,3,5,7,9], 6))   # 3  (6 이상 첫 값은 7, 인덱스 3)
print(solution([1,3,5,7,9], 10))  # 5  (없음 → len 반환)

기본 이진 탐색과 3가지 차이점:

왜 right = mid 이고 mid - 1 이 아닌가?

• 기본 버전: arr[mid] == target 이면 바로 반환이라 mid는 이후 볼 필요 없음 → 제외 가능 → mid ± 1
• lower bound: arr[mid] >= target 이면 mid도 답 후보 로 남겨야 함 → 제외 금지 → right = mid

왜 < 로 등호를 뺐나?

• 만약 <= 이면 left == right == mid 에서 right = mid 로 범위가 그대로 → 무한 루프
• < 면 left == right 에서 루프 종료하고 그 값이 답

풀이 중에는 print(f"left={left} right={right} mid={mid} arr[mid]={arr[mid]}") 로 실행을 직접 추적하며 ㉠에 right = mid, ㉡에 left = mid + 1 을 채웠다. 이진 탐색처럼 조건이 헷갈릴 때는 한 번 찍어보고 가는 게 확실하다.

4) 디버깅 — / vs // 함정

문제: 한 줄만 고쳐라.

def solution(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) / 2    # ← 버그!
        if arr[mid] == target:
            return mid
        ...

답: mid = (left + right) // 2 (정수 나눗셈으로 교체)

이유:

• Python의 / 는 항상 실수(float) 를 반환한다. (0 + 6) / 2 는 3.0 이다.
• arr[3.0] 은 TypeError: list indices must be integers 에러가 난다. 리스트 인덱스는 반드시 정수여야 한다.
• 따라서 정수 나눗셈 // 를 써야 한다.

Java와 비교:

Java 경험이 있으면 오히려 이 함정에 걸리기 쉽다. / 가 Java에서처럼 자동으로 정수로 떨어질 거라 기대하기 때문. 이진 탐색 디버깅 단골 함정이므로 반드시 기억해두자.

5) 함수 작성 — target 등장 횟수 (lower + upper bound 조합)

문제: 정렬된 리스트 arr 에서 target 이 몇 번 등장하는지 반환. 중복 가능.

아이디어: 두 번의 이진 탐색으로 경계를 찾아 뺀다.

• target 이상 첫 위치 = left_idx
• target + 1 이상 첫 위치 = right_idx (= target 초과 첫 위치)
• 개수 = right_idx - left_idx

예: [1, 2, 2, 2, 3], target=2

• 2 이상 첫 위치 = 1
• 3 이상 첫 위치 = 4
• 개수 = 4 − 1 = 3 ✓

풀이:

def solution(arr, target):
    # right_idx 찾기 (target+1 이상 첫 위치)
    left, right = 0, len(arr)
    while left < right:
        mid = (left + right) // 2
        if arr[mid] >= target + 1:
            right = mid
        else:
            left = mid + 1
    right_idx = left

    # left_idx 찾기 (target 이상 첫 위치)
    left, right = 0, right_idx  # 위에서 이미 찾은 범위만 뒤지면 충분
    while left < right:
        mid = (left + right) // 2
        if arr[mid] >= target:
            right = mid
        else:
            left = mid + 1
    left_idx = left

    return right_idx - left_idx

테스트 [1,2,2,2,3,4,5] target=2 → 3, [1,1,1,1,1] target=1 → 5, 빈 리스트 [] → 0 (while 루프 자체에 진입 안 해서 자연스럽게 0 반환) 까지 전부 통과.

빈 리스트 대응을 위해 별도 방어 코드를 쓰지 않아도 left=0, right=0 이면 while left < right 가 바로 거짓이 되어 빠져나간다. 이진 탐색 템플릿의 숨겨진 장점 중 하나.

더 간결한 방법 (학습자 질문)

수업 중 질문 (풀이 직후): "이진 탐색 로직을 두 번 썼는데 더 간결한 방법도 있을까?"

크게 두 가지 대안이 있다.

방법 1: bisect 표준 라이브러리 활용

from bisect import bisect_left, bisect_right

def solution(arr, target):
    return bisect_right(arr, target) - bisect_left(arr, target)

• bisect_left(arr, x) = x 이상 첫 위치 (= left_idx)
• bisect_right(arr, x) = x 초과 첫 위치 (= right_idx)
• 위에서 손으로 짠 두 이진 탐색을 한 줄로 대체

방법 2: 헬퍼 함수로 중복 제거

def solution(arr, target):
    def lower_bound(x):
        left, right = 0, len(arr)
        while left < right:
            mid = (left + right) // 2
            if arr[mid] >= x:
                right = mid
            else:
                left = mid + 1
        return left
    return lower_bound(target + 1) - lower_bound(target)

이진 탐색 로직이 한 곳에만 있어 중복이 제거된다. 바깥 변수 arr 는 클로저로 자연스럽게 참조된다.

결론: 중복처럼 보여도 if 조건이 다르기 때문에 직접 두 번 쓰는 것도 완전히 정답. 리팩터링은 취향.

6) 시험 전략 — bisect 를 시험에서 그대로 써도 되나?

수업 중 질문: "시험에서 bisect를 그대로 써도 되는거야?"

좋은 질문이다. 정답은 "쓸 수 있다, 하지만 뉘앙스 주의".

COS Pro 1급에서 허용되는 표준 라이브러리:

import bisect                          # 이진 탐색
from collections import Counter, deque  # 빈도 / 큐
from itertools import combinations      # 조합
import heapq                            # 우선순위 큐
import math                             # gcd, sqrt

하지만 유형별로 활용 가능 범위가 다르다:

왜 빈칸에선 직접 구현이 더 많이 나오나? 출제자 입장에서 bisect_left(arr, target) 한 줄을 빈칸으로 내면 시험이 너무 쉬워진다. 그래서 이진 탐색 로직을 풀어쓴 코드에서 left = mid + 1 같은 부분을 빈칸으로 내는 게 일반적이다.

결론적인 학습 전략:

1. 직접 구현 원리를 확실히 이해 — 빈칸/디버깅 대비 (부분형 7문제 = 700점, 훨씬 큰 비중)
2. bisect 사용법도 알아두기 — 완성형에서 시간 단축 무기
3. 완성형에서 남은 시간이 빠듯하면 bisect 한 줄로 처리하고 다음 문제로 넘어가는 판단도 가능

오늘 세션에서 빈칸 2개 + 디버깅 1개 + 함수 작성 1개 모두 직접 구현으로 풀었으니, 부분형 대비의 기초는 탄탄히 깔린 셈이다.

오늘의 결과

• 푼 문제 4문제 (빈칸 2 + 디버깅 1 + 함수 작성 1), 1차 정답률 100% (4/4)
• 이진 탐색 기본 / lower bound 변형 / 개수 세기 응용까지 한 세션에 체화
• 다음 학습: 수학 (소수 판별 / GCD / LCM) 진입 예정

4/20 20차 세션에서 구현/시뮬레이션 범위를 복습하며 18차 약점이던 y 차원 경계 체크(0 <= ny < n)를 힌트 없이 재현하여 정착을 확인했다. 반면 2차원 90도 회전 공식 rotated[i][j]=arr[n-1-j][i] 은 재노출 공백으로 잠시 날아갔고, 경계 순회 문제에선 arr[x][y] not in result 같은 값 기반 중복 체크가 중복 값 반례에서 깨져 좌표 기반 visited = {(0,0)} 방식으로 교정했다. 세션 말미에 스스로 "루프 전 초기 값 세팅을 자주 깜빡한다", "인덱스+값을 병렬로 다루는 감각이 아직 약하다" 두 약점을 정확히 진단했고, 오늘은 그 연장선에서 가볍게 워밍업한다.

오늘 수업 계획

20차 자기 진단에서 나온 두 약점(초기값 세팅 누락 / 인덱스+값 병렬 처리 미숙)을 겨냥해 enumerate → zip → 튜플 정렬 순서로 빈칸 세 문제만 가볍게 푼다. 이 세 도구는 겉보기엔 다르지만 "두 종류의 데이터를 같은 시점에 묶어 다룬다"는 같은 범주에 속한다. 풀이 중 학습자가 제기한 "부호 뒤집기 트릭의 경계 조건" 질문에서 stable sort 기반 2단계 정렬 트릭까지 확장하고, 마지막에 그리디 알고리즘 개념을 이미 푼 프린터 우선순위 문제를 매개로 정립한다.

학습 내용 정리

0) 세션 시작 전 질문: 알고리즘 용어 점검

수업 중 질문: "최근에 1급 딴 다른 사람 후기 봤는데 DFS BFS DP 그리디 이런
알고리즘 용어가 나오더라고? 잘 몰랐는데 이미 내가 푼 적도 있는거야?"

현 커리큘럼 기준으로 정리하면 다음과 같다.

특히 그리디의 경우 이미 17차/19차에서 푼 프린터 우선순위 문제가 정통 그리디 유형이었다는 점을 확인하고, 오늘 세션 마지막에 개념을 명시적으로 정립하기로 했다.

1) enumerate — 인덱스와 값을 같이 순회

문제: 숫자 리스트에서 가장 큰 값이 있는 위치(인덱스)를 반환하는 함수를 작성하라. max(), index() 사용 금지.

def find_max_index(arr):
    max_idx = 0
    max_val = arr[0]
    for i, v in enumerate(arr):
        if v > max_val:
            max_val = v
            max_idx = i
    return max_idx

핵심:

• enumerate(arr) 은 (인덱스, 값) 튜플을 하나씩 내어주는 반복자. 이걸 for i, v in ... 로 언패킹하면 한 번의 순회로 두 정보를 동시에 쓸 수 있다.
• > 부등호(등호 없음) 때문에 동점이면 먼저 나온 인덱스가 유지된다. [5, 5, 5] 입력에서 0 이 나오는 이유.

수업 중 질문 (풀이 직후): "초기값 세팅은 내가 한 거 아니야."

정확한 지적이었다. 이 문제에서 max_idx = 0 / max_val = arr[0] 두 줄은 빈칸 바깥에 제시된 코드라 학습자가 직접 쓴 부분은 아니었다. 초기값 세팅 약점 개선은 다음 문제에서 진짜로 확인하기로 했다.

2) zip — 두 리스트를 값끼리 병렬 순회

문제: 학생 이름 리스트와 점수 리스트가 있을 때, 가장 높은 점수를 받은 학생의 이름을 반환하라.

def top_student(names, scores):
    top_score = scores[0]
    top_name = names[0]
    for name, score in zip(names, scores):
        if score > top_score:
            top_score = score
            top_name = name
    return top_name

핵심:

• zip(names, scores) 는 같은 위치의 두 원소를 튜플로 묶어 내어주는 반복자. 길이가 다르면 짧은 쪽에 맞춰 멈춘다 (그래서 짧은 리스트의 길이까지만 순회됨).
• enumerate 가 "(인덱스, 값)" 을 묶었다면 zip 은 "(값, 값)" 을 묶는다. 묶는 대상이 다를 뿐 "두 데이터를 병렬로 쓴다" 는 목적은 같다.

이번 문제에서는 top_score = scores[0], top_name = names[0] 초기값 세팅 두 줄을 힌트 없이 직접 썼다. 20차 때 스스로 진단했던 "루프 전 초기값을 자주 깜빡한다" 약점이 이번엔 작동하지 않았다 — 한 번의 실전 노출로 개선 신호를 확인한 셈.

enumerate ↔ zip 비교표:

3) 튜플 정렬 — 다중 key + 부호 뒤집기 트릭

문제: [(이름, 점수), ...] 리스트를 점수 내림차순, 동점이면 이름 가나다순으로 정렬하라.

def sort_students(students):
    return sorted(students, key=lambda x: (-x[1], x[0]))

핵심 아이디어:

• sorted() 의 key 함수가 튜플을 반환하면 Python은 튜플을 앞에서부터 순서대로 비교한다. 1차 기준이 같을 때만 2차 기준을 본다.
• 문제의 함정: 점수는 내림차, 이름은 오름차 — 방향이 섞였다. reverse=True 는 튜플 전체를 뒤집기 때문에 둘 다 내림차가 되어 버린다.
• 해법: 한 쪽만 부호를 뒤집는다. 점수 -x[1] 로 넣으면 정렬은 오름차로 하면서 실제 결과는 점수 내림차가 된다.

Java와 비교:

Java의 .reversed().thenComparing() 체이닝과 Python의 부호 뒤집기 트릭은 목표는 같지만 표현이 다르다. Python 쪽이 짧은 대신 "숫자에만 먹힌다"는 제약이 있다.

4) 부호 뒤집기 트릭의 경계: 문자열에 적용하려면?

수업 중 질문: "지금은 내림차순 정렬하는 값이 숫자라서 가능한 거지?
만약 이름을 내림차순(사전 반대방향)으로 정렬한다고 하면
어쩔 수 없이 reverse=True 사용해야되겠지?"

매우 정확한 경계 질문이다. 답을 정리하면:

>>> -"abc"
TypeError: bad operand type for unary -: 'str'

부호 뒤집기는 숫자에만 먹힌다. 그렇다고 reverse=True 만이 유일한 답은 아니다. Python의 sorted() 가 stable(안정 정렬) 이라는 성질을 이용하면 문자열에도 "방향이 섞인 다중 정렬"이 가능하다.

Stable sort 의 정의: 같은 key 값을 가진 원소들의 상대 순서가 정렬 전후에 유지된다.

활용법 — 2단계 정렬: "덜 중요한 기준을 먼저, 더 중요한 기준을 나중에" 두 번 정렬한다.

# 예: 점수 오름차 + 이름 내림차 (사전 반대 방향)
students = [("철수", 80), ("영희", 80), ("민수", 70)]

# 1단계: 덜 중요한 기준 먼저 — 이름 내림차
temp = sorted(students, key=lambda x: x[0], reverse=True)
# → [('철수', 80), ('영희', 80), ('민수', 70)]

# 2단계: 더 중요한 기준 나중 — 점수 오름차
result = sorted(temp, key=lambda x: x[1])
# → [('민수', 70), ('철수', 80), ('영희', 80)]
#    점수 오름차 ✓, 동점은 이름 내림차(철 > 영) ✓

정리표:

COS Pro 1급에서 문자열 내림차 + 다른 기준 조합은 빈도가 낮다. 실전 빈출은 점수 내림 + 이름 오름 쪽이라 오늘 푼 (-x[1], x[0]) 패턴이 훨씬 자주 나온다. 2단계 정렬은 "이런 카드도 있다" 정도로 알아두면 충분하다.

5) 그리디 (Greedy) 개념 정립

수업 중 질문: "끝내기 전에 이미 내가 한 적 있다던 그리디에 대해
정리하고 가자. 문제 풀 건 아니고 개념 → 예시 문제 → 바로 풀이법 설명까지.
내가 푼 적 있는 문제면 더 좋고."

한 문장 정의:

"매 순간, 지금 당장 가장 좋아 보이는 선택을 한다."

• 전체 경로를 미리 고민하지 않고 지역 최적(local optimal) 을 고른다.
• 이 선택들을 쌓은 결과가 전체 최적(global optimal) 과 일치하는 문제에서만 그리디로 풀 수 있다.

이미 푼 예시: 프린터 우선순위

문제 요약: 대기열에 있는 문서들에 각자 우선순위가 있다. 큐 맨 앞 문서를 꺼냈을 때, 뒤에 더 높은 우선순위가 남아있으면 그 문서를 맨 뒤로 보낸다. 없으면 인쇄한다.

입력 예: priorities = [2, 1, 3, 2], 내 문서 위치 = 2 → 출력: 1

왜 이게 그리디냐:

"현재 대기열에서 우선순위가 가장 높은 문서부터 먼저 인쇄한다."

지금 남아있는 것 중 제일 큰 것을 처리하면 된다 — 이게 곧 탐욕 규칙.

from collections import deque

def solution(priorities, location):
    queue = deque((i, p) for i, p in enumerate(priorities))
    count = 0
    while queue:
        idx, pri = queue.popleft()
        if queue and max(p for _, p in queue) > pri:
            queue.append((idx, pri))   # 더 큰 거 있으니 뒤로
        else:
            count += 1
            if idx == location:
                return count

max(...) > pri 로 "지금 가장 높은 게 뭐냐" 를 묻는 부분이 그리디의 핵심이다.

그리디가 항상 맞는 건 아니다 (중요)

반례: 동전 [1원, 4원, 5원] 으로 8원 만들기

그래서 그리디를 선택하기 전에 "이 전략이 정말 전체 최적과 일치하는가?" 를 한 번 점검해야 한다. 애매하면 DP 영역으로 넘어가야 한다.

다행히 COS Pro 1급 수준의 그리디는 대부분 "정렬 후 순서대로 집어먹기" 패턴으로 해결되어 복잡한 증명 없이 접근 가능하다. 그래서 그리디 문제에는 거의 항상 sorted() 가 등장한다.

대표 유형 (이름만 기억)

이미 가진 그리디 감각

• 17차·19차 프린터 우선순위 — 19차에선 (인덱스, 우선순위) 튜플을 힌트 없이 스스로 설계
• 20차 점수 순 정렬 — "가장 좋은 것부터" 사고방식은 그리디와 결이 같음

용어만 몰랐을 뿐 감각은 이미 있다. 앞으로 문제에서 "가장 ~한 것부터" 라는 키워드가 보이면 "그리디 + 정렬" 을 먼저 떠올리면 된다.

오늘의 결과

• 푼 문제 3문제 (enumerate / zip / 튜플 정렬 빈칸 채우기), 1차 정답률 100%
• 20차 자기 진단 약점 "초기값 세팅 깜빡" — 문제 2에서 힌트 없이 직접 세팅하여 개선 확인
• 다음 학습: 이진 탐색 + 수학(소수/GCD/LCM) 진입

4/17 19차 세션에서 17차 약점이었던 스택/큐 두 가지 — 스택에 무엇을 저장할지 판단과 빈 스택 체크 — 를 힌트 없이 재현하며 완전 정착을 확인했다. 프린터 우선순위 문제도 17차와 달리 (인덱스, 우선순위) 튜플을 스스로 설계했다. 다만 괄호 중첩 깊이 문제에서 "깊이"를 "완성된 쌍 수"로 해석해 ((())()) 반례에서 깨지는 풀이를 낸 적이 있다.

오늘 수업 계획

학습 공백이 좀 있었기 때문에 감각 복구 목적으로 18차 범위(구현/시뮬레이션 기초)를 복습한다. dx/dy 좌표 이동, 2차원 배열 90도 회전, 주기성 활용을 빈칸 → 디버깅 → 함수 작성 순서로 점진적으로 끌어올리고, 마지막에 응용 함수 작성 문제로 현재 실력을 진단한다.

학습 내용 정리

1) dx/dy 이동 + 경계 체크 — (행, 열) 규약 복습

로봇이 N×N 격자에서 상하좌우 명령을 받아 이동하는 문제. 격자를 벗어나는 이동은 무시한다.

def solution(n, commands):
    direction = {
        'U': (-1, 0),   # 위 = 행 감소
        'D': (1, 0),
        'L': (0, -1),
        'R': (0, 1)
    }
    x, y = 0, 0
    for cmd in commands:
        nx = x + direction[cmd][0]
        ny = y + direction[cmd][1]
        if 0 <= nx < n and 0 <= ny < n:   # ← 18차 약점이었던 y 차원 체크
            x, y = nx, ny
    return (x, y)

18차 약점 재확인: 경계 체크 시 x 차원만 검사하고 y 차원을 빠뜨린 실수가 있었다. 오늘은 힌트 없이 0 <= ny < n까지 스스로 썼다 → 완전 정착.

좌표 규약 핵심: (행, 열) 규약에서

• '위'로 가면 행이 감소 (인덱스 값 작은 쪽 위)
• '왼쪽'으로 가면 열이 감소

2) 2차원 배열 90도 회전 — 공식 재암기

수업 중 질문: "공식 가르쳐줬었는데 기억 안나네"

시간이 좀 지나니 18차에 배운 회전 공식이 가물가물해졌다. 개념부터 재구축.

직관적 규칙

원본:              시계 90도:
1 2 3              7 4 1
4 5 6       →      8 5 2
7 8 9              9 6 3

눈에 보이는 규칙: 원본의 첫 번째 열 [1, 4, 7]이 회전 후 맨 윗줄에 뒤집혀서 [7, 4, 1]로 들어간다.

공식

rotated[i][j] = arr[n - 1 - j][i]

왜 이렇게 되는가 — 인덱스 추적

외우는 팁 (18차 때와 동일한 분해)

i → 원본의 "열"로 간다
j → 원본의 "행"으로 뒤집혀서 간다 (n-1-j)

행/열이 서로 바뀌고(transpose) + 새 행 쪽이 뒤집힌다(reverse) → 그래서 zip(*arr[::-1]) 한 줄 풀이도 가능했던 것.

교훈: 한동안 안 보면 공식은 날아간다. 주기적으로 다시 노출할 것.

3) K번 회전 + 주기성

K가 10억이어도 빠르게 동작해야 한다 → 주기성 활용.

def solution(arr, k):
    n = len(arr)
    k = k % 4          # ① 90도 회전 4번이면 원상복구 = 주기 4

    for _ in range(k): # ② 나머지 횟수만큼만 회전
        rotated = [[0] * n for _ in range(n)]
        for i in range(n):
            for j in range(n):
                rotated[i][j] = arr[n - 1 - j][i]
        arr = rotated
    return arr

18차에 배운 K % 주기 패턴이 새 문제에서도 즉시 적용됐다. 스택/큐에서 "무엇을 저장할지" 판단이 정착한 것처럼, 주기성 감각도 정착 단계.

보너스 — 테스트 시 [row[:] for row in arr]의 의미: 2차원 배열의 깊은 복사. 바깥 리스트만 복사하는 arr[:]은 내부 행이 공유되어 원본 오염 가능. 각 행까지 복사해야 안전. 16차에 정착한 원본 보존 패턴의 연장선.

4) 2차원 경계 순회 — "값 기반 중복 체크"의 함정

N×N 배열의 경계를 시계 방향으로 순회해 값 리스트를 반환하는 함수. 처음 작성한 풀이:

def solution(arr):
    dx = [0, 1, 0, -1]   # 우 하 좌 상
    dy = [1, 0, -1, 0]
    n = len(arr)
    d = 0
    x, y = 0, 0
    result = []

    while d < 4:
        if arr[x][y] not in result:   # ← 여기가 문제
            result.append(arr[x][y])
        nx, ny = x + dx[d], y + dy[d]
        if 0 <= nx < n and 0 <= ny < n:
            x, y = nx, ny
        else:
            d += 1
    return result

주어진 테스트 4개(3x3, 4x4, 1x1, 2x2)는 전부 통과. 하지만 반례가 있었다.

반례

arr = [[1, 2, 1],
       [3, 4, 5],
       [1, 6, 7]]
# 기대: [1, 2, 1, 5, 7, 6, 1, 3]
# 실제: [1, 2, 5, 7, 6, 3]     ← 중복 값이 전부 사라짐

원인

result에 값을 저장하고 값으로 중복 체크 → 경계에 같은 값이 여러 번 나오면 하나로 취급된다. arr[x][y] not in result 가드는 "코너에서 방향 바뀔 때 같은 칸을 두 번 기록하는 것"을 막으려는 의도였으나, 값으로 판단해서 다른 위치의 동일 값까지 막아버린다.

올바른 방법 — 좌표(위치) 기반 체크

def solution(arr):
    dx = [0, 1, 0, -1]
    dy = [1, 0, -1, 0]
    n = len(arr)
    d = 0
    x, y = 0, 0
    result = [arr[0][0]]       # ← 첫 값을 루프 전에 세팅
    visited = {(0, 0)}          # ← 좌표 set으로 방문 체크

    while d < 4:
        nx, ny = x + dx[d], y + dy[d]
        if 0 <= nx < n and 0 <= ny < n and (nx, ny) not in visited:
            x, y = nx, ny
            visited.add((x, y))
            result.append(arr[x][y])
        else:
            d += 1
    return result

핵심 변화: 방문 체크 대상이 값 → 좌표로 바뀌었다. 이것이 인덱스+값 병렬 처리 패턴의 전형.

반복되는 학습 패턴 — "테스트 통과 ≠ 정답"

앞으로 지킬 습관: 풀이를 내기 전 "이 풀이가 깨지는 입력이 뭘까?" 반례를 상상해보기. 특히 "값 기반 체크"는 중복을 의심.

5) 점수 순 학생 정렬 — zip + sorted + key 컴비네이션

names[i] 학생이 scores[i]점일 때, 점수 내림차순 이름 반환 (동점은 입력 순서 유지).

def solution(names, scores):
    # 단계별 버전
    result = list(zip(names, scores))
    result2 = sorted(result, key=lambda x: x[1], reverse=True)
    result3 = [name for name, score in result2]
    return result3


def solution(names, scores):
    # 한 줄 버전
    return [name for name, _ in sorted(zip(names, scores),
                                       key=lambda x: x[1],
                                       reverse=True)]

세 가지 핵심 도구

# ① zip — 두 리스트를 같은 인덱스로 묶기
list(zip(["A","B","C"], [1, 2, 3]))
# [('A', 1), ('B', 2), ('C', 3)]

# ② sorted + key + reverse — 기준과 방향 지정
sorted([('A', 85), ('B', 92)], key=lambda x: x[1], reverse=True)

# ③ enumerate — 값 + 원본 인덱스
list(enumerate(["철수","영희"]))
# [(0, '철수'), (1, '영희')]

동점 시 원래 순서 유지 — Python sorted의 stable sort 특성

Python sorted()는 안정 정렬(stable sort) 이다. 같은 키 값을 가진 원소들은 입력 순서를 보존한다. 그래서 동점 92점인 영희와 지영 중 영희가 먼저 나왔다.

시험에 "동점 시 원래 순서 유지" 문구가 나오면 별도 처리 없이 sorted 그냥 쓰면 된다.

6) 오늘의 자기 진단 — 다음 학습 주제 선정

수업 중 질문: "이해했어. 최초 값 미리 세팅해두는 걸 자꾸 깜빡하네.
             그리고 파이썬에서 인덱스(위치)랑 값을 별도 리스트에 저장한 다음
             같은 인덱스로 돌면서 처리하는 게 많이 나오는데 아직 익숙하지 않은듯"

정확한 자기 진단이다. 두 포인트가 다음 단계 핵심:

약점 1: 첫 값 미리 세팅을 깜빡함

루프 안에서 "이동 후 기록" 구조를 쓰면, 시작 위치는 이동 없이 거기 있으니 루프 전에 먼저 넣어줘야 한다.

• result = [arr[0][0]], visited = {(0,0)} 같은 초기화
• 슬라이딩 윈도우에서 첫 윈도우 합은 루프 전에 계산하는 패턴과 동일 (15차)

약점 2: 인덱스+값 병렬 관리 패턴 미숙

이미 경험한 문제들을 관통하는 공통 패턴:

공통 도구: enumerate, zip, 튜플 리스트 + sort, 좌표 키 set/dict.

이 다섯 문제를 하나의 범주로 묶어 이해하는 시점이 왔다 → 다음 세션에서 집중 훈련.

오늘의 결과

총 5문제 풀이, 1차 정답 3/5 (60%) — 감각 복귀 구간치고는 양호. 18차 약점(y 차원 경계 체크)은 힌트 없이 해결하며 정착 확인. 다음 세션은 오늘 스스로 진단한 인덱스+값 병렬 패턴을 핵심 주제로 잡고 enumerate/zip/튜플 정렬을 집중 훈련한다.

4/15 18차 세션에서 구현/시뮬레이션 기초로 dx/dy 좌표 이동과 2차원 배열 90도 회전(zip(*arr[::-1]))을 학습했다. 빈칸 3칸 전부 1차 정답, 함수 작성 로직도 완벽했고 (행,열) 좌표 규약도 시각적 분해로 이해했다. 4/13 17차에서 처음 접한 스택/큐는 1차 정답률 50%로, 그때 "스택에 무엇을 저장할지" 판단과 빈 스택 체크 두 가지가 약점으로 남아있었다.

오늘 수업 계획

17차 스택/큐 약점 2가지를 스스로 극복할 수 있는지 확인하는 것이 오늘의 주요 목표. 괄호 문자열을 재료로 5문제를 풀며 점진적으로 난이도를 올렸다.

학습 내용 정리

1) 스택에 "무엇을 저장할지" 판단 — 인덱스 저장 패턴

짝이 맞지 않는 여는 괄호의 위치를 반환하는 문제였다. 17차 약점이 바로 이 부분이었는데, 이번엔 스스로 판단했다.

핵심 규칙: 스택에 저장할 값은 "나중에 뭘 반환해야 하는지" 에서 역산한다.

• 위치(인덱스)를 반환해야 함 → 스택에 i를 저장
• 그냥 괄호 자체(()를 저장하면 나중에 위치 복원 불가

def solution(s):
    stack = []
    for i in range(len(s)):
        if s[i] == '(':
            stack.append(i)      # ← 위치 저장
        else:  # ')'
            if not stack:
                return i         # 닫는 괄호가 먼저 → 그 위치
            stack.pop()
    if stack:
        return stack[0]          # "가장 먼저 나온" → 첫 번째
    return -1

포인트: stack[0] vs stack[-1] 구분.

• "가장 먼저 나온 것" = 제일 먼저 append된 것 = stack[0]
• "가장 나중" = stack[-1]

스택은 단순 LIFO 자료구조가 아니라 순서 정보를 담은 기록 장치로 활용하는 감각이 생겼다.

2) 빈 스택 체크 — 단락평가(short-circuit) 패턴

연속된 같은 문자를 제거하는 "쌍쌍 지우기" 디버깅 문제였다.

버그가 있는 원본:

if stack[-1] == ch:
    stack.pop()

첫 글자에서 스택이 비어있으면 IndexError 발생.

수정:

if stack and stack[-1] == ch:
    stack.pop()

Python의 and는 단락평가를 한다. 앞이 False면 뒤는 아예 평가하지 않음.

• stack이 빈 리스트([]) → Falsy → stack and ... 전체가 False → stack[-1] 아예 접근하지 않음
• stack이 비어있지 않음 → Truthy → 뒤 조건 평가

이 패턴은 stack[-1], queue[0], lst[i], dict[key] 접근 전 어디든 쓸 수 있는 관용구다. not stack 체크 후 return/continue하는 방식과 동등하지만 한 줄로 처리된다.

3) 큐 + (인덱스, 우선순위) 튜플 추적 — 17차 힌트 유형

"프린터 우선순위" 유형. 17차에서는 힌트가 필요했지만 이번엔 스스로 설계했다.

from collections import deque

def solution(priorities, target):
    queue = deque((idx, p) for idx, p in enumerate(priorities))
    count = 0

    while queue:
        idx, p = queue.popleft()
        if queue and p < max(p for _, p in queue):
            queue.append((idx, p))
        else:
            count += 1
            if idx == target:
                return count

핵심 설계 결정:

• 큐에 단순 우선순위 값만 넣으면 원래 위치를 잃어버림 → 튜플로 (인덱스, 우선순위) 함께 저장
• _로 인덱스 무시: max(p for _, p in queue) — 언패킹 관용구
• queue and 단락평가로 마지막 하나 남은 경우 max() 에러 방지 → 위 2번에서 배운 패턴을 여기에도 적용

17차에서 힌트 받았던 "스택에 무엇을 저장할지"가 큐 문제에서도 같은 원리로 작동한다는 것을 체감했다.

4) 여러 종류 괄호 매칭 — 딕셔너리 매핑 활용

(, {, [ 세 종류가 섞인 문자열의 올바름을 판단하는 문제.

def solution(s):
    brackets = {"[":"]", "(":")", "{":"}"}
    stack = []

    for ch in s:
        if ch in brackets:
            stack.append(ch)
        else:
            if stack and ch == brackets[stack[-1]]:
                stack.pop()
            else:
                return False
    return not stack  # 남은 여는 괄호 없으면 True

핵심 설계:

• 딕셔너리로 여는→닫는 매핑을 선언 → if/elif 지옥 회피
• ch in brackets → dict의 키 존재 체크, 여는 괄호 판별로 활용
• brackets[stack[-1]] → 스택 맨 위 여는 괄호의 짝(닫는 괄호) 을 조회
• return not stack → 마지막에 남은 여는 괄호 없으면 True (Falsy 체크)

5) 중첩 깊이 최댓값 — 해석 오류와 교정

여기서 오늘의 실수가 나왔다. "괄호 중첩 깊이"를 완성된 괄호 쌍의 수로 해석해 버렸다. 그래서 연속된 )의 개수를 추적하는 창의적인(?) 풀이를 만들었다.

# 잘못된 풀이 (핵심 부분)
if ch == "(":
    if count > 0:
        count = 0          # )가 나오다가 (가 나오면 리셋
    stack.append(ch)
elif ch == ")":
    stack.pop()
    count += 1             # 연속 ) 개수 카운트
    max_count = max(max_count, count)

주어진 7개 테스트는 전부 통과했다. 하지만 반례 하나에서 무너졌다.

반례: "((())())"

( ( ( ) )  ( ) )
1 2 3 2 1  2 1 0   ← 실제 깊이: 최대 3

최대 깊이 3을 찍고 2만 닫은 뒤 다시 열기 때문에 "연속 ) 개수"는 2밖에 안 된다. 내 풀이는 2를 반환. 정답은 3.

개념 교정:

• 중첩 깊이 = "그 시점에 동시에 열려있는 괄호의 개수" = 스택 크기
• 완성 여부는 상관 없음. 닫기 전이라도 "열려있으면 카운트"

비유하자면 바다 수영에서 깊이 3m는 "지금 발 밑에 물이 3m 있다"이지, "3m까지 내려갔다가 수면까지 다시 올라온 횟수"가 아니다.

교정 후 풀이:

def solution(s):
    max_depth = 0
    depth = 0
    for ch in s:
        if ch == "(":
            depth += 1
            max_depth = max(max_depth, depth)
        elif ch == ")":
            depth -= 1
    return max_depth

이 문제에서는 스택이 필요 없다. 지금 몇 개 열려있는가만 알면 되기 때문에 단순 카운터로 충분하다. depth는 사실상 "스택 크기"와 같은 값을 추적하는 것이다.

도구 선택 감각: 스택은 "LIFO 순서나 저장했다가 나중에 꺼낼 정보"가 있을 때 빛난다. 이 문제는 그런 요구가 없어서 카운터가 더 직관적이다.

오늘의 교훈 — 반례를 스스로 떠올려보기

주어진 테스트케이스 7개를 전부 통과해도, 출제자가 놓쳤을 법한 패턴을 스스로 떠올려보는 검증 습관이 필요하다. 특히 "일반적이지 않은 접근" 으로 풀었다면 더욱 그렇다. 오늘처럼 "연속 ) 개수 추적" 같은 간접 지표로 푸는 경우엔 그 지표가 정말 원래 목표값과 동치인지 반례로 검증해야 한다.

오늘의 결과

5문제 해결, 1차 정답 4/5(80%). 17차 약점 2가지(스택에 무엇을 저장할지 / 빈 스택 체크)는 완전 정착 판정.

• 스택과 큐 개념 학습: 리스트 기반 스택, collections.deque 기반 큐, 괄호 매칭/요세푸스/프린터 우선순위 등 6문제 풀이
• 스택 활용 시 "무엇을 저장할지" 판단하는 부분에서 약간의 혼동이 있었으나 힌트 후 해결
• 이어서 미학습 유형인 구현/시뮬레이션으로 넘어감

오늘 수업 계획

COS Pro 단골 유형인 구현/시뮬레이션 기초를 다룬다. 좌표 이동 패턴(dx/dy), 2차원 배열 90도 회전을 핵심 개념으로 잡고 빈칸 2문제 + 함수 작성 1문제를 푼다.

학습 내용 정리

1. 좌표 이동 dx/dy 패턴

시뮬레이션 문제의 출발점. 상하좌우를 일일이 if-else로 쓰지 않고, 방향 배열 두 개로 한 번에 처리한다.

# 북, 동, 남, 서 (시계방향)
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]

for i in range(4):
    nx = x + dx[i]
    ny = y + dy[i]

핵심: dx, dy의 배열 순서는 방향 순서(N/E/S/W 또는 U/R/D/L)에 따라 달라진다. 문제마다 방향 규약을 먼저 확인해야 한다.

수업 중 질문: "dx dy에 방향값 넣어두는건 방향 순서에 따라 달라지겠네?" → 정확한 일반화. 이전에 푼 소용돌이 문제에서 방향이 우→하→좌→상 순서로 돌았던 것을 떠올리면, 그 문제의 dx/dy와 이번 문제의 dx/dy가 왜 다른지 자연스럽게 연결된다.

2. 경계 체크 (Out-of-bound 방어)

좌표 이동 후 새 좌표가 격자 안에 있는지 확인하는 패턴.

if 0 <= nx < N and 0 <= ny < N:
    x, y = nx, ny   # 유효하면 이동
# 아니면 그대로 (명령 무시)

피드백 포인트: 경계 체크를 0 <= x < N처럼 이동 전 좌표로 쓰거나, y 차원을 빠뜨리는 실수가 잦다.

• 체크 대상은 반드시 이동 후 좌표(nx, ny)
• 2차원이면 x, y 둘 다 검사해야 함 (and로 연결)

3. 2차원 배열 90도 시계 회전

공식 버전:

def rotate_once(arr):
    N = len(arr)
    rotated = [[0]*N for _ in range(N)]
    for i in range(N):
        for j in range(N):
            rotated[j][N-1-i] = arr[i][j]
    return rotated

Pythonic 버전:

rotated = [list(row) for row in zip(*arr[::-1])]

수업 중 질문: "zip 사용한 부분이 왜 90도 회전이랑 같아지는지 모르겠다." → 시각적 분해로 이해하면 쉽다.

1. arr[::-1] — 위아래 뒤집기 (행 순서 역전)
2. zip(*...) — 전치(transpose), 즉 행↔열 교환
3. 뒤집기 + 전치 = 시계방향 90도 회전

수학적 증명보다는 "왜 이게 그렇게 되는지 그림으로 한 번 그려보기"가 기억에 잘 남는다.

4. 주기성 활용 — K % 4

같은 회전을 K번 반복할 때, 4번 돌면 원상복귀하므로 K = K % 4로 불필요한 반복을 제거한다.

K = K % 4
for _ in range(K):
    result = rotate_once(result)

이 패턴은 회전뿐 아니라 순환 구조 전반에 쓰인다. 요세푸스, 원형 큐, 방향 회전 등.

5. (행, 열) 좌표 규약

구현 문제에서 가장 헷갈리는 부분. 리스트 기반 2차원 배열은 수학 좌표계와 다르다.

왜 이렇게 쓰는가? grid[x][y]라고 쓰면, grid[x]가 먼저 행을 선택하고, 그 다음 [y]가 열을 고른다. 즉 x는 행 번호(세로 위치), y는 열 번호(가로 위치)가 되는 것이 자연스럽다.

수업 중 질문: "행열 규약이 왜 저런지 아직 이해 못했어." → 수학식으로 이해하려 하지 말고, 리스트 구조가 원래 그렇게 생겼다고 받아들이는 것이 실전에 빠르다. 문제 풀 때 "북이면 x를 줄인다"만 기억하면 됨.

6. 방향 전환 로직 — % 4

L/R 명령으로 방향을 바꿀 때:

# 방향: 0(북) 1(동) 2(남) 3(서)
if cmd == 'R':
    d = (d + 1) % 4
elif cmd == 'L':
    d = (d - 1) % 4   # Python은 음수 % 양수도 자동 양수화

Python의 %는 음수에서도 양수 결과를 반환하므로 (d-1) % 4가 안전하게 작동한다. (Java/C는 음수 나올 수 있어 주의.)

7. 문제에서 예시 답을 의심하는 능력

오늘의 중요 발견: 함수 작성 문제에서 (가로, 세로) 좌표계로 dx/dy를 짠 답과 예시 답이 달랐다. 학습자가 먼저 "예시 답이 정확한지 검증해달라"고 요청 → 확인해보니 학습자의 로직도 완벽했고, 단지 좌표 규약이 (가로,세로)냐 (행,열)이냐의 차이였다.

피드백 포인트:

• 자기 답이 틀렸다고 바로 단정하지 말 것
• 예시 답과 다르면 규약 차이인지 로직 오류인지부터 구분해야 함
• COS Pro 실전에서는 문제에 명시된 좌표 규약을 먼저 확인하고 시작하는 습관이 중요

오늘의 결과

• 풀이 3문제 (빈칸 2, 함수 작성 1) / 1차 정답률 100% (경계 체크 부분만 힌트 후 수정)
• 좌표 이동 dx/dy + 90도 회전 + K%4 주기성 — 구현 3대 기초 패턴 습득
• 다음 학습(4/16)은 구현/시뮬레이션 기초 마무리 (달팽이 배열, 종이접기 등 복합 시뮬레이션 예정)

• 약점 집중 연습 2회차에서 원본 보존 패턴, 순환 순회 범위 모두 정착 판정
• 주요 약점 전부 해소 → 실력 강화 기간으로 전환 결정
• 아직 안 다룬 유형: 스택/큐, 그리디, BFS/DFS, 이진 탐색, DP 등

오늘 수업 계획

COS Pro 출제 범위 중 미학습 유형인 스택과 큐를 집중 학습한다. 개념 설명 후 빈칸/디버깅/함수 작성 6문제를 풀며 핵심 패턴을 익힌다.

학습 내용 정리

1. 스택 (Stack) — LIFO

마지막에 넣은 걸 먼저 꺼내는 구조. Java에서는 Stack 클래스를 쓰지만, Python에서는 그냥 리스트로 스택을 구현한다.

2. 큐 (Queue) — FIFO

먼저 넣은 걸 먼저 꺼내는 구조. 리스트의 pop(0)은 O(n)이라 느리므로, collections.deque를 사용한다.

from collections import deque

queue = deque()
queue.append(1)        # 뒤에 넣기
front = queue.popleft() # 앞에서 꺼내기 — O(1)

COS Pro 포인트: 큐 문제가 나오면 deque를 import하는 게 정석이다.

3. 빈 컨테이너 체크 — not 활용

수업 중 질문: "stack이 리스트니까 not list도 되는 거야? dict이나 튜플 같은 다른 자료구조는?"

Python의 모든 컨테이너에 동일하게 적용된다:

not []         # True  (빈 리스트)
not {}         # True  (빈 딕셔너리)
not ()         # True  (빈 튜플)
not set()      # True  (빈 집합)
not deque()    # True  (빈 덱)
not ""         # True  (빈 문자열)

Java의 isEmpty()를 모든 자료구조에 통일해서 쓸 수 있는 셈. COS Pro 빈칸에서 not 변수명이 나오면 "비어있는지 확인"이라고 읽으면 된다.

# 이 둘은 같은 의미
if len(stack) == 0:    # 명시적
if not stack:          # Pythonic — 시험에서 자주 나오는 형태

4. 괄호 매칭 — 스택의 대표 패턴

단일 괄호 검사

여는 괄호를 만나면 push, 닫는 괄호를 만나면 스택이 비어있는지 확인 후 pop.

def is_valid_parentheses(s):
    stack = []
    for char in s:
        if char == '(':
            stack.append(char)
        elif char == ')':
            if not stack:       # 짝이 없다
                return False
            stack.pop()
    return not stack            # 남은 괄호 없으면 True

다중 괄호 검사 ((), {}, [])

딕셔너리로 여는/닫는 괄호의 짝을 매핑한다:

def is_valid_brackets(s):
    stack = []
    brackets = {"[": "]", "(": ")", "{": "}"}

    for char in s:
        if char in brackets:           # .keys() 생략 가능!
            stack.append(char)
        elif char in brackets.values():
            if not stack or brackets[stack[-1]] != char:
                return False
            stack.pop()
    return not stack

딕셔너리 팁: "[" in brackets는 기본적으로 key에서 검색한다. .keys() 안 붙여도 된다.

5. 브라우저 뒤로가기 — 스택 활용

수업 중 질문: "visit과 back 개수가 같으면 '홈'으로 돌아가는 조건이 따로 필요한 거 아니야?"

"홈"도 visit할 때 스택에 들어가기 때문에 별도 조건 없이 자동으로 복귀된다.

def browser_history(actions):
    history = []
    current = "홈"
    for action, value in actions:
        if action == "visit":
            history.append(current)   # ← 새 페이지가 아니라 "지금 페이지"를 저장!
            current = value
        elif action == "back":
            if history:
                current = history.pop()
    return current

핵심 포인트: 스택에 저장하는 건 "어디로 가는지(value)"가 아니라 "어디서 왔는지(current)". 뒤로 가기니까!

6. 요세푸스 문제 — 큐로 원형 순환

N명이 원형으로 앉아있고 K번째 사람을 순서대로 제거하는 문제. 큐로 원형을 표현하는 트릭: 앞에서 빼서 뒤로 보내면 원형처럼 동작한다.

from collections import deque

def josephus(n, k):
    queue = deque(range(1, n + 1))  # deque는 range를 직접 받을 수 있다
    result = []
    while queue:
        for _ in range(k - 1):         # k-1명 건너뛰기
            queue.append(queue.popleft())  # 앞에서 빼서 뒤로
        result.append(queue.popleft())     # k번째 사람 제거
    return result

7. 프린터 우선순위 — 큐 + 튜플 추적

우선순위가 높은 문서가 먼저 인쇄되는 프린터. 내 문서가 몇 번째로 인쇄되는지 구하는 문제.

수업 중 질문: "'deque mutated during iteration' 에러는 뭐야?"

deque를 for로 순회하는 도중에 내용을 변경하면 발생하는 에러. while로 바꿔서 해결한다.

from collections import deque

def print_order(priorities, target):
    queue = deque((p, idx) for idx, p in enumerate(priorities))
    count = 0
    while queue:
        p, idx = queue.popleft()
        if queue and p < max(p for p, _ in queue):
            queue.append((p, idx))    # 우선순위 낮으면 뒤로
        else:
            count += 1
            if idx == target:         # 내 문서면 바로 반환
                return count

핵심: 큐에 (우선순위, 원래 인덱스) 튜플을 넣어서 내 문서를 추적한다. 인쇄 즉시 카운터로 반환하면 불필요한 순회를 줄일 수 있다.

오늘의 결과

• 스택/큐 개념 + 6문제 풀이 (1차 정답 3문제, 최종 전부 정답)
• 핵심 패턴 정리: 괄호 매칭, 원형 순환, 우선순위 큐
• 다음 학습: 그리디 알고리즘 개념 및 문제 풀이

• 약점 집중 연습 1회차에서 슬라이딩 윈도우 완전 정착 확인
• 문자열 순환 text*2 패턴 정착, 순회 범위 구분은 추가 연습 필요
• 데이터 변환 후 원본 소실 실수 1건 발견 — 반복 노출 필요 판정

오늘 수업 계획

남은 약점 2가지(원본 보존, 순환 순회 범위)를 집중 연습하고, 두 패턴을 결합한 종합 문제까지 도전한다.

학습 내용 정리

1. 원본 보존 패턴 — "비교는 변환, 반환은 원본"

COS Pro에서 자주 나오는 패턴이다. 대소문자 무시하고 비교하되, 결과는 원래 형태 그대로 돌려줘야 하는 문제.

핵심 원칙은 간단하다:

for w in words:
    if w.lower().startswith(prefix_lower):  # 비교할 때만 변환
        result.append(w)                     # 결과엔 원본

주의할 점은 변환한 리스트를 따로 만들어서 순회하면 안 된다는 것이다.

# 잘못된 패턴
cleaned_words = [w.lower() for w in words]
for word in cleaned_words:  # 여기서 이미 원본을 잃음
    result = word           # 소문자 버전이 저장됨

# 올바른 패턴
for word in words:          # 원본 리스트를 순회
    if word.lower() == ...: # 비교만 변환
        result = word       # 원본 저장

디버깅 문제에서 cleaned_words라는 변수가 만들어져 있었는데, isalpha()로 알파벳만 세는 로직에서는 사실 대소문자 변환 자체가 불필요했다. 이런 함정용 변수를 코드에 넣어두고 순회 대상을 바꾸게 만드는 유형이 시험에 나올 수 있으니, 코드 전체를 비판적으로 읽는 습관이 중요하다.

2. 중복 제거 순서의 중요성

평균 이상인 학생을 점수 내림차순으로 반환하되, 동명이인(대소문자 무시)은 먼저 나온 학생만 포함하는 함수를 작성했다.

처음에는 정렬 후 중복 제거를 했더니, 점수가 높은 쪽이 먼저 처리되어 원래 순서의 이름이 아닌 다른 대소문자 버전이 남았다.

# 문제가 되는 순서
students_sorted = sorted(students, key=lambda x: x[1], reverse=True)
# ("ALICE", 90)이 ("Alice", 85)보다 먼저 → "ALICE"가 남음

# 올바른 순서: 중복 제거(원본 순서) → 필터 → 정렬

"먼저 나온"이라는 기준은 원본 리스트 순서를 의미하므로, 정렬 전에 중복 제거를 해야 한다.

수업 중 질문: "코드가 마음에 안 드는데 더 효율적이고 깔끔한 방법 추천해줘" → 두 가지 개선 포인트를 배웠다:

특히 set을 이용한 중복 체크는 시험에서도 자주 쓰이는 최적화 패턴이다.

# 최종
def above_average_students(students):
    avg = sum(s for _, s in students) / len(students)

    seen = set()
    unique = []
    for name, score in students:
        if name.lower() not in seen and score >= avg:
            seen.add(name.lower())
            unique.append((name, score))

    return [name for name, score in sorted(unique, key=lambda x: x[1], reverse=True)]

3. 순환 순회 범위 복습 — len(text)가 정답

원형 문자열에서 길이 k인 부분 문자열을 탐색할 때:

extended = text * 2
for i in range(len(text)):  # len(extended)-k 아님!
    sub = extended[i:i+k]

text * 2로 확장해도, 원래 문자열의 시작 위치는 len(text)개뿐이다. len(extended) - k를 쓰면 중복 탐색이 발생한다.

4. 종합 문제 — 순환 + 원본 보존

마지막 문제는 원형 배치된 학생 이름 리스트에서 연속 k명의 이름을 이어붙인 문자열이 사전순으로 가장 빠른 그룹을 찾아 원래 이름 리스트로 반환하는 함수였다.

두 약점을 한 번에 적용해야 하는 종합 문제:

def smallest_circular_group(names, k):
    names_extended = names * 2                              # 순환 처리
    names_lowered = [name.lower() for name in names_extended]  # 비교용 변환

    result = "".join(names_lowered[:k])
    result_idx = 0

    for i in range(1, len(names)):                          # 순회 범위: len(names)
        sub = "".join(names_lowered[i:k+i])
        if sub < result:
            result = sub
            result_idx = i

    return names_extended[result_idx: result_idx+k]         # 반환은 원본

• names_lowered로 비교하고 names_extended에서 꺼내서 원본 보존
• 순회 범위는 len(names)로 정확히 제한
• result_idx로 위치를 추적해서 원본 리스트에서 슬라이싱

참고: 디버깅용 print()는 시험 제출 전에 반드시 삭제해야 한다. 감점 요인이 될 수 있다.

오늘의 결과

• 약점 연습 5문제 전부 1차 정답 — 원본 보존, 순환 범위 모두 정착 판정
• 주요 약점 모두 해소 완료, 내일부터 프로그래머스/백준 문제 풀이로 전환

• 구름EDU 기출 3회차 전체 완료 (10문제 모두 최종 정답)
• 슬라이딩 윈도우, 문자열 순환 처리(text*2) 새로 학습
• 내장함수명 변수 사용, 하드코딩 습관 재발 → 지속 주의 필요

오늘 수업 계획

• 14차에서 발견된 취약 영역 3가지를 집중 복습
• 슬라이딩 윈도우 → 문자열 순환 → 함수 작성 종합 순서로 총 6문제

학습 내용 정리

1. 슬라이딩 윈도우 — 빈칸 채우기

연속된 k개 원소의 합이 최대인 구간의 합을 구하는 함수.

def max_subarray_sum(nums, k):
    if len(nums) < k:
        return 0

    window_sum = sum(nums[:k])       # (a) 첫 윈도우
    max_sum = window_sum

    for i in range(k, len(nums)):    # (b) k부터 시작
        window_sum += nums[i] - nums[i-k]  # (c) 왼쪽 제거
        if window_sum > max_sum:
            max_sum = window_sum

    return max_sum

슬라이딩 윈도우 핵심 구조

1. 첫 윈도우: sum(nums[:k])로 초기값 계산
2. 이동 시작: 첫 윈도우 이미 구했으므로 range(k, len(nums))
3. 갱신: 오른쪽 추가(nums[i]) - 왼쪽 제거(nums[i-k])

14차에서는 range 시작값에서 힌트가 필요했는데, 이번엔 바로 정답!

2. 슬라이딩 윈도우 — 함수 작성

연속된 k개 원소의 평균이 최대인 구간의 시작 인덱스를 반환하는 함수.

def solution(nums, k):
    std_sum = sum(nums[:k])
    std_idx = 0
    max_sum = std_sum

    for i in range(k, len(nums)):
        std_sum += nums[i] - nums[i-k]
        if std_sum > max_sum:
            max_sum = std_sum
            std_idx = i - k + 1

    return std_idx

포인트

• 합이 최대면 평균도 최대 — k가 고정이니까 나누기 불필요. 불필요한 연산을 줄이는 판단이 좋았다는 피드백을 받았다.
• 시작 인덱스: i - k + 1 (빠진 원소의 다음 인덱스)
• > vs >=: 같은 합일 때 앞쪽 인덱스를 유지해야 하므로 >(초과) 사용

수업 중 질문: "첫번째 문제처럼 len(nums) < k인 경우는 없어?" → COS Pro 실제 시험에서는 보통 입력 조건이 보장되어 있어서 예외 처리 없이 바로 로직에 집중하면 된다.

3. 문자열 순환 — 빈칸 채우기

문자열을 원형(순환)으로 간주하여 연속된 k글자 중 사전순으로 가장 앞서는 부분 문자열을 반환하는 함수.

def earliest_circular_substring(text, k):
    extended = text * 2            # (a) 순환 처리
    result = extended[:k]

    for i in range(1, len(text)):  # (b) 고유 시작점은 len(text)개
        substring = extended[i:i+k]
        if substring < result:
            result = substring

    return result

순환 처리 핵심

• text * 2: 문자열을 두 번 이어붙여서 끝을 넘어가는 케이스 해결
• 순회 범위는 len(text): 원형 문자열에서 고유한 시작점은 원본 길이만큼만 존재

처음에 len(extended) - k로 답했는데, 동작은 하지만 중복 순회가 발생한다. 시험 빈칸 채우기에서는 len(text)가 정답이므로 오답 처리될 수 있다는 피드백을 받았다.

4. 문자열 순환 — 함수 작성

문자열을 순환으로 간주하여 연속된 k글자로 만들 수 있는 서로 다른 부분 문자열의 개수를 반환하는 함수.

def solution(text, k):
    extended = text * 2
    str_set = set()

    for i in range(0, len(text)):
        sub_str = extended[i:i+k]
        str_set.add(sub_str)

    return len(str_set)

포인트

• set()으로 중복 제거 — "서로 다른 개수"에 딱 맞는 자료구조
• 앞 문제 피드백을 바로 반영하여 len(text) 범위로 정확히 설정
• 변수명 str_set — str로 지었으면 내장함수를 덮어쓸 뻔했는데 잘 피함

5. 함수 작성 종합 (1) — 상하위 평균 차이

학생들의 점수에서 상위 k명과 하위 k명의 평균 차이를 반환하는 함수.

def solution(scores, k):
    sorted_scores = sorted(scores)
    high_avg = sum(sorted_scores[-k:]) / k
    low_avg = sum(sorted_scores[:k]) / k

    return high_avg - low_avg

포인트

• sorted()로 원본 안 건드림 (좋은 습관)
• [-k:], [:k] 슬라이싱 정확
• 변수명 sorted_scores — 내장함수명 안 겹침

수업 중 질문: "abs() 감싼다는 건 마지막 return할 때 abs(high_avg - low_avg) 하라는 거야?" → 맞다. 이 문제에서는 정렬 후 상위 >= 하위가 보장되지만, "절댓값으로 반환하라"는 조건이 명시된 문제라면 abs()를 감싸는 게 안전하다.

풀이 중 출제자가 제시한 예시 답(35.0)이 틀렸다는 것을 직접 계산해서 발견했다 (정답: 40.0). 검증 습관이 좋다는 피드백을 받았다.

6. 함수 작성 종합 (2) — 모음 최다 단어

문자열 리스트에서 모음(a, e, i, o, u)이 가장 많은 단어를 반환하는 함수.

첫 번째 시도 (버그 있음)

def solution(words):
    lowered_words = [x.lower() for x in words]  # 여기서 원본 소실!
    chk_list = ['a', 'e', 'i', 'o', 'u']
    max_count = 0
    result_word = ""

    for w in lowered_words:  # 소문자 버전을 순회
        ...
        result_word = w      # 소문자 버전이 저장됨

    return result_word

문제: lowered_words를 순회하면서 result_word에 소문자 변환된 값이 저장된다. ["APPLE"] 입력 시 "apple"이 반환됨.

수정 후 (정답)

def solution(words):
    chk_list = ['a', 'e', 'i', 'o', 'u']
    max_count = 0
    result_word = ""

    for w in words:              # 원본을 순회
        cnt = 0
        for ch in w.lower():    # 비교할 때만 소문자로
            if ch in chk_list:
                cnt += 1
        if cnt > max_count:
            max_count = cnt
            result_word = w      # 원본이 저장됨

    return result_word

데이터 변환 시 원본 보존 패턴

핵심: 비교/검색에만 변환을 쓰고, 결과에는 원본을 저장할 것!

추가로 chk_list 대신 문자열로도 가능하다는 팁을 받았다: if ch in "aeiou"

오늘의 결과

• 6문제 풀이, 1차 정답률 67% (4/6) — 함수 작성 3/4로 개선 추세 유지
• 슬라이딩 윈도우 완전 정착, 내장함수명 변수 사용·하드코딩 미발생
• 다음 학습: 프로그래머스/백준 문제 풀이로 함수 작성 실전 연습 시작

• 구름EDU 기출 3회차 전반부(1, 2, 3, 6, 7번) 5문제 전부 1차 정답
• 배열 회전, 팰린드롬, 소수 판별, 카프리카 수, 비숍 공격 범위 학습
• 3회차 나머지 5문제(4, 5, 8, 9, 10번) 풀이 예정이었음

오늘 수업 계획

• 구름EDU 기출 3회차 나머지 5문제 풀이 (4, 5, 8, 9, 10번)
• 디버깅 2문제 + 빈칸 1문제 + 함수 작성 2문제

학습 내용 정리

1. break vs continue vs pass — 디버깅 (문제 8)

선풍기 대수를 구하는 디버깅 문제. 교실마다 선풍기 4대가 있고, 선풍기 1대당 k명에게 바람을 보낼 때, 추가로 필요한 선풍기 총 대수를 구하는 코드에서 한 줄 수정.

버그: break → continue

for s in student:
    s -= 4 * k
    if s <= 0:
        break       # ❌ 루프 전체 종료 — 뒤 교실 무시
        continue     # ✅ 이 교실 건너뛰고 다음으로
    answer += (s + k - 1) // k

break / continue / pass 차이 정리

이 문제에서 pass를 쓰면 if 블록 이후의 answer += ... 줄이 실행되어 0이하 값이 더해질 수 있다. continue가 정확한 답이다.

2. 슬라이딩 윈도우 — 디버깅 (문제 9)

팝업스토어를 열 최적의 날짜를 찾는 문제. n일간의 매출액 중 연속 k일의 합이 최대인 값을 구한다.

슬라이딩 윈도우 패턴

연속 k개 합을 구할 때, 매번 sum()을 쓰면 느리다. 대신 "하나 빼고 하나 더하기"로 O(n)에 해결한다.

# 첫 윈도우 합
rsum = sum(revenue[0:k])
answer = rsum

# 윈도우를 한 칸씩 밀기
for i in range(k, len(revenue)):    # ← i는 k부터!
    rsum = rsum - revenue[i - k] + revenue[i]
    if answer < rsum:
        answer = rsum

핵심 포인트:

• 첫 윈도우(0~k-1)는 이미 구했으니, for문은 i=k부터 시작
• i는 항상 윈도우의 오른쪽 끝을 가리킴
• revenue[i-k]는 빠지는 왼쪽 값, revenue[i]는 새로 들어오는 오른쪽 값

예시 (k=4, [1, 1, 9, 3, 7, 6, 5, 10]):

첫 윈도우: [1, 1, 9, 3]              → sum = 14
i=4:        1 [1, 9, 3, 7]           → 14 - 1 + 7 = 20
i=5:           [9, 3, 7, 6]          → 20 - 1 + 6 = 25
i=6:              [3, 7, 6, 5]       → 25 - 9 + 5 = 21
i=7:                 [7, 6, 5, 10]   → 21 - 3 + 10 = 28 ← 최대!

수업 중 질문: "range 시작값으로 0이나 1이 아닌 k를 쓰는 이유?" → i가 len을 넘지 않으면서도 i-k가 0부터 시작하게 하려는 것. i가 윈도우의 오른쪽 끝이기 때문에, i=k일 때 첫 번째로 빠지는 값이 revenue[0]이 된다.

3. 클래스 상속 + 메서드 오버라이드 — 빈칸 채우기 (문제 10)

미용실(HairShop)과 레스토랑(Restaurant)이 Shop을 상속받아 각각 예약 조건을 다르게 구현하는 문제. 빈칸 8개를 채워야 한다.

예약 조건

• 미용실: 인원수 1명만, 시간 겹침 불가
• 레스토랑: 인원수 2~8명, 같은 시간 최대 2팀까지

class HairShop(Shop):                        # 상속
    def __init__(self):
        super().__init__()

    def reserve(self, customer):             # 메서드 오버라이드
        if customer.num_of_people != 1:      # 1명 아니면 거절
            return False
        for r in self.reserve_list:
            if r.time == customer.time:      # 시간 겹침 체크
                return False
        self.reserve_list.append(customer)
        return True

class Restaurant(Shop):
    def reserve(self, customer):
        if customer.num_of_people < 2 or customer.num_of_people > 8:
            return False
        count = 0
        for r in self.reserve_list:
            if r.time == customer.time:
                count += 1
        if count >= 2:          # for문 밖에서 판단!
            return False
        self.reserve_list.append(customer)
        return True

포인트: Restaurant의 count >= 2 체크는 for문 밖에서 한다. 안에서 하면 아직 다 세지도 않았는데 판단하게 될 수 있다.

이 문제는 10차 세션에서 배운 클래스 상속 개념으로 8개 빈칸 전부 1차 정답!

4. 문자열 겹침 이어붙이기 — 함수 작성 (문제 4)

두 문자열 s1, s2를 이어붙이되, 한쪽 끝과 다른 쪽 시작이 겹치면 한 번만 쓴다. s1+s2, s2+s1 중 더 짧은 길이를 return.

풀이 핵심: 두 방향 겹침 중 최대값 찾기

def solution(s1, s2):
    answer = 0
    std_len = min(len(s1), len(s2))
    dup_len = 0

    for i in range(1, std_len + 1):    # ← +1 주의!
        # s2 뒤에 s1 붙이는 경우 (s1 시작 = s2 끝)
        if s1[:i] == s2[-i:]:
            dup_len = i
        # s1 뒤에 s2 붙이는 경우 (s1 끝 = s2 시작)
        if s1[-i:] == s2[:i] and i > dup_len:
            dup_len = i

    answer = len(s1) + len(s2) - dup_len
    return answer

주의: range(1, std_len)이 아니라 range(1, std_len + 1) — 겹침이 짧은 쪽 문자열 전체 길이와 같을 수 있기 때문이다.

5. 전광판 스크롤 — 함수 작성 (문제 5)

화면에 14자를 표시하는 전광판에서, 문구가 왼쪽으로 1초에 한 칸씩 스크롤된다. 주어진 초(second)에 화면에 보이는 문자열을 return.

풀이 핵심: 밑줄 패딩 + text*2로 순환 처리

def solution(phrases, second):
    answer = ''
    text = phrases.zfill(len(phrases) * 2).replace("0", "_")
    d_text = text * 2
    cal_sc = second % len(text)
    answer = d_text[cal_sc:len(phrases) + cal_sc]
    return answer

단계별 동작:

1. zfill(28): "happy-birthday" → "00000000000000happy-birthday" (14개의 0 + 문구)
2. .replace("0", "_"): "______________happy-birthday" (밑줄 14개 + 문구)
3. text * 2: 문자열을 두 번 이어붙여서 순환 처리
4. second % len(text): 나머지 연산으로 반복 주기 처리
5. 슬라이싱으로 14글자 추출

수업 중 질문: "왜 text를 두 번 붙이나요?" → 슬라이싱이 문자열 끝을 넘어가면 잘린다. 예를 들어 t=20일 때 text[20:34]인데 text는 28자라 8글자만 나온다. text*2로 56자를 만들어두면 어디서 잘라도 항상 14글자가 보장된다.

주의: str은 Python 내장함수이므로 변수명으로 사용하면 안 된다! text, display_str 같은 이름을 쓰자.

6. 음수 인덱스와 슬라이싱 복습

문제 4에서 s1[-i:] 같은 표현이 나왔는데, 왜 이게 "뒤에서 i글자"가 되는지 정리.

음수 인덱스 = 뒤에서부터 세는 위치

s = "hello"
#     h  e  l  l  o
# 양수: 0  1  2  3  4
# 음수:-5 -4 -3 -2 -1

슬라이싱에서 생략된 부분

s[-1:]은 사실 s[-1:len(s)]와 같다. 뒤쪽을 생략하면 끝까지라는 뜻.

s[-1:]   # s[-1:5] → "o"       (뒤 1글자)
s[-2:]   # s[-2:5] → "lo"      (뒤 2글자)
s[-3:]   # s[-3:5] → "llo"     (뒤 3글자)

마찬가지로 s[:3]은 s[0:3]과 같다. 앞쪽 생략하면 처음부터.

주의: 음수 인덱스 ≠ 역순 출력

수업 중 질문: "음수 인덱스를 쓰면 거꾸로 출력되나요?" → 아니다! 음수는 시작 위치만 뒤쪽일 뿐, 출력 순서는 왼→오 그대로다.

s = "hello"
s[-3:]    # "llo" ← 뒤에서 3글자를 순서대로
s[::-1]   # "olleh" ← 이게 진짜 역순! (step이 -1)

역순은 step에 -1을 줘야 한다. 음수가 나오는 위치가 다르다:

• 인덱스의 음수 → 위치 (어디서부터)
• step의 음수 → 방향 (어느 쪽으로)

# 뒤 3글자를 거꾸로 출력하려면?
s[:-4:-1]   # "oll" ← start 생략(=끝), end=-4(=index 1) 전까지, step=-1

오늘의 결과

• 기출 3회차 나머지 5문제 완료 → 3회차 전체 10문제 완료!
• 1차 정답률 3/5 (60%) — 슬라이딩 윈도우, 전광판 스크롤은 힌트 후 해결
• 다음 학습: 구름EDU 기출 4회차 (학습용 마지막)

• 구름EDU 기출 2회차 1~4번, 10번 풀이 완료
• 클래스 상속/추상 클래스, itertools.combinations 새로 학습
• combinations에서 상수/변수 혼동 실수 1건 (힌트 후 교정)

오늘 수업 계획

• 구름EDU 기출 2회차 나머지 5~9번 마무리
• 2회차 완료 후 학습 일정 점검

학습 내용 정리

1. 거스름돈 구하기 — 빈칸 채우기 (문제 7)

금액을 8가지 화폐(10원~50000원)로 거슬러줄 때 동전+지폐 개수의 합을 최소로 만드는 문제다.

그리디(Greedy) 알고리즘

"큰 단위부터 최대한 많이 쓰고, 나머지를 다음 단위로 넘긴다"는 전략이다. 이 문제처럼 화폐 단위가 배수 관계일 때 그리디가 최적해를 보장한다.

def solution(money):
    coin = [10, 50, 100, 500, 1000, 5000, 10000, 50000]
    counter = 0
    idx = len(coin) - 1
    while money:
        counter += money // coin[idx]  # 해당 화폐로 몇 개 거슬러줄 수 있는지
        money %= coin[idx]             # 나머지를 다음 화폐로 넘김
        idx -= 1
    return counter

처음에 counter += 1로 작성했다가, 50000원짜리를 0개 써도 카운터가 올라가는 문제를 발견했다. money // coin[idx]로 해당 화폐를 최대 몇 개 쓸 수 있는지 계산해야 한다.

2. 규칙에 맞는 배열 구하기 — 디버깅 (문제 8)

배열의 앞/뒤에서 번갈아 가져와 새 배열을 만드는 문제다.

# 버그 코드
if left % 2 == 0:    # left는 앞에서 가져올 때만 증가

# 수정
if idx % 2 == 0:     # idx는 매 반복마다 증가 → 번갈아 동작

left는 앞에서 가져올 때만 증가하므로, 한 번 홀수가 되면 계속 뒤에서만 가져오게 된다. 매 반복마다 1씩 증가하는 idx를 기준으로 짝수/홀수를 판단해야 번갈아 동작한다.

3. 비밀번호 검사 — 디버깅 (문제 9)

비밀번호에 연속 3자리 이상의 알파벳이나 숫자(abc, 987 등)가 있으면 안전하지 않다고 판단하는 문제다.

# 버그 코드
first_check = ord(password[i + 1]) - ord(password[i])
second_check = ord(password[i]) - ord(password[i+1])   # first_check의 부호 반대일 뿐

# 수정
second_check = ord(password[i+2]) - ord(password[i+1])  # 다음 쌍의 차이

3연속을 판단하려면 연속된 두 쌍의 차이를 비교해야 한다:

• i→i+1 차이와 i+1→i+2 차이가 같고, 그 값이 ±1이면 3연속이다.

4. 언제까지 오르막길이야 — 함수 작성 (문제 5)

배열에서 숫자가 연속해서 증가하는 가장 긴 구간의 길이를 구하는 문제다. 같은 값은 증가로 치지 않는다.

def solution(arr):
    answer = 0
    tmp_answer = 1
    std_num = arr[0]

    for i in range(1, len(arr)):
        if arr[i] > std_num:
            tmp_answer += 1
        else:
            tmp_answer = 1
        answer = max(answer, tmp_answer)  # 매 반복마다 갱신!
        std_num = arr[i]

    return answer

수업 중 질문: 처음에 answer = max(answer, tmp_answer)를 else 블록 안에만 넣었더니, 배열 끝까지 증가하는 경우 answer가 갱신되지 않는 문제가 있었다. → for 루프 안, if/else 바깥으로 옮겨서 매 반복마다 최댓값을 갱신하도록 수정했다.

5. 로봇을 움직여주세요 — 함수 작성 (문제 6)

명령 문자열(L, R, U, D)에 따라 로봇을 이동시킨 최종 위치를 반환하는 문제다.

from collections import Counter

def solution(commands):
    x, y = 0, 0
    dir = Counter(commands)
    for key, value in dir.items():
        if key == "L":
            x -= value
        if key == "R":
            x += value
        if key == "U":
            y += value
        if key == "D":
            y -= value
    return [x, y]

Counter로 각 방향의 횟수를 한 번에 세서 처리하는 방식으로 풀었다. 이 문제는 이동 순서와 상관없이 최종 위치만 구하면 되기 때문에 Counter 방식이 유효하다. 만약 이동 경로를 추적해야 했다면 한 글자씩 순회해야 한다.

학습 일정 점검

구름EDU 기출 6세트의 활용 계획을 정리했다:

3~4회차 사이에는 프로그래머스, 백준 등 외부 플랫폼으로 추가 연습을 병행할 예정이다.

오늘의 결과

• 기출 2회차 5~9번 완료 → 2회차 전체 완료 (빈칸 1 + 디버깅 2 + 함수 작성 2)
• 힌트 1회 (오르막길 문제: 루프 종료 후 answer 갱신 누락)
• 다음 학습: 구름EDU 기출 3회차 시작

• 구름EDU 기출 1회차 6~10번 풀이 완료 (빈칸 1 + 디버깅 3 + 함수 작성 1)
• & vs and 혼동, 범위 체크 불일치 등 실수 포인트 정리
• ord(), max(0, x) 패턴 새로 학습

오늘 수업 계획

• 구름EDU 기출 2회차 시작
• 새로운 개념(클래스 상속, itertools.combinations)이 등장하면 설명 먼저 → 응용문제 풀기

학습 내용 정리

1. 클래스 상속과 추상 클래스 (문제 1: 도서 대여점 운영)

기출 1번 문제에서 추상 클래스와 상속 개념이 처음 등장했다. Java의 interface/abstract class와 같은 개념이다.

추상 클래스 만들기

from abc import ABC, abstractmethod

class Book(ABC):               # ABC를 상속 = 추상 클래스
    @abstractmethod            # 자식이 반드시 구현해야 하는 메서드
    def get_rental_price(self, day):
        pass

• ABC = Abstract Base Class
• @abstractmethod = Java의 abstract 키워드와 동일
• 추상 클래스는 직접 객체 생성 불가 (Book()하면 에러)

문제 코드에서는 metaclass=ABCMeta 방식이 사용되었는데, ABC를 상속하는 것과 동일한 의미이다.

# 방법 1: metaclass 직접 지정 (기출 코드 방식)
class Book(metaclass=ABCMeta):
    ...

# 방법 2: ABC 상속 (더 간단, 실무에서 주로 사용)
class Book(ABC):
    ...

상속 문법

# Java:   class ComicBook extends Book
# Python: class ComicBook(Book)
class ComicBook(Book):
    def get_rental_price(self, day):   # 추상 메서드 구현
        cost = 500
        day -= 2
        if day > 0:
            cost += day * 200
        return cost

응용문제로 연습 (주차장 요금 계산)

같은 구조로 Vehicle 추상 클래스 → SmallCar, LargeCar 상속 문제를 풀었다. 기출 구조를 그대로 응용해서 직접 클래스를 작성하고 solution 함수까지 완성했다.

주의: type은 Python 내장 함수명이라 변수명으로 쓰면 내장 type()을 덮어쓴다. car_type 같은 이름이 안전하다. (이전에 sum을 변수명으로 쓴 것과 같은 패턴!)

2. 시간 → 분 변환 (문제 2: 지하철 기다리기)

빈칸 채우기 문제. "HH:MM" 문자열을 분 단위 정수로 변환하는 func_a가 핵심이었다.

def func_a(times):
    hour = int(times[:2])
    minute = int(times[3:])
    return hour * 60 + minute

도착 시간이 순서대로 정렬되어 있으므로, 현재 시간 이후인 첫 번째 지하철을 찾으면 바로 break하는 패턴이다.

3. 이름 없는 함수 역할 파악 (문제 3: 경품 당첨자를 구해주세요)

func_a, func_b, func_c처럼 이름만으로 역할을 알 수 없는 함수가 나오는 빈칸 채우기 문제.

역할 파악 팁: 간단한 값을 넣어서 결과를 머릿속으로 돌려보기

자주 나오는 숫자 처리 패턴:

수업 중 질문: "func_a, func_b, func_c 역할 파악하는데 시간이 오래 걸렸어" → 코드를 한 줄씩 읽기 전에 간단한 값을 넣어서 입출력을 먼저 확인하면 빠르게 파악할 수 있다. 이런 패턴은 반복 출제되므로 몇 번 더 보면 코드 읽기 전에 바로 알아볼 수 있게 된다.

팁: length / 2는 Python 3에서 float가 된다 (예: 6 / 2 → 3.0). 정수 나눗셈 //를 쓰는 습관을 들이자.

4. itertools.combinations (문제 4: 합이 K배가 되는 수)

함수 작성 문제에서 itertools.combinations가 처음 등장했다. 배열에서 n개를 뽑는 모든 조합을 구하는 도구이다.

from itertools import combinations

arr = [1, 2, 3, 4, 5]
for combo in combinations(arr, 3):   # 3개씩 뽑기
    print(combo)
# (1, 2, 3), (1, 2, 4), (1, 2, 5), ...

Java로 비유하면 for문 3중첩으로 조합을 구하는 걸 한 줄로 해주는 것이다.

// Java: 3중 for문
for (int i = 0; i < n; i++)
    for (int j = i+1; j < n; j++)
        for (int k = j+1; k < n; k++)

# Python: 한 줄
for combo in combinations(arr, 3)

실수 포인트: combinations(arr, K)로 썼다가 교정했다. K=3이라 우연히 맞았지만, K는 배수 조건(변수)이고 뽑는 개수는 3(상수)이다. 문제에서 변수와 상수를 정확히 구분하자!

from itertools import combinations

def solution(arr, K):
    answer = 0
    for combo in combinations(arr, 3):    # 3개 뽑기 (상수!)
        if sum(combo) % K == 0:           # K의 배수 (변수!)
            answer += 1
    return answer

5. 디버깅: else에서 조건부 처리 (문제 10: 0들을 0으로 만들기)

연속된 0을 하나의 0으로 압축하는 디버깅 문제. 한 줄만 수정해야 한다.

# 버그 코드
if s[i] == '0' and s[i + 1] != '0':
    answer += '0'       # 연속 0의 마지막 → 0 추가 (정상)
else:
    answer += '1'       # 버그! 무조건 '1' 추가

else에 들어오는 경우가 세 가지 섞여있었다:

• s[i] == '1' → '1' 추가해야 함
• s[i] == '0' (연속 0) → 아무것도 안 해야 함
• s[i] == '#' (끝 표시) → 아무것도 안 해야 함

수정: 11행을 if s[i] == '1': answer += '1'로 변경

else:
    if s[i] == '1': answer += '1'   # '1'일 때만 추가, 나머지는 자동 패스

Python은 한 줄에 if 조건: 동작을 쓸 수 있어서 한 줄 수정으로 해결 가능하다.

수업 중 질문: "else: if 대신 그냥 if만 쓰거나, elif를 써도 똑같지 않아?" → 안 된다! 11행은 else: 블록 안에 있는 코드라서, elif로 바꾸려면 else:(10행)도 지워야 해서 두 줄 수정이 된다. 독립 if도 마찬가지.

디버깅 팁: else에서 무조건 고정값을 넣는 코드가 보이면 의심하자!

6. -= 공백 실수 주의

응용문제에서 발견한 실수:

hours -= 1   # hours = hours - 1  (3 → 2) ✅
hours = -1   # hours에 -1 대입     (3 → -1) ❌

+=는 헷갈릴 일이 없지만, -=는 공백 하나로 의미가 완전히 바뀐다. 시험에서는 반드시 붙여서 쓰자!

오늘의 결과

• 기출 2회차 5문제 + 응용 1문제 풀이, 1차 정답률 83% (5/6)
• 클래스 상속, itertools.combinations 새로 학습
• 다음 시간: 기출 2회차 5~9번 마무리 → 함수작성 응용문제

• 구름EDU 기출 1회차 1~5번 풀이 완료 (빈칸 3 + 함수 작성 2)
• 클래스 상속 문법, 인덱스 vs 값 혼동, 그리드 시뮬레이션 초기값 누락 등 실수 포인트 정리
• Phase 2 본격 시작

오늘 수업 계획

구름EDU COS Pro 1급 기출 1회차 6~10번 문제 풀이 리뷰. 빈칸 채우기 1문제 + 디버깅 2문제 + 함수 작성 2문제 구성.

학습 내용 정리

문제 7 — 병합 and 정렬 (빈칸 채우기)

오름차순으로 정렬된 두 배열을 하나의 정렬된 배열로 합치는 문제. 병합 정렬(merge sort)의 merge 단계와 같은 로직.

빈칸:

while arrA_len > arrA_idx and arrB_len > arrB_idx:  # 빈칸 1: 두 배열 모두 남아있을 때
    ...비교하며 작은 값 append...

while arrA_len > arrA_idx:   # 빈칸 2: arrA에 남은 원소 처리
    ...

while arrB_len > arrB_idx:   # 빈칸 3: arrB에 남은 원소 처리
    ...

수업 중 질문: &랑 and는 다른 거야?

→ Python에서 &는 비트 연산자, and는 논리 연산자다.

COS Pro 시험에서 조건 연결할 때는 반드시 and를 쓸 것!

문제 8 — 누가 당선 되나요 (디버깅)

투표 결과에서 가장 많은 표를 받은 후보 번호를 반환하는 문제. 공동 1위면 번호를 오름차순으로 모두 반환.

버그 위치: 14번 줄

# 수정 전
answer.append(vote_counter[idx])  # 득표수를 넣고 있음

# 수정 후
answer.append(idx)                # 후보 번호를 넣어야 함

핵심: 문제가 요구하는 반환값이 무엇인지 정확히 파악하기. vote_counter[idx]는 idx번 후보의 득표수이고, 문제가 원하는 건 후보 번호 idx 자체다.

문제 9 — 계단 게임 (디버깅)

두 학생이 가위바위보를 하면서 계단을 오르내리는 게임. A가 이기면 +3칸, 지면 -1칸, 비기면 제자리. 단, 0칸 아래로는 내려갈 수 없음.

func 함수 동작:

def func(record):   # 이기는 패를 반환
    0(가위) → 1(바위)
    1(바위) → 2(보)
    2(보)   → 0(가위)

버그 위치: 19번 줄

# 수정 전
cnt = cnt - 1              # 0 아래로 내려갈 수 있음

# 수정 후
cnt = max(0, cnt - 1)      # 0 아래로 못 내려가게 보호

기억 포인트: max(0, 값)은 "0 아래로 내려가지 않게" 할 때 자주 쓰는 패턴. 시험에서 디버깅은 한 줄 교체이므로, if문을 추가하는 것보다 max() 한 줄로 처리하는 게 안전하다.

문제 10 — 주식으로 최대 수익을 내세요 (디버깅)

n일 동안의 주가에서 한 번 사고 한 번 팔았을 때 최대 수익을 구하는 문제. 산 날에 바로 못 팔고, 최소 하루 뒤에 팔아야 한다. 수익이 음수일 수도 있다.

버그 위치: 10번 줄

# 수정 전
answer = max(answer, tmp - price)    # 매수가 - 판매가 (반대!)

# 수정 후
answer = max(answer, price - tmp)    # 판매가 - 매수가 (정답!)

코드 구조 이해:

for price in prices:
    if tmp != INF:                      # ① 먼저 팔아보기 (매수한 적 있을 때만)
        answer = max(answer, price - tmp)
    tmp = min(tmp, price)               # ② 그 다음 사볼지 결정

수업 중 질문: if tmp != INF: 이 조건은 왜 있는 거야?

→ 이 조건은 "산 날에 바로 못 팔고, 최소 하루 뒤에 팔아야 한다" 규칙을 지키기 위한 것이다.

• 첫 번째 날: tmp=INF → if 건너뜀 → tmp만 세팅 (산 것)
• 두 번째 날부터: tmp에 이전 최소가가 있으므로 → 수익 계산 가능 (팔기)

"먼저 팔아보고(answer 갱신) → 그 다음 살지 결정(tmp 갱신)" 이 순서가 하루 뒤 매도 규칙을 보장한다. 순서를 바꾸면 같은 날 사고파는 셈이 되어 [3, 1] 같은 케이스에서 수익이 0이 나오는 버그가 생긴다.

문제 6 — 체스의 나이트 (함수 작성)

체스판 위 나이트의 위치가 주어지면, 한 번에 이동할 수 있는 칸의 개수를 반환하는 문제.

작성한 코드:

def solution(pos):
    answer = 0
    r = "ABCDEFGH".find(pos[0])   # A=0, B=1, ... H=7
    c = int(pos[1]) - 1            # 1~8 → 0~7로 통일

    moves = [(-2, -1), (-2, 1), (-1, -2), (-1, 2),
             (1, -2), (1, 2), (2, -1), (2, 1)]

    for move in moves:
        nr, nc = r + move[0], c + move[1]
        if nr >= 0 and nr <= 7 and nc >= 0 and nc <= 7:
            answer += 1

    return answer

풀면서 실수한 포인트:

위치 파싱 두 가지 방법:

# 방법 1: find()
r = "ABCDEFGH".find(pos[0])

# 방법 2: ord()
r = ord(pos[0]) - ord('A')

ord()는 문자를 아스키 코드(숫자)로 변환하는 함수. chr()는 반대. Java의 (char) - 'A' 패턴과 동일하다.

오늘의 결과

• 기출 1회차 6~10번 완료 (빈칸 1 + 디버깅 3 + 함수 작성 1), 기출 1회차 전체 10문제 완료
• 주요 포인트: and vs & 차이, max(0, x) 패턴, 주식 문제의 매수/매도 순서 보장 로직
• 다음 시간: 구름EDU 기출 2회차 시작

• Phase 1 종합 복습 완료 — 딕셔너리+컴프리헨션, set 교집합, 다중 정렬 key 등 마무리
• Phase 1 전 범위 종료, Phase 2 전환 준비 완료
• 총 8회 세션, 67문제 풀이 (1차 정답률 84%)

오늘 수업 계획

Phase 2 첫 번째 세션. 구름EDU COS Pro 1급 기출 1회차 1~5번 문제를 직접 풀고 리뷰. 빈칸 채우기 3문제 + 함수 작성 2문제 구성.

학습 내용 정리

문제 1 — 음식전문점 운영 (빈칸 채우기)

클래스 상속 구조를 읽고 빈칸을 채우는 문제.

빈칸:

class PizzaStore(DeliveryStore):       # 1. 상속
    def set_order_list(self, order_list):  # 2. 추상 메서드 구현
    def get_total_price(self):             # 3. 추상 메서드 구현

Python 클래스 상속 문법 정리:

핵심: Python에서 추상 메서드를 구현할 때는 self를 포함한 시그니처를 부모와 동일하게 맞춰야 한다.

이 문제에서 함수명은 바로 알았지만 상속 문법은 인터넷 검색 후 해결. → 별도 정리 필요 영역으로 기록.

문제 2 — 해밍 거리 구하기 (빈칸 채우기)

두 이진수 문자열의 해밍 거리(같은 위치에서 다른 문자 수)를 구하는 문제. 길이가 다르면 짧은 쪽 앞에 0을 채워 맞춤.

빈칸:

padSize = length - len(string)    # 채워야 할 0의 개수
if binaryA[i] != binaryB[i]:     # 같은 위치에서 다르면 해밍 거리 +1

막힘 없이 해결.

문제 3 — 계산기 by 문자열 (빈칸 채우기)

"123+12" 같은 문자열 수식을 받아 계산 결과를 return하는 문제. func_a (계산), func_b (연산자 위치 탐색), func_c (숫자 분리) 세 함수가 주어지고, solution의 빈칸을 채우는 구조.

빈칸:

exp_index = func_b(expression)                          # 연산자 위치(인덱스)
first_num, second_num = func_c(expression, exp_index)   # 두 숫자 분리
result = func_a(first_num, second_num, expression[exp_index])  # 계산

수업 중 질문: 마지막 인자를 exp_index로 넣었더니 None이 출력됐어

→ exp_index는 연산자의 위치를 나타내는 숫자(int) 이고, func_a가 필요로 하는 건 '+', '-', '*' 같은 문자(str) 다. expression[exp_index]로 인덱스 위치의 값을 꺼내야 한다.

exp_index = 3           # 숫자 — 위치
expression[exp_index]   # 문자 — 그 위치의 값 '+'

기억 포인트: 인덱스를 구했으면 값을 꺼낼 때 [인덱스]를 한 번 더 써줘야 한다.

문제 4 — 타임머신 (함수 작성)

0이 없는 수 체계(1, 2, ..., 9, 11, 12, ...)에서 주어진 수의 다음 수를 return하는 문제.

작성한 코드:

def solution(num):
    tmp_num = str(num + 1)
    answer = int(tmp_num.replace("0", "1"))
    return answer

왜 이게 맞는가?

num은 0이 없는 수이므로, num + 1을 하면 올림(carry)이 9를 타고 올라가면서 0은 반드시 뒤에서부터(suffix)만 생긴다.

예: 1899999 + 1 = 1900000
    └─ 뒤의 9들이 연쇄 올림 → suffix에만 0 생성

suffix의 0을 전부 1로 바꾸면 → 0 없는 수 중 가장 작은 다음 수가 된다. replace("0", "1")이 항상 정답인 이유가 바로 이 입력 조건 덕분이다.

문제 5 — 소용돌이 수 (함수 작성)

n×n 격자에 1~n²을 소용돌이(나선) 순서로 채운 뒤, 주 대각선(좌상→우하) 값의 합을 return하는 문제.

작성한 코드 (핵심 구조):

def solution(n):
    if n == 1: return 1  # 엣지케이스

    grid = [[0]*n for _ in range(n)]
    dr = [0, 1, 0, -1]   # 우 하 좌 상
    dc = [1, 0, -1, 0]
    r, c, d = 0, 0, 0

    answer = 0
    for num in range(1, n*n+1):
        grid[r][c] = num
        if r == c:
            answer += num

        nr, nc = r + dr[d], c + dc[d]
        if nr < 0 or nr >= n or nc < 0 or nc >= n:
            d = (d+1) % 4
            nr, nc = r + dr[d], c + dc[d]
        if grid[nr][nc] != 0:
            d = (d+1) % 4
            nr, nc = r + dr[d], c + dc[d]
        r, c = nr, nc

    return answer

풀면서 실수한 포인트:

대각선 조건: r == c 이면 주 대각선. 단순하고 정확한 판별식.

그리드 시뮬레이션 세팅 체크리스트:

1. 그리드 생성
2. 4방향 정의 (dr, dc)
3. 시작점 (r, c)
4. 현재 방향 (d = 0) ← 자주 빠트림!

오늘의 결과

• 기출 1회차 1~5번 완료 (빈칸 3 + 함수 작성 2), 전부 최종 정답
• 1차 실수: 문제 3 인덱스vs값 혼동, 문제 5 초기값 누락
• 다음 시간: 기출 1회차 6~10번 + 클래스 상속/오버라이드 보충 정리