코드: 패 규칙 적용 play()

핵심은 단 두 줄 추가야. prev_board 인자를 받아서, 새 상태가 그것과 같으면 'ko' 반환하고 되돌림.

🔑 패 체크 로직

if prev_board is not None and board == prev_board:
    # 직전 상태로 돌아감 → 패 위반
    # 보드 되돌리고 'ko' 반환
    return 'ko'

파이썬 리스트 비교 ==는 모든 원소가 같은지 자동 확인. 2D 리스트도 그대로 동작.

코드를 실행하면 백이 (2,3)에 두려는 순간 'ko' 반환되면서 보드가 바뀌지 않는 게 보일 거야. 정확히 패 규칙이 작동한 거.

실제 진짜 알파고 구현에서는 positional superko라는 더 엄격한 규칙도 있어 (어느 시점 어느 상태와도 반복 금지). 우리는 일단 단순 패로 충분.

PYTHON

# 패 규칙 적용 play() — 직전 상태와 비교.
# 핵심 변경: prev_board를 인자로 받아서 비교.

EMPTY, BLACK, WHITE = 0, 1, 2
SIZE = 5

def neighbors(r, c):
    result = []
    for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
        nr, nc = r + dr, c + dc
        if 0 <= nr < SIZE and 0 <= nc < SIZE:
            result.append((nr, nc))
    return result

def find_group(board, r, c):
    if board[r][c] == EMPTY: return set()
    color = board[r][c]
    group = set()
    stack = [(r, c)]
    while stack:
        cr, cc = stack.pop()
        if (cr, cc) in group: continue
        if board[cr][cc] != color: continue
        group.add((cr, cc))
        for nr, nc in neighbors(cr, cc):
            if (nr, nc) not in group:
                stack.append((nr, nc))
    return group

def group_liberties(board, r, c):
    group = find_group(board, r, c)
    libs = set()
    for cr, cc in group:
        for nr, nc in neighbors(cr, cc):
            if board[nr][nc] == EMPTY:
                libs.add((nr, nc))
    return libs


def play_with_ko(board, r, c, color, prev_board=None):
    """패 규칙 적용 play. prev_board는 직전 수 직후의 상태(2D 리스트).
    None, 'ko', 또는 잡은 돌 set 반환."""

    if board[r][c] != EMPTY:
        return None

    # 백업
    backup = [row[:] for row in board]
    board[r][c] = color
    enemy = WHITE if color == BLACK else BLACK

    # 적 따냄
    captured = set()
    for nr, nc in neighbors(r, c):
        if board[nr][nc] == enemy and not group_liberties(board, nr, nc):
            captured |= find_group(board, nr, nc)
    for cr, cc in captured:
        board[cr][cc] = EMPTY

    # 자살수 체크
    if not group_liberties(board, r, c):
        # 되돌리기
        for i in range(SIZE):
            for j in range(SIZE):
                board[i][j] = backup[i][j]
        return None

    # 🔑 패 체크: 새 상태가 직전 상태와 같으면 무효
    if prev_board is not None and board == prev_board:
        for i in range(SIZE):
            for j in range(SIZE):
                board[i][j] = backup[i][j]
        return 'ko'  # 패 위반

    return captured


# === 시뮬레이션: 패 발생 ===
def show(b):
    sym = {EMPTY: ".", BLACK: "X", WHITE: "O"}
    for row in b:
        print(" ".join(sym[v] for v in row))

# 패 모양 셋업 — 백 (1,1)이 정확히 단수 (활로 1개)
# 흑 (0,1),(1,0),(2,1)이 사방을 막고, 우측 (1,2)가 패의 핵심 빈자리
board = [[EMPTY] * SIZE for _ in range(SIZE)]
board[0][1] = BLACK
board[0][2] = WHITE
board[1][0] = BLACK
board[1][1] = WHITE   # 단수 (활로: (1,2) 한 개)
board[1][3] = WHITE
board[2][1] = BLACK
board[2][2] = WHITE

print("초기 보드:")
show(board)

# 흑 두기 전 보드 백업 — 패 비교용
prev = [row[:] for row in board]

# 흑이 (1,2)에 둠 (백 (1,1) 잡음)
result = play_with_ko(board, 1, 2, BLACK, prev_board=None)  # 첫 수, prev 없음
print(f"\n흑 (1,2) 둠 → 잡은 돌: {sorted(result) if isinstance(result, set) else result}")
show(board)

# 백이 즉시 (1,1)에 두려고 시도 → 따냄 후 보드가 원래로 돌아감 → 패!
result = play_with_ko(board, 1, 1, WHITE, prev_board=prev)
print(f"\n백이 (1,1) 시도 → 결과: {result}")
print("(패 위반 — 두지 못함)")
show(board)

출력

기대 출력:

초기 보드:
. X O . .
X O . O .
. X O . .
. . . . .
. . . . .

흑 (1,2) 둠 → 잡은 돌: [(1, 1)]
. X O . .
X . X O .
. X O . .
. . . . .
. . . . .

백이 (1,1) 시도 → 결과: ko
(패 위반 — 두지 못함)
. X O . .
X . X O .
. X O . .
. . . . .
. . . . .

← 이전 패 규칙 — 직전 상태로 돌아가지 마라 다음 → 패 싸움이라는 전술