nim.py

#! /usr/bin/python

from __future__ import division, print_function

from enum import Enum
from copy import copy
from random import randrange


class Evaluation(Enum):
    LOSS = 'LOSS'
    WIN = 'WIN'


def convert_to_single_heap_using_builtin(heap_a, heap_b):
    """
    Convert a pair of Nim heap sizes to the size of an equivalent single heap.
    Python happens to have an operator (^) that works exactly as we need it to.
    """
    return heap_a ^ heap_b


def convert_to_single_heap_recursively(heap_a, heap_b):
    """
    Convert a pair of Nim heap sizes to the size of an equivalent single heap.
    This time, use recursion.

    >>> convert_to_single_heap_recursively(0, 0)
    0
    >>> convert_to_single_heap_recursively(5, 0)
    5
    >>> convert_to_single_heap_recursively(0, 5)
    5
    >>> convert_to_single_heap_recursively(5, 6)
    3
    >>> convert_to_single_heap_recursively(9, 5)
    12
    >>> convert_to_single_heap_recursively(21, 10)
    31
    >>> convert_to_single_heap_recursively(21, 11)
    30
    """
    return 0  # Stub


def evaluate(heap_sizes):
    """
    Evaluate a Nim position given as a list of heap sizes, returning
    Evaluation.LOSS if the player who just moved will lose under perfect play,
    Evaluation.WIN if the player who just moved will win under perfect play.

    >>> evaluate([])
    <Evaluation.WIN: 'WIN'>
    >>> evaluate([0])
    <Evaluation.WIN: 'WIN'>
    >>> evaluate([1])
    <Evaluation.LOSS: 'LOSS'>
    >>> evaluate([0, 1])
    <Evaluation.LOSS: 'LOSS'>
    >>> evaluate([1, 1])
    <Evaluation.WIN: 'WIN'>
    >>> evaluate([1, 2, 2])
    <Evaluation.LOSS: 'LOSS'>
    >>> evaluate([3, 2, 1])
    <Evaluation.WIN: 'WIN'>
    >>> evaluate([9, 12, 3, 6])
    <Evaluation.WIN: 'WIN'>
    >>> evaluate([9, 12, 3, 7])
    <Evaluation.LOSS: 'LOSS'>
    """
    return Evaluation.LOSS  # Stub


def make_computer_move(position):
    """
    Return a Nim position after the computer has made a move from the position
    given.
    """
    for i, heap_size in enumerate(position):
        next_position = copy(position)
        for j in range(heap_size):
            next_position[i] = j
            if evaluate(next_position) is Evaluation.WIN:
                return next_position
    return next_position


def main():
    """
    A simple command-line Nim game with no error handling.
    """
    position = [randrange(1, 10) for _ in range(randrange(3, 7))]
    while True:
        print('Heaps: {position}'.format(position=position))
        if sum(position) == 0:
            print('Human Wins!')
            print()
            return
        print('Computer moves...')
        print()
        position = make_computer_move(position)
        print('Heaps: {position}'.format(position=position))
        if sum(position) == 0:
            print('Computer Wins!')
            print()
            return
        index = int(input('Index at which to take stones? '))
        count = int(input('Number of stones to take? '))
        print()
        position[index] -= count


if __name__ == '__main__':
    main()