Principles of Computing (Part 2) -- week 3 (Tree, Lambda, Minimax)

lambda:

Anonymous functions are simplified forms of function definitions.
- they do not have a name.
- the parameter list is not in parentheses.
- the function body is just a single expression, which is implicitly returned.
This simplicity is convenient especially when the function is simply passed as an argument, as in the last example above.

Example:

    data = [1, 3, 6, 9, 18]

    # square elements in a list by lambda
    data3 = map(lambda x: x ** 2, data)

    # filter the even number
    data4 = filter(lambda val: val % 2 == 0, data)

Tree

A rooted tree is a hierarchical data structure with applications in many areas of computer science. These applications include searching, sorting, modeling biological processes (such as genealogy), and representing hierarchical programming constructs such as arithmetic expressions.
This distinction between leaf nodes and internal nodes allows us to specify simple recursive definitions for several important structural quantities associated with trees.

• The number of nodes in a tree satisfies:

    If the root node of the tree is a leaf:
        return 1
    else:
        return 1 + the sum of the number of nodes for each subtree

• The number of leaves in a tree satisfies:

    If the root node of the tree is a leaf:
        return 1
    else:
        return the sum of the number of leaves for each subtree

• The height of a tree is the length of the longest sequence of edges from the root to a leaf. The height can be computed recursively via:

    If the root node of the tree is a leaf:
        return 0
    else:
        return 1 + the maximum of the heights of the subtrees

In the case of binary trees, the two subtrees of a node are usually referred to as the left subtree and the right subtree. For binary trees, there are three common types of tree traversals:

• Pre-order traversals - process root, process left subtree, process right subtree
• Post-order traversals - process left subtree, process right subtree, process root
• In-order traversals - process left subtree, process root, process right subtree

ArithmeticExpression class implement uses In-order traversals

Mini Project – TicTacToe with Minimax

• Use Minimax to return the best move
• Use Memo_dict to record the score the boards, reduce iteration
• Use equivalent_boards by mirror & rotation to optimize
• Use opt_empty_cell to reduce the empty cell search list

    """
    Mini-max Tic-Tac-Toe Player
    """

    import poc_ttt_gui
    import poc_ttt_provided as provided

    # Set timeout, as mini-max can take a long time
    import codeskulptor
    codeskulptor.set_timeout(600)
    import math
    import random
    # SCORING VALUES - DO NOT MODIFY
    SCORES = {provided.PLAYERX: 1,
              provided.DRAW: 0,
              provided.PLAYERO: -1}

    # helper function
    def transpose_board(board):
        """
        return the transposed board
        """
        dim = board.get_dim()
        tboard = provided.TTTBoard(dim)
        for row in range(dim):
            for col in range(dim):
                if board.square(row, col) != provided.EMPTY:
                    tboard.move(col, row, board.square(row, col))            
        return tboard                                    

    def x_mirror_board(board):
        """
        return the board mirrored by x
        """
        dim = board.get_dim()
        xboard = provided.TTTBoard(dim)
        for row in range(dim):
            for col in range(dim):
                if board.square(row, col) != provided.EMPTY:
                    xrow = dim - row - 1
                    xboard.move(xrow, col, board.square(row, col))
        return xboard            

    def y_mirror_board(board):
        """
        return the board mirrored by y
        """
        dim = board.get_dim()
        yboard = provided.TTTBoard(dim)
        for row in range(dim):
            for col in range(dim):
                if board.square(row, col) != provided.EMPTY:
                    ycol = dim - col - 1
                    yboard.move(row, ycol, board.square(row, col))
        return yboard       

    def rotate_board(board, retation = 90):
        """
        retate the board by 0, 90, 180, 270 degree
        """
        dim = board.get_dim()
        rboard = provided.TTTBoard(dim)

        valid_rotation_list = [0, 90, 180, 270]
        if retation not in valid_rotation_list:
            return "Invalid retation", retation

        for row in range(dim):
            for col in range(dim):
                if retation == 90:
                    rboard.move(dim - col - 1, row, board.square(row, col))
                elif retation == 180:
                    rboard.move(dim - row - 1, dim - col - 1, board.square(row, col))
                elif retation == 270:
                    rboard.move(col, dim - row - 1, board.square(row, col))
                else:
                    rboard.move(row, col, board.square(row, col))
        return rboard

    def all_equivalent_board(board):
        """
        return all the equivalent boards
        """
        all_boards = []

        rotation_list = [0, 90, 180, 270]
        for rotation in rotation_list:
            rboard = rotate_board(board, rotation)
            tboard = transpose_board(rboard)
            all_boards.append(rboard)
            all_boards.append(tboard)
        return all_boards

    def opt_empty_cell(board):
        """
        reduce the empty cell according to the board
        """
        dim = board.get_dim()
        all_empty_cells = board.get_empty_squares()

        xboard = x_mirror_board(board)
        if str(board) == str(xboard):
            xrow = int(math.ceil(dim / 2.0))
            for row in range(xrow, dim):
                for col in range(dim):
                    cell = (row, col)
                    if cell in all_empty_cells:
                        all_empty_cells.remove(cell)

        yboard = y_mirror_board(board)
        if str(board) == str(yboard):
            ycol = int(math.ceil(dim / 2.0))
            for row in range(dim):
                for col in range(ycol, dim):
                    cell = (row, col)
                    if cell in all_empty_cells:
                        all_empty_cells.remove(cell)

        tboard = transpose_board(board)
        if str(board) == str(tboard):
            xrow = int(math.floor(dim / 2.0))
            ycol = int(math.ceil(dim / 2.0))
            for row in range(xrow, dim):
                for col in range(ycol):
                    if row != col:
                        cell = (row, col)
                        if cell in all_empty_cells:
                            all_empty_cells.remove(cell)

        return all_empty_cells

    def mm_move_helper(board, player, memo_dict):
        """
        helper function for mm_move for not corrupt origial structure
        """

        if (str(board)) in memo_dict.keys():
            return memo_dict[(str(board))]

        # DFS the tree until game finishes
        if board.check_win() == None:
            cell_dict = {}

            # score the next moves
            # for cell in board.get_empty_squares():
            for cell in opt_empty_cell(board):
                board_clone = board.clone()
                board_clone.move(cell[0], cell[1], player)
                move = mm_move_helper(board_clone, provided.switch_player(player), memo_dict)

                # stop DFS search as long as the best solution is found
                if move[0] * SCORES[player] == 1:
                    # memo the result
                    all_boards = all_equivalent_board(board)
                    for a_board in all_boards:
                        memo_dict[str(a_board)] = (move[0], cell)                
                    return move[0], cell

                if move[0] * SCORES[player] not in cell_dict.keys():
                    cell_dict[move[0] * SCORES[player]] = cell

            # return the best score and move
            max_score = max(cell_dict.keys())
            best_score = max_score * SCORES[player]
            best_move = cell_dict[max_score]

        else:
            # Score the board when game finishes
            best_score = SCORES[board.check_win()]
            best_move = (-1, -1)

        # memo the result
        all_boards = all_equivalent_board(board)
        for a_board in all_boards:
            memo_dict[str(a_board)] = (best_score, best_move)

        return best_score, best_move

    def mm_move(board, player):
        """
        Make a move on the board.

        Returns a tuple with two elements.  The first element is the score
        of the given board and the second element is the desired move as a
        tuple, (row, col).

        memo_dict is a dictionary that stores previously computed results
        """
        return mm_move_helper(board, player, {})

    def move_wrapper(board, player, trials):
        """
        Wrapper to allow the use of the same infrastructure that was used
        for Monte Carlo Tic-Tac-Toe.
        """
        move = mm_move(board, player)
        assert move[1] != (-1, -1), "returned illegal move (-1, -1)"
        return move[1]

    # Test game with the console or the GUI.
    # Uncomment whichever you prefer.
    # Both should be commented out when you submit for
    # testing to save time.

    #provided.play_game(move_wrapper, 1, False)        
    poc_ttt_gui.run_gui(3, provided.PLAYERX, move_wrapper, 1, False)