control_flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0",
   "metadata": {},
   "source": [
    "# Control flow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1",
   "metadata": {},
   "source": [
    "# Table of contents\n",
    "- [References](#References)\n",
    "- [Conditionals](#Conditionals)\n",
    "- [The `while` loop](#The-while-loop)\n",
    "- [The `for` loop](#The-for-loop)\n",
    "    - [The `enumerate` built-in](#The-enumerate-built-in)\n",
    "    - [The `range` built-in](#The-range-built-in)\n",
    "- [Warm-up exercises 👈 **solve these first**](#Warm-up-exercises)\n",
    "- [Nested loops](#Nested-loops)\n",
    "- [Altering loops](#Altering-loops)\n",
    "    - [`if` statement inside `for`/`while`](#if-statement-inside-for/while)\n",
    "    - [The `break` keyword](#The-break-keyword)\n",
    "    - [The `continue` keyword](#The-continue-keyword)\n",
    "    - [`else` after a `for`/`while`](#else-after-a-for/while)\n",
    "- [Exceptions](#Exceptions)\n",
    "    - [The `try-except` block](#The-try-except-block)\n",
    "- [Exercises](#Exercises)\n",
    "  - [Find the factors 🌶️](#Find-the-factors-🌶️)\n",
    "  - [Find the pair 🌶️](#Find-the-pair-🌶️)\n",
    "    - [Part 1](#Part-1)\n",
    "    - [Part 2](#Part-2)\n",
    "  - [Cats with hats 🌶️🌶️](#Cats-with-hats-🌶️🌶️)\n",
    "  - [Toboggan trajectory 🌶️🌶️🌶️](#Toboggan-trajectory-🌶️🌶️🌶️)\n",
    "      - [Part 1 🌶️](#Part-1-🌶️)\n",
    "      - [Part 2 🌶️🌶️](#Part-2-🌶️🌶️)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3",
   "metadata": {},
   "source": [
    "From \"Python 4 Everybody\" online tutorial:\n",
    "\n",
    "- [Conditionals](https://www.py4e.com/html3/03-conditional)\n",
    "- [Loops and iterations](https://www.py4e.com/html3/05-iterations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5",
   "metadata": {},
   "source": [
    "Python [supports](./basic_datatypes.ipynb#Comparison-operators) different comparison expressions. They return either `True` or `False`.\n",
    "\n",
    "We use these results to evaluate **conditional statements**, and branch have our program behave differently."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6",
   "metadata": {},
   "source": [
    "The main conditional is the `if-elif-else` block:\n",
    "\n",
    "```python\n",
    "if condition:\n",
    "    if sub_condition:\n",
    "        sub_statement\n",
    "        if sub_sub_condition:\n",
    "            sub_sub_statement\n",
    "elif another_condition:\n",
    "    other_statements\n",
    "else:\n",
    "    suite\n",
    "```\n",
    "\n",
    "- When a condition is false, the entire block of statements just below are **skipped**\n",
    "- The `elif` and `else` sections are **optional**\n",
    "- The block of statements under `else` is executed **only if all the conditions above are false**\n",
    "- You can nest conditionals, but try to avoid too many branches for both readability and performance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Case 1\n",
    "if True:\n",
    "    print(\"If is True\")\n",
    "elif False:\n",
    "    print(\"This won't be printed\")\n",
    "else:\n",
    "    print(\"This won't be printed either\")\n",
    "\n",
    "# Case 2\n",
    "if False:\n",
    "    print(\"This won't be printed\")\n",
    "elif True:\n",
    "    print(\"Elif is True\")\n",
    "else:\n",
    "    print(\"This won't be printed\")\n",
    "    \n",
    "# Case 3\n",
    "if False:\n",
    "    print(\"This won't be printed\")\n",
    "elif False:\n",
    "    print(\"This won't be printed either\")\n",
    "else:\n",
    "    print(\"Only statement under else is executed\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8",
   "metadata": {
    "tags": []
   },
   "source": [
    "## The `while` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9",
   "metadata": {},
   "source": [
    "`while` loops repeat a block of code until some condition remains true.\n",
    "\n",
    "1. The `while` **statement** starts with the `while` (reserved) keyword, followed by a `test_condition`, and must end with a colon (`:`)\n",
    "2. The **loop body** contains the lines of code that get repeated. Each line must be indented, or you will get a syntax error\n",
    "3. The **else** clause is optional, and is executed when the `test_condition` becomes false.\n",
    "\n",
    "\n",
    "```python\n",
    "while test_condition:\n",
    "    body\n",
    "else:\n",
    "    suite\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10",
   "metadata": {},
   "source": [
    "A very simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "n = 1\n",
    "while n < 5:\n",
    "    print(n)\n",
    "    n = n + 1\n",
    "else:\n",
    "    print(\"While loop is over\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12",
   "metadata": {},
   "source": [
    "First, `n` is initialized to 1.\n",
    "Then the `while` loop starts and tests the condition `n < 5`.\n",
    "Since it's `True`, it enters the loop body, where it prints the number and increment `n` by 1.\n",
    "As soon as `n = 5`, the `n < 5` evaluates to `False`, and the loop stops.\n",
    "The only statement executed after the loop is over is the `print` statement in the `else` clause.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "If you are not careful, you can create an **infinite loop**: it happens when your condition is always `True`.\n",
    "The above example can be easily turn into an infinite loop:\n",
    "\n",
    "```python\n",
    "n = 1\n",
    "while n < 5:\n",
    "    print(n)\n",
    "```\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Note</b></h4>\n",
    "    Infinite loops are not inherently bad. They can be the precise thing you need sometimes. For example, when you need to continously perform a check and perform the same set of steps.\n",
    "</div>\n",
    "\n",
    "But in that case you would write something like:\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    # do something indefinitely\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14",
   "metadata": {
    "tags": []
   },
   "source": [
    "## The `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15",
   "metadata": {},
   "source": [
    "In Python, an **iterable** is an **object** capable of returning its members one at a time.\n",
    "It's a generic object with this particular property.\n",
    "\n",
    "Iterable objects are: lists, strings, `range()` objects, file objects and many more.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Important</b></h4>\n",
    "    The main purpose of the <code>for</code> loop is to access all the elements of an iterable\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16",
   "metadata": {},
   "source": [
    "In other languages (C++, Java or JavaScript), a `for` loop is more similar to `while` in Python. For example, the C++ loop\n",
    "\n",
    "```cpp\n",
    "for (unsigned int i = 0; i < 10; ++i) {\n",
    "    std::cout << i << std::endl;\n",
    "}\n",
    "```\n",
    "\n",
    "could be translated to Python as we've seen before\n",
    "\n",
    "```python\n",
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i = i + 1\n",
    "```\n",
    "\n",
    "In the C++ code, the looping variable `i` is automatically discarded when the loop is over. In Python, `i` will retain the **last value** that was assigned inside the `while` body.\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "The syntax of a `for` loop is\n",
    "\n",
    "```python\n",
    "for target in iterable:\n",
    "    body\n",
    "[else:\n",
    "   suite]\n",
    "```\n",
    "\n",
    "1. The `for` **statement** starts with the keyword `for`, followed by a **membership expression**, and ends with a colon (`:`)\n",
    "2. The **loop body** contains the code to be repeated, in the same way as the `while` loop\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for letter in \"Python\":\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18",
   "metadata": {},
   "source": [
    "The loops runs until there are letters in the string `'Python'`, as strings are iterable.\n",
    "Doing the same with a `while` loop would be just more complex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "word = \"Python\"\n",
    "index = 0\n",
    "\n",
    "while index < len(word):\n",
    "    print(word[index])\n",
    "    index = index + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20",
   "metadata": {},
   "source": [
    "Why writing six lines of code when we can do the same with just two?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21",
   "metadata": {},
   "source": [
    "### The `enumerate` built-in\n",
    "Often, you need to iterate through a collection and operate on each value while keeping track of the *position* (index) of the loop.\n",
    "In other languages, you would define an index variable and increment it at every loop. While this is possible in Python, as shown in the previous code snippet, we usually prefer to use the built-in `enumerate` function, documented [here](https://docs.python.org/3/library/functions.html#enumerate).\n",
    "\n",
    "This function takes any iterable object and returns a new iterable that yields a tuple `(index, value)` when you iterate over it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22",
   "metadata": {},
   "outputs": [],
   "source": [
    "for index, letter in enumerate(\"Python\"):\n",
    "    print(index, letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23",
   "metadata": {},
   "source": [
    "### The `range` built-in\n",
    "\n",
    "Sometimes you want to loop over a range of numbers.\n",
    "Python has the built-in function `range()`: it produces a **range object** which is... an iterable, you guessed!\n",
    "\n",
    "The syntax is `range([start,] stop[, step])`, where `start` is optional and defaults to 0. If `step` is omitted, it's taken to be 1.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Note</b></h4>\n",
    "    <code>range()</code> <strong>never</strong> includes its <code>stop</code> element.\n",
    "    It always provides a sequence of numbers that is <strong>less than</strong> the <code>stop</code> value.<br>\n",
    "    For instance <code>range(10)</code> produces the numbers 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Warm-up exercises\n",
    "\n",
    "Here are a few exercises to practice the concepts seen above.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <h4><b>Important</b></h4>\n",
    "    <ul>\n",
    "        <li>Try to use loop constructs like <code>for</code> or <code>while</code>, and the built-in iteration functions like <code>range()</code></li>\n",
    "        <li>Try to solve these exercises <strong>first</strong> before attempting any of those suggested in the last section.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26",
   "metadata": {},
   "source": [
    "#### 1. Write a Python program that returns the characters in a string and their indexes\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Note</b></h4> \n",
    "    The index should be returned <strong>after</strong> the corresponding character.\n",
    "</div>\n",
    "\n",
    "For example, if the string is `python`, the result should be `[('p', 0), ('y', 1), ('t', 2), ('h', 3), ('o', 4), ('n', 5)]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_indexed_string(string: str) -> list[tuple]:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 2. Write a Python program that returns all the numbers in a given range, __including__ the first and the last elements\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Note</b></h4>\n",
    "    Ranges can also contain <strong>decreasing</strong> numbers. Make sure to build the correct range.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_range_of_nums(start: int, end: int) -> list[int]:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 3. Write a Python program that takes a list of integers and returns the square root of each of them\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>You can use the <code>math.sqrt</code> function to compute the square root of a number</li>\n",
    "        <li>If a number does not have a square root in the real domain, you should skip it</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "import math\n",
    "\n",
    "def solution_sqrt_of_nums(numbers: list) -> list:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32",
   "metadata": {},
   "source": [
    "#### 4. Write a Python program that takes an integer and divides it by 2 until the result is no longer an even number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    Your program should <strong>return</strong> the number when the iteration stopped\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_divide_until(num: int) -> int:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Nested loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "You can put loops inside of other loops (of any kind). Just be careful to respect the indentation:\n",
    "\n",
    "```python\n",
    "for n in range(1, 4):\n",
    "    for m in range(4, 7):\n",
    "        print(\"n = \", n, \" and j = \", m)\n",
    "```\n",
    "\n",
    "The outer loop over `n` goes from 1 to 3. For each iteration, a new inner loop over `m` is started from 4 to 6. You will get **9 lines of output**, as the two range objects contain exactly 3 elements each.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <h4><b>Important</b></h4>\n",
    "    Nesting loops can have <strong>dramatic</strong> consequences on your program's performance.<br>\n",
    "    The body of the loop above repeats $n \\times m$ times. If $n$, $m$, or both are large numbers, your program might take a while to finish.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Altering loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39",
   "metadata": {},
   "source": [
    "There are **4 ways** in which you can alter the normal execution of a loop:\n",
    "\n",
    "1. With an `if` statement inside a `for`/`while` loop\n",
    "2. With the `break` keyword: the loop stops **immediately**\n",
    "3. With the `continue` keyword: the statements **after** the keyword are skipped and the next iteration is started\n",
    "4. With the `else` clause after a `for`/`while` body: the `else` statement(s) are run **only** if no `break` statement is encountered in the loop body\n",
    "\n",
    "Let's see an example for each of these"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40",
   "metadata": {},
   "source": [
    "### `if` statement inside `for`/`while`\n",
    "\n",
    "The following code sums **only** the even numbers from 1 to 100. It also prints when an odd number is encountered:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sum_of_evens = 0\n",
    "\n",
    "for n in range(101):\n",
    "    if n % 2 == 0:\n",
    "        sum_of_evens = sum_of_evens + n\n",
    "    else:\n",
    "        print(n, \"is an odd number\")\n",
    "\n",
    "print(sum_of_evens)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42",
   "metadata": {},
   "source": [
    "### The `break` keyword\n",
    "\n",
    "In this example, the `while` loop will continue until `i` is equal to 5. At that point, the `break` statement is executed, causing the loop to terminate prematurely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    i += 1\n",
    "    if i == 5:\n",
    "        break\n",
    "    print(i)\n",
    "\n",
    "print(\"Loop terminated with break\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44",
   "metadata": {},
   "source": [
    "### The `continue` keyword\n",
    "\n",
    "In this example, the `for` loop will iterate over the numbers from 0 to 9. However, when `i` is **even**, the `continue` statement is executed, causing the loop to skip the rest of the statements in the loop and move on to the next iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    if i % 2 == 0:\n",
    "        continue\n",
    "    print(i)\n",
    "\n",
    "print(\"Loop terminated normally\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46",
   "metadata": {},
   "source": [
    "### `else` after a `for`/`while`\n",
    "\n",
    "Here the `for` loop iterates over a list of numbers. If the current `num` is equal to 4, a print statement and then `break` are executed.\n",
    "\n",
    "If we complete the loop without finding 4, then the `else` block is executed and a message is printed indicating that 4 was not found in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "numbers = [1, 3, 5, 7, 9]\n",
    "\n",
    "for num in numbers:\n",
    "    if num == 4:\n",
    "        print(\"Found 4 - breaking loop\")\n",
    "        break\n",
    "else:\n",
    "    print(\"4 not found in list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48",
   "metadata": {},
   "source": [
    "Let's see what happens if we change the list to `[1, 2, 3, 4]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4]\n",
    "\n",
    "for num in numbers:\n",
    "    if num == 4:\n",
    "        print(\"Found 4 - breaking loop\")\n",
    "        break\n",
    "else:\n",
    "    print(\"4 not found in list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51",
   "metadata": {},
   "source": [
    "Another way of controlling the flow of a program is by **catching exceptions**.\n",
    "Exceptions are run-time errors that are raised by the interpreter while executing the program.\n",
    "Python has many [built-in exceptions](https://docs.python.org/3/library/exceptions.html#built-in-exceptions), including:\n",
    "\n",
    "| Exception         | Raised when...\n",
    "| ------------------|---------------\n",
    "| `SyntaxError`     | there is a problem with the syntax of a Python code\n",
    "| `TypeError`       | an operation is performed on the wrong type\n",
    "| `NameError`       | a local or global name is not found\n",
    "| `ValueError`      | a function receives an argument of the correct type but an inappropriate value\n",
    "| `KeyError`        | a mapping (e.g. dictionary) key is not found in the set of existing keys\n",
    "| `IndexError`      | you try to access an index that is outside the bounds of a list, tuple, or other sequence\n",
    "| `ZeroDivisionError`| an attempt is made to divide a number by zero\n",
    "| `OverflowError`   | a calculation exceeds the maximum limit for a numeric type\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## The `try-except` block"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53",
   "metadata": {},
   "source": [
    "When you can predict if a certain exception might occur, it's **always a good programming practice** to write what the program should do in that case\n",
    "\n",
    "Python provides you with the `try-except` construct for this purpose. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "numerator = 10\n",
    "denominator = 0\n",
    "\n",
    "try:\n",
    "    result = numerator / denominator\n",
    "    print(result)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: division by zero\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55",
   "metadata": {},
   "source": [
    "You can handle **multiple exceptions** at the same time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "num_1 = 30\n",
    "# num_2 = 0   # this leaves num_2 undefined\n",
    "\n",
    "try:\n",
    "    print(num_1 / num_2)\n",
    "except (NameError, ZeroDivisionError) as err:\n",
    "    print(\"Error encountered:\", err)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57",
   "metadata": {
    "tags": []
   },
   "source": [
    "Or you can **catch each exceptions individually** to give more information about the kind of error encountered\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    You can use <code>except</code> <strong>without</strong> any exception name, a <em>bare</em> <code>except</code>. Python will catch any exception. It's usually much better to let the user know about the kind of error encountered with all the details you can collect\n",
    "</div>\n",
    "\n",
    "\n",
    "The `try-except` construct includes two **optional** clauses: `else` and `finally`\n",
    "\n",
    "- Any statement in the `else` is executed **only** if the `try` block did **not** raise any exception\n",
    "- The statements belonging to `finally` will be **always** executed, regardless of any exception raised\n",
    "\n",
    "Here's an example of a *full* `try-except` block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    file = open(\"README.txt\", \"r\")\n",
    "except FileNotFoundError:\n",
    "    print(\"Error: file not found\")\n",
    "else:\n",
    "    contents = file.read()\n",
    "    print(contents)\n",
    "finally:\n",
    "    file.close()  # this statement is always executed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59",
   "metadata": {},
   "source": [
    "- We try to open a file called `README.txt`. A `FileNotFoundError` will be raised if it's not found\n",
    "- If the file exists, the `else` block is executed: we read and print its contents\n",
    "- We use a `finally` block to close the file handle, ensuring that it is properly cleaned up\n",
    "\n",
    "We will see a much better way to handle files tomorrow. This was just an example to illustrate the `try-except-finally` block."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite\n",
    "\n",
    "import pathlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Find the factors 🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63",
   "metadata": {},
   "source": [
    "A factor of a positive integer `n` is any positive integer less than or equal to `n` that divides `n` with no remainder.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    Complete the Python code below. Given an integer $n$, return the list of all integers $m \\leq n$ that are factors of $n$.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    For the moment, consider <b>all</b> integers less than or equal to $n$\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_find_factors(n: int) -> list[int]:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Find the pair 🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66",
   "metadata": {},
   "source": [
    "Given a list of integers, your task is to complete the code below that finds the pair of numbers in the list that add up to `2020`. The list of numbers is already available as the variable `nums`.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    What do you get if you multiply them together?\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    Does <em>nested loops</em> ring a bell?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_find_pair(nums: list[int]) -> int:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Part 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    Can you find the <b>product</b> of <em>three</em> numbers that add up to <code>2020</code>?\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    Too many nested loops can worsen a lot your code's performance\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_find_triplet(nums: list[int]) -> int:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Cats with hats 🌶️🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73",
   "metadata": {},
   "source": [
    "You have 100 cats.\n",
    "One day you decide to arrange all your cats in a giant circle. Initially, none of your cats have any hats on. You walk around the circle 100 times, always starting at the same spot, with the ﬁrst cat (cat #1).\n",
    "\n",
    "Every time you stop at a cat, you either put a hat on it if it **doesn’t** have one on, or you take its hat oﬀ if it has one.\n",
    "\n",
    "1. The ﬁrst round, you stop at every cat, placing a hat on each one.\n",
    "2. The second round, you only stop at every second cat (2, 4, 6, 8, etc.)\n",
    "3. The third round, you only stop at every third cat (3, 6, 9, 12, etc.)\n",
    "4. You continue this process until you’ve made 100 rounds around the cats (e.g., you only visit the last cat).\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4> \n",
    "    After the 100th round, how many cats will have a hat?\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    You can approach this problem with either <strong>lists</strong> (<code>[]</code>) or <strong>dictionaries</strong> (key-value pairs).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_cats_with_hats() -> int:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Toboggan trajectory 🌶️🌶️🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76",
   "metadata": {},
   "source": [
    "During a winter holidays break, your friends propose to hold a [toboggan](https://en.wikipedia.org/wiki/Toboggan) race. While inspecting the map of the place where you decided to hold the race, you realize that it could be rather dangerous as there are many trees along the slope.\n",
    "\n",
    "The following is an example of a map:\n",
    "\n",
    "```\n",
    "..##.......\n",
    "#...#...#..\n",
    ".#....#..#.\n",
    "..#.#...#.#\n",
    ".#...##..#.\n",
    "..#.##.....\n",
    ".#.#.#....#\n",
    ".#........#\n",
    "#.##...#...\n",
    "#...##....#\n",
    ".#..#...#.#\n",
    "```\n",
    "\n",
    "A `#` character indicates the position of a tree. These aren't the only trees though, because the map extends **on the right** many times. Your toboggan is an old model which can only follow certain paths with fixed steps **down** and **right**.\n",
    "\n",
    "You start at the top-left and check the position that is **right 3 and down 1**. Then, check the position that is right 3 and down 1 from there, and so on until you go past the bottom of the map."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77",
   "metadata": {},
   "source": [
    "#### Part 1 🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4> \n",
    "    How many trees would you encounter during your slope?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4> \n",
    "    Read the trees map as a <strong>nested list</strong> where each <code>#</code> corresponds to 1 and each empty site is 0\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    In the <code>solution_</code> function, define <strong>4 variables</strong>:\n",
    "    <ol>\n",
    "    <li>the position (starting at <code>[0, 0]</code>)</li>\n",
    "    <li>the number of trees encountered</li>\n",
    "    <li>the depth of the map</li>\n",
    "    <li>the width of the map</li>\n",
    "    </ol>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "trees_map_str = pathlib.Path(\"tutorial/tests/data/trees_1.txt\").read_text()  # do NOT change this line\n",
    "\n",
    "trees_map = []\n",
    "\n",
    "for line in trees_map_str.splitlines():\n",
    "    row = []\n",
    "    for position in line:\n",
    "        # TODO\n",
    "        # For each position, add 1 to `row` if you meet a '#', 0 otherwise\n",
    "    # TODO\n",
    "    # add `row` to the `trees_map` list\n",
    "\n",
    "\n",
    "def solution_toboggan_p1(trees_map, right=3, down=1):\n",
    "    \"\"\"\n",
    "    Complete your solution with the given hints\n",
    "    \"\"\"     \n",
    "    pos = [0, 0]\n",
    "    trees = # TODO\n",
    "    depth = len(trees_map)\n",
    "    width = # TODO\n",
    "\n",
    "    # Hints:\n",
    "    #   - write a loop until you reach the bottom of the map\n",
    "    #   - if the current location is a tree, add 1 to `trees`\n",
    "    #   - update `pos` by moving 3 right and 1 down\n",
    "    \n",
    "    return trees"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Part 2 🌶️🌶️"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83",
   "metadata": {},
   "source": [
    "You check other possible slopes to see if you chose the safest one. These are all the possible slopes according to your map:\n",
    "\n",
    "- Right 1, down 1\n",
    "- Right 3, down 1 (**just checked**)\n",
    "- Right 5, down 1\n",
    "- Right 7, down 1\n",
    "- Right 1, down 2\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <h4><b>Question</b></h4>\n",
    "    What do you get if you multiply together the number of trees encountered on each of the above slopes?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hint</b></h4>\n",
    "    Define a variable <code>slopes</code> as a list (or tuple) containing lists (or tuples) of the slopes' steps above\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "slopes = ((3, 1), ) # TODO\n",
    "\n",
    "def solution_toboggan_p2(trees_map, slopes):\n",
    "    total = 1\n",
    "    for right, down in slopes:\n",
    "        # TODO\n",
    "        # use your solution of Part 1 to calculate the trees for a given slope\n",
    "        # accumulate the product in `total`\n",
    "    \n",
    "    return total"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  },
  "toc-autonumbering": false,
  "toc-showmarkdowntxt": false,
  "vscode": {
   "interpreter": {
    "hash": "44a67ea841dc2166b3d2091af057378db3e19d02bed11714ee13c6843dc2a264"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}