사람이 실수하면 — AI의 응징

시나리오 1 결과를 보면 AI가 정확히 이긴다:

O가 변에 두는 약한 응수 → 점수 1 (X 이길 확정)
X는 정확히 5수에 가로 (0,0)-(1,1)-(2,2) 대각선 완성
O가 막아도 다른 위협을 만들어서 결국 이김

시나리오 2:

O가 대각 코너 (2,2)에 두면 → 점수 1 (X 여전히 이김!)
코너 응수가 보통 강한 응수로 알려졌는데, X (0,0) 후에는 (1,1) 가운데가 유일한 무승부 보장 응수
O가 (2,2)에 두면 X가 (1,1) 가운데로 이중 위협을 만들어 결국 이김

🎯 이 결과의 의미

이 AI는 두 가지를 동시에 보장:

지지 않음 — 어떤 상대든 최소 무승부 보장 (단, 최선의 응수 둘 때)
실수 응징 — 상대가 최선 외 다른 수를 두면 즉시 이길 길로 끌고 감

이게 이론적 최적 게임. X (0,0) 시작 후에는 O가 정확히 (1,1)만 무승부 가능. 다른 8자리 응수는 모두 X 승으로 끝남. minimax는 이 모든 경로를 정확히 계산.

💡 직접 실험해봐

위 코드 수정해서:

X가 가운데 (1,1) 시작 → O 최선 응수 알아보기
X가 변 (0,1) 시작 → 어떤 결과인가?
중간 상황 만들어서 AI 다음 수 예측

좋아하는 시작 상황을 board 리스트에 직접 넣어서 실험해봐.

좋아. 우리 작은 게임에서는 minimax가 완벽하게 동작. 이걸로 끝낼 수 있으면 좋겠는데... 바둑에 적용하려고 하면 어떻게 될까?

PYTHON

# AI가 진짜 강한 건 실수 응징 능력에서 드러나.
# 시나리오: O가 첫 수에 실수해서 변(0,1)에 둠. AI X가 어떻게 응징?

class TicTacToe:
    EMPTY, X, O = ' ', 'X', 'O'
    LINES = [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]
    def __init__(self, board=None, turn=None):
        self.board = board if board is not None else [self.EMPTY]*9
        self.turn = turn or self.X
    def show(self):
        for r in range(3):
            print(' | '.join(self.board[r*3:(r+1)*3]))
            if r < 2: print('-'*9)
    def possible_moves(self):
        return [i for i in range(9) if self.board[i] == self.EMPTY]
    def play(self, pos):
        nb = self.board[:]; nb[pos] = self.turn
        return TicTacToe(nb, self.O if self.turn == self.X else self.X)
    def winner(self):
        for a,b,c in self.LINES:
            if self.board[a] != self.EMPTY and self.board[a]==self.board[b]==self.board[c]:
                return self.board[a]
        if self.EMPTY not in self.board: return 'draw'
        return None
    def score(self):
        return {self.X:1, self.O:-1, 'draw':0}.get(self.winner())

def minimax_ab(game, alpha=-float('inf'), beta=float('inf')):
    score = game.score()
    if score is not None: return score, None
    is_max = (game.turn == TicTacToe.X)
    best_pos = None
    if is_max:
        v = -float('inf')
        for pos in game.possible_moves():
            cs, _ = minimax_ab(game.play(pos), alpha, beta)
            if cs > v: v, best_pos = cs, pos
            alpha = max(alpha, v)
            if beta <= alpha: break
        return v, best_pos
    else:
        v = float('inf')
        for pos in game.possible_moves():
            cs, _ = minimax_ab(game.play(pos), alpha, beta)
            if cs < v: v, best_pos = cs, pos
            beta = min(beta, v)
            if beta <= alpha: break
        return v, best_pos


# === 시나리오 1: O가 변에 두는 실수 ===
print("=== 시나리오 1: O의 첫 수 (0,1) 변 — 약한 응수 ===")
g = TicTacToe()
g = g.play(0)  # X (0,0)
g = g.play(1)  # O (0,1)  ← 실수 (코너로 가야 함)

print("현재 보드:")
g.show()
score, _ = minimax_ab(g)
print(f"이 상황의 X 입장 점수: {score} (1 = X가 결국 이김)")
print()

# AI 두 명이 끝까지 두기
move_num = 3
while g.winner() is None:
    _, best = minimax_ab(g)
    r, c = best // 3, best % 3
    print(f"수 {move_num}: {g.turn} ({r},{c})")
    g = g.play(best)
    move_num += 1

print("\n최종 보드:")
g.show()
print(f"\n결과: {g.winner()}")

print()
print("=== 시나리오 2: O가 (2,2) 코너 응수 — 사실 약한 응수 ===")
g = TicTacToe()
g = g.play(0)  # X (0,0)
g = g.play(8)  # O (2,2)  ← 대각 코너 (강해 보이지만 X 승)
print("이 상황의 점수:")
score, _ = minimax_ab(g)
print(f"점수: {score} (1 = X가 여전히 이김! 코너 응수도 무패 보장 아님)")

출력

기대 출력:

=== 시나리오 1: O의 첫 수 (0,1) 변 — 약한 응수 ===
현재 보드:
X | O |  
---------
  |   |  
---------
  |   |  
이 상황의 X 입장 점수: 1 (1 = X가 결국 이김)

수 3: X (1,0)
수 4: O (0,2)
수 5: X (1,1)
수 6: O (1,2)
수 7: X (2,0)

최종 보드:
X | O | O
---------
X | X | O
---------
X |   |  

결과: X

=== 시나리오 2: O가 (2,2) 코너 응수 — 사실 약한 응수 ===
이 상황의 점수:
점수: 1 (1 = X가 여전히 이김! 코너 응수도 무패 보장 아님)

← 이전 AI vs AI — 항상 무승부 다음 → 확인 퀴즈