intro-to-python/05_loops_iteration.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "05_loops_iteration.ipynb",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "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/Ada-Developers-Academy/ada-build/blob/master/intro-to-python/05_loops_iteration.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5V8U7H72sMhz",
        "colab_type": "text"
      },
      "source": [
        "# Loops and Iterators\n",
        "\n",
        "_Ada Build - Intro to Python - Lesson 5_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Q3mFR7GsIhy",
        "colab_type": "text"
      },
      "source": [
        "# Learning Goals\n",
        "\n",
        "By the end of this lesson you will be able to:\n",
        "\n",
        "- Define the following terms:\n",
        "  - loops\n",
        "  - iterator\n",
        "  - iteration\n",
        "  - iteration variable\n",
        "  - counter-controlled\n",
        "  - sentinel-controlled\n",
        "  - loop table\n",
        "  - for loop\n",
        "  - range\n",
        "  - while loop\n",
        "  - blocks\n",
        "- Explain the purpose for iteration in creating programs.\n",
        "- Write loops in order to prevent code duplication and repetition.\n",
        "- Understand how a loop will execute the statements inside and what the resulting output will be.\n",
        "- Debug code with loops."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LoT_HYqzsbFb",
        "colab_type": "text"
      },
      "source": [
        "# Notes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vz8HB9VqX9UI",
        "colab_type": "text"
      },
      "source": [
        "## Copy to Drive\n",
        "\n",
        "Before you get started, remember to copy this Colab notebook to your Google Drive so that you can save your work."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xeDMjvhOsdBf",
        "colab_type": "text"
      },
      "source": [
        "## Loops\n",
        "\n",
        "Loops are programming constructs that help you repeat a code action a certain number of times based on algorithmic logic, without needing to copy and paste the code. Another term for looping is iteration. All high-level programming languages provide various forms of loops, which can be used to execute one or more statements repeatedly.\n",
        "\n",
        "For example, if we wanted to print out \"hello\" five hundred times, we could write:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fSGKmIUBoH7T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"hello!\")\n",
        "print(\"hello!\")\n",
        "print(\"hello!\")\n",
        "print(\"hello!\")\n",
        "print(\"hello!\")\n",
        "# ... 495 more times"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1CYkoID3s0pZ",
        "colab_type": "text"
      },
      "source": [
        "Using a loop, we could rewrite this as:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fBtYli-1s2mA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(500):\n",
        "  print(\"hello!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kGqNAgAFs_pk",
        "colab_type": "text"
      },
      "source": [
        "The above program leverages the _for_ loop, which is a counter-controlled loop as we will soon see. The same loop may be written using different programming constructs and syntax. For example, we could achieve the same result using a _while_ loop, which is a sentinel-controlled loop, as we will soon see. Here's a program using a while loop to achieve the same result:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nrnvTEfUtL_i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "i = 0\n",
        "while i < 500:\n",
        "  print(\"hello!\")\n",
        "  i += 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d35mSjOLq4iL",
        "colab_type": "text"
      },
      "source": [
        "Note that you should prefer a `for` loop in this situation as it's much clearer and less error prone (you can't forget to increment `i`).  We have included it here to demonstrate this syntax.\n",
        "\n",
        "Note that we use `i` as the loop variable in both cases.  By convention we use a short variable name like `i` for loop variables unless we need to be more descriptive."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wVUJ7ZwxtYxx",
        "colab_type": "text"
      },
      "source": [
        "### Exercise\n",
        "- Review the code block above. \n",
        "- Recall that `i += 1` is shorthand for `i = i + 1`.\n",
        "- What is the value of `i` after the final iteration?\n",
        "- Add the statement `print(i)` after the last line of code, at the same tab level as the `while` statement, to check your answer. \n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vFSN5EvCuI9M",
        "colab_type": "text"
      },
      "source": [
        "## Types of Loops\n",
        "\n",
        "There are 2 broad categories of loops:  **counter-controlled** and **sentinel-controlled** loops\n",
        "\n",
        "**Counter-controlled** loops are used when the number of loops **can** be determined prior to loop execution. The example we saw above, where we wanted to print `hello!` 500 times, is an example of _counter-controlled_ loop. Another example of _counter-controlled_ loop could be a copy machine which copies a paper a set number of times, and we know exactly how many times the copier will copy the paper.\n",
        "\n",
        "**Sentinel-controlled** loops are used when the number of loops **cannot** be determined prior to loop execution. For example, if you do jumping jacks until you get tired, it is uncertain how many jumping jacks you will do before stopping. Another example could be a program which asks the user if the user would like to continue playing a guessing game. Based on comparing the user input value, the program determines whether to continue or exit the loop.\n",
        "\n",
        "We will by introducing three types of Python loops: `for` (range), `for` (list, string), and `while`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vzyHjkBlu6x9",
        "colab_type": "text"
      },
      "source": [
        "### `for` (range)\n",
        "\n",
        "We use a [`for`](https://docs.python.org/3/reference/compound_stmts.html#the-for-statement) loop with a specific [`range(n)`](https://docs.python.org/3/library/stdtypes.html#typesseq-range) to run the code in its block `n` times.\n",
        "\n",
        "Let's explore how the `for` (range) loop works by considering the example of printing `hello` multiple times."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5BZE9bImvML5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(5):\n",
        "  print(i, \"hello!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7T2feK7kNROR",
        "colab_type": "text"
      },
      "source": [
        "In the above code block, `i` starts at 0 and the `print` function executes, printing `0 hello!`.  Then the loop repeats and `i` becomes 1 and so on, until `i` becomes 5 and the loop stops.\n",
        "We can illustrate this loop with a table.\n",
        "\n",
        "| Iteration \t| `i` \t| output |\n",
        "|-\t|-\t|- |\n",
        "|  1\t|  0\t| 0 hello! |\n",
        "|  2\t| 1 \t| 1 hello! |\n",
        "|  3\t| 2 \t| 2 hello! |\n",
        "|  4\t| 3 \t| 3 hello! |\n",
        "|  5\t| 4 \t| 4 hello! |\n",
        "\n",
        "Programmers sometimes use these tables to reason about what a loop is doing.  This is called a _loop table_.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BFzHWdRjvqs1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "range(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sMBcbLO5OjEN",
        "colab_type": "text"
      },
      "source": [
        "The `range` function returns a sequence of numbers.  If we give it one argument, which we can call _n_, it will give you a sequence from _0_ to _n - 1_.\n",
        "\n",
        "So `range(5)` will give you numbers 0, 1, 2, 3, 4.\n",
        "\n",
        "We can use a `range` function with _two_ arguments in a `for` loop like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SAunjNbHvvIT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(5, 10):\n",
        "  print(i, \"hello\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4RfkEF79POQY",
        "colab_type": "text"
      },
      "source": [
        "The corresponding loop table for the example above looks like this:\n",
        "\n",
        "| Iteration \t| `i` \t| output |\n",
        "|-\t|-\t|- |\n",
        "|  1\t|  5\t| 5 hello! |\n",
        "|  2\t| 6 \t| 6 hello! |\n",
        "|  3\t| 7 \t| 7 hello! |\n",
        "|  4\t| 8 \t| 8 hello! |\n",
        "|  5\t| 9 \t| 9 hello! |"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QPYQvqgYZD8a",
        "colab_type": "text"
      },
      "source": [
        "### `for` (string)\n",
        "\n",
        "A `for` loop can also be used to iterate over the characters in a string, or the elements in a list (lists will be covered in the next lesson). This is often called a _for-each loop_ in other programming languages."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LfG8lf7dZRld",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Loop Table\n",
        "\n",
        "Run the code below and create a loop table. The columns should be `iteration`, `letter`, and `output`. \n",
        "\n",
        "In this `for` loop the _iteration variable_ is `letter`, we chose this name because each iteration of the loop will update the iteration variable with the next letter from the string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w-EF9QIFZQoU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "word = \"banana\"\n",
        "\n",
        "for letter in word:\n",
        "    print(letter)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nKi_ugKpZWeT",
        "colab_type": "text"
      },
      "source": [
        "### `while`\n",
        "\n",
        "The [`while`](https://docs.python.org/3/reference/compound_stmts.html#the-while-statement) loop is useful when you want to continue doing an action a certain condition is `True`, but you may not know how many times you'll need to complete that action. It is an example of a _sentinel-controlled loop_. As soon as the condition stops being true, the loop will terminate.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3PT3PuKYaeJl",
        "colab_type": "text"
      },
      "source": [
        "#### Exercise\n",
        "\n",
        "Take a look at the code cell below. Predict the output. Run the code cell to check your answer."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WmvqopE5Zo0h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "i = 0 # initialize loop control variable to the value of 0\n",
        "\n",
        "while i < 4: # loop is executed while value of loop control variable is less than 4\n",
        "    print(i)\n",
        "    i += 1 # increment the value of loop control variable by 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sEbXzbRnZ8dZ",
        "colab_type": "text"
      },
      "source": [
        "Here's the loop table for the above example:\n",
        "\n",
        "| Iteration | i    | i < 4 | Output   |\n",
        "| :-------- | :--- | :---- | :------- |\n",
        "| 1         | 0    | True  | 0        |\n",
        "| 2         | 1    | True  | 1        |\n",
        "| 3         | 2    | True  | 2        |\n",
        "| 4         | 3    | True  | 3        |\n",
        "| 5         | 4    | False | \\<None\\> |\n",
        "\n",
        "We can read the condition and execution of the `while` loop as _while condition is **true** do..._\n",
        "\n",
        "Below is another example of a `while` loop:\n",
        "This loop repeats until `again` is set to `False`. \n",
        "\n",
        "_Note the use of a helper function `play_again()` to randomly set again to `True` or `False`._  Be sure to run the code multiple times to see the random behavior in action."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sM2xS5_2aAeG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import random\n",
        "\n",
        "def play_again():\n",
        "    r = random.randint(0, 1)\n",
        "\n",
        "    return r == 0\n",
        "\n",
        "again = True\n",
        "while again:\n",
        "    print(\"Let's play a game!\")\n",
        "    print(\"...\")\n",
        "    again = play_again()\n",
        "\n",
        "print(\"Game Over!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0kJJa02Qynod",
        "colab_type": "text"
      },
      "source": [
        "This is a more typical usage of a while loop.  \n",
        "\n",
        "Here we check a variable we don't know the value of ahead of time to see if we should exit instead of iterating a fixed number of times."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qNSRJSKNaxiP",
        "colab_type": "text"
      },
      "source": [
        "## Blocks\n",
        "\n",
        "For iteration, a *block* is a section of code which is grouped together and intended to be executed if a certain condition is satisfied.\n",
        "\n",
        "Example:\n",
        "\n",
        "```python\n",
        "i = 0\n",
        "while i < 4:\n",
        "    # the code indented below block of code\n",
        "    multiple = i * 10\n",
        "    print(f\"{i} times 10 is {multiple}\")\n",
        "    i += 1\n",
        "```\n",
        "\n",
        "_In Python, just as with conditionals, a code block is indented (4 spaces)_.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BI-ihmVQ0uUg",
        "colab_type": "text"
      },
      "source": [
        "## Vocabulary\n",
        "\n",
        "Below are an explanation of various terms we will encounter in the curriculum and while writing code.\n",
        "\n",
        "| Term \t| Definition \t|\n",
        "|-\t|-\t|\n",
        "| **Loop** \t| A block of code designed to repeat \t|\n",
        "| **Iteration** \t| The process of repeating steps; commonly referred to as looping |\n",
        "| **Iteration Variable** \t| A variable created by the loop to either track the number of times the loop has <br> executed or the current element of a container \t|\n",
        "| **Counter Controlled Loop** \t| A loop which will iterate a specific number of times \t|\n",
        "| **Sentinel Controlled Loop** \t| A loop which is controlled by the truthiness of a variable or conditional expression\t|\n",
        "| **Loop Table** \t| A debugging/understanding technique for tracking each iteration of a loop and|\n",
        "| |each variable within that loop\t|\n",
        "| **`for` Loop** \t| A type of counter controlled loop in Python \t|\n",
        "| **`while` Loop** | A type of sentinel controlled loop in Python |\n",
        "| **`range`** | A function in Python which returns a sequence of numbers |\n",
        "| **Block** | A section of code that is a executed as a unit |"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nVuHAPvPPlbJ",
        "colab_type": "text"
      },
      "source": [
        "## Debugging Loops\n",
        "\n",
        "Now let's practice debugging _logical errors_ in loops."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7lHXxeGBS4zL",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Infinite Loops\n",
        "\n",
        "We intended the following code to print all the even numbers from 0 to 10, but instead it runs forever printing `0`.  Can you spot the problem?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bN3MmYoLVKpM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "num = 0\n",
        "while num <= 10:\n",
        "    print(num)\n",
        "\n",
        "num += 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gorr0tk9VvNh",
        "colab_type": "text"
      },
      "source": [
        "How to go about fixing this?  One way is to look at the output and look for a pattern, comparing it to the condition in the `while` loop.\n",
        "\n",
        "If you notice the loop is printing `num` and the value never changes from 0.  So `num` isn't changing it's never becoming greater than 10.\n",
        "\n",
        "Then we can look at the code and see that `num = num + 2` is not indented to be inside the loop.\n",
        "\n",
        "It's common when debugging a loop, to put `print` statements into the loop body to identify the values of variables and how they change as the loop continues."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fH9Qw9kVUljO",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Debugging Loops\n",
        "\n",
        "The following loop is intended to sum up all the numbers from 1 to 5, but it doesn't give the right answer.  How can we figure out what's wrong?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "30KMRY99YcHo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# initialize sum and counter\n",
        "sum = 0\n",
        "i = 1\n",
        "\n",
        "while i <= 5:\n",
        "    i = i + 1    # update counter\n",
        "    sum = sum + i\n",
        "\n",
        "print(f\"The Sum is {sum}\")  # It should be 1 + 2 + 3 + 4 + 5 = 15"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0t3HFr5QZPAo",
        "colab_type": "text"
      },
      "source": [
        "### Loop Tables for Debugging\n",
        "\n",
        "It's very helpful to build a table to figure out what is happening.  A loop table lets us mentally walk through each step in the process.\n",
        "\n",
        "| Iteration \t| i \t| sum \t|  i <= 5 \t|\n",
        "|-\t|-\t|-\t|-\t|\n",
        "| 1 \t| 2 \t| 2 \t| true \t| \n",
        "| 2 \t| 3 \t| 5 \t| true \t| \n",
        "| 3 \t| 4 \t| 9 \t| true \t| \n",
        "| 4 \t| 5 \t| 14 \t| true \t| \n",
        "| 5 \t| 6 \t| 20 \t| false \t| \n",
        "\n",
        "So if we look at this loop table, we can see that 1 is not getting added to sum in the 1st iteration and that 6 is getting into the arithmetic.  So if you do the `sum = sum + i` first in the loop you get the following, which works!\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hBho_PA4bWsd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# initialize sum and counter\n",
        "sum = 0\n",
        "i = 1\n",
        "\n",
        "while i <= 5:\n",
        "    sum = sum + i\n",
        "    i = i + 1    # update counter\n",
        "\n",
        "print(f\"The Sum is {sum}\")  # It should be 1 + 2 + 3 + 4 + 5 = 15"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5MeILJj_Z_Tb",
        "colab_type": "text"
      },
      "source": [
        "# Practice Problems"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gqqupA1CmKoo",
        "colab_type": "text"
      },
      "source": [
        "### Reversing a String\n",
        "\n",
        "Fill in the below function to take a string as a parameter and returns the reverse of the string. \n",
        "\n",
        "There are a set of tests following the function that will call your code and report any errors. Don't change them. They're there to help you check your solution."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yaESMjiRpKP3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def reverse_string(input_str):\n",
        "    answer = \"\"\n",
        "    # Your code goes here\n",
        "\n",
        "\n",
        "    #  End of your code\n",
        "    return answer\n",
        "\n",
        "# Tests below, do not change\n",
        "assert reverse_string(\"hello\") == \"olleh\", \"Cannot reverse 'hello'\"\n",
        "assert reverse_string(\"\") == \"\", \"When given an empty string it returns an empty string, but doesn't\"\n",
        "assert reverse_string(\"racecar\") == \"racecar\", \"Cannot reverse 'racecar'\"\n",
        "assert reverse_string(\"12345\") == \"54321\", \"Cannot reverse 12345\"\n",
        "\n",
        "# If the program gets here, the code works!\n",
        "print(\"Your solution works!\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_cL72kUHtyUR",
        "colab_type": "text"
      },
      "source": [
        "We have provided [one possible solution](https://repl.it/@CheezItMan/reversestring).   \n",
        "\n",
        "If yours is different, that's okay!  But take a moment to think about any differences you notice."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sJGTTlRkqxwX",
        "colab_type": "text"
      },
      "source": [
        "### Totaling Even Numbers\n",
        "\n",
        "Fill in the function below, which takes an argument `num` and returns the sum of all the even numbers from 0 to `num`, inclusive.  Like with the previous problem there are tests at the bottom to verify your answer like the previous problem."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JXHxBq6BrM-O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def total_even_numbers(num):\n",
        "    sum = 0\n",
        "    # Your code goes here\n",
        "\n",
        "\n",
        "    # End of your code\n",
        "    return sum\n",
        "\n",
        "# Tests below, do not change\n",
        "assert total_even_numbers(6) == 12, f\"Reported {total_even_numbers(6)} for total_even_numbers(6) instead of 12\"\n",
        "assert total_even_numbers(0) == 0, f\"Reported {total_even_numbers(0)} for total_even_numbers(0) instead of 0\"\n",
        "assert total_even_numbers(1) == 0, f\"Reported {total_even_numbers(1)} for total_even_numbers(1) instead of 0\"\n",
        "assert total_even_numbers(15) == 56, f\"Reported {total_even_numbers(15)} for total_even_numbers(15) instead of 56\"\n",
        "\n",
        "# If the program gets here, the code works!\n",
        "print(\"Your solution works!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NLj_HzSGtMsL",
        "colab_type": "text"
      },
      "source": [
        "We have provided [one possible solution](https://repl.it/@CheezItMan/totalevennums). \n",
        "\n",
        "Again, if yours is different, that's okay! There are many ways to solve the same problem. Think about any differences, and try to come up with an additional solution of your own!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OKyiwayVQAQX",
        "colab_type": "text"
      },
      "source": [
        "# Project: Rock, Paper, Scissors v3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fXXI8rrxbiQP",
        "colab_type": "text"
      },
      "source": [
        "Throughout this course we will continue working with the **Rock, Paper, Scissors**. Here's the third version of the program:\n",
        "\n",
        "Leveraging your learnings from the notes you read (use at least one loop), write a program that does the following with a `while` loop:\n",
        "\n",
        "* Randomly select Rock, Paper, Scissors for `player1` and `player2`.\n",
        "\n",
        "* Determine the winner using the Rock Paper Scissors function you wrote in the [previous lesson on functions](https://github.com/Ada-Developers-Academy/ada-build/blob/master/intro-to-python/04_functions.ipynb).\n",
        "\n",
        "* Randomly set the variable `play` to `True` or `False`. \n",
        "    - If `play` is set to `True`, another round of Rock, Paper, Scissors should begin\n",
        "    - If `play` is set to `False`, `\"Thank you for playing!\"` should be output and game play should end.\n",
        "\n",
        "* Once you have a working program, try to rewrite your code to use a `for` loop to play the game a specific number of times.\n",
        "\n",
        "\n",
        "Example output:\n",
        "\n",
        "\n",
        "```\n",
        "Welcome to Rock, Paper, Scissors!\n",
        "\n",
        "-----\n",
        "\n",
        "Player 1 chose rock\n",
        "Player 2 chose paper\n",
        "\n",
        "Player 2 wins\n",
        "\n",
        "-----\n",
        "\n",
        "Player 1 chose scissors\n",
        "Player 2 chose scissors\n",
        "\n",
        "It's a tie!\n",
        "\n",
        "-----\n",
        "\n",
        "Thank you for playing!\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OYnd4Yk2SV9q",
        "colab_type": "text"
      },
      "source": [
        "We can start with the following partial implementation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b9bHkHGzbGQ-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import random\n",
        "\n",
        "def choose_rps():\n",
        "    \"output: randomly returns rock, paper, or scissors\"\n",
        "    r = random.randint(0,2)\n",
        "    if r == 0:\n",
        "        return \"rock\"\n",
        "    elif r == 1:\n",
        "        return \"scissors\"\n",
        "    else:\n",
        "        return \"paper\"\n",
        "\n",
        "\n",
        "# complete the program here\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NRghsZyvE1J2",
        "colab_type": "text"
      },
      "source": [
        "Here's a sample [solution](https://repl.it/join/pfyodgpf-beccaelenzil) for the `while` loop version. \n",
        "\n",
        "Be sure to try using a `for` loop as well!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6oUuvhand2KI",
        "colab_type": "text"
      },
      "source": [
        "# Extra Practice\n",
        "\n",
        "For extra practice, you can complete [these loop exercises](https://colab.research.google.com/drive/1_9HfdNBK6q9prjPEDUpqpJ-X5SGqgBYW?usp=sharing)."
      ]
    }
  ]
}