Copy_of_03_branching_katina.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of 03_branching-katina.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [
        "NrNnR9DVj36W"
      ],
      "toc_visible": true,
      "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/kmcarranza/Pre-Bootcamp/blob/main/Copy_of_03_branching_katina.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNfppVGHsyXO"
      },
      "source": [
        "**Branching**\n",
        "\n",
        "_Ada Build - Intro to Python - Lesson 3_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qV6EZua7swCh"
      },
      "source": [
        "# Learning Goals\n",
        "\n",
        "By the end of this lesson we will be able to:\n",
        "\n",
        "- Understand and use relational operators.\n",
        "- Understand and be able to use conditional statements.\n",
        "- Understand the control flow of a program.\n",
        "- Identify and debug simple logic errors."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zlyqQF1XuanM"
      },
      "source": [
        "# Notes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avOzPJaSgRId"
      },
      "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": "8Naa68i5ublL"
      },
      "source": [
        "## [Relational Operators](https://docs.python.org/3/reference/expressions.html?highlight=boolean#value-comparisons)\n",
        "\n",
        "Relational operators allow us to compare two or three values.  Below is a list of different relational operators:\n",
        "\n",
        "| __Operator__ | __Description__ | __Example__ | __Result__ |\n",
        "| :--- | :--- | :--- | :--- |\n",
        "| `==` | equals | `1 + 1 == 2` | `True` |\n",
        "| `!=` | does not equal | `3.2 != 2.5` | `True` |\n",
        "| `<` | less than | `10 < 5 ` | `False` |\n",
        "| `>` | greater than | `10 > 5` | `True` |\n",
        "| `<=` | less than or equal to | `126 <= 100` | `False` |\n",
        "| `>=` | greater than or equal to | `5.0 >= 5.0` | `True` |\n",
        "\n",
        "- In Python, we can use relational operators on all numbers and strings. Additionally we can use equals and does not equal on lists and dictionaries. (Note: We'll learn more about Lists and Dictionaries later in the Build curriculum.)\n",
        "- The opposite of `>` (greater than) is `<=` (less than or equal to). Similarly, the opposite of `<` (less than) is `>=` (greater than or equal to).\n",
        "- `=` is the assignment operator, which is very different than `==` which is the **equality operator**.\n",
        "- The result of a relational operator is either `True` or `False`, also known as a _boolean_.\n",
        "- We can chain relational operators together like 0 < x <= 100 or 10 > x > 1."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y7cEY4qTvkld"
      },
      "source": [
        "#### Boolean values\n",
        "\n",
        "- The two possible values of the boolean data type (`bool`) are `True` and `False`\n",
        "\n",
        "- A non-boolean value that evaluates to `False`, is called \"falsey\", also sometimes \"falsy\". Below is a list of all \"falsy\" values in Python. (Note: We will cover these terms moving forward in the Build curriculum) \n",
        "\n",
        "  - **Sequences and Collections:**\n",
        "    - Empty lists `[]`\n",
        "    - Empty tuples `()`\n",
        "    - Empty dictionaries `{}`\n",
        "    - Empty sets `set()`\n",
        "    - Empty strings `\"\"`\n",
        "    - Empty ranges `range(0)`\n",
        "  - **Numbers**\n",
        "    - Zero of any numeric type.\n",
        "    - Integer: 0\n",
        "    - Float: 0.0\n",
        "    - Complex: 0j\n",
        "  - **Constants**\n",
        "    - None\n",
        "    - False\n",
        "- A non-boolean value that evaluates to `True`, is called \"truthy\"\n",
        "  - Everything not included in the \"falsy\" list above is \"truthy\" in Python.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ymX8uKAgXZb"
      },
      "source": [
        "#### Exercise\n",
        "\n",
        "- Using the function `bool` we can see the way that different values evaluate to `True` or `False`.\n",
        "\n",
        "- Make a prediction about each of the expressions below.\n",
        "\n",
        "- Uncomment and recomment each of the expressions below to evaluate their `bool` value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mWHrEQ2MgL2k"
      },
      "source": [
        "#bool(0)\n",
        "#bool(\"\")\n",
        "#bool(\"hello\")\n",
        "#bool(1)\n",
        "#bool(None)\n",
        "#bool([])\n",
        "#bool([1,2,3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Thd_ZbCOyf9o"
      },
      "source": [
        "## [Conditionals](https://docs.python.org/3/tutorial/controlflow.html#if-statements)\n",
        "\n",
        "Conditional statements allow our programs to take different paths based on different inputs. You have already seen some version of conditional statements if you have ever seen a flow diagram like the one below.\n",
        "\n",
        "![flow diagram](https://drive.google.com/uc?id=1OTo3lOnq8MwT7ypjyq_k8DPkVXXBrmKF)\n",
        "\n",
        "To create conditional statements we use `if`, `elif`, and `else` to control the flow of a program. \n",
        "- It is important to properly indent conditional statements. In Python, indentation _is required_ for a program to execute.\n",
        "- `elif` comes from the contraction of else if. We can just read it as else if, but many people just say el-if.\n",
        "- A colon `:` must be used after the boolean expression and `else`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AUV7ygjVYpOL"
      },
      "source": [
        "### Syntax\n",
        "\n",
        "```python\n",
        "if <boolean expression>:\n",
        "    # note the colon \n",
        "    # conditional body\n",
        "    # this code only executes if the <boolean expression> evaluates as true\n",
        "    # the conditional body is indented one more than the if statement\n",
        "```\n",
        "\n",
        "```python\n",
        "if <boolean expression>:\n",
        "    # conditional body\n",
        "    # the conditional body is indented one more than the if, elif, and else statements\n",
        "elif <boolean expression>:\n",
        "    # conditional body\n",
        "    # the conditional body is indented one more than the if, elif, and else statements\n",
        "else:\n",
        "    # else body\n",
        "    # the else body is indented one more than the if, elif, and else statements\n",
        "```\n",
        "\n",
        "```python\n",
        "if <boolean expression>:\n",
        "    # conditional body\n",
        "    # the conditional body is indented one more than the if, elif, and else statements\n",
        "else:\n",
        "    # else body\n",
        "    # the else body is indented one more than the if, elif, and else statements\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Om-VhoFmN9iE"
      },
      "source": [
        "#### Blocks\n",
        "\n",
        "Each indented section of code (the code under the `if`, `elif`, and `else`) is called a _block_. A block of code in a conditional control structure describes the behavior the code performs for each different condition."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kOxS6FJYY_Vw"
      },
      "source": [
        "### Exercise: Conditionals Syntax\n",
        "\n",
        "- Make a prediction about what the code will output. \n",
        "- Run the code to check your prediction.\n",
        "- Change the value of `temp` to explore how it changes the output.\n",
        "\n",
        "_You can click on the links for [a livecode video of this exercise](https://adaacademy.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=4ad7204f-1103-4d4f-8a99-acb0012da32f)._"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qiO6AUneZjAk"
      },
      "source": [
        "# Practice #1\n",
        "temp = 40\n",
        "\n",
        "if temp < 50:\n",
        "    print(\"It's a bit chilly outside\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I4KobyT0aTXO"
      },
      "source": [
        "# Practice #2\n",
        "temp = 100\n",
        "\n",
        "if temp < 50:\n",
        "    print(\"It's a bit chilly outside\")\n",
        "else:\n",
        "    print(\"It's pleasant outside\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hRtdoQdVZoO8"
      },
      "source": [
        "# Practice #3\n",
        "temp = 0\n",
        "\n",
        "if temp == 100:\n",
        "    print(\"It's ONE HUNDRED DEGREES outside!\")\n",
        "elif temp < 100:\n",
        "    print(\"It's warm outside\")\n",
        "elif temp < 50:\n",
        "    print(\"It's a bit chilly outside\")  \n",
        "elif temp == 0:\n",
        "    print(\"It's ZERO DEGREES outside!\")    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LBij5JT8bauV"
      },
      "source": [
        "**Consider** Why does the last code cell above **not** print ```It's ZERO DEGREES outside```? What could we change to make it print this statement.\n",
        "\n",
        "Think about it for a minute and then look at the code below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-0dVY5v-bnTc"
      },
      "source": [
        "temp = 0\n",
        "\n",
        "if temp == 0:\n",
        "    print(\"It's ZERO DEGREES outside!\") \n",
        "elif temp == 100:\n",
        "    print(\"It's ONE HUNDDRED DEGREES outside!\")\n",
        "elif temp < 50:\n",
        "    print(\"It's a bit chilly outside\") \n",
        "elif temp < 100:\n",
        "    print(\"It's warm outside\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1fttbcPz-XVv"
      },
      "source": [
        "## Debugging Logic Errors: Black Jack\n",
        "\n",
        "The error we encountered in the temperatures exercise above is considered a _Logic Error_. Logic errors are a bug that cause our program to behave incorrectly. They may result in unintended or undesired output. \n",
        "\n",
        "### Logic Errors & Syntax Errors\n",
        "\n",
        "We have already encountered one category of errors which prevent programs from running: syntax errors. We know that if we had left the `:` off of the `if` statement in Practice #3, the program would have given an error and failed to execute. Logic errors are different in that the program runs, but performs contrary to expectations. For example, in Practice #3 the program runs but prints \"It's warm outside\" instead of \"It's ZERO DEGREES outside!\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mWNPbG4r_Q3M"
      },
      "source": [
        "### Exercise\n",
        "\n",
        "In black jack, you \"bust\" if your cards total over 21. The code cell below should print \n",
        "* `Bust!` if `score` is greater than 21.\n",
        "* `Black Jack!` if `score` equals 21.\n",
        "* `Great Hand!` if `score` is greater than or equal to 17, but less than 21.\n",
        "* `Hit Me!` if `score` is less than 17\n",
        "\n",
        "(_`Hit Me!` means give me another card_)\n",
        "\n",
        "Currently, our `score` is `21` but the code block mistakenly outputs `Bust!`. Find and fix the error and then review the solution code below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VLLbDtip-5_Y"
      },
      "source": [
        "score = 21\n",
        "\n",
        "if score < 17:\n",
        "    print(\"Hit Me!\")\n",
        "elif score < 21:\n",
        "    print(\"Great Hand\")\n",
        "elif score >= 21:\n",
        "    print(\"Bust!\")\n",
        "else:\n",
        "    print(\"Black Jack!\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B1fQ1bqMBC3c"
      },
      "source": [
        "#### Solutions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VA9d-I2T0149"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4p2LHK8nBLo7"
      },
      "source": [
        "Solution 1: change the `score >= 21` to `score > 21`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bnt3Q3FmBGFs"
      },
      "source": [
        "score = 21\n",
        "\n",
        "if score < 17:\n",
        "    print(\"Hit Me!\")\n",
        "elif score < 21:\n",
        "    print(\"Great Hand!\")\n",
        "elif score > 21:\n",
        "    print(\"Bust!\")\n",
        "else:\n",
        "    print(\"Black Jack!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SnyLK9tsBZ43"
      },
      "source": [
        "Solution 2: Consider changing the design of the conditional to test for a score of 21 first."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qKwjm7jaBRbU"
      },
      "source": [
        "score = 21\n",
        "\n",
        "if score == 21:\n",
        "    print(\"Black Jack!\")\n",
        "elif score < 17:\n",
        "    print(\"Hit Me!\")\n",
        "elif score < 21:\n",
        "    print(\"Great Hand!\")\n",
        "else:\n",
        "    print(\"Bust!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WbYEKRq6FweT"
      },
      "source": [
        "##### Musings on the Solutions\n",
        "\n",
        "Solution 1 is a minimal change, but fails to explicitly call out the most specific case, leaving it to be implied by the `else`. The reader must recognize that the only case that can reach the `else` is a Black Jack. It also mixes greater than and less than comparisons in its `elif` clauses which can further complicate understanding.\n",
        "\n",
        "Was it obvious to you that the only case that triggered Black Jack was when the score was 21? Did you have to think about it a little? What if you saw this code again in six months? Would it still be obvious?\n",
        "\n",
        "Solution 2 explicitly calls out the most specific case right from the start, and builds the `elif` cases using only less than checks, making it easier to reason about the cases that each handles. Finally, the `else` still handles a reasonably sized class of conditions, those being larger than 21, building naturally from the previous `elif` statements that each handled cases with larger boundary values. Solution 2 is arranged to benefit the understanding of subsequent readers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0QxYUqu7-b9P"
      },
      "source": [
        "## More Conditionals Practice"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d0BD9P8ChPRZ"
      },
      "source": [
        "### Exercise: Conditionals without relational operators.\n",
        "\n",
        "As we mentioned above, all non boolean data-types evaluate to \"Truthy\" or \"Falsey\" and as such can be used in a conditional control structure as shown below.\n",
        "\n",
        "- Uncomment and recomment each of the `x` assignment statements to see how different values of `x` change the output."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MQ1v6t3UhrYG"
      },
      "source": [
        "#x = 1\n",
        "#x = 0\n",
        "#x = None\n",
        "#x = \"\"\n",
        "#x = \"hi\"\n",
        "\n",
        "if x:\n",
        "    print(f'x = {x}, and therefore it\\'s truthy')\n",
        "else:\n",
        "    print(f\"x = {x}, and therefore it's falsey\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7viQ20CWGeaP"
      },
      "source": [
        "Note:\n",
        "\n",
        "The statement under the `if` clause uses the escaped apostrophe `\\'` because the string is in single quotes.\n",
        "\n",
        "The statement under `else` does not require an escaped apostrophe because the string is in double quotes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "itUQJR20d9hb"
      },
      "source": [
        "### Exercise: Divisible by 5\n",
        "\n",
        "Complete the program below by replacing the `...` with code such that that the program outputs `\"x is divisible by 5\"` or `\"x is not divisible by 5\"` correctly (with the value for x in place of x).\n",
        "\n",
        "_Hint: the modulus operator `%` will be helpful with this problem._\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Np3T3KJ4jJ_y"
      },
      "source": [
        "x = 5\n",
        "\n",
        "if x % 5 == 0:\n",
        "    print(f\"{x} is divisible by 5\")\n",
        "else:\n",
        "    print(f\"{x} is not divisible by 5\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wVtZ9K-ZT8XL"
      },
      "source": [
        "_You can click on the links for [a solution in repl.it](https://repl.it/@BeccaElenzil/divisible-by-5#main.py)._"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CjsUdy5Tx_C1"
      },
      "source": [
        "## Logical operators\n",
        "\n",
        "Logical operators allow us to combine or modify boolean expressions.\n",
        "\n",
        "| Operator | Example | Result |\n",
        "| :--- | :--- | :--- |\n",
        "| `and` | `(2 == 3) and (-1 < 5)` | `False` |\n",
        "| `or` | `(2 == 3) or (-1 < 5)` | `True` |\n",
        "| `not` | `not (2 == 3)` | `True` |\n",
        "\n",
        "---\n",
        "\n",
        "| `p` | `q` | `p and q` | `p or q` |\n",
        "| :--- | :--- | :--- | :--- |\n",
        "| `True` | `True` | `True` | `True` |\n",
        "| `True` | `False` | `False` | `True` |\n",
        "| `False` | `True` | `False` | `True` |\n",
        "| `False` | `False` | `False` | `False` |\n",
        "\n",
        "---\n",
        "\n",
        "| `p` | `not p` |\n",
        "| :--- | :--- |\n",
        "| `True` | `False` |\n",
        "| `False` | `True` |\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LMkis-KMcO92"
      },
      "source": [
        "### Exercise\n",
        "\n",
        "- Consider an example where you need a good night sleep _and_ a cup of coffee to have a productive day. \n",
        "\n",
        "- Note how the code below represents this situation using the `and` operation and boolean values for `coffee` and `good_sleep`.\n",
        "\n",
        "- Uncomment the different pairs of values for `coffee` and `good_sleep` in the code below to see the output for the different combinations.\n",
        "\n",
        "| |coffee = True|coffee = False|\n",
        "|---|---|---|\n",
        "|**good_sleep = True**|\"Great day!\"|\"Eh.\"|\n",
        "|**good_sleep = False**|\"Eh.\"|\"Eh.\"|"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "57ynHxBIcNnw"
      },
      "source": [
        "# coffee = True\n",
        "# good_sleep = True\n",
        "\n",
        "# coffee = False\n",
        "# good_sleep = True\n",
        "\n",
        "# coffee = True\n",
        "# good_sleep = False\n",
        "\n",
        "# coffee = False\n",
        "# good_sleep = False\n",
        "\n",
        "if coffee and good_sleep:\n",
        "    print(\"It's going to be a great day!\")\n",
        "else:\n",
        "    print(\"Eh. Today's going to be a wash.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrNnR9DVj36W"
      },
      "source": [
        "# Practice Problems\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZAjNFyY1kw8L"
      },
      "source": [
        "## 1. Diagram → Code\n",
        "\n",
        "Use your new knowledge of conditionals to recreate this flow control diagram using conditionals in code.  \n",
        "\n",
        "![flow control assignment](https://drive.google.com/uc?id=1ADe_klzPOzCIKg9piGqlENhU2b1l01zn)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rp0updFyk7qD"
      },
      "source": [
        "x = ...\n",
        "y = ..."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NoORB9lBILhB"
      },
      "source": [
        "_You can click on the links for [a solution in repl.it](https://repl.it/@BeccaElenzil/branching-diagram#main.py) and a [livecode video solution](https://adaacademy.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=eee29d97-f6ec-426c-9ee6-acb00004e4d5)._"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MHFdSGpVlDtB"
      },
      "source": [
        "## 2. Code → Diagram\n",
        "\n",
        "Now we will go the other way! Using the code below create the flow control diagram that would represent it. We can assume that `number_of_sides` data is provided prior to the conditional execution either through user input or through an assignment statement.\n",
        "\n",
        "```python\n",
        "if number_of_sides == 1:\n",
        "    print(\"You've got a line\")\n",
        "elif number_of_sides == 2:\n",
        "    print(\"I'm not really sure what you have\")\n",
        "elif number_of_sides == 3:\n",
        "    print \"You've got a triangle\"\n",
        "elif number_of_sides == 4:\n",
        "    print(\"You've got some sort of quadrilateral\")\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k-m0TkMplpsq"
      },
      "source": [
        "## 3. Diagram and Output Prediction\n",
        "\n",
        "Read the code in each section, draw a corresponding flow chart and then predict the output. Check your answers by running the code.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w7O70QA7l601"
      },
      "source": [
        "# problem 1\n",
        "cookies = True\n",
        "cake = False\n",
        "\n",
        "if cookies:\n",
        "    print(\"OMG COOKIEZ\")\n",
        "\n",
        "if cake:\n",
        "    print(\"OMG CAKE!\")\n",
        "else:\n",
        "    print(\"WHATEVZ DESSERTZ.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E3V8LQh5mVC3"
      },
      "source": [
        "# problem 2\n",
        "person_age = 55\n",
        "ada_age = 6\n",
        "\n",
        "if person_age < ada_age:\n",
        "    print(\"This person is younger\")\n",
        "elif ada_age < person_age:\n",
        "    print(\"Ada is younger\")\n",
        "else:\n",
        "    print(\"They’re the same!\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nh2U8d9Nmuwi"
      },
      "source": [
        "# problem 3\n",
        "pet = \"cat\"\n",
        "food = \"ice cream\"\n",
        "\n",
        "if pet == \"cat\":\n",
        "    print(\"here kitty\")\n",
        "elif pet == \"dog\":\n",
        "    print(\"woof\")\n",
        "else:\n",
        "    print(\"some other sound\")\n",
        "\n",
        "if food == \"broccoli\":\n",
        "    print(\"eh.\")\n",
        "elif food == \"ice cream\":\n",
        "    print(\"yum\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i7_DM30inAZB"
      },
      "source": [
        "# problem 4\n",
        "x = 7\n",
        "y = 7\n",
        "\n",
        "if x >= y:\n",
        "    if x > y:\n",
        "        print(\"x is bigger\")\n",
        "    else:\n",
        "        print(\"x = y\")\n",
        "else:\n",
        "    print(\"y is bigger\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vB4v8MUMnTD_"
      },
      "source": [
        "# problem 5\n",
        "x = 7\n",
        "y = 7\n",
        "\n",
        "if x > y or x == y:\n",
        "    if x > y:\n",
        "        print(\"x is bigger\")\n",
        "    else:\n",
        "        print(\"x = y\")\n",
        "else:\n",
        "    print(\"y is bigger\")\n",
        "      "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e3zazj6qnkNR"
      },
      "source": [
        "# problem 6\n",
        "x = 7\n",
        "y = 7\n",
        "\n",
        "if x >= y:\n",
        "    print(\"x is bigger\")\n",
        "else:\n",
        "    print(\"y is bigger\")\n",
        "\n",
        "if x == y:\n",
        "    print(\"x = y\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ee35HN2sn6Ll"
      },
      "source": [
        "# Project: Rock, Paper, Scissors\n",
        "\n",
        "The script below gives the correct response for a few cases in the game of **Rock, Paper, Scissors.** Play with this code a bit to get a feel for how it works. [Here are the rules for the game of rock, paper, scissors.](https://www.wrpsa.com/the-official-rules-of-rock-paper-scissors/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IYK6kJPfofbl"
      },
      "source": [
        "player1 = 'rock'\n",
        "player2 = 'paper' \n",
        "\n",
        "if player1 == 'paper' and player2 == 'paper':\n",
        "    print('It\\'s a tie!')\n",
        "elif player2 == 'rock':\n",
        "    if player1 == 'scissors':\n",
        "        print('Player 2 won!')\n",
        "    else:\n",
        "        print('Player 1 won!')\n",
        "else:\n",
        "    print('It\\'s a tie!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S_ckag6Voqr-"
      },
      "source": [
        "Now create a program that gives the correct response for all cases in the game of **Rock, Paper, Scissors.** You should write your code in the code block below.\n",
        "- There are 9 different input cases summarized in the table below.\n",
        "- Create a flow chart to outline the logic.\n",
        "- There is more than one way to implement this program.\n",
        "- Consider: How could you use nested control structures as in Problems 3.4, 3.5, and 3.6 in the above practice problems?\n",
        "\n",
        "\n",
        "|Player 1|Player 2|Winner|\n",
        "|---|---|---|\n",
        "|Rock|Rock|Tie|\n",
        "|Paper|Paper|Tie|\n",
        "|Scissors|Scissors|Tie|\n",
        "|Rock|Paper|Player 2|\n",
        "|Rock|Scissors|Player 1|\n",
        "|Paper|Rock|Player 1|\n",
        "|Paper|Scissors|Player 2|\n",
        "|Scissors|Rock|Player 2|\n",
        "|Scissors|Paper|Player 1|\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z7hyyo8Jorat"
      },
      "source": [
        "# complete game of rock, paper, scissors\n",
        "\n",
        "player1 = 'scissors'\n",
        "player2 = 'scissors' \n",
        "\n",
        "# Tie\n",
        "if player1 == 'rock' and player2 == 'rock':\n",
        "    print('It\\'s a tie!')\n",
        "elif player1 == 'paper' and player2 == 'paper':\n",
        "    print('It\\'s a tie!')\n",
        "elif player1 == 'scissors' and player2 == 'scissors':\n",
        "    print('It\\'s a tie!')\n",
        "# player 1 = rock\n",
        "elif player1 == 'rock' and player2 == 'paper':\n",
        "        print('Player 2 won!')\n",
        "elif player1 == 'rock' and player2 == 'scissors':\n",
        "        print('Player 1 won!')\n",
        "#player 1 = paper\n",
        "elif player1 == 'paper' and player2 == 'rock':\n",
        "        print('Player 1 won!')\n",
        "elif player1 == 'paper' and player2 == 'scissors':\n",
        "        print('Player 2 won!')\n",
        "#player 1 = scissors\n",
        "elif player1 == 'scissors' and player2 == 'rock':\n",
        "        print('Player 2 won!')\n",
        "elif player1 == 'scissors' and player2 == 'paper':\n",
        "        print('Player 1 won!')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SiAbXIacYEcb"
      },
      "source": [
        "_You can click on the links for [a solution in repl.it](https://repl.it/@BeccaElenzil/RPS-v1#main.py) and a [livecode video solution](https://adaacademy.hosted.panopto.com/Panopto/Pages/Viewer.aspx?pid=b0bcbc46-5ded-4eca-94a8-acaf0180c797)._"
      ]
    }
  ]
}