04_Python_Projects(Basic)/04_ProjPy_Tic-Tac-Toe_Help.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Z01_PYTHON_PROJECT_01_HELP.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "b7bjbd2jnKOj",
        "oahy7Qhqt6Xo",
        "q_PR0Bp9AXq8",
        "Z60MpCSYHbTo"
      ],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNIpnj2GqqGV7DQ2+jRpRzb",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mohd-faizy/00_Python_Notebooks_Concept/blob/master/Z01_PYTHON_PROJECT_01_HELP.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b7bjbd2jnKOj",
        "colab_type": "text"
      },
      "source": [
        "### __INTERACTIVE PROGRAMMING__\n",
        "\n",
        "- *Grab user input*\n",
        "- *Minuplate a varible based on input*\n",
        "- *Return back adjusted varible*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MWrsjJQYoOiE",
        "colab_type": "text"
      },
      "source": [
        "__Update visual Representation__    $\\Rightarrow$ __User input__ Some Decision  e.g Choose the top right corner in the tic-tac-toe game $\\Rightarrow$ user input go inside the some Python __Function__ $\\Rightarrow$ inside the function we __Update__ what the Board Varible is $\\Rightarrow$ & then we have a __New Visual__ to show the user $\\Rightarrow$  This circle runs over and over again in order to have an interactive python running programn"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7cRUEQLtrqjg",
        "colab_type": "text"
      },
      "source": [
        "**Tic-Tac-Toe**\n",
        "\n",
        "\n",
        "<center><img src = 'https://www.cdn.geeksforgeeks.org/wp-content/uploads/implementation-tic-tac-toe.png'></center>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xgDY9EvMsqlK",
        "colab_type": "text"
      },
      "source": [
        "Most program that are interactive work on this simple idea.\n",
        "\n",
        "- Display something visual to the user\n",
        "-Let the user update through the interation.\n",
        "- Update the Varibles in the program\n",
        "- Display the Updated viusual "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q_PR0Bp9AXq8",
        "colab_type": "text"
      },
      "source": [
        "### __Displaying/Accepting -- the user Input__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "41ClgHkmF-aU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 107
        },
        "outputId": "78e1beff-5239-44b9-f479-12b6816327f8"
      },
      "source": [
        "row1 = ['','','']\n",
        "row2 = ['','','']\n",
        "row3 = ['','','']  \n",
        "\n",
        "def display(row1, row2, row3):\n",
        "     print(row1)\n",
        "     print(row2)\n",
        "     print(row3)\n",
        "\n",
        "\n",
        "position_index = int(input('choose the index position: '))    \n",
        "row2[position_index] = 'X'\n",
        "\n",
        "display(row1,row2,row3)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "choose the index position: 1\n",
            "['', '', '']\n",
            "['', 'X', '']\n",
            "['', '', '']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z60MpCSYHbTo",
        "colab_type": "text"
      },
      "source": [
        "### __Validating the user Input__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BRx3-9Z0MMFU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "fce48b6d-91a2-4b6a-92d5-0cc07d15e8f3"
      },
      "source": [
        "position_index = int(input('choose the index position: '))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "choose the index position: 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sA3VX3LrHbQf",
        "colab_type": "text"
      },
      "source": [
        "In the above code if we enter 'two' insted of '2'\n",
        "$\\rightarrow$ This will results in the error belown $\\Downarrow$\n",
        "\n",
        "```\n",
        "ValueError: invalid literal for int() with base 10: 'two'\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cVUXFY0LY-Ar",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "some_value = '100'"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7KCuG8NvYyrc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "72feedc7-73c7-4fc4-8eea-cf08a3e65b0f"
      },
      "source": [
        "some_value.isdigit()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TU0DYkllg55C",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d63b9d22-815f-447a-c545-fa4a978fb39a"
      },
      "source": [
        "result = 'WRONG VALUE'\n",
        "acceptable_values = [0,1,2]\n",
        "result in acceptable_values"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SMyA2ILJjICr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5f229f77-a46b-4f67-f62d-2ab199ea30f9"
      },
      "source": [
        "result not in acceptable_values"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dSdEFBqGNBh3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 107
        },
        "outputId": "487c8bab-c62b-4718-f27c-cfcb53940b85"
      },
      "source": [
        "def user_choice():\n",
        "    # VARIBLES\n",
        "\n",
        "    # INITIAL CHOICE \n",
        "    choice = 'Worng'\n",
        "\n",
        "    '''Note: We got integers from 1 to 9 because range() function \n",
        "    doesn’t include the last (stop) number in the result.'''\n",
        "    \n",
        "    acceptable_range = range(1,10)\n",
        "    within_range = False\n",
        "\n",
        "    # Two Condition to check\n",
        "    # Digits or not / within range or not\n",
        "\n",
        "    while choice.isdigit() == False or within_range == False:\n",
        "        choice = input('Please Enter a number (1-9):  ')\n",
        "\n",
        "        # 1_Digit Check\n",
        "        if choice.isdigit() == False:\n",
        "            print('Sorry!!!  that is not a DIGIT')\n",
        "        \n",
        "        # 2_Range check\n",
        "        if choice.isdigit() == True: # Check for EQUALITY\n",
        "            if int(choice) in acceptable_range:\n",
        "                within_range = True  # Here its assignment\n",
        "            else:\n",
        "                within_range = False\n",
        "                print('Sorry You are out of acceptable RANGE (--> 1-9)')\n",
        "                \n",
        "    return int(choice)\n",
        "\n",
        "\n",
        "user_choice()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Please Enter a number (1-9):  10\n",
            "Sorry You are out of acceptable RANGE (--> 1-9)\n",
            "Please Enter a number (1-9):  1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CQ_QafVmmR_9",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "In the above code `.isdigit()` is itself a Boolen value and there is no need to Check it if its `True`\n",
        "```\n",
        "# Range check\n",
        "if choice.isdigit() == True:\n",
        "```\n",
        "\n",
        "This will also work\n",
        "```\n",
        "if choice.isdigit():\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oMsOXFqng4EC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 107
        },
        "outputId": "d53b80a2-242b-43d7-88aa-2f529c9d6e77"
      },
      "source": [
        "user_choice()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Please Enter a number (1-9):  12\n",
            "Sorry You are out of acceptable RANGE (--> 1-9)\n",
            "Please Enter a number (1-9):  2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3xgK3myid-xm",
        "colab_type": "text"
      },
      "source": [
        "### __Simple User Interaction__\n",
        "\n",
        "> Indented block\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FlQpBiebfffn",
        "colab_type": "text"
      },
      "source": [
        "The Program will\n",
        "- Display The List\n",
        "- Have a user choose an index position and an input value.\n",
        "- Replace value at index position with user's choosen input value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ESjTd2J12-cU",
        "colab_type": "text"
      },
      "source": [
        "####  1. __Display the List__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ld1NSM5i29yx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "game_list = [0,1,2]\n",
        " \n",
        "def display_game(game_list):\n",
        "    print('Here is the currrnt list: {}'.format(game_list))"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o7C3y47q3S-C",
        "colab_type": "text"
      },
      "source": [
        "#### 2. __Index Position Choice__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q7ry8fAo3T9l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def position_choice():\n",
        "\n",
        "    choice = 'wrong'\n",
        "\n",
        "    while choice not in str(game_list):\n",
        "        choice = input('Pick the position [0,1,2]: ')\n",
        "\n",
        "        if choice not in str(game_list):\n",
        "            print('Sorry, Invalid Choice! ')\n",
        "    return int(choice)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mBGh5hLH92O8",
        "colab_type": "text"
      },
      "source": [
        "__Note__: In the above code we use `str` before the `game_list` --  as we pass the choice as string."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "09jMW-yS3nFj",
        "colab_type": "text"
      },
      "source": [
        "####  3. __Replacement Value__\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BtK_apVD32C3",
        "colab_type": "text"
      },
      "source": [
        "> Player has already choosen a __correct Index position__ Choice\n",
        "\n",
        "> Now  they have  to  enter  the  __Replacementv Value__\n",
        "    \n",
        "which takes takes the two arguments:\n",
        "\n",
        "1. __game_list__ : That  keep sending back and forth between functions in order to update it.\n",
        "\n",
        "2. __position__ : This will return the position."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TkKZL2GO5TZ6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def replacement_choice(game_list, position):\n",
        "\n",
        "    user_placement = input('Type a string to place at position: ')\n",
        "    \n",
        "    game_list[position] = user_placement\n",
        "    \n",
        "    return game_list\n"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sYE4TThq5d72",
        "colab_type": "text"
      },
      "source": [
        "#### 4. __GameOn Choice__\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HKBQNdCM53HN",
        "colab_type": "text"
      },
      "source": [
        "it will ask the wether the user wants to keep playing the game or he wants to quit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YIgkDtyw54Zv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gameon_choice():\n",
        "\n",
        "    choice = 'wrong'\n",
        "\n",
        "    while choice not in ['Y', 'N']: # str: as choice is passed as string\n",
        "        choice = input('Keep Playing? (Y or N) ')\n",
        "\n",
        "        if choice not in ['Y', 'N']:\n",
        "            print('Sorry, I dont understand please choose Y or N')\n",
        "    \n",
        "    if choice == 'Y':\n",
        "        return True\n",
        "    else:\n",
        "        return False\n"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rD4-Kj7T5_8W",
        "colab_type": "text"
      },
      "source": [
        "####  5. __GameOn -- if the User wants to Continue the game__\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WJnUg9Yt6KrD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 267
        },
        "outputId": "2b41d699-2d50-4bc5-b043-5cf0c267fe21"
      },
      "source": [
        "game_on = True\n",
        "game_list = [0,1,2]\n",
        "\n",
        "while game_on: # This is boolen -- No need of verifying it == True\n",
        "    \n",
        "    '''Calling each created function sequentially'''\n",
        "    \n",
        "    # 1_Display the Game list\n",
        "    display_game(game_list)\n",
        "\n",
        "    # 2_Position choice\n",
        "    position = position_choice()\n",
        "\n",
        "    # 3_Replacement Values\n",
        "    game_list = replacement_choice(game_list, position)\n",
        "\n",
        "    # 4_Display the Updated Game list\n",
        "    display_game(game_list)\n",
        "\n",
        "    # 5_Gameon choice \n",
        "    game_on = gameon_choice()\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Here is the currrnt list: [0, 1, 2]\n",
            "Pick the position [0,1,2]: 3\n",
            "Sorry, Invalid Choice! \n",
            "Pick the position [0,1,2]: 1\n",
            "Type a string to place at position: 2\n",
            "Here is the currrnt list: [0, '2', 2]\n",
            "Keep Playing? (Y or N) 3\n",
            "Sorry, I dont understand please choose Y or N\n",
            "Keep Playing? (Y or N) 0\n",
            "Sorry, I dont understand please choose Y or N\n",
            "Keep Playing? (Y or N) n\n",
            "Sorry, I dont understand please choose Y or N\n",
            "Keep Playing? (Y or N) N\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uT82hlcaJRFQ",
        "colab_type": "text"
      },
      "source": [
        "# __Project: Building the Tic-Tac-Toe Game__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6QdUsSH7Ultc",
        "colab_type": "text"
      },
      "source": [
        "1. **Printing a Board**\n",
        "2. **Player input.**\n",
        "3. **('X' or 'O') Place marker**\n",
        "4. **Win Checker**\n",
        "5. **Randomly decide which player goes first**\n",
        "6. **whether a space on the board is freely available**\n",
        "7. **If the board is full and returns a boolean value**\n",
        "8. **Asks for a player's next position (as a number 1-9) & Then uses the function from step 6 to check if its a free position**\n",
        "9. **If the Player wants to play again**\n",
        "10. __MAIN LOGIC__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5tMbcEv6mrmt",
        "colab_type": "text"
      },
      "source": [
        "## __FIRST CODE__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkwRJIieLP0y",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "outputId": "07860004-d53a-433a-ab8d-57982f6cbd89"
      },
      "source": [
        "#----------------------------1_Printing a Board---------------------------------\n",
        " \n",
        "from IPython.display import clear_output\n",
        " \n",
        "def display_board(board):\n",
        "    clear_output()  # Remember, this only works in jupyter!\n",
        "                    # This will prevent the Board to get printed multiple times\n",
        "    \n",
        "   \n",
        "    print(' ' + board[7] + ' | ' + board[8] + ' | ' + board[9])\n",
        "    print('---+---+---')\n",
        "    print(' ' + board[4] + ' | ' + board[5] + ' | ' + board[6])\n",
        "    print('---+---+---')\n",
        "    print(' ' + board[1] + ' | ' + board[2] + ' | ' + board[3])\n",
        "    \n",
        " \n",
        "test_board = ['#','X','O','X','O','X','O','X','O','X']\n",
        "display_board(test_board)\n",
        " \n",
        "#---------------------------2_Choose the Marker---------------------------------\n",
        " \n",
        "def player_input():\n",
        "    '''\n",
        "    OUTPUT: Player 1 marker, Player 2 marker\n",
        "    '''\n",
        "    marker = ''\n",
        "    \n",
        "    while not (marker == 'X' or marker == 'O'):\n",
        "        marker = input('Choice: Do you want to be X or O? ').upper()\n",
        " \n",
        "    if marker == 'X':\n",
        "        return ('X', 'O') # Tuple Unpacking\n",
        "    else:\n",
        "        return ('O', 'X') # Tuple Unpacking\n",
        " \n",
        "player_input()\n",
        " \n",
        "#-----------------------3_('X' or 'O') Place marker-----------------------------\n",
        " \n",
        "def place_marker(board, marker, position):\n",
        "    board[position] = marker\n",
        " \n",
        "place_marker(test_board,'$',8)\n",
        "display_board(test_board)\n",
        " \n",
        "#-----------------------------4_Win Checker-------------------------------------\n",
        " \n",
        "def win_check(board,mark):\n",
        "    \n",
        "    return ((board[7] == mark and board[8] == mark and board[9] == mark) or # across the top\n",
        "            (board[4] == mark and board[5] == mark and board[6] == mark) or # across the middle\n",
        "            (board[1] == mark and board[2] == mark and board[3] == mark) or # across the bottom\n",
        "            (board[7] == mark and board[4] == mark and board[1] == mark) or # down the middle\n",
        "            (board[8] == mark and board[5] == mark and board[2] == mark) or # down the middle\n",
        "            (board[9] == mark and board[6] == mark and board[3] == mark) or # down the right side\n",
        "            (board[7] == mark and board[5] == mark and board[3] == mark) or # diagonal\n",
        "            (board[9] == mark and board[5] == mark and board[1] == mark))   # diagonal\n",
        " \n",
        "win_check(test_board,'X')\n",
        " \n",
        "#-----------------5_Randomly decide which player goes first---------------------\n",
        " \n",
        "import random\n",
        " \n",
        "def choose_first():\n",
        "    if random.randint(0, 1) == 0:\n",
        "        return 'Player 2'\n",
        "    else:\n",
        "        return 'Player 1'\n",
        " \n",
        "#----------------6_whether a space on the board is freely available-------------\n",
        " \n",
        "def space_check(board, position):\n",
        "    \n",
        "    return board[position] == ' '\n",
        " \n",
        "#-------------7_If the board is full and returns a boolean value----------------\n",
        " \n",
        "def full_board_check(board):\n",
        "    for i in range(1,10):\n",
        "        if space_check(board, i):\n",
        "            return False\n",
        "    return True\n",
        " \n",
        "#------------8_Asks for a player's next position (as a number 1-9)--------------\n",
        "#------Then uses the function from step 6 to check if its a free position-------\n",
        " \n",
        "def player_choice(board):\n",
        "    position = 0\n",
        "    \n",
        "    while position not in [1,2,3,4,5,6,7,8,9] or not space_check(board, position):\n",
        "        position = int(input('Choose your next position: (1-9) '))\n",
        "        \n",
        "    return position\n",
        " \n",
        "#---------------------9_If the Player wants to play again ----------------------\n",
        " \n",
        "def replay():\n",
        "    \n",
        "    return input('Do you want to play again? Enter Yes or No: ').lower().startswith('y')\n",
        " \n",
        "#------------------------------10_MAIN LOGIC------------------------------------\n",
        " \n",
        "print('Welcome to Tic Tac Toe!')\n",
        " \n",
        "while True:\n",
        "    # Reset the board\n",
        "    theBoard = [' '] * 10                                        # 1\n",
        "    player1_marker, player2_marker = player_input()              # 2    \n",
        "    turn = choose_first()                                        # 5\n",
        "    print(turn + ' will go first.')\n",
        "    \n",
        "    play_game = input('Are you ready to play? Enter Yes or No.')\n",
        "    \n",
        "    if play_game.lower()[0] == 'y':\n",
        "        game_on = True\n",
        "    else:\n",
        "        game_on = False\n",
        " \n",
        "    while game_on:\n",
        "        if turn == 'Player 1':\n",
        "            # Player1's turn.\n",
        "            \n",
        "            display_board(theBoard)                              # 1\n",
        "            position = player_choice(theBoard)                   # 8\n",
        "            place_marker(theBoard, player1_marker, position)     # 3\n",
        " \n",
        "            if win_check(theBoard, player1_marker):              # 4\n",
        "                display_board(theBoard)                          # 1\n",
        "                print('Congratulations! You have won the game!')\n",
        "                game_on = False\n",
        "            else:\n",
        "                if full_board_check(theBoard):\n",
        "                    display_board(theBoard)\n",
        "                    print('The game is a draw!')\n",
        "                    break\n",
        "                else:\n",
        "                    turn = 'Player 2'\n",
        " \n",
        "        else:\n",
        "            # Player2's turn.\n",
        "            \n",
        "            display_board(theBoard)\n",
        "            position = player_choice(theBoard)\n",
        "            place_marker(theBoard, player2_marker, position)\n",
        " \n",
        "            if win_check(theBoard, player2_marker):\n",
        "                display_board(theBoard)\n",
        "                print('Player 2 has won!')\n",
        "                game_on = False\n",
        "            else:\n",
        "                if full_board_check(theBoard):\n",
        "                    display_board(theBoard)\n",
        "                    print('The game is a draw!')\n",
        "                    break\n",
        "                else:\n",
        "                    turn = 'Player 1'\n",
        " \n",
        "    if not replay():                                                # 9 \n",
        "        break"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " X |   |  \n",
            "---+---+---\n",
            " O | X | O\n",
            "---+---+---\n",
            " X | O | X\n",
            "Congratulations! You have won the game!\n",
            "Do you want to play again? Enter Yes or No: n\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "41-v9nzYhvvv",
        "colab_type": "text"
      },
      "source": [
        "-----------------------------------------------------------------------"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y4fmFdmcmS4r",
        "colab_type": "text"
      },
      "source": [
        "## __SECOND CODE__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "odg2RHuwhb5M",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "2b58169b-e2e9-49bc-84dc-7c2ececc9ba0"
      },
      "source": [
        "#Implementation of Two Player Tic-Tac-Toe game in Python.\n",
        "\n",
        "''' We will make the board using dictionary \n",
        "    in which keys will be the location(i.e : top-left,mid-right,etc.)\n",
        "    and initialliy it's values will be empty space and then after every move \n",
        "    we will change the value according to player's choice of move. '''\n",
        "\n",
        "theBoard = {'7': ' ' , '8': ' ' , '9': ' ' ,\n",
        "            '4': ' ' , '5': ' ' , '6': ' ' ,\n",
        "            '1': ' ' , '2': ' ' , '3': ' ' }\n",
        "\n",
        "board_keys = []\n",
        "\n",
        "for key in theBoard:\n",
        "    board_keys.append(key)\n",
        "\n",
        "''' We will have to print the updated board after every move in the game and \n",
        "    thus we will make a function in which we'll define the printBoard function\n",
        "    so that we can easily print the board everytime by calling this function. '''\n",
        "\n",
        "def printBoard(board):\n",
        "    print(board['7'] + '|' + board['8'] + '|' + board['9'])\n",
        "    print('-+-+-')\n",
        "    print(board['4'] + '|' + board['5'] + '|' + board['6'])\n",
        "    print('-+-+-')\n",
        "    print(board['1'] + '|' + board['2'] + '|' + board['3'])\n",
        "\n",
        "# Now we'll write the main function which has all the gameplay functionality.\n",
        "def game():\n",
        "\n",
        "    turn = 'X'\n",
        "    count = 0\n",
        "\n",
        "\n",
        "    for i in range(10):\n",
        "        printBoard(theBoard)\n",
        "        print(\"It's your turn,\" + turn + \".Move to which place?\")\n",
        "\n",
        "        move = input()        \n",
        "\n",
        "        if theBoard[move] == ' ':\n",
        "            theBoard[move] = turn\n",
        "            count += 1\n",
        "        else:\n",
        "            print(\"That place is already filled.\\nMove to which place?\")\n",
        "            continue\n",
        "\n",
        "        # Now we will check if player X or O has won,for every move after 5 moves. \n",
        "        if count >= 5:\n",
        "            if theBoard['7'] == theBoard['8'] == theBoard['9'] != ' ': # across the top\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")                \n",
        "                break\n",
        "            elif theBoard['4'] == theBoard['5'] == theBoard['6'] != ' ': # across the middle\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")\n",
        "                break\n",
        "            elif theBoard['1'] == theBoard['2'] == theBoard['3'] != ' ': # across the bottom\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")\n",
        "                break\n",
        "            elif theBoard['1'] == theBoard['4'] == theBoard['7'] != ' ': # down the left side\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")\n",
        "                break\n",
        "            elif theBoard['2'] == theBoard['5'] == theBoard['8'] != ' ': # down the middle\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")\n",
        "                break\n",
        "            elif theBoard['3'] == theBoard['6'] == theBoard['9'] != ' ': # down the right side\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")\n",
        "                break \n",
        "            elif theBoard['7'] == theBoard['5'] == theBoard['3'] != ' ': # diagonal\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")\n",
        "                break\n",
        "            elif theBoard['1'] == theBoard['5'] == theBoard['9'] != ' ': # diagonal\n",
        "                printBoard(theBoard)\n",
        "                print(\"\\nGame Over.\\n\")                \n",
        "                print(\" **** \" +turn + \" won. ****\")\n",
        "                break \n",
        "\n",
        "        # If neither X nor O wins and the board is full, we'll declare the result as 'tie'.\n",
        "        if count == 9:\n",
        "            print(\"\\nGame Over.\\n\")                \n",
        "            print(\"It's a Tie!!\")\n",
        "\n",
        "        # Now we have to change the player after every move.\n",
        "        if turn =='X':\n",
        "            turn = 'O'\n",
        "        else:\n",
        "            turn = 'X'        \n",
        "    \n",
        "    # Now we will ask if player wants to restart the game or not.\n",
        "    restart = input(\"Do want to play Again?(y/n)\")\n",
        "    if restart == \"y\" or restart == \"Y\":  \n",
        "        for key in board_keys:\n",
        "            theBoard[key] = \" \"\n",
        "\n",
        "        game()\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    game()"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " | | \n",
            "-+-+-\n",
            " | | \n",
            "-+-+-\n",
            " | | \n",
            "It's your turn,X.Move to which place?\n",
            "1\n",
            " | | \n",
            "-+-+-\n",
            " | | \n",
            "-+-+-\n",
            "X| | \n",
            "It's your turn,O.Move to which place?\n",
            "2\n",
            " | | \n",
            "-+-+-\n",
            " | | \n",
            "-+-+-\n",
            "X|O| \n",
            "It's your turn,X.Move to which place?\n",
            "3\n",
            " | | \n",
            "-+-+-\n",
            " | | \n",
            "-+-+-\n",
            "X|O|X\n",
            "It's your turn,O.Move to which place?\n",
            "4\n",
            " | | \n",
            "-+-+-\n",
            "O| | \n",
            "-+-+-\n",
            "X|O|X\n",
            "It's your turn,X.Move to which place?\n",
            "5\n",
            "6\n",
            " | | \n",
            "-+-+-\n",
            "O|X| \n",
            "-+-+-\n",
            "X|O|X\n",
            "It's your turn,O.Move to which place?\n",
            " | | \n",
            "-+-+-\n",
            "O|X|O\n",
            "-+-+-\n",
            "X|O|X\n",
            "It's your turn,X.Move to which place?\n",
            "7\n",
            "X| | \n",
            "-+-+-\n",
            "O|X|O\n",
            "-+-+-\n",
            "X|O|X\n",
            "\n",
            "Game Over.\n",
            "\n",
            " **** X won. ****\n",
            "Do want to play Again?(y/n)n\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MEqhHWa9ivVs",
        "colab_type": "text"
      },
      "source": [
        "-----------------------------------------------------------------------"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5k9U94hqjCnQ",
        "colab_type": "text"
      },
      "source": [
        "[TIC TAC TOE](https://inventwithpython.com/chapter10.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_GBe_62CJGk5",
        "colab_type": "text"
      },
      "source": [
        "**Tuple packing & UnPacking**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8DQ2kjWLQv9f",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "d41e08c5-be75-44b8-e13c-071ac31149a1"
      },
      "source": [
        "# Tuple Packing & Unpacking\n",
        "\n",
        "a = (\"NIT Allahabad\", 5000, \"Engineering\") \n",
        "\n",
        "# this lines UNPACKS values \n",
        "# of variable a \n",
        "(college, student, type_ofcollege) = a \n",
        "\n",
        "# print college name \n",
        "print(college) \n",
        "\n",
        "# print no of student \n",
        "print(student) \n",
        "\n",
        "# print type of college \n",
        "print(type_ofcollege) \n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "NIT Allahabad\n",
            "5000\n",
            "Engineering\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DjrTjAVBJTWJ",
        "colab_type": "text"
      },
      "source": [
        "The `startswith()` method returns a boolean. It returns `True` if the string starts with the specified prefix. It returns `False` if the string doesn't start with the specified prefix."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ilOs5nL1JDSC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "223ff110-e03c-4eb7-cac2-969350e60be7"
      },
      "source": [
        "txt = \"Hello, welcome to my world.\"\n",
        "\n",
        "x = txt.startswith(\"Hello\")\n",
        "\n",
        "print(x)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}