Tic_Tac_Toe.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lab 2- Tic Tac Toe\n",
    "\n",
    "In this lab your will build a n x n Tic Tac Toe game. As you do the exercises, make sure your solutions work for any size Tic Tac Toe game. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 1:* Write a function that creates an n by n matrix (of list of lists) which will represent the state of a Tie Tac Toe game. Let 0, 1, and 2 represent empty, \"X\", and \"O\", respectively.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_state(value):\n",
    "    state = {0: ' ', 1: 'X', 2: 'O'}\n",
    "    return state[value]\n",
    "\n",
    "def create_board(size):\n",
    "    board = [[0 for x in range(size)] for y in range(size)]\n",
    "    return board"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 2:* Write a function that takes 2 integers `n` and `m` as input and draws a `n` by `m` game board. For example the following is a 3x3 board:\n",
    "```\n",
    "   --- --- --- \n",
    "  |   |   |   | \n",
    "   --- --- ---  \n",
    "  |   |   |   | \n",
    "   --- --- ---  \n",
    "  |   |   |   | \n",
    "   --- --- --- \n",
    "   ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter board size: 3\n"
     ]
    }
   ],
   "source": [
    "# Write you solution here\n",
    "# Get the board size from user input\n",
    "state = {0: ' ', 1: 'X', 2: 'O'}\n",
    "size = int(input(\"Enter board size: \"))\n",
    "while size <= 0:\n",
    "    print(\"Invalid size\")\n",
    "    size = int(input(\"Enter board size: \"))\n",
    "\n",
    "board = create_board(size)\n",
    "\n",
    "def game_board(board, size):\n",
    "    #top border\n",
    "    print(\" --- \" * size)\n",
    "\n",
    "    for x in range(size):\n",
    "        print(\" | \", end='')#left border\n",
    "        for y in range(size):\n",
    "            print(state[board[x][y]], end=' | ')#cell content and right border\n",
    "        print()\n",
    "\n",
    "        #bottom borders\n",
    "        if x < size - 1:\n",
    "            print(\" --- \" * size)\n",
    "\n",
    "    #bottom border\n",
    "    print(\" --- \" * size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ---  ---  --- \n",
      " |   |   |   | \n",
      " ---  ---  --- \n",
      " |   |   |   | \n",
      " ---  ---  --- \n",
      " |   |   |   | \n",
      " ---  ---  --- \n"
     ]
    }
   ],
   "source": [
    "# Test your solution here\n",
    "game_board(board, size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 3:* Modify exercise 2, so that it takes a matrix of the form from exercise 1 and draws a tic-tac-tie board with \"X\"s and \"O\"s.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write you solution here\n",
    "tic_tac_toe_board = [[1, 2, 0],[2, 1, 0],[1, 0, 2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ---  ---  --- \n",
      " | X | O |   | \n",
      " ---  ---  --- \n",
      " | O | X |   | \n",
      " ---  ---  --- \n",
      " | X |   | O | \n",
      " ---  ---  --- \n"
     ]
    }
   ],
   "source": [
    "# Test your solution here\n",
    "game_board(tic_tac_toe_board,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 4:* Write a function that takes a `n` by `n` matrix representing a tic-tac-toe game, and returns -1, 0, 1, or 2 indicating the game is incomplete, the game is a draw, player 1 has won, or player 2 has one, respectively. Here are some example inputs you can use to test your code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write you solution here\n",
    "def tic_tac_toe(matrix):\n",
    "    n = len(matrix)\n",
    "\n",
    "    def check_w(player):\n",
    "        for i in range(n):\n",
    "            if all(matrix[i][j] == player for j in range(n)) or all(matrix[j][i] == player for j in range(n)):\n",
    "                return True\n",
    "\n",
    "        if all(matrix[i][i] == player for i in range(n)) or all(matrix[i][n - 1 - i] == player for i in range(n)):\n",
    "            return True\n",
    "\n",
    "        return False#no w yet\n",
    "\n",
    "    x_count = sum(row.count(1) for row in matrix)\n",
    "    o_count = sum(row.count(2) for row in matrix)\n",
    "\n",
    "    #turns\n",
    "    if x_count == o_count + 1 and not check_w(2):\n",
    "        return 1 if check_w(1) else -1\n",
    "\n",
    "    if o_count == x_count and not check_w(1):\n",
    "        return 2 if check_w(2) else -1\n",
    "    \n",
    "    #incomplete or draw\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: -1\n",
      "2: 0\n",
      "3: -1\n"
     ]
    }
   ],
   "source": [
    "# Test your solution here\n",
    "\n",
    "ex1 = [[1, 2, 0],[2, 1, 0],[1, 0, 2]]\n",
    "ex2 = [[1, 2, 1],[2, 1, 2],[2, 1, 2]]\n",
    "ex3 = [[1, 2, 1],[2, 1, 1],[2, 1, 2]]\n",
    "\n",
    "r1 = tic_tac_toe(ex1)\n",
    "r2 = tic_tac_toe(ex2)\n",
    "r3 = tic_tac_toe(ex3)\n",
    "\n",
    "print(\"1:\", r1)#1\n",
    "print(\"2:\", r2)#0\n",
    "print(\"3:\", r3)#-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ---  ---  --- \n",
      " | X | O |   | \n",
      " ---  ---  --- \n",
      " | O | X |   | \n",
      " ---  ---  --- \n",
      " | X |   | O | \n",
      " ---  ---  --- \n"
     ]
    }
   ],
   "source": [
    "game_board(ex1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ---  ---  --- \n",
      " | X | O | X | \n",
      " ---  ---  --- \n",
      " | O | X | O | \n",
      " ---  ---  --- \n",
      " | O | X | O | \n",
      " ---  ---  --- \n"
     ]
    }
   ],
   "source": [
    "game_board(ex2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ---  ---  --- \n",
      " | X | O | X | \n",
      " ---  ---  --- \n",
      " | O | X | X | \n",
      " ---  ---  --- \n",
      " | O | X | O | \n",
      " ---  ---  --- \n"
     ]
    }
   ],
   "source": [
    "game_board(ex3,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 5:* Write a function that takes a game board, player number, and `(x,y)` coordinates and places \"X\" or \"O\" in the correct location of the game board. Make sure that you only allow filling previously empty locations. Return `True` or `False` to indicate successful placement of \"X\" or \"O\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write you solution here\n",
    "def move(game_board, player, x, y):\n",
    "    #check bounds\n",
    "    if x < 0 or y < 0 or x >= len(board) or y >= len(board[0]):\n",
    "        return False#out of bounds\n",
    "\n",
    "    #check if 0\n",
    "    if game_board[x][y] == 0:\n",
    "        game_board[x][y] = player\n",
    "        return True\n",
    "    else:\n",
    "        return False#already there"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4: True\n",
      "5: False\n",
      "6: False\n"
     ]
    }
   ],
   "source": [
    "# Test your solution here\n",
    "game_board = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n",
    "\n",
    "#X at (1,1)\n",
    "r4 = move(game_board, 1, 1, 1)\n",
    "print(\"4:\", r4)\n",
    "\n",
    "#O at (1,2)\n",
    "r5 = move(game_board, 2, 1, 1)\n",
    "print(\"5:\", r5)#false\n",
    "\n",
    "#out of bounds test\n",
    "r6 = move(game_board, 2, 3, 3)\n",
    "print(\"6:\", r6)#false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 6:* Modify Exercise 4 to show column and row labels so that players can specify location using \"A2\" or \"C1\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   A B C \n",
      "  +---+---+---+\n",
      "1 | X |   | O |\n",
      "  +---+---+---+\n",
      "2 |   | X | O |\n",
      "  +---+---+---+\n",
      "3 | O | X |   |\n",
      "  +---+---+---+\n"
     ]
    }
   ],
   "source": [
    "# Write you solution here\n",
    "def game_board(board, size):\n",
    "    column_labels = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "\n",
    "    print(\"   \", end=\"\")\n",
    "    for i in range(size):\n",
    "        print(column_labels[i], end=\" \")\n",
    "    print()\n",
    "\n",
    "    print(\"  +\" + \"---+\" * size)\n",
    "\n",
    "    for x in range(size):\n",
    "        print(x + 1, end=\" |\")\n",
    "\n",
    "        for y in range(size):\n",
    "            print(\" \" + state[board[x][y]] + \" |\", end=\"\")\n",
    "\n",
    "        print()\n",
    "\n",
    "        if x < size - 1:\n",
    "            print(\"  +\" + \"---+\" * size)\n",
    "\n",
    "    print(\"  +\" + \"---+\" * size)\n",
    "\n",
    "sample_board = [[1, 0, 2], [0, 1, 2], [2, 1, 0]]\n",
    "board_size = 3\n",
    "\n",
    "game_board(sample_board, board_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   A B C \n",
      "  +---+---+---+\n",
      "1 | X |   | O |\n",
      "  +---+---+---+\n",
      "2 |   | X | O |\n",
      "  +---+---+---+\n",
      "3 | O | X |   |\n",
      "  +---+---+---+\n"
     ]
    }
   ],
   "source": [
    "sample_board = [[1, 0, 2], [0, 1, 2], [2, 1, 0]]\n",
    "board_size = 3\n",
    "\n",
    "game_board(sample_board, board_size)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 7:* Write a function that takes a board, player number, and location specified as in exercise 6 and then calls exercise 5 to correctly modify the board.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modify_board(board, player, location):\n",
    "    if labels(board, player, location):\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test case 1: True\n",
      "Test case 2: True\n",
      "Test case 3: False\n",
      "Test case 4: True\n"
     ]
    }
   ],
   "source": [
    "# Test your solution here\n",
    "column_labels = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "sample_board = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n",
    "\n",
    "r1 = modify_board(sample_board, 1, \"A2\")\n",
    "print(\"Test case 1:\", result1)#true\n",
    "\n",
    "r2 = modify_board(sample_board, 2, \"B1\")\n",
    "print(\"Test case 2:\", result2)#true\n",
    "\n",
    "\n",
    "r3 = modify_board(sample_board, 1, \"A2\")\n",
    "print(\"Test case 3:\", result3)#false\n",
    "\n",
    "r4 = modify_board(sample_board, 2, \"A3\")\n",
    "print(\"Test case 4:\", result4)#false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 8:* Write a function is called with a board and player number, takes input from the player using python's `input`, and modifies the board using your function from exercise 7. Note that you should keep asking for input until you have gotten a valid input that results in a valid move."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write you solution here\n",
    "def player_input(board, player):\n",
    "    while True:\n",
    "        location = input(f\"Player {player}, enter your move: \")\n",
    "        if make_move(board, player, location):\n",
    "            break\n",
    "        else:\n",
    "            print(\"invalid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1, enter your move: A2\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   |   |   |\n",
      "  +---+---+---+\n",
      "2 | X |   |   |\n",
      "  +---+---+---+\n",
      "3 |   |   |   |\n",
      "  +---+---+---+\n"
     ]
    }
   ],
   "source": [
    "# Test your solution here\n",
    "game_board = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n",
    "player = 1\n",
    "\n",
    "player_input(game_board, player)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 9:* Use all of the previous exercises to implement a full tic-tac-toe game, where an appropriate board is drawn, 2 players are repeatedly asked for a location coordinates of where they wish to place a mark, and the game status is checked until a player wins or a draw occurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write you solution here\n",
    "def play_tic_tac_toe():\n",
    "    n = 3#size\n",
    "    game_state = [[0 for _ in range(n)] for _ in range(n)]\n",
    "    current_player = 1\n",
    "    moves = 0\n",
    "\n",
    "    print(\"Welcome to Tic-Tac-Toe!\")\n",
    "\n",
    "    while True:\n",
    "        game_board(game_state)\n",
    "        label = input(f\"Player {current_player}, enter your move: \")\n",
    "\n",
    "        if labels(game_state, current_player, label):\n",
    "            moves += 1\n",
    "\n",
    "            game_result = check_w(game_state)\n",
    "            \n",
    "        if game_result == 1:\n",
    "                game_board(game_state)\n",
    "                print(\"X wins\")\n",
    "                break\n",
    "        elif game_result == 2:\n",
    "                game_board(game_state)\n",
    "                print(\"O wins\")\n",
    "                break\n",
    "        elif game_result == 0 and moves == n * n:\n",
    "                game_board(game_state)\n",
    "                print(\"draw\")\n",
    "                break\n",
    "    #switch players\n",
    "    current_player = 3 - current_player\n",
    "            \n",
    "    if __name__ == \"__main__\":\n",
    "        play_tic_tac_toe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1: A1\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 | X |   |   |\n",
      "  +---+---+---+\n",
      "2 |   |   |   |\n",
      "  +---+---+---+\n",
      "3 |   |   |   |\n",
      "  +---+---+---+\n",
      "Player 2: B2\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 | X |   |   |\n",
      "  +---+---+---+\n",
      "2 |   | O |   |\n",
      "  +---+---+---+\n",
      "3 |   |   |   |\n",
      "  +---+---+---+\n",
      "Player 1: A2\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 | X |   |   |\n",
      "  +---+---+---+\n",
      "2 | X | O |   |\n",
      "  +---+---+---+\n",
      "3 |   |   |   |\n",
      "  +---+---+---+\n",
      "Player 2: C3\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 | X |   |   |\n",
      "  +---+---+---+\n",
      "2 | X | O |   |\n",
      "  +---+---+---+\n",
      "3 |   |   | O |\n",
      "  +---+---+---+\n",
      "Player 1: A3\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 | X |   |   |\n",
      "  +---+---+---+\n",
      "2 | X | O |   |\n",
      "  +---+---+---+\n",
      "3 | X |   | O |\n",
      "  +---+---+---+\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'int' object has no attribute 'count'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_13404\\4106767679.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m         \u001b[0mcurrent_player\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mcurrent_player\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mgame_result\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcheck_w\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"__main__\"\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_13404\\4255865443.py\u001b[0m in \u001b[0;36mcheck_w\u001b[1;34m(matrix)\u001b[0m\n\u001b[0;32m     55\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     56\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 57\u001b[1;33m     \u001b[0mx_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     58\u001b[0m     \u001b[0mo_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     59\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_13404\\4255865443.py\u001b[0m in \u001b[0;36m<genexpr>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m     55\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     56\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 57\u001b[1;33m     \u001b[0mx_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     58\u001b[0m     \u001b[0mo_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     59\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'int' object has no attribute 'count'"
     ]
    }
   ],
   "source": [
    "#Test your solution here\n",
    "game_state = [[0 for _ in range(size)] for _ in range(size)]\n",
    "moves = [(\"A1\", 1), (\"B2\", 2), (\"A2\", 1), (\"C3\", 2), (\"A3\", 1)]\n",
    "\n",
    "current_player = 1\n",
    "for label, player in moves:\n",
    "        print(f\"Player {current_player}: {label}\")\n",
    "        labels(game_state, player, label)\n",
    "        draw_board(game_state)\n",
    "        current_player = 3 - current_player\n",
    "\n",
    "game_result = check_w(state)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    test_tic_tac_toe()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 10:* Test that your game works for 5x5 Tic Tac Toe.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter board size: 5\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Test your solution here\n",
    "size = int(input(\"Enter board size: \"))\n",
    "\n",
    "board = create_board(size)\n",
    "\n",
    "def game_board(board, size):\n",
    "\n",
    "    tic_tac_toe_board = [[1, 2, 0, 0, 0],[2, 1, 0, 0, 0],[1, 0, 2, 0, 0]]\n",
    "print(game_board(tic_tac_toe_board,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Exercise 11:* (Advanced / Challenge) Develop a version of the game where one player is the computer. Note that you don't need to do an extensive seach for the best move. You can have the computer simply protect against loosing and otherwise try to win with straight or diagonal patterns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Tic-Tac-Toe!\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   |   |   |\n",
      "  +---+---+---+\n",
      "2 |   |   |   |\n",
      "  +---+---+---+\n",
      "3 |   |   |   |\n",
      "  +---+---+---+\n",
      "Player 1, enter your move: A2\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   |   |   |\n",
      "  +---+---+---+\n",
      "2 | X |   |   |\n",
      "  +---+---+---+\n",
      "3 |   |   |   |\n",
      "  +---+---+---+\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   |   |   |\n",
      "  +---+---+---+\n",
      "2 | X |   |   |\n",
      "  +---+---+---+\n",
      "3 | O |   |   |\n",
      "  +---+---+---+\n",
      "Player 1, enter your move: B1\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   | X |   |\n",
      "  +---+---+---+\n",
      "2 | X |   |   |\n",
      "  +---+---+---+\n",
      "3 | O |   |   |\n",
      "  +---+---+---+\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   | X |   |\n",
      "  +---+---+---+\n",
      "2 | X |   | O |\n",
      "  +---+---+---+\n",
      "3 | O |   |   |\n",
      "  +---+---+---+\n",
      "Player 1, enter your move: B3\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   | X |   |\n",
      "  +---+---+---+\n",
      "2 | X |   | O |\n",
      "  +---+---+---+\n",
      "3 | O | X |   |\n",
      "  +---+---+---+\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   | X | O |\n",
      "  +---+---+---+\n",
      "2 | X |   | O |\n",
      "  +---+---+---+\n",
      "3 | O | X |   |\n",
      "  +---+---+---+\n",
      "Player 1, enter your move: B2\n",
      "   A B C \n",
      "  +---+---+---+\n",
      "1 |   | X | O |\n",
      "  +---+---+---+\n",
      "2 | X | X | O |\n",
      "  +---+---+---+\n",
      "3 | O | X |   |\n",
      "  +---+---+---+\n",
      "O wins\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def draw_board(board):\n",
    "    n = len(board)\n",
    "\n",
    "    column_labels = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "\n",
    "    print(\"   \", end=\"\")\n",
    "    for i in range(n):\n",
    "        print(column_labels[ i ], end=\" \")\n",
    "    print()\n",
    "\n",
    "    print(\"  +\" + \"---+\" * n)\n",
    "\n",
    "    for x in range(n):\n",
    "        print(x + 1, end=\" |\")\n",
    "\n",
    "        for y in range(n):\n",
    "            print(\" \" + state[board[x][y]] + \" |\", end=\"\")\n",
    "\n",
    "        print()\n",
    "\n",
    "        if x < n - 1:\n",
    "            print(\"  +\" + \"---+\" * n)\n",
    "\n",
    "    print(\"  +\" + \"---+\" * n)\n",
    "\n",
    "def labels(board, player, label):\n",
    "\n",
    "    label = label.upper()\n",
    "\n",
    "    if len(label) != 2 or label[0] not in column_labels or not label[1].isdigit():\n",
    "        return False\n",
    "\n",
    "    column = column_labels.index(label[0])\n",
    "    row = int(label[1]) - 1\n",
    "\n",
    "    if board[row][column] == 0:\n",
    "        board[row][column] = player\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "def check_w(matrix):\n",
    "    n = len(matrix)\n",
    "\n",
    "    def check_winner(player):\n",
    "        for i in range(n):\n",
    "            if all(matrix[i][j] == player for j in range(n)) or all(matrix[j][i] == player for j in range(n)):\n",
    "                return True\n",
    "\n",
    "        if all(matrix[i][i] == player for i in range(n)) or all(matrix[i][n - 1 - i] == player for i in range(n)):\n",
    "            return True\n",
    "\n",
    "        return False\n",
    "\n",
    "    x_count = sum(row.count(1) for row in matrix)\n",
    "    o_count = sum(row.count(2) for row in matrix)\n",
    "\n",
    "    if x_count == o_count + 1 and not check_winner(2):\n",
    "        return 1 if check_winner(1) else -1\n",
    "\n",
    "    if o_count == x_count and not check_winner(1):\n",
    "        return 2 if check_winner(2) else -1\n",
    "\n",
    "    return 0\n",
    "\n",
    "state = {0: ' ', 1: 'X', 2: 'O'}\n",
    "\n",
    "def computer_move(board, player):\n",
    "    n = len(board)\n",
    "    empty_cells = []\n",
    "\n",
    "    for row in range(n):\n",
    "        if board[row].count(player) == n - 1 and 0 in board[row]:\n",
    "            empty_cells.append((row, board[row].index(0)))\n",
    "\n",
    "    for col in range(n):\n",
    "        col_values = [board[row][col] for row in range(n)]\n",
    "        if col_values.count(player) == n - 1 and 0 in col_values:\n",
    "            empty_cells.append((col_values.index(0), col))\n",
    "\n",
    "    diag1_values = [board[i][i] for i in range(n)]\n",
    "    diag2_values = [board[i][n - 1 - i] for i in range(n)]\n",
    "\n",
    "    if diag1_values.count(player) == n - 1 and 0 in diag1_values:\n",
    "        index = diag1_values.index(0)\n",
    "        empty_cells.append((index, index))\n",
    "\n",
    "    if diag2_values.count(player) == n - 1 and 0 in diag2_values:\n",
    "        index = diag2_values.index(0)\n",
    "        empty_cells.append((index, n - 1 - index))\n",
    "\n",
    "    if empty_cells:\n",
    "        return random.choice(empty_cells)\n",
    "    else:\n",
    "        empty_cells = [(i, j) for i in range(n) for j in range(n) if board[i][j] == 0]\n",
    "        return random.choice(empty_cells)\n",
    "\n",
    "def play_tic_tac_toe():\n",
    "    n = 3\n",
    "    game_state = [[0 for _ in range(n)] for _ in range(n)]\n",
    "    current_player = 1\n",
    "    moves = 0\n",
    "\n",
    "    print(\"Welcome to Tic-Tac-Toe!\")\n",
    "\n",
    "    while True:\n",
    "        draw_board(game_state)\n",
    "\n",
    "        if current_player == 1:\n",
    "            label = input(f\"Player {current_player}, enter your move: \")\n",
    "            while not labels(game_state, current_player, label):\n",
    "                print(\"Invalid move. Try again.\")\n",
    "                label = input(f\"Player {current_player}, enter your move: \")\n",
    "        else:\n",
    "            row, col = computer_move(game_state, current_player)\n",
    "            game_state[row][col] = current_player\n",
    "\n",
    "        moves += 1\n",
    "\n",
    "        game_result = check_w(game_state)\n",
    "\n",
    "        if game_result == 1:\n",
    "            draw_board(game_state)\n",
    "            print(\"O wins\")\n",
    "            break\n",
    "        elif game_result == 2:\n",
    "            draw_board(game_state)\n",
    "            print(\"X wins\")\n",
    "            break\n",
    "        elif game_result == 0 and moves == n * n:\n",
    "            draw_board(game_state)\n",
    "            print(\"draw\")\n",
    "            break\n",
    "            \n",
    "        current_player = 3 - current_player\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    play_tic_tac_toe()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}