HW_10_Bulls_Cows.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/KCM2005/Kalenga-Mumba/blob/main/HW_10_Bulls_Cows.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lSwr8T3SNrkj"
      },
      "source": [
        "## Bulls and Cows:\n",
        "### Another guessing game.\n",
        "### Assignment due Wednesday 10 April at 10 am\n",
        "\n",
        "General instructions:\n",
        "\n",
        "1. You may work in teams of up to three people.  As usual, if you do this, make sure all names are clearly displayed at the top of your submission, and all team members should submit the same GitHub URL.\n",
        "\n",
        "1. Use only basic Python code.  Do not use `numpy` arrays or functions.\n",
        "\n",
        "2. Practice utilizing the coding concepts we have studied.  \n",
        "\n",
        "3. Write docstrings for all your functions.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrWRyeI2NwHA"
      },
      "source": [
        "### Goal:  program this game\n",
        "In this assignment you will program a version of an old game called Bulls and Cows.  It is somewhat similar to Wordle, but with numbers instead of words (and various other differences . . . read carefully!).\n",
        "\n",
        "The game is played like this:  \n",
        "1. The computer will choose a secret code that the player is trying to guess.\n",
        "2. The secret code will be 4 digits long.  It will use only the digits 1-6, and it will have no repeated digits.  For example the secret code might be 1326 or 6241 but it cannot be 2652 or 4913 or 2601.\n",
        "3. The computer will prompt the user for a guess, and the user will guess.  The guess must follow the same rules (4 digits long, only use digits 1-6, no repeats).  The program should not allow an invalid guess.\n",
        "4. After each guess, the computer will give feedback to the user as follows:  \n",
        "(i) Each digit of the guess that is in the secret code and in the correct position is called a Bull (B).  \n",
        "(ii) Each digit of the guess that exists somewhere in the secret code, but *not* in the same position as in the guess, is called a Cow (C).  \n",
        "(iii) A digit of the guess that doesn't occur anywhere in the secret code is called a miss (X).  \n",
        "The computer will inform the user how many Bulls, how many Cows, and how many misses the user's guess had.  \n",
        "The feedback will always start with B's, then list C's, then list X's.  \n",
        "For example if the secret code is 1326  \n",
        "and the guess is 4316  \n",
        "then the computer should respond with \"BBCX\"  \n",
        "because there are two Bulls (the 3 and the 6 are Bulls, because they occur in the same position in the guess as in the secret code),  \n",
        "one Cow (the 1, which is a correct digit but in the wrong position),  \n",
        "and one Miss (the 4, which does not occur anywhere in the secret code).  \n",
        "> **Important:** the feedback string should always list the Bulls first, then the Cows, then the Misses.  It should **not** tell the user which digits are which!  The only information in the feedback string is how many of each there are.  In the example above, for instance, the feedback is **not** \"XBCB\" but rather \"BBCX\".  This is different from Wordle, if you are familiar with that game.\n",
        "5. The user should then be prompted for another guess.  This guess-with-feedback process should be repeated until the user gets the correct code, at which point the computer should indicate that they have won the game.  However, the user should only be allowed 6 guesses; if they don't guess correctly in 6 attempts, then following the feedback from their final guess they should get a message that they have lost the game, and the secret code should be revealed.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Steps\n",
        "We will build this game using several functions.  \n",
        "\n",
        "1. **Count the Bulls:**  \n",
        "Write a function that takes two lists of the same length, and returns the number of Bulls.  That is, it should return the number of indices where the lists contain the same element.  *(Note:  you don't have to check that the entries are between 1 and 6, or that there are no repeats, etc.  A different function will do that.)*\n",
        "\n",
        "> A sample run might look like\n",
        "```\n",
        "first = [11, 3, 17, 5, 1]\n",
        "second = [20, 2, 17, 3, 1]\n",
        "count_bulls(first,second)\n",
        "```\n",
        "```\n",
        " 2\n",
        "```\n"
      ],
      "metadata": {
        "id": "XSH1JULaurD1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define your function in the code chunk below.  The function definition command and the return command are pre-populated for you.  You just have to fill in the part which does the actual counting.  I recommend using a list comprehension to do this.\n"
      ],
      "metadata": {
        "id": "pXoOyBk7xmPa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# the Bull-counting function\n",
        "def count_bulls(first, second):\n",
        "    \"\"\"\n",
        "    Counts the number of elements in two lists that are at the same index and have the same value.\n",
        "\n",
        "    Arguments:\n",
        "        first: The first list.\n",
        "        second: The second list.\n",
        "\n",
        "    Returns:\n",
        "        The number of elements in both lists that are at the same index and have the same value.\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "    num_bulls = 0\n",
        "    for i in range(len(first)):\n",
        "      if first[i] == second[i]:\n",
        "        num_bulls += 1\n",
        "    return num_bulls\n",
        "\n",
        "first = [5, 3, 15, 24, 1, 30]\n",
        "second = [8, 5, 15, 4, 1, 30]\n",
        "\n",
        "num_bulls = count_bulls(first, second)\n",
        "print(num_bulls)"
      ],
      "metadata": {
        "id": "vEsRSe8KxlcF",
        "outputId": "a27fa98a-c006-4097-afb9-5b079a399bb7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#First test of Bull-counting code function\n",
        "first = [2, 5, 12, 35, 4, 18]\n",
        "second = [8, 5, 15, 4, 1, 30]\n",
        "\n",
        "num_bulls = count_bulls(first, second)\n",
        "print(num_bulls)"
      ],
      "metadata": {
        "id": "wtdJmMkmNH9o",
        "outputId": "bb71d811-4d05-49f5-c011-bc8fcc81f7b2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Second test of Bull-counting code function\n",
        "first = [12, 3, 15, 17, 1, 60]\n",
        "second = [10, 3, 25, 17, 1, 60]\n",
        "\n",
        "num_bulls = count_bulls(first, second)\n",
        "print(num_bulls)"
      ],
      "metadata": {
        "id": "UTXRb-0XNO5G",
        "outputId": "1ac899d3-df85-41ee-8e04-7d32a5364b21",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Third test of Bull-counting code function\n",
        "first = [20, 3, 17, 29, 1, 60]\n",
        "second = [9, 3, 25, 17, 1, 45]\n",
        "\n",
        "num_bulls = count_bulls(first, second)\n",
        "print(num_bulls)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1BQGDlYZFQKz",
        "outputId": "f7680dd9-330e-4c53-cce8-e576841739fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Add code and/or text chunks below to demonstrate that you have tested your code and that it works correctly."
      ],
      "metadata": {
        "id": "yACJyJtOzE2U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. **Count something else:**  \n",
        "To count the cows it will be helpful first to count how many of the elements occur in both strings, without paying attention their positions.\n",
        "Write a function called `count_animals` that takes two lists of the same length, and returns the number of elements of the second list that are also in the first list.  (In the game setting, each such element is either a Bull or a Cow, but don't worry about which is which for this problem.)\n",
        "You may assume the lists do not contain repeated elements, since this will be the case when the function is called in the game.\n",
        "\n",
        "> This time a sample run might look like\n",
        "```\n",
        "first = [11, 3, 17, 5, 1]\n",
        "second = [20, 2, 17, 3, 1]\n",
        "count_animals(first,second)\n",
        "```\n",
        "```\n",
        " 3\n",
        "```\n",
        "\n",
        "This one isn't started for you.  Remember to include a docstring.  This can also be done using a list comprehension, similar to the previous function.\n",
        "\n"
      ],
      "metadata": {
        "id": "aMsOmejkzNVN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#The count_animals function\n",
        "def count_animals(first, second):\n",
        "  \"\"\"\n",
        "  Counts the number of elements in two lists that are the same.\n",
        "\n",
        "  Arguments:\n",
        "      first: The first list.\n",
        "      second: The second list.\n",
        "\n",
        "  Returns:\n",
        "      The number of elements in both lists that are the same.\n",
        "  \"\"\"\n",
        "\n",
        "\n",
        "  num_of_elements = 0\n",
        "  for i in range(len(first)):\n",
        "    if first[i] in second:\n",
        "      num_of_elements += 1\n",
        "\n",
        "  return num_of_elements\n",
        "\n",
        "\n",
        "first = [7, 3, 22, 31, 1, 18]\n",
        "second = [9, 1, 15, 4, 7, 30]\n",
        "\n",
        "num_of_elements = count_animals(first, second)\n",
        "print(num_of_elements)"
      ],
      "metadata": {
        "id": "yRX219q02e6i",
        "outputId": "3cbc8835-fcb7-4db8-a1ff-457cfe0a29e0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#First test of count_animals code function\n",
        "first = [52, 73, 62, 81, 71, 98]\n",
        "second = [27, 4, 2, 4, 62, 70]\n",
        "\n",
        "num_of_elements = count_animals(first, second)\n",
        "print(num_of_elements)"
      ],
      "metadata": {
        "id": "JosO4BGpR-Nc",
        "outputId": "616398ab-de7b-4457-9921-f37cae121a23",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Second test of count_animals code function\n",
        "first = [48, 26, 22, 32, 1, 100]\n",
        "second = [100, 26, 22, 32, 77, 48]\n",
        "\n",
        "num_of_elements = count_animals(first, second)\n",
        "print(num_of_elements)"
      ],
      "metadata": {
        "id": "uPeEfcHzSL0t",
        "outputId": "0cbabab3-9fcb-40e7-b21d-6618132bb438",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Third test of count_animals code function\n",
        "first = [26, 26, 22, 32, 1, 100]\n",
        "second = [33, 37, 22, 32, 77, 26]\n",
        "\n",
        "num_of_elements = count_animals(first, second)\n",
        "print(num_of_elements)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V9946M8oFm8Z",
        "outputId": "e78907a8-4042-467b-9748-9e72f0bb1e7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Again, demonstrate below that you have tested your code and that it works."
      ],
      "metadata": {
        "id": "HXRNwANS2f-4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. **Count the cows:**  \n",
        "Write a function called `count_cows` that counts the cows.  \n",
        "> This time a sample run might look like\n",
        "```\n",
        "first = [11, 3, 17, 5, 1]\n",
        "second = [20, 2, 17, 3, 1]\n",
        "count_cows(first,second)\n",
        "```\n",
        "```\n",
        " 1\n",
        "```\n",
        "*Use the two previously defined functions to help you!  \n",
        "In fact, remember that the only reason we wrote the `count_animals` function was to help count the cows.*\n",
        "\n",
        "You can do this with only two lines of code, not counting documentation!"
      ],
      "metadata": {
        "id": "x2DAPkxj2GMo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def count_cows(first, second):\n",
        "  \"\"\"\n",
        "  This function takes two lists of cows and returns the total number of cows.\n",
        "\n",
        "  Arguments:\n",
        "    first: A list containing the first group of cows.\n",
        "    second: A list containing the second group of cows.\n",
        "\n",
        "  Returns:\n",
        "    The total number of cows in both groups.\n",
        "  \"\"\"\n",
        "\n",
        "  num_cows = len(first) + len(second)\n",
        "  print(num_cows)\n",
        "count_cows(first, second)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OLuLtaqmGWoi",
        "outputId": "fd193d59-b5b1-4da6-f817-b17b7fe9d386"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hWQhYDIVYjXr"
      },
      "source": [
        "4. **Create feedback string**  \n",
        "Write a `build_response_str` function that takes three numbers, say `b,c,l`, and outputs a string of total length `l` that consists of `b` B's, followed by `c` C's, and the rest X's (until the total length is `l`).\n",
        "\n",
        "> Sample run:\n",
        "```\n",
        "build_response_str(4,3,9)\n",
        "```\n",
        "```\n",
        "BBBBCCCXX\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#The Build_response_str function\n",
        "def build_response_str(b, c, l):\n",
        "  \"\"\"\n",
        "  This function builds a response string based on the given parameters.\n",
        "\n",
        "  Arguments:\n",
        "    b: The number of 'B's to include in the string.\n",
        "    c: The number of 'C's to include in the string.\n",
        "    l: The total length of the string.\n",
        "\n",
        "  Returns:\n",
        "    A string containing the number of 'B', 'C', and 'X' values\n",
        "  \"\"\"\n",
        "\n",
        "  response_str = ''\n",
        "  for i in range(b):\n",
        "      response_str += 'B'\n",
        "  for i in range(c):\n",
        "      response_str += 'C'\n",
        "  for i in range(l - b - c):\n",
        "      response_str += 'X'\n",
        "\n",
        "  return response_str\n",
        "\n",
        "response_str = build_response_str(2, 5, 8)\n",
        "print(response_str)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TAy17If7GiFi",
        "outputId": "cd2d38db-0afd-43a6-e581-a651fa84ad15"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BBCCCCCX\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#First test of build_response_str function\n",
        "response_str = build_response_str(1, 4, 8)\n",
        "print(response_str)"
      ],
      "metadata": {
        "id": "6KzGj9L-cGbl",
        "outputId": "75bc8e9f-bcbc-4972-ca47-8dbad402dd2a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BCCCCXXX\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Second test of build_response_str function\n",
        "response_str = build_response_str(3, 1, 9)\n",
        "print(response_str)"
      ],
      "metadata": {
        "id": "J6KQSd3BcHMw",
        "outputId": "218cf7c4-c93e-4a94-d22a-2cc4b47a40f2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BBBCXXXXX\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Third test of build_response_str function\n",
        "response_str = build_response_str(2, 2, 7)\n",
        "print(response_str)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zCbaIwVTGvmR",
        "outputId": "6c5c2150-f21a-428b-8fa6-06dfdb3a2913"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BBCCXXX\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Test your code here."
      ],
      "metadata": {
        "id": "2D14kxTU7ApH"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "omzE6sLKwsMC"
      },
      "source": [
        "5.  **Generate feedback for guesses**  \n",
        "Write a function `response(first,second)` that takes two lists of the same length, and outputs a string consisting of some number of B's followed by some number of C's followed by some number of X's, where the numbers correspond to the things we counted above.  That is, if `first` were the secret code in the game and `second` were the user's guess, then we would print one B for each Bull, one C for each Cow, and one X for each Miss. The total output string should have the same length as the input strings.\n",
        "\n",
        "> Sample run:\n",
        "```\n",
        "first = [11, 3, 17, 5, 1]\n",
        "second = [20, 2, 17, 3, 1]\n",
        "response(first,second)\n",
        "```\n",
        "```\n",
        " BBCXX\n",
        "```\n",
        "\n",
        "With all the functions you've already put in place, this should be simple.  Test your code once it's written.\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def response(first, second):\n",
        "  \"\"\"\n",
        "  This function takes two lists of the same length and returns a string\n",
        "  consisting of some number of B's followed by some number of C's followed\n",
        "  by some number of X's.\n",
        "\n",
        "  \"\"\"\n",
        "\n",
        "  bulls = 0\n",
        "  cows = 0\n",
        "\n",
        "  for i in range(len(first)):\n",
        "    if first[i] == second[i]:\n",
        "      bulls += 1\n",
        "    if second[i] in first:\n",
        "      cows += 1\n",
        "\n",
        "  output = 'B' * bulls + 'C' * cows + 'X' * (len(first) - bulls - cows)\n",
        "  return output\n",
        "\n",
        "response(first, second)\n",
        "print(response_str)"
      ],
      "metadata": {
        "id": "RD1qq7l783y5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ec27079-18ec-479f-c66d-dd6852d6c439"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BBBCXXXXX\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LWshNPjPZJdQ"
      },
      "source": [
        "6.  **Choose the secret code**  \n",
        "The `random` package, and specifically the `sample` sub-package, is useful for generating random samples.  Try running the following lines of code several times.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from random import sample\n",
        "\n",
        "sample(range(1,7),4)  # the first argument is the population to be sampled, and the second is the number of samples\n",
        "                      # recall that `range(a,b)` includes `a` but stops at `b-1`"
      ],
      "metadata": {
        "id": "OzEZ5BQZ85jV",
        "outputId": "67794bc6-3c2d-4bbd-b602-897bbc52b8db",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 6, 2, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What type of object is returned by the `sample` function?\n"
      ],
      "metadata": {
        "id": "N1BOe2Xd-kr4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#The sample function returns multiple lists of integers\n",
        "#Examples: [6, 1, 4, 2], [2, 1, 4, 5], [4, 2, 6, 1], [3, 5, 1, 4]"
      ],
      "metadata": {
        "id": "U5AAu9sG-slX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "yGZw8xFZ-uN4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "7. **Verify the guess**  \n",
        "Finish writing a function called `get_guess` (started below) to prompt the user for a guess and then make sure the input is valid according to the rules of the game.\n",
        "The prompt is already given.  Note that the `list` command converts the input into a list of characters so that it can be passed to the other functions (which are expecting lists).   \n",
        ">**Alert:  you will likely have to think more about data types before this is all over.**"
      ],
      "metadata": {
        "id": "mbK84TdIAVsO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_guess():\n",
        "  \"\"\"\n",
        "  Prompts the user for a 4-digit guess and checks the input.\n",
        "\n",
        "  Returns:\n",
        "    A list of 4 digits representing the user's guess.\n",
        "\n",
        "  \"\"\"\n",
        "  while True:\n",
        "    guess = list(input(\"Enter your guess: \"))\n",
        "    if len(guess) != 4:\n",
        "      print(\"Guess must be 4 characters long. Try again.\")\n",
        "      for user_input in guess:\n",
        "        if not user_input.isdigit():\n",
        "          print(\"Guess must only contain digits. Try again.\")\n",
        "    return guess"
      ],
      "metadata": {
        "id": "13HGg6VvBXSH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "As usual, test your code.  What type of objects are we dealing with here?"
      ],
      "metadata": {
        "id": "PSPYpeZYONf0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#The above code does not output or return anything, but we are dealing with integers"
      ],
      "metadata": {
        "id": "ytgf6BfiOPNh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "8. **Put it all together**  \n",
        "Finally, fill in the details of the function `bulls_cows` below so that it will play the game of Bulls and Cows when called.  Note that the function takes no arguments and returns nothing.\n"
      ],
      "metadata": {
        "id": "WdtvUrA4-uzn"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_u48oidGzRKX"
      },
      "outputs": [],
      "source": [
        "from random import sample\n",
        "\n",
        "def bulls_cows():\n",
        "  '''\n",
        "  This function plays the game \"Bulls and Cows.\"\n",
        "  It takes no arguments and returns nothing.\n",
        "  '''\n",
        "  code = sample(range(10), 4)\n",
        "\n",
        "  for i in range(6):\n",
        "    guess = get_guess()\n",
        "    if code==guess:\n",
        "      print(\"You guessed it!\")\n",
        "      return\n",
        "    print(response(code, guess))\n",
        "  print(f\"You have run out of guesses. The secret code was {code}.\")\n",
        "  return"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NzjqX_9K3OuV"
      },
      "source": [
        "Play the game a few times below.  Make sure it behaves as you think it should!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b-HELV-z3OuW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8b938c33-10a3-4f21-deb1-3599c7b44579"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your guess: 2385\n",
            "XXXX\n",
            "Enter your guess: 13456\n",
            "Guess must be 4 characters long. Try again.\n",
            "Enter your guess: 1709\n",
            "XXXX\n",
            "Enter your guess: 2334\n",
            "XXXX\n",
            "Enter your guess: 2541\n",
            "XXXX\n",
            "Enter your guess: 1378\n",
            "XXXX\n",
            "Enter your guess: 1348\n",
            "XXXX\n",
            "You have run out of guesses. The secret code was [9, 8, 0, 5].\n"
          ]
        }
      ],
      "source": [
        "bulls_cows()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bulls_cows()"
      ],
      "metadata": {
        "id": "inzOdtimDfGU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3dfdd6b4-79d9-4943-f7ce-52388aedd4de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your guess: 8521\n",
            "XXXX\n",
            "Enter your guess: 3445\n",
            "XXXX\n",
            "Enter your guess: 1238\n",
            "XXXX\n",
            "Enter your guess: 2589\n",
            "XXXX\n",
            "Enter your guess: 3180\n",
            "XXXX\n",
            "Enter your guess: 1145\n",
            "XXXX\n",
            "You have run out of guesses. The secret code was [2, 8, 9, 6].\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bulls_cows()"
      ],
      "metadata": {
        "id": "Eqw-5laFDfkG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3fb7781f-4be9-4bd7-f630-44ccd94c72fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your guess: 1234\n",
            "XXXX\n",
            "Enter your guess: 48765\n",
            "Guess must be 4 characters long. Try again.\n",
            "Enter your guess: 28\n",
            "Guess must be 4 characters long. Try again.\n",
            "Enter your guess: 1228\n",
            "XXXX\n",
            "Enter your guess: 2458\n",
            "XXXX\n",
            "Enter your guess: 2369\n",
            "XXXX\n",
            "Enter your guess: 9268\n",
            "XXXX\n",
            "Enter your guess: 3128\n",
            "XXXX\n",
            "You have run out of guesses. The secret code was [1, 9, 7, 6].\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "9. **Reflect**  \n",
        "Think of at least three ways you could change the rules or setup of the game, and in each case describe (in one sentence, you don't need to write code) what you would have to do to modify your code to play the new version of the game.  Use a text box below for each of your ideas."
      ],
      "metadata": {
        "id": "a58-KCX4ELRO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(1) I would use letters instead of numbers since words would be easier to guess than numbers (given the fact that numbers are difficult to guess as shown in my code output tests of the game above)."
      ],
      "metadata": {
        "id": "Jof2vIZSEfwo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(2) I would increase the number of characters if I am using letters to make it easier to spot the number of bulls and cows within the code outputs."
      ],
      "metadata": {
        "id": "f2_QlBavEiqW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(3) I would also provide hints within the code that help the player guess the hidden word provided by the computer."
      ],
      "metadata": {
        "id": "sqfq2EFpEjZt"
      }
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}