Foundational-Math-5.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Foundational Math 5 (Learn).ipynb",
      "provenance": [],
      "collapsed_sections": [
        "szp5flp1fA8-",
        "Qi3pkfJRV_v7",
        "6zpZEwUCmuZO",
        "5Cj-FObSK2q-",
        "0bQkm-zyLHBr",
        "MRHJIxaULIdT",
        "hCbQuMWFLLCE",
        "IuJnWUEQLKE7",
        "drMb9BFILNLA",
        "59_NbvdoLOLJ",
        "dANvnqZzLPdY",
        "V8abW4jeLWFW",
        "RHslnjqULQ42",
        "Onw98nlfLRpV",
        "wVboaZONLd1x",
        "UOEMFJ6cLTLh",
        "J0sC7Ib_LfW1",
        "hhYH2x-PLUZQ",
        "7Gb2KZz6gPEf",
        "T3T_XZYOhgmZ"
      ],
      "authorship_tag": "ABX9TyO5ewe5aUfWfTTXzAYgCFM7",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/edatfreecodecamp/python-math/blob/main/Foundational_Math_5_(Learn).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EsfO5Q92tL-6"
      },
      "source": [
        "[![freeCodeCamp](https://cdn.freecodecamp.org/testable-projects-fcc/images/fcc_secondary.svg)](https://freecodecamp.org/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qwxbk7XGKxEq"
      },
      "source": [
        "**Learn Foundational Math 5 by Building a Casino Simulator**<br>\n",
        "Each of these steps will lead you toward the Certification Project. First you have to copy the files and set them up in your Google Drive."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "szp5flp1fA8-"
      },
      "source": [
        "# &darr; **Do this first** &darr;\n",
        "Make sure you are logged into your Google account, and copy this notebook to your own account. Click \"File\" (at the top of this page) and then click \"Save a copy in Drive.\"  The file will be in a folder called \"Colab Notebooks\" in your Google Drive. "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Directions - Click to expand the next step<br>\n",
        "Click on the little <i>triangle</i> next to the word \"Step\" to do that step. Once you complete a step, click the triangle to expand the next step."
      ],
      "metadata": {
        "id": "Qi3pkfJRV_v7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 0 - Acquire the testing library"
      ],
      "metadata": {
        "id": "6zpZEwUCmuZO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Please run this code to get the library file from FreeCodeCamp. Each step will use this library to test your code. You do not need to edit anything; just run this code cell and wait a few seconds until it tells you to go on to the next step."
      ],
      "metadata": {
        "id": "jWxBcDfdmmN9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# You may need to run this cell at the beginning of each new session\n",
        "\n",
        "!pip install requests\n",
        "\n",
        "# This will just take a few seconds\n",
        "\n",
        "import requests\n",
        "\n",
        "# Get the library from GitHub\n",
        "url = 'https://raw.githubusercontent.com/edatfreecodecamp/python-math/main/math-code-test-e.py'\n",
        "r = requests.get(url)\n",
        "\n",
        "# Save the library in a local working directory \n",
        "with open('math_code_test_e.py', 'w') as f:\n",
        "    f.write(r.text)\n",
        "\n",
        "# Now you can import the library\n",
        "import math_code_test_e as test\n",
        "\n",
        "# This will tell you if the code works\n",
        "test.step00()"
      ],
      "metadata": {
        "id": "usSQCh5PmqUL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Cj-FObSK2q-"
      },
      "source": [
        "#Step 1 - Sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CJ_o5jJpK4tN"
      },
      "source": [
        "A mathematical <i>sequence</i> is a group of numbers in a certain order, following a particular pattern. You can write an equation to generate each number in the sequence. Look at the print statement in the loop and predict what you think this sequence will be, then run the code to see if you are correct. (You don't have to change anything here.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jvCyAWK8HxCo"
      },
      "source": [
        "for a in range(1,7):\n",
        "    print(a**2, \", \", end=\" \")\n",
        "\n",
        "print(\"___\")\n",
        "\n",
        "\n",
        "# Just run this code\n",
        "import math_code_test_e as test\n",
        "test.step01()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0bQkm-zyLHBr"
      },
      "source": [
        "#Step 2 - Arithmetic Sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E9qVIltTLHBr"
      },
      "source": [
        "In an <i>arithmetic sequence</i>, you add or subtract something to get to the next number. The general formula is<br>\n",
        "N<sup>th</sup> number = [first number] + [difference]$*$(n-1)<br>\n",
        "The (n-1) is because n=1 for the first number of a sequence, and that number is already in the formula. Python loops start at zero, so you don't need to subract 1. Write a loop the generates an aritmetic sequence, beginning with 3 and adding 2 each time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6lXNONyLHBs"
      },
      "source": [
        "for a in range(1,7):\n",
        "    # Change the first part of the print statement\n",
        "    print(a**2, \", \", end=\" \")\n",
        "\n",
        "\n",
        "# Keep this line at the end if you want\n",
        "print(\"...\")\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step02(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MRHJIxaULIdT"
      },
      "source": [
        "#Step 3 - Geometric Sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HIecO24ILIdV"
      },
      "source": [
        "In a `geometric sequence`, you multiply or divide something to get the next number. The general formula is<br>\n",
        "N<sup>th</sup> number = [first number]$*$[ratio]<sup>n-1</sup><br>\n",
        "Just like artithmetic sequences, the (n-1) is because n=1 for the first number of a sequence, and it is already in the formula. Remember Python loops start at zero, so you don't need to subract 1. Write a loop that generates a geometric sequence, starting with 3 and doubling every time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q_Ln2qanLIdW"
      },
      "source": [
        "for a in range(1,7):\n",
        "    # Change the first part of the print statement\n",
        "    print(a**2, \", \", end=\" \")\n",
        "\n",
        "\n",
        "# Keep this line at the end if you want to\n",
        "print(\"...\")\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step03(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hCbQuMWFLLCE"
      },
      "source": [
        "#Step 4 - Sequences as Python Lists"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uWFvfeRhLLCF"
      },
      "source": [
        "In Python, a <i>list</i> is a good way to store a sequence. Lists are indexed, and the first index is zero (while math sequences start counting at 1). The first element in a list called \"my_list\" would be `my_list[0]` and the second element would be `my_list[1]`. You can print the entire list or just certain elements. Notice the first element in this list is `5`. Create a sequence where you multiply by 2 then add 3 to get the next number. Then you will `append` that new element to the list and print the list.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "59giIvM4LLCF"
      },
      "source": [
        "a_list = [5] \n",
        "# Now a_list[0] = 5\n",
        "\n",
        "\n",
        "for n in range(1,10):\n",
        "    # Change the next line:\n",
        "    next_number = 0\n",
        "    a_list.append(next_number)\n",
        "\n",
        "print(a_list)\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step04(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IuJnWUEQLKE7"
      },
      "source": [
        "#Step 5 - Recursive Sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GywerJe-LKE8"
      },
      "source": [
        "In a <i>recursive sequence</i>, you need to know the previous number to generate the next number. The first two numbers in a Fibonacci sequence are 1 and 1. You need to know this because you get the next number by adding the two previous numbers. Use a list and create a loop that generates the first 10 terms in the Fibonacci sequence. Print the list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WVdiSqxqLKE9"
      },
      "source": [
        "fib = [1,1]\n",
        "\n",
        "# hints:\n",
        "# fib[n] = one element\n",
        "# fib[n-1] = previous element\n",
        "# fib[n-2] = element before that\n",
        "\n",
        "for n in range(2,11):\n",
        "\n",
        "    # Change the next line\n",
        "    next = 0\n",
        "    fib.append(next)\n",
        "\n",
        "# Keep this line\n",
        "print(fib)\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step05(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "drMb9BFILNLA"
      },
      "source": [
        "#Step 6 - Graphing Sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZUBLfLqLNLB"
      },
      "source": [
        "If you turn a sequence into a Python list, you can graph that sequence. The element number (`n`) is your x value, and the value of that element is your y value. The graph will be a descrete set of points. Run the code to see an example, then make `b_list` the first few Fibbonacci numbers and change the loop to plot that sequence."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GTtDx5YcLNLC"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "a_list = [1,4,9,16,25,36,49,64,81,100]\n",
        "b_list = [1,1,2,3]\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "plt.axis([0,10,0,100])\n",
        "\n",
        "# Notice how the range is the length of the list\n",
        "for n in range(len(a_list)):\n",
        "    # Change the next line when you change b_list\n",
        "    plt.plot([n], [a_list[n]], 'ro')\n",
        "    \n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step06(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59_NbvdoLOLJ"
      },
      "source": [
        "#Step 7 - Series"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gattM08DLOLK"
      },
      "source": [
        "When you add up all of the elements in a sequence, it becomes a <i>series</i>. In the loop, update the `sum` variable to make it a series."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "98jMcMl6LOLK"
      },
      "source": [
        "# Use this variable\n",
        "sum = 0\n",
        "\n",
        "for n in range(11):\n",
        "    element = 2*n+4\n",
        "    # Write your code here\n",
        "    \n",
        "\n",
        "# Keep this line\n",
        "print(\"Sum = \", sum)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step07(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dANvnqZzLPdY"
      },
      "source": [
        "#Step 8 - Divergent and Convergent Series"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zmA-KlOeLPdY"
      },
      "source": [
        "In a <i>divergent series</i>, the sum keeps getting larger. In a <i>convergent series</i>, the sum approaches a definite number (that is not infinity). A series will converge if the denominator keeps getting bigger than the numerator. Run the following code and notice the sum. Then change the range of the loop to 42 and notice how the sum converges on a number. Finally, change the range to 100 and see what happens to the sum."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ASMRCU6ALPdZ"
      },
      "source": [
        "sum = 0\n",
        "\n",
        "# Run the code, then only change the range\n",
        "for n in range(11):\n",
        "    element = 1/(2**n)\n",
        "    sum = sum + element\n",
        "\n",
        "print(\"Sum = \", sum)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step08(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V8abW4jeLWFW"
      },
      "source": [
        "#Step 9 - Factorial"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kN-uaoLrLWFW"
      },
      "source": [
        "The <i>factorial</i> of a number, written with an exclamation point(\"!\"), is that number multiplied by every number less than it.<br> \n",
        "For example, 5! = 5 $*$ 4 $*$ 3 $*$ 2 $*$ 1. So 5! would equal 120.<br>\n",
        "By definition, zero factorial equals one (because of the situations where this arises). In Python, you need to import math to use the `math.factorial()` function. Add that function to the print statement. You can also change the number variable if you like."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NZHfIBrDLWFW"
      },
      "source": [
        "import math\n",
        "\n",
        "number = 7\n",
        "\n",
        "# Put something else in the print statement \n",
        "print(number, \"! = \")\n",
        "\n",
        "# Keep this code\n",
        "for n in range(number-1):\n",
        "    print(number-n, \" * \", end=\" \")\n",
        "\n",
        "print(\"1\")\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step09(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHslnjqULQ42"
      },
      "source": [
        "#Step 10 - Euler's number"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zNfDIWKoLQ42"
      },
      "source": [
        "Mathematicians discovered and used Euler's number, *`e`*, before he was born, but they began using the letter \"*e*\" to represent it as a tribute to him. You can generate *`e`*, which is approximately 2.718281828, using a convergent series: the sum of $\\frac{1}{N!}$ as N goes from zero to infinity. Run the following code, then change the range to 100 and see how the series converges."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z0rSpzS6LQ42"
      },
      "source": [
        "import math\n",
        "\n",
        "sum = 0\n",
        "\n",
        "# Only change the range in the next line\n",
        "for a in range(11):\n",
        "    element = 1/math.factorial(a)\n",
        "    sum = sum + element\n",
        "\n",
        "print(\"sum = \", sum)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step10(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Onw98nlfLRpV"
      },
      "source": [
        "#Step 11 - Probability"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EpOOEXzULRpW"
      },
      "source": [
        "You express probability, the likelihood of something happening, as a fraction or a decimal. To calculate probability you count the number of \"correct\" outcomes, and divide that by the number of possible outcomes. Complete the code to calculate the probability of randomly guessing someone's birthday."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vf9rMRkapkM3"
      },
      "source": [
        "\n",
        "correct = 1\n",
        "possible = 365\n",
        "\n",
        "# Change the following line\n",
        "probability = 0\n",
        "\n",
        "print(probability)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step11(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wVboaZONLd1x"
      },
      "source": [
        "#Step 12 - Probability of \"A\" AND \"B\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D9IrfNCmLd1y"
      },
      "source": [
        "To calculate the probability of two independent events happening (so it is a \"correct\" outcome only if both events happen) find the probability of each event then multiply the probabilities. Complete the code to calculate the probability of a flipped coin landing on \"heads\" four times in a row."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5faGO_JaLRpW"
      },
      "source": [
        "prob = .5\n",
        "\n",
        "# Just change the following line:\n",
        "combined_prob = 0\n",
        "\n",
        "print(combined_prob)\n",
        "\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step12(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOEMFJ6cLTLh"
      },
      "source": [
        "#Step 13 - Probability of \"A\" OR \"B\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jG3Oox6WLTLi"
      },
      "source": [
        "To find the probability of one or another event happening (so it is a \"correct\" outcome if either event happens) you find each probability and add the probabilities. Complete the following code to calculate the probability of winning the \"pick 3\" lottery when buying 7 tickets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2X9VYLOwLTLi"
      },
      "source": [
        "prob = .001\n",
        "\n",
        "# Just change the following line:\n",
        "combined_prob = 0\n",
        "\n",
        "print(combined_prob)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step13(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J0sC7Ib_LfW1"
      },
      "source": [
        "#Step 14 - Combinations\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F42N_UfwLfW2"
      },
      "source": [
        "With <i>combinations</i> you are counting how many unique groups of size \"r\" you can make from a pool of \"n\" things, when order does not matter. Here is the common notation: <sub>n</sub>C<sub>r</sub> and here is the formula: $\\frac{n!}{r!(n-r)!}$ Complete the code to determine how many unique 5-person starting lineups a team can have if there are 12 players on the team.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ecohfh9ULfW3"
      },
      "source": [
        "import math\n",
        "\n",
        "n = 12\n",
        "r = 5\n",
        "\n",
        "# Write your code here\n",
        "starters = 0\n",
        "\n",
        "print(\"Possible starting lineups: \", starters)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step14(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hhYH2x-PLUZQ"
      },
      "source": [
        "#Step 15 - Permutations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EGk7Nx78LUZR"
      },
      "source": [
        "With <i>permutations</i> you are counting how many unique groups of size \"r\" you can make from a pool of \"n\" things, when order within the group does matter. Here is the common notation: <sub>n</sub>P<sub>r</sub> and here is the formula: $\\frac{n!}{(n-r)!}$ . If you have 8 different participation trophies and want to pick 3 to arrange on a shelf, how many unique shelf arrangements can you make? Complete the code to answer this question."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JPJsHy-MLUZR"
      },
      "source": [
        "import math\n",
        "\n",
        "n = 8\n",
        "r = 3\n",
        "\n",
        "# Change the next line\n",
        "arr = 0\n",
        "\n",
        "print(\"Number of possible arrangements: \", arr)\n",
        "\n",
        "\n",
        "# Only change code above this line\n",
        "import math_code_test_e as test\n",
        "test.step15(In[-1].split('# Only change code above this line')[0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 16 - Pascal's Triangle"
      ],
      "metadata": {
        "id": "7Gb2KZz6gPEf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Pascal's Triangle, each row begins and ends with a 1. You get each number by adding the two numbers above it. This pattern shows up in several math topics. You can also use <i>combinations</i> to generate Pascal's triangle, as \"n\" increases with each new row, and \"r\" increases as you go across each row. Run the code to see what this triangle looks like, then delete this code. Write new code using combinations to generate 11 rows of Pascal's Triangle."
      ],
      "metadata": {
        "id": "Aai1z2qkgHSG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"    1  \")\n",
        "print(\"   1 1 \")\n",
        "print(\"  1 2 1\")\n",
        "print(\" 1 3 3 1\")\n",
        "print(\"1 4 6 4 1\")\n"
      ],
      "metadata": {
        "id": "PjEXb5m-gKbE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step 20 - Certification Project 5"
      ],
      "metadata": {
        "id": "T3T_XZYOhgmZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use `random` to simulate a card game where you play against the computer. Create variables to count your wins and losses."
      ],
      "metadata": {
        "id": "ZU38vU5whdDC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "# Create a deck of cards\n",
        "cards =['2','3','4','5','6','7','8','9','10','Jack','Queen','King','Ace']\n",
        "suits =['Hearts','Clubs','Diamonds','Spades']\n",
        "deck = []\n",
        "temp_card = \" \"\n",
        "for a in range(len(cards)):\n",
        "    for b in range (len(suits)):\n",
        "        temp_card = cards[a] + \" 0f \" + suits[b]\n",
        "        deck.append(temp_card)\n",
        "\n",
        "# Print deck to verify\n",
        "for c in range(len(deck)):\n",
        "    print(deck[c])\n",
        "\n",
        "# One random card\n",
        "pick_1 = deck[random.randint(0,53)]\n",
        "\n",
        "\n",
        "# Hint: make a list of card numbers already picked\n",
        "\n",
        "\n",
        "# Write your code here\n"
      ],
      "metadata": {
        "id": "mbmqDUJshSWu"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}