실전: 짧은 대국 시뮬레이션

위 코드를 실행하면 두 사람이 번갈아 두는 시뮬레이션이 끝나고 점수가 나와. 흑이 좌측을 가로로 차지하고, 백이 우측을 차지한 단순 모양.

결과: 흑집 4, 백집 4 + 덤 6.5 = 백 6.5집 승. 양쪽이 비슷한 영역인데 덤 때문에 백이 이기지. 중립 지역이 가운데 7집이라 양쪽 집이 보드 크기에 비해 적어 보임.

💡 이게 알파고의 환경

알파고는 매 수 둘 때마다 머릿속에서 이런 시뮬레이션을 수만 번 돌려. "내가 여기 두면 → 상대가 저기 두면 → ... → 끝까지 가면 누가 이길까?" play()를 빠르게 호출하는 게 너무 중요한 이유.

실제 알파고 코드는 C++로 최적화돼 있고, 이 단순한 파이썬 구현보다 수백 배 빨라. 하지만 알고리즘 본질은 똑같아.

축하해. 완전히 작동하는 작은 바둑 엔진이 완성됐어. 다음 페이지에서 5x5 바둑의 진실(=흑이 절대 이긴다)을 알아보고 PART 1을 마무리하자.

PYTHON

# 미리 정해진 수순으로 짧은 대국을 시뮬레이션.
# 위 페이지의 Board 클래스를 그대로 사용한다고 가정.
# (편의상 클래스 다시 정의)

class Board:
    EMPTY, BLACK, WHITE = 0, 1, 2
    def __init__(self, size=5):
        self.size = size
        self.grid = [[0] * size for _ in range(size)]
        self.prev_grid = None
        self.captures = {1: 0, 2: 0}
    def neighbors(self, r, c):
        return [(r+dr, c+dc) for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]
                if 0 <= r+dr < self.size and 0 <= c+dc < self.size]
    def find_group(self, r, c):
        if self.grid[r][c] == 0: return set()
        color = self.grid[r][c]; group = set(); stack = [(r, c)]
        while stack:
            cr, cc = stack.pop()
            if (cr, cc) in group or self.grid[cr][cc] != color: continue
            group.add((cr, cc))
            stack.extend(self.neighbors(cr, cc))
        return group
    def group_liberties(self, r, c):
        return {(nr, nc) for cr, cc in self.find_group(r, c)
                for nr, nc in self.neighbors(cr, cc) if self.grid[nr][nc] == 0}
    def play(self, r, c, color):
        if self.grid[r][c] != 0: return 'illegal'
        backup = [row[:] for row in self.grid]
        self.grid[r][c] = color
        enemy = 3 - color
        captured = set()
        for nr, nc in self.neighbors(r, c):
            if self.grid[nr][nc] == enemy and not self.group_liberties(nr, nc):
                captured |= self.find_group(nr, nc)
        for cr, cc in captured: self.grid[cr][cc] = 0
        if not self.group_liberties(r, c):
            self.grid = backup; return 'illegal'
        if self.prev_grid is not None and self.grid == self.prev_grid:
            self.grid = backup; return 'ko'
        self.prev_grid = backup
        self.captures[color] += len(captured)
        return captured
    def find_territories(self):
        visited = set()
        result = {'black': [], 'white': [], 'neutral': []}
        for r in range(self.size):
            for c in range(self.size):
                if (r, c) in visited or self.grid[r][c] != 0: continue
                region = set(); borders = set(); stack = [(r, c)]
                while stack:
                    cr, cc = stack.pop()
                    if (cr, cc) in region: continue
                    if self.grid[cr][cc] == 0:
                        region.add((cr, cc)); visited.add((cr, cc))
                        stack.extend(self.neighbors(cr, cc))
                    else:
                        borders.add(self.grid[cr][cc])
                if borders == {1}: result['black'].extend(region)
                elif borders == {2}: result['white'].extend(region)
                else: result['neutral'].extend(region)
        return result
    def score(self, komi=6.5):
        t = self.find_territories()
        b, w = len(t['black']), len(t['white']) + komi
        winner = (f'흑 {b-w:.1f}집 승' if b > w
                  else f'백 {w-b:.1f}집 승' if w > b else '무승부')
        return b, w, winner
    def show(self):
        sym = {0: ".", 1: "X", 2: "O"}
        for row in self.grid:
            print(" ".join(sym[v] for v in row))


# === 짧은 대국 — 흑이 좌측, 백이 우측 차지 ===
b = Board(size=5)
moves = [
    (1, 1, 1), (1, 3, 2),   # 흑 (1,1), 백 (1,3)
    (3, 1, 1), (3, 3, 2),   # 흑 (3,1), 백 (3,3)
    (2, 0, 1), (2, 4, 2),   # 흑 (2,0), 백 (2,4)
    (0, 1, 1), (0, 3, 2),   # 흑 (0,1), 백 (0,3)
    (4, 1, 1), (4, 3, 2),   # 흑 (4,1), 백 (4,3)
]

for r, c, color in moves:
    result = b.play(r, c, color)
    name = '흑' if color == 1 else '백'
    print(f"{name} ({r},{c}) → {result if result == 'illegal' or result == 'ko' else 'OK'}")

print()
print("=== 최종 보드 ===")
b.show()

# 두 사람 패스 가정, 점수 계산
print()
print("=== 점수 ===")
black, white, winner = b.score(komi=6.5)
print(f"흑 {black}집, 백 {white}집 → {winner}")
print(f"흑 포로 {b.captures[1]}개, 백 포로 {b.captures[2]}개")

출력

기대 출력:

흑 (1,1) → OK
백 (1,3) → OK
흑 (3,1) → OK
백 (3,3) → OK
흑 (2,0) → OK
백 (2,4) → OK
흑 (0,1) → OK
백 (0,3) → OK
흑 (4,1) → OK
백 (4,3) → OK

=== 최종 보드 ===
. X . O .
. X . O .
X . . . O
. X . O .
. X . O .

=== 최종 보드 ===
. X . O .
. X . O .
X . . . O
. X . O .
. X . O .

=== 점수 ===
흑 4집, 백 10.5집 → 백 6.5집 승
흑 포로 0개, 백 포로 0개

← 이전 코드 2부: play() + score() 다음 → 확인 퀴즈