HW2-TicTacToe.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Python for Research Homework: Week 2\n",
    "\n",
    "In this homework, we will use the tools we've covered in the past two weeks to create a tic-tac-toe (noughts and crosses) simulator and evaluate basic winning strategies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Tic-tac-toe (or noughts and crosses) is a simple strategy game in which two players take turns placing a mark on a 3x3 board, attempting to make a row, column, or diagonal of three with their mark. In this homework, we will use the tools we've covered in the past two weeks to create a tic-tac-toe simulator and evaluate basic winning strategies.\n",
    "\n",
    "In the following exercises, we will learn to create a tic-tac-toe board, place markers on the board, evaluate if either player has won, and use this to simulate two basic strategies.\n",
    "\n",
    "#### Instructions \n",
    "\n",
    "- For our tic-tac-toe board, we will use a numpy array with dimension 3 by 3. \n",
    "- Make a function `create_board()` that creates such a board with the value of each cell set to the integer `0`.\n",
    "- Call `create_board()` and store it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def create_board():\n",
    "    board = np.zeros((3, 3))\n",
    "    return board\n",
    "create_board()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "Players 1 and 2 will take turns changing values of this array from a 0 to a 1 or 2, indicating the number of the player who places a marker there.\n",
    "\n",
    "#### Instructions \n",
    "\n",
    "- Create a function `place(board, player, position)`, where:\n",
    "    - `player` is the current player (an integer 1 or 2).\n",
    "    - `position` is a tuple of length 2 specifying a desired location to place their marker.\n",
    "    - Your function should only allow the current player to place a marker on the board (change the board position to their number) if that position is empty (zero).\n",
    "- Use `create_board()` to store a board as `board`, and use `place` to have Player 1 place a marker on location `(0, 0)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "board = create_board()\n",
    "\n",
    "def place(board, player, position):\n",
    "    \n",
    "    if board[position] == 0:\n",
    "        board[position] = player\n",
    "    else:\n",
    "        print(\"position already marked!\")\n",
    "    return board\n",
    "\n",
    "place(board, 1, (0,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "In this exercise, we will determine which positions are available to either player for placing their marker.\n",
    "\n",
    "#### Instructions \n",
    "- Create a function `possibilities(board)` that returns a list of all positions (tuples) on the board that are not occupied (0). (Hint: `numpy.where` is a handy function that returns a list of indices that meet a condition.)\n",
    "- `board` is already defined from previous exercises. Call `possibilities(board)` to see what it returns!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 0, 1, 1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2, 0, 1, 2]))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def possibilities(board):\n",
    "    return np.where(board == 0)\n",
    "\n",
    "possibilities(board)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "The next step is for the current player to place a marker among the available positions. In this exercise, we will select an available board position at random and place a marker there.\n",
    "\n",
    "#### Instructions \n",
    "\n",
    "- Write a function `random_place(board, player)` that places a marker for the current player at random among all the available positions (those currently set to 0).\n",
    "    - Find possible placements with `possibilities(board)`.\n",
    "    - Select one possible placement at random using `random.choice(selection)`.\n",
    "- `board` is already defined from previous exercises. Call `random_place(board, player)` to place a random marker for Player 2, and store this as board to update its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [2., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random \n",
    "random.seed(1)\n",
    "print(board)\n",
    "# board = create_board()\n",
    "\n",
    "def random_place(board, player):\n",
    "    xs = possibilities(board)[0]\n",
    "    ys = possibilities(board)[1]\n",
    "    if len(possibilities(board)[0]) < 1:\n",
    "        return board\n",
    "    index = random.randrange(len(possibilities(board)[0]))\n",
    "    selection = (xs[index], ys[index])\n",
    "    \n",
    "#     print(player)\n",
    "#     print(xs)\n",
    "#     print(xs)\n",
    "#     print(selection)\n",
    "    \n",
    "    board[selection] = player\n",
    "#     print(board)\n",
    "    return board\n",
    "\n",
    "random_place(board, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "\n",
    "We will now have both players place three markers each.\n",
    "\n",
    "#### Instructions \n",
    "\n",
    "- A new `board` is already given. Call `random_place(board, player)` to place three pieces each on board for players 1 and 2.\n",
    "- Print board to see your result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2., 1.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 1., 2.]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.seed(1)\n",
    "board = create_board()\n",
    "\n",
    "random_place(board, 1)\n",
    "random_place(board, 2)\n",
    "random_place(board, 1)\n",
    "random_place(board, 2)\n",
    "random_place(board, 1)\n",
    "random_place(board, 2)\n",
    "\n",
    "board"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6\n",
    "\n",
    "In the next few exercises, we will make functions that check whether either player has won the game.\n",
    "\n",
    "#### Instructions \n",
    "- Make a function `row_win(board, player)` that takes the player (integer) and determines if any row consists of only their marker. \n",
    "    - Have it return `True` if this condition is met and `False` otherwise.\n",
    "- `board` is already defined from previous exercises. Call `row_win` to check if Player 1 has a complete row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def row_win(board, player):\n",
    "    for row in range(board.shape[0]):\n",
    "        if (board[row, :] == player).all():\n",
    "            return True\n",
    "    return False\n",
    "    \n",
    "\n",
    "row_win(board, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7\n",
    "\n",
    "In the next few exercises, we will make functions that verify if either player has won the game.\n",
    "\n",
    "#### Instructions \n",
    "- Make a function `col_win(board, player)` that takes the player (integer) and determines if any column consists of only their marker. \n",
    "    - Have it return `True` if this condition is met and `False` otherwise.\n",
    "- `board` is already defined from previous exercises. Call `col_win` to check if Player 1 has a complete row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def col_win(board, player):\n",
    "    for col in range(board.shape[0]):\n",
    "        if (board[:, col] == player).all():\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "col_win(board, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 8\n",
    "\n",
    "In the next few exercises, we will make functions that verify if either player has won the game.\n",
    "\n",
    "#### Instructions \n",
    "- Finally, create a function `diag_win(board, player)` that tests if either diagonal of the board consists of only their marker. Have it return `True` if this condition is met, and `False` otherwise.\n",
    "- `board` has been slightly modified from a previous exercise. Call `diag_win` to check if Player 2 has a complete diagonal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "board[1,1] = 2\n",
    "\n",
    "def diag_win(board, player):\n",
    "    if np.all(board.diagonal() == player):\n",
    "        return True\n",
    "    elif np.all(np.fliplr(board).diagonal() == player):\n",
    "        return True\n",
    "    return False\n",
    "    \n",
    "\n",
    "diag_win(board, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 9\n",
    "\n",
    "In the next few exercises, we will make functions that check whether either player has won the game.\n",
    "\n",
    "#### Instructions \n",
    "- Create a function `evaluate(board)` that uses `row_win`, `col_win`, and `diag_win` functions for both players. If one of them has won, return that player's number. If the board is full but no one has won, return -1. Otherwise, return 0.\n",
    "- `board` is already defined from previous exercises. Call evaluate to see if either player has won the game yet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# def evaluate(board):\n",
    "#     winner = 0\n",
    "#     for player in [1, 2]:\n",
    "#         if row_win(board, player):\n",
    "# #             print(\"row\")\n",
    "#             winner = player\n",
    "#             break\n",
    "#         elif col_win(board, player):\n",
    "#             winner = player\n",
    "# #             print(\"col\")\n",
    "#             break\n",
    "#         elif diag_win(board, player):\n",
    "#             winner = player\n",
    "# #             print(\"diag\")\n",
    "#             break\n",
    "#     if np.all(board != 0) and winner == 0:\n",
    "#         winner = -1\n",
    "# #     print(winner)\n",
    "#     return winner\n",
    "\n",
    "def evaluate(board):\n",
    "    winner = 0\n",
    "    for player in [1, 2]:\n",
    "        if row_win(board, player) or col_win(board, player) or diag_win(board, player):\n",
    "            winner = player\n",
    "            return winner\n",
    "            break\n",
    "    if np.all(board != 0) and winner == 0:\n",
    "        winner = -1\n",
    "#     print(winner)\n",
    "    return winner\n",
    "\n",
    "evaluate(board)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 10\n",
    "\n",
    "In this exercise, we will use all the functions we have made to simulate an entire game.\n",
    "\n",
    "#### Instructions \n",
    "\n",
    "- `create_board()`, `random_place(board, player)`, and `evaluate(board)` have been created in previous exercises. Create a function `play_game()` that:\n",
    "    - Creates a board.\n",
    "    - Alternates taking turns between two players (beginning with Player 1), placing a marker during each turn.\n",
    "    - Evaluates the board for a winner after each placement.\n",
    "    - Continues the game until one player wins (returning 1 or 2 to reflect the winning player), or the game is a draw (returning -1).\n",
    "- Call play_game 1000 times, and store the results of the game in a list called `results`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "569"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.seed(1)\n",
    "\n",
    "def play_game():\n",
    "    \n",
    "    board = create_board()\n",
    "    winner = 0\n",
    "\n",
    "    while winner == 0:\n",
    "        random_place(board, 1)\n",
    "        winner = evaluate(board)\n",
    "        random_place(board, 2)\n",
    "        winner = evaluate(board)\n",
    "#     print(winner)\n",
    "#     print(board)\n",
    "    return winner\n",
    "    \n",
    "results = []\n",
    "\n",
    "for i in range(1000):\n",
    "    results.append(play_game())\n",
    "    \n",
    "# len(results)\n",
    "results.count(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 11\n",
    "\n",
    "In the previous exercise, we see that when guessing at random, it's better to go first, as expected. Let's see if Player 1 can improve their strategy. \n",
    "\n",
    "#### Instructions \n",
    "- Create a function `play_strategic_game()`, where Player 1 always starts with the middle square, and otherwise both players place their markers randomly.\n",
    "- Call `play_strategic_game` 1000 times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "859"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.seed(1)\n",
    "\n",
    "def play_strategic_game():\n",
    "    \n",
    "    board = create_board()\n",
    "    board[1,1] = 1\n",
    "    winner = 0\n",
    "\n",
    "    while winner == 0:\n",
    "        random_place(board, 2)\n",
    "        winner = evaluate(board)\n",
    "        random_place(board, 1)\n",
    "        winner = evaluate(board)\n",
    "#         print(board)\n",
    "    return winner\n",
    "\n",
    "# play_strategic_game()\n",
    "    \n",
    "strategic_results = []\n",
    "\n",
    "for i in range(1000):\n",
    "    strategic_results.append(play_strategic_game())\n",
    "    \n",
    "# len(strategic_results)\n",
    "strategic_results.count(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}