### demo

>>> min_conflicts(australia)

{'WA': 'B', 'Q': 'B', 'T': 'G', 'V': 'B', 'SA': 'R', 'NT': 'G', 'NSW': 'G'}

>>> min_conflicts(usa)

{'WA': 'B', 'DE': 'R', 'DC': 'Y', 'WI': 'G', 'WV': 'Y', 'HI': 'R', 'FL': 'B', 'WY': 'Y', 'NH': 'R', 'NJ': 'Y', 'NM': 'Y', 'TX': 'G', 'LA': 'R', 'NC': 'B', 'ND': 'Y', 'NE': 'B', 'TN': 'G', 'NY': 'R', 'PA': 'B', 'RI': 'R', 'NV': 'Y', 'VA': 'R', 'CO': 'R', 'CA': 'B', 'AL': 'R', 'AR': 'Y', 'VT': 'Y', 'IL': 'B', 'GA': 'Y', 'IN': 'Y', 'IA': 'Y', 'OK': 'B', 'AZ': 'R', 'ID': 'G', 'CT': 'Y', 'ME': 'B', 'MD': 'G', 'KA': 'Y', 'MA': 'B', 'OH': 'R', 'UT': 'B', 'MO': 'R', 'MN': 'R', 'MI': 'B', 'AK': 'B', 'MT': 'R', 'MS': 'B', 'SC': 'G', 'KY': 'B', 'OR': 'R', 'SD': 'G'}

import doctest, re

def run_tests(modules, verbose=None):

"Run tests for a list of modules; then summarize results."

for module in modules:

tests, demos = split_extra_tests(module.__name__ + ".txt")

if tests:

if '__doc__' not in dir(module):

module.__doc__ = ''

module.__doc__ += '\n' + tests + '\n'

doctest.testmod(module, report=0, verbose=verbose)

if demos:

for stmt in re.findall(">>> (.*)", demos):

exec stmt in module.__dict__

doctest.master.summarize()

def split_extra_tests(filename):

"""Take a filename and, if it exists, return a 2-tuple of

try:

contents = open(filename).read() + '# demo'

return contents.split("# demo", 1)

except IOError:

return ('', '')

if __name__ == "__main__":

import sys

modules = [__import__(name.replace('.py',''))

for name in sys.argv if name != "-v"]

run_tests(modules, ("-v" in sys.argv))

### This is an example module.txt file.

### It should contain unit tests and their expected results:

>>> 2 + 2

4

>>> '2' + '2'

'22'

### demo

### After the part that says 'demo' we have statements that

### are intended not as unit tests, but as demos of how to

### use the functions and methods in the module. The

### statements are executed, but the results are not

### compared to the expected results. This can be useful

### for nondeterministic functions:

>>> import random; random.choice('abc')

'c'

from utils import *

import random

def minimax_decision(state, game):

"""Given a state in a game, calculate the best move by searching

player = game.to_move(state)

def max_value(state):

if game.terminal_test(state):

return game.utility(state, player)

v = -infinity

for (a, s) in game.successors(state):

v = max(v, min_value(s))

return v

def min_value(state):

if game.terminal_test(state):

return game.utility(state, player)

v = infinity

for (a, s) in game.successors(state):

v = min(v, max_value(s))

return v

# Body of minimax_decision starts here:

action, state = argmax(game.successors(state),

lambda ((a, s)): min_value(s))

return action

def alphabeta_full_search(state, game):

"""Search game to determine best action; use alpha-beta pruning.

player = game.to_move(state)

def max_value(state, alpha, beta):

if game.terminal_test(state):

return game.utility(state, player)

v = -infinity

for (a, s) in game.successors(state):

v = max(v, min_value(s, alpha, beta))

if v >= beta:

return v

alpha = max(alpha, v)

return v

def min_value(state, alpha, beta):

if game.terminal_test(state):

return game.utility(state, player)

v = infinity

for (a, s) in game.successors(state):

v = min(v, max_value(s, alpha, beta))

if v <= alpha:

return v

beta = min(beta, v)

return v

# Body of alphabeta_search starts here:

action, state = argmax(game.successors(state),

lambda ((a, s)): min_value(s, -infinity, infinity))

return action

def alphabeta_search(state, game, d=4, cutoff_test=None, eval_fn=None):

"""Search game to determine best action; use alpha-beta pruning.

player = game.to_move(state)

def max_value(state, alpha, beta, depth):

if cutoff_test(state, depth):

return eval_fn(state)

v = -infinity

for (a, s) in game.successors(state):

v = max(v, min_value(s, alpha, beta, depth+1))

if v >= beta:

return v

alpha = max(alpha, v)

return v

def min_value(state, alpha, beta, depth):

if cutoff_test(state, depth):

return eval_fn(state)

v = infinity

for (a, s) in game.successors(state):

v = min(v, max_value(s, alpha, beta, depth+1))

if v <= alpha:

return v

beta = min(beta, v)

return v

# Body of alphabeta_search starts here:

# The default test cuts off at depth d or at a terminal state

cutoff_test = (cutoff_test or

(lambda state,depth: depth>d or game.terminal_test(state)))

eval_fn = eval_fn or (lambda state: game.utility(state, player))

action, state = argmax(game.successors(state),

lambda ((a, s)): min_value(s, -infinity, infinity, 0))

return action

def query_player(game, state):

"Make a move by querying standard input."

game.display(state)

return num_or_str(raw_input('Your move? '))

def random_player(game, state):

"A player that chooses a legal move at random."

return random.choice(game.legal_moves())

def alphabeta_player(game, state):

return alphabeta_search(state, game)

def play_game(game, *players):

"Play an n-person, move-alternating game."

state = game.initial

while True:

for player in players:

move = player(game, state)

state = game.make_move(move, state)

if game.terminal_test(state):

return game.utility(state, players[0])

class Game:

"""A game is similar to a problem, but it has a utility for each

def legal_moves(self, state):

"Return a list of the allowable moves at this point."

abstract

def make_move(self, move, state):

"Return the state that results from making a move from a state."

abstract

def utility(self, state, player):

"Return the value of this final state to player."

abstract

def terminal_test(self, state):

"Return True if this is a final state for the game."

return not self.legal_moves(state)

def to_move(self, state):

"Return the player whose move it is in this state."

return state.to_move

def display(self, state):

"Print or otherwise display the state."

print state

def successors(self, state):

"Return a list of legal (move, state) pairs."

return [(move, self.make_move(move, state))

for move in self.legal_moves(state)]

def __repr__(self):

return '<%s>' % self.__class__.__name__

class Fig62Game(Game):

"""The game represented in [Fig. 6.2]. Serves as a simple test case.

succs = {'A': [('a1', 'B'), ('a2', 'C'), ('a3', 'D')],

'B': [('b1', 'B1'), ('b2', 'B2'), ('b3', 'B3')],

'C': [('c1', 'C1'), ('c2', 'C2'), ('c3', 'C3')],

'D': [('d1', 'D1'), ('d2', 'D2'), ('d3', 'D3')]}

utils = Dict(B1=3, B2=12, B3=8, C1=2, C2=4, C3=6, D1=14, D2=5, D3=2)

initial = 'A'

def successors(self, state):

return self.succs.get(state, [])

def utility(self, state, player):

if player == 'MAX':

return self.utils[state]

else:

return -self.utils[state]

def terminal_test(self, state):

return state not in ('A', 'B', 'C', 'D')

def to_move(self, state):

return if_(state in 'BCD', 'MIN', 'MAX')

class TicTacToe(Game):

"""Play TicTacToe on an h x v board, with Max (first player) playing 'X'.

def __init__(self, h=3, v=3, k=3):

update(self, h=h, v=v, k=k)

moves = [(x, y) for x in range(1, h+1)

for y in range(1, v+1)]

self.initial = Struct(to_move='X', utility=0, board={}, moves=moves)

def legal_moves(self, state):

"Legal moves are any square not yet taken."

return state.moves

def make_move(self, move, state):

if move not in state.moves:

return state # Illegal move has no effect

board = state.board.copy(); board[move] = state.to_move

moves = list(state.moves); moves.remove(move)

return Struct(to_move=if_(state.to_move == 'X', 'O', 'X'),

utility=self.compute_utility(board, move, state.to_move),

board=board, moves=moves)

def utility(self, state):

"Return the value to X; 1 for win, -1 for loss, 0 otherwise."

return state.utility

def terminal_test(self, state):

"A state is terminal if it is won or there are no empty squares."

return state.utility != 0 or len(state.moves) == 0

def display(self, state):

board = state.board

for x in range(1, self.h+1):

for y in range(1, self.v+1):

print board.get((x, y), '.'),

print

def compute_utility(self, board, move, player):

"If X wins with this move, return 1; if O return -1; else return 0."

if (self.k_in_row(board, move, player, (0, 1)) or

self.k_in_row(board, move, player, (1, 0)) or

self.k_in_row(board, move, player, (1, -1)) or

self.k_in_row(board, move, player, (1, 1))):

return if_(player == 'X', +1, -1)

else:

return 0

def k_in_row(self, board, move, player, (delta_x, delta_y)):

"Return true if there is a line through move on board for player."

x, y = move

n = 0 # n is number of moves in row

while board.get((x, y)) == player:

n += 1

x, y = x + delta_x, y + delta_y

x, y = move

while board.get((x, y)) == player:

n += 1

x, y = x - delta_x, y - delta_y

n -= 1 # Because we counted move itself twice

return n >= self.k

class ConnectFour(TicTacToe):

"""A TicTacToe-like game in which you can only make a move on the bottom

def __init__(self, h=7, v=6, k=4):

TicTacToe.__init__(self, h, v, k)

def legal_moves(self, state):

"Legal moves are any square not yet taken."

return [(x, y) for (x, y) in state.moves

if y == 0 or (x, y-1) in state.board]