지난 세션(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번 + 클래스 상속/오버라이드 보충 정리

• Phase 1 종합 복습 테스트 10문제 풀이 (1차 정답률 60%)
• dict+key 패턴, 다중 정렬, 달팽이 수열 등 약점 확인
• Phase 2 전환 전 보충 학습 필요로 판단

오늘 수업 계획

짧은 세션으로 Phase 1 마무리 복습. 그동안 배운 딕셔너리, set, 정렬, 함수 작성을 골고루 점검하고, 주말부터 Phase 2 전환을 준비한다.

학습 내용 정리

문제 1 (빈칸) — 딕셔너리 + 리스트 컴프리헨션 필터링

학생 점수 딕셔너리에서 평균 이상인 학생 이름만 리스트로 반환하는 문제.

def above_average(scores):
    avg = sum(scores.values()) / len(scores)
    result = [name for name, score in scores.items() if score >= avg]
    return result

.items()로 name, score 언패킹 → 조건에 맞는 name만 리스트에 담는 패턴. 딕셔너리 컴프리헨션과 조건 필터링의 조합 문제.

✅ 1차 정답

문제 2 (디버깅) — set 합집합/교집합 연산

여러 리스트에서 공통 원소만 반환해야 하는데, |(합집합)을 쓰고 있어서 모든 원소가 다 나오는 버그.

# 버그
result = result | set(lst)    # 합집합 → 하나라도 있으면 포함

# 수정
result = result & set(lst)    # 교집합 → 모든 리스트에 있어야 포함

✅ 1차 정답 — 원인까지 정확히 설명

문제 3 (함수 작성) — 다중 조건 정렬

문자열 리스트를 길이 내림차순 + 같으면 사전순 오름차순으로 정렬하는 함수.

def sort_by_length(words):
    return sorted(words, key=lambda x: (-len(x), x))

9차 종합 테스트에서 배운 다중 정렬 key 튜플 패턴을 완벽하게 활용. -len(x)로 내림차순, x로 오름차순을 하나의 lambda에서 처리.

✅ 1차 정답

문제 4 (빈칸) — set 순서 유지 중복 제거

리스트에서 중복을 제거하되 원래 순서를 유지하는 문제. 빈 set()으로 시작해서 add()로 이미 본 원소를 추적한다.

def remove_duplicates(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

이전에 set() vs set(items) 초기값 혼동이 있었는데, 이번에는 빈 set으로 정확히 시작. set의 in 검사가 O(1)이라 효율적이다.

✅ 1차 정답

문제 5 (디버깅) — 초기값 설정 함정

딕셔너리에서 value가 가장 큰 key를 찾는 함수인데, max_val = 0으로 초기화해서 음수만 있는 경우 조건을 만족하는 값이 없어 None이 반환되는 버그.

# 버그
max_val = 0                        # 모든 value가 음수면 업데이트 안 됨

# 수정
max_val = list(d.values())[0]      # 실제 데이터의 첫 값으로 초기화

다른 방법으로 float('-inf')(음의 무한대)도 가능. 어떤 숫자와 비교해도 항상 더 작기 때문에, 첫 번째 비교에서 무조건 업데이트가 된다.

float('-inf') < -99999999  # True — 어떤 수보다도 작음
max_val = float('-inf')    # 최대값 초기값으로 사용
min_val = float('inf')     # 반대로 최소값 찾을 때는 양의 무한대

초기값을 0이나 빈 값으로 두면 음수/특수 케이스에서 실패할 수 있다는 점을 기억하자.

✅ 1차 정답

문제 6 (함수 작성) — 문자 빈도 카운팅 + 정렬

문자열에서 각 문자의 등장 횟수를 횟수 내림차순으로 정렬된 딕셔너리로 반환하는 문제.

수업 중 질문: "Counter를 import해서 써도 되나?" → COS Pro 시험에서 collections 모듈 사용 가능. 실전에서는 Counter를 쓰는 게 효율적.

풀이 1 — Counter 사용:

from collections import Counter

def char_count(s):
    tmp_dict = Counter(s)
    tmp_list = sorted(tmp_dict.items(), key=lambda x: -x[1])
    return dict(tmp_list)

풀이 2 — Counter 없이 dict.get() 활용:

def char_count(s):
    tmp_dict = {}
    for w in s:
        tmp_dict[w] = tmp_dict.get(w, 0) + 1
    return dict(sorted(tmp_dict.items(), key=lambda x: -x[1]))

두 가지 방식 모두 작성할 수 있으면 실전에서 유연하게 대응 가능.

✅ 1차 정답 — 두 가지 풀이 모두 자발적으로 작성

오늘의 결과

• 6문제 전부 1차 정답, 정답률 100% — Phase 1 기초 완전히 정착
• 이전 약점이었던 set 초기값, 함수 작성 모두 안정적으로 해결
• 다음 학습(주말): Phase 2 전환 — 구름EDU COS Pro 기출 1회차 시작 예정

• 예외 처리(try/except/else/finally) 학습, Java의 try/catch와 비교
• 10문제 풀이, 1차 정답률 70%
• Phase 1 마지막 주제까지 완료

오늘 수업 계획

Phase 1 전 영역 종합 복습 테스트. 리스트, 딕셔너리, 문자열, 집합, 내장함수, 튜플, 함수, 예외 처리까지 골고루 10문제를 풀어 Phase 2 전환 여부를 판단한다.

학습 내용 정리

문제 1 (빈칸) — 2차원 배열 대각선 합

n×n 행렬의 주대각선 합을 구하는 문제. 대각선 원소는 행과 열 인덱스가 같으므로 matrix[i][i]로 접근한다.

total += matrix[i][i]  # (0,0), (1,1), (2,2) → 주대각선

✅ 1차 정답

문제 2 (빈칸) — 딕셔너리 최빈 문자

문자열에서 가장 많이 등장한 문자를 반환하는 문제.

1차 시도: sorted(count)[0] → 오답. sorted(dict)는 키를 알파벳순으로 정렬할 뿐, 등장 횟수와 무관하다.

정답: max(count, key=count.get)

max(count, key=count.get)   # 값(등장 횟수)이 가장 큰 키를 반환
min(count, key=count.get)   # 값이 가장 작은 키를 반환

수업 중 질문: "key=count.get할 때 get()에 키 값이 없어도 되나?" → count.get은 호출(count.get('a'))이 아니라 함수 자체를 넘기는 것. max가 내부적으로 각 키를 넣어서 호출해주기 때문에 우리가 키를 지정할 필요가 없다. Java의 메서드 레퍼런스(count::get)와 같은 개념.

문제 3 (빈칸) — 문자열 capitalize + join

각 단어의 첫 글자를 대문자로 바꾸는 문제. capitalize() 메서드를 써봤더니 동작했다.

result.append(w.capitalize())   # 첫 글자 대문자 + 나머지 소문자
return " ".join(result)

capitalize()를 몰라도 w[0].upper() + w[1:]로 대체 가능.

✅ 1차 정답

문제 4 (빈칸) — set 교집합 + 순서 유지

두 리스트의 공통 원소를 원래 순서 유지하며 반환하는 문제.

1차 시도: 리스트 컴프리헨션으로 교집합 리스트를 만들어 비교 → 동작은 하지만 set을 활용하는 문제 의도와 다름.

정답: list2를 set으로 변환 후 in 검사.

common = set(list2)
return [x for x in list1 if x in common]

set을 쓰면 in 검색이 O(1)으로 빠르다.

문제 5 (빈칸) — 다중 정렬 키

점수 내림차순 + 이름 오름차순으로 정렬하는 문제. 정렬 기준이 여러 개일 때 튜플로 묶어서 반환한다는 걸 새로 배웠다.

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

-를 붙이면 크기 관계가 뒤집혀서 내림차순이 된다. 단, 숫자에만 가능.

수업 중 질문: "조건 2개 이상이라 튜플로 줘야 될 때 reverse=True는 어디에?" → reverse=True는 sorted()의 매개변수로 넣지만 전체 기준이 다 뒤집히므로, 방향이 섞여 있으면 사용 불가.

sorted 두 번 쓰는 방법은 Python의 안정 정렬(stable sort) 을 이용. 같은 값이면 이전 순서를 유지하므로, 덜 중요한 기준을 먼저 정렬하고 더 중요한 기준을 나중에 정렬하면 된다.

문제 6 (디버깅) — nonlocal 클로저

바깥 함수의 변수를 내부 함수에서 수정하려면 nonlocal 선언이 필요하다.

def increment(n):
    nonlocal count      # 함수 시작 부분에 선언 (관례)
    for i in range(n):
        count += 1

✅ 1차 정답

문제 7 (디버깅) — except에서 continue

변환 실패한 값을 "건너뛰는" 함수인데, except에서 실패한 값을 리스트에 추가하고 있었다. result.append(s) → continue로 수정.

수업 중 질문: "int(4.5)는 4가 되는데 int('4.5')는 ValueError가 뜨는 이유?" → int()는 입력 타입에 따라 동작이 다르다. float → 소수점 버림, 문자열 → 정수 형태만 파싱 가능. "4.5"를 정수로 바꾸려면 int(float("4.5"))로 두 단계 거쳐야 한다.

✅ 1차 정답

문제 8 (함수 작성) — 투표 집계

def get_winner(votes):
    result = {}
    for vote in votes:
        result[vote] = result.get(vote, 0) + 1
    return max(result, key=result.get)

문제 2에서 배운 max(dict, key=dict.get) 패턴을 바로 활용했다. 개선점으로 if/else 분기 없이 get(vote, 0)만으로 충분하고, sorted()[0] 대신 max()가 더 효율적이라는 피드백을 받았다. sorted()는 전체를 정렬(O(n log n))하지만 max()는 한 번 순회(O(n))만 하면 되기 때문.

✅ 1차 정답

문제 9 (함수 작성) — 애너그램 판별

사고 과정: palindrome과 헷갈림 → set 교집합은 중복 제거돼서 안됨 → 값을 빼가면서 체크? → 힌트 후 sorted 비교로 해결.

def is_anagram(s1, s2):
    return sorted(s1) == sorted(s2)

정렬하면 글자 구성이 같은지 바로 비교 가능. Counter(s1) == Counter(s2)도 유효.

수업 중 질문: "Counter가 뭔지 찾아봤는데 딕셔너리끼리도 == 비교가 가능한가?" → 가능. 키와 값이 모두 같으면 True, 순서와 무관. Java의 map1.equals(map2)와 동일.

문제 10 (함수 작성) — 달팽이 수열 (Spiral Matrix)

가장 난이도가 높았던 문제. 힌트를 받아 방향 배열 + 방향 전환 구조로 직접 구현했다.

def make_spiral(n):
    grid = [[0] * n for _ in range(n)]
    dr = [0, 1, 0, -1]       # 오른쪽 → 아래 → 왼쪽 → 위
    dc = [1, 0, -1, 0]
    r, c = 0, 0
    d = 0

    for num in range(1, n * n + 1):
        grid[r][c] = num
        nr, nc = r + dr[d], c + dc[d]

        if nr < 0 or nr >= n or nc < 0 or nc >= n or grid[nr][nc] != 0:
            d = (d + 1) % 4
            nr, nc = r + dr[d], c + dc[d]

        r, c = nr, nc
    return grid

디버깅 과정: n=3은 통과했는데 n=4에서 실패. 원인은 if d == n으로 방향 리셋을 했기 때문. n=3일 때 d == 3이 우연히 맞았지만, n=4일 때 d == 4는 절대 발생하지 않음. (d + 1) % 4로 수정하여 해결.

자발적 추가 연습: 반시계 방향 + 역순(n×n → 1)도 직접 구현. 방향 배열만 바꾸고 range를 역순으로 변경하여 성공.

오늘의 결과

• Phase 1 종합 테스트 10문제 완료, 1차 정답률 60% (6/10), 최종 전부 정답
• 1차 정답률 80% 미달이므로 Phase 2 전환 전 약점 보충 필요 (dict+key 패턴, 다중 정렬, 알고리즘 구현)
• 다음 학습: 약점 영역 보충 연습 후 Phase 2 전환 예정

• 튜플 활용(언패킹, sorted+lambda) + 함수 심화(args, *kwargs, 클로저)
• 10문제 풀이, 1차 정답률 70%
• 함수 작성에서 불필요한 dict 변환 시도 → 컴프리헨션으로 수정

오늘 수업 계획

Phase 1 마지막 주제인 예외 처리(try/except) 학습. Java의 try/catch와 비교하면서 Python만의 차이점을 익히고, 빈칸/디버깅/함수 작성 문제로 확인.

학습 내용 정리

1. Java try/catch vs Python try/except

Java와 거의 동일한 구조인데, Python만의 else 블록이 추가된 것이 특징이다.

2. try/except/else/finally 실행 순서

try:
    result = 10 / 2
except ZeroDivisionError:
    print("0으로 나눌 수 없음")
else:
    print(f"결과: {result}")  # 예외 안 났을 때만 실행
finally:
    print("항상 실행")

핵심 실행 순서:

• 예외 발생 → except → finally
• 예외 없음 → else → finally
• finally는 무조건 실행 (return이 있어도!)

3. 자주 나오는 예외 종류 (COS Pro 빈출)

4. ValueError vs TypeError — 헷갈리기 쉬운 구분

int() 함수를 예로 들면:

수업 중 질문: "int(None)과 int("abc")의 차이를 잘 모르겠어. 왜 각각 다른 에러가 나는 거지?" → 함수가 해당 타입을 받을 수 있느냐의 문제. int()는 문자열을 받을 수 있지만(변환 지원) 값이 이상하면 ValueError, 애초에 받을 수 없는 타입이면 TypeError. 이 구분은 sum += "없음"이 TypeError인 이유와도 연결된다 — int와 str의 + 연산 자체가 지원되지 않는 타입 문제이므로.

5. finally는 return보다 먼저 실행된다

def convert(value):
    try:
        num = int(value)
    except ValueError:
        return "변환 실패"
    else:
        return num * 2
    finally:
        print("처리 완료")

result = convert("abc")
print(result)

출력:

처리 완료
변환 실패

except에서 return "변환 실패"가 준비되지만, 반환되기 전에 finally가 먼저 실행된다. 이건 Java도 동일한 동작이다.

6. finally에 return이 있으면 다른 return을 덮어쓴다

def test():
    try:
        return 1
    except:
        return 2
    finally:
        return 3

print(test())  # 3

try에서 return 1을 준비했지만, finally의 return 3이 이를 완전히 덮어써버린다. 그래서 실무에서는 finally에 return을 넣지 않는 것이 원칙. 하지만 COS Pro에서 함정 문제로 나올 수 있으니 알아두자.

7. 다중 except 괄호 묶기

# 개별 except
except KeyError:
    continue
except TypeError:
    continue

# 한 줄로 묶기
except (KeyError, TypeError):
    continue

처리 로직이 같으면 괄호로 묶어서 한 번에 잡을 수 있다.

8. try/except 활용 — 안전한 변환 패턴

def safe_convert(items):
    result = []
    for item in items:
        try:
            num = int(item)
            result.append(num)
        except ValueError:
            continue
    return result

print(safe_convert(["10", "hello", "20", "3.5", "30"]))
# [10, 20, 30]

변환이 보장되면 [int(x) for x in items] 한 줄이면 되지만, 예외 처리가 필요하면 try/except + for문이 정석이다. try는 컴프리헨션 안에 넣을 수 없기 때문.

9. 딕셔너리 안전 합산 패턴

def safe_sum(dict_list, key):
    total = 0
    for d in dict_list:
        try:
            total += d[key]
        except (KeyError, TypeError):
            continue
    return total

• KeyError: 키가 없는 딕셔너리 건너뛰기
• TypeError: int + str 연산 불가능한 경우 건너뛰기

수업 중 질문: "TypeError인지 ValueError인지 고민했는데, 형변환 과정이 없으니 TypeError가 맞나?" → 정확하다. int("없음")처럼 형변환을 시도하면 ValueError, 0 + "없음"처럼 형변환 없이 바로 더하면 int+str 연산이 되어 TypeError. 이 코드에서는 형변환 없이 바로 +=하니까 TypeError.

10. 내장함수명을 변수명으로 쓰지 말 것

# 위험한 코드
sum = 0           # 내장함수 sum()을 덮어씀
dict = {"a": 1}   # 내장타입 dict를 덮어씀

# 안전한 코드
total = 0
d = {"a": 1}

Python은 내장함수/타입도 변수처럼 재할당할 수 있어서, 실수로 덮어쓰면 이후 sum(), dict()를 사용할 수 없게 된다.

오늘의 결과

• 9문제 풀이, 1차 정답률 89% (8/9)
• 예외 처리 개념이 Java 경험에서 잘 전이됨, 함수 작성 2문제 모두 1차 정답
• 다음 시간: Phase 1 종합 복습 → Phase 2 전환

• Python 내장함수 정리 (sorted, enumerate, zip, map, filter, any/all, sum)
• 6문제 풀이, 1차 정답률 100%
• 함수 작성에서 하드코딩 없이 일반화 성공 (개선 추세)

오늘 수업 계획

Phase 1 마무리를 향해 남은 두 주제를 진행: 튜플 활용법과 함수 심화(args, *kwargs, 클로저). 문제 10개로 확인.

학습 내용 정리

1. 튜플(tuple) — 수정 못하는 리스트

# 리스트 — 변경 가능 (mutable)
fruits = ["사과", "바나나", "딸기"]
fruits[0] = "포도"  # OK

# 튜플 — 변경 불가 (immutable)
colors = ("빨강", "파랑", "초록")
colors[0] = "노랑"  # TypeError!

Java에는 튜플이 없어서 생소할 수 있지만, Python에서는 엄청 자주 쓰인다. "이 데이터는 바뀌면 안 돼"라는 의도를 코드로 표현하는 것.

2. 튜플을 쓰는 주요 상황

특히 함수 반환값과 언패킹은 COS Pro에서 거의 매번 나온다.

3. 튜플 핵심 문법

# 생성
t1 = (1, 2, 3)
t2 = 1, 2, 3        # 괄호 없어도 튜플!
t3 = (42,)           # 원소 1개일 때 반드시 콤마!
t4 = (42)            # 이건 그냥 int 42

# 인덱싱/슬라이싱 — 리스트와 동일
t1[0]      # 1
t1[1:]     # (2, 3)

# 스왑 (Java에서는 temp 변수 필요!)
a, b = b, a

# 함수에서 여러 값 반환
def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([3, 1, 7, 2])  # lo=1, hi=7

4. 튜플 리스트 + sorted + lambda — COS Pro 단골 패턴

students = [("김철수", 85), ("이영희", 92), ("박민수", 78), ("정수진", 95)]

# 점수 기준 내림차순 정렬
students_sorted = sorted(students, key=lambda x: x[1], reverse=True)

# 1등 언패킹
top_name, top_score = students_sorted[0]

이 조합은 시험에서 정말 자주 나오니까 익숙해져야 한다.

5. Python 동시 할당 — temp 변수 없이 스왑

디버깅 문제에서 나온 포인트. 첫 번째와 마지막 요소를 교환할 때:

# Java 스타일 — temp 필요
first = data[0]
data[0] = data[-1]
data[-1] = first

# Python — 동시 할당이라 한 줄이면 끝
data[0], data[-1] = data[-1], data[0]

Python은 우변을 먼저 전부 평가한 뒤 좌변에 할당하기 때문에 중간 변수가 필요 없다. 디버깅 문제에서 data[0], data[-1] = first, last처럼 같은 순서로 넣으면 아무것도 안 바뀌는 게 함정이었다.

6. 딕셔너리 그룹핑 패턴

# 키가 없으면 빈 리스트 만들고 → append
if grade not in groups:
    groups[grade] = []
groups[grade].append(name)

# 한 줄 버전
groups.setdefault(grade, []).append(name)

수업 중 질문: "dict로 변환해서 keys()로 이름을 꺼내면 안 되나?" → 동작은 하지만 불필요한 변환이다. 이미 정렬된 튜플 리스트에서 리스트 컴프리헨션으로 바로 꺼내는 게 깔끔하다: [x[0] for x in sorted_list[:n]]

6. 기본값 매개변수 (Default Parameter)

# Java에서는 오버로딩 2개 만들어야 했지만
# Python은 기본값 하나면 끝
def greet(name, greeting="안녕하세요"):
    return f"{greeting}, {name}님!"

greet("홍길동")              # "안녕하세요, 홍길동님!"
greet("홍길동", "반갑습니다")  # "반갑습니다, 홍길동님!"

7. args와 *kwargs

# *args — 가변 위치 인자 (튜플로 들어옴)
def add_all(*args):
    return sum(args)

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

# **kwargs — 가변 키워드 인자 (딕셔너리로 들어옴)
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="홍길동", age=25)

Java의 int... numbers (가변인자)와 비슷하지만, **kwargs는 Java에 없는 개념이다.

매개변수 순서: 일반 → 기본값 → *args → **kwargs

8. 예약어를 키워드 인자로 넘기기

# class는 Python 예약어라서 직접 쓰면 SyntaxError!
make_tag("Image", "div", class="container")  # 에러!

# 딕셔너리 언패킹으로 우회
make_tag("Image", "div", **{"class": "container"})  # OK!

딕셔너리 키는 문자열이라 예약어 충돌이 없다. **로 언패킹하면 키워드 인자로 넘어간다.

9. nonlocal — 클로저에서 바깥 변수 수정

def create_counter(start=0):
    count = start

    def increment():
        nonlocal count   # "count는 바깥 함수 변수야"
        count += 1
        return count

    return increment

수업 중 질문: "함수 외부에 변수 안 두고 값을 저장해둘 수 있는 거야?" → Python의 클로저(closure)가 이걸 가능하게 한다. 안쪽 함수가 바깥 함수의 변수를 기억하고 있다가, nonlocal을 선언하면 수정까지 할 수 있다. Java에서는 클래스 필드에 저장해야 했던 걸, Python에서는 클로저로 간단하게 처리할 수 있다.

10. 함수를 인자로 넘기기

def apply_all(value, *functions):
    result = value
    for func in functions:
        result = func(result)
    return result

double = lambda x: x * 2
add_ten = lambda x: x + 10
apply_all(3, double, add_ten)  # 3 → 6 → 16

Python에서는 함수도 변수처럼 넘기고 호출할 수 있다.

11. *args + all()로 다중 조건 필터링

def filter_all(items, *conditions):
    result = []
    for item in items:
        if all(condition(item) for condition in conditions):
            result.append(item)
    return result

is_positive = lambda x: x > 0
is_even = lambda x: x % 2 == 0
is_small = lambda x: x < 50

filter_all([-3, 4, 7, 12, -8, 50, 22], is_positive, is_even, is_small)
# → [4, 12, 22]

*conditions로 조건 함수를 여러 개 받고, all()로 모든 조건을 만족하는지 확인하는 패턴. 함수를 인자로 넘기는 것과 *args, all()이 합쳐진 종합 문제다.

리스트 컴프리헨션 버전:

def filter_all(items, *conditions):
    return [item for item in items if all(c(item) for c in conditions)]

12. lambda 루프 함정 — 알아두면 좋은 것

# 이렇게 쓰면 전부 같은 값이 나온다!
multipliers = []
for i in range(1, 4):
    multipliers.append(lambda x: x * i)  # i를 값이 아니라 변수 자체를 기억

# 전부 15 (i가 마지막에 3이 되어있으니까)
print(multipliers[0](5))  # 15!

# 함수로 감싸면 해결
def make_multiplier(n):
    return lambda x: x * n  # n에 그 시점의 값이 복사됨

lambda는 변수를 기억하지, 값을 기억하는 게 아니다. 루프 안에서 직접 쓸 때 주의!

오늘의 결과

• 10문제 풀이, 1차 정답률 70% (7/10), 최종 전부 정답
• 튜플 활용 안정적, 함수 심화 개념 빠르게 흡수
• 다음 시간: Phase 1 마무리 — 예외 처리(try/except) + 종합 복습