lecture1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:18.654806Z",
     "iopub.status.busy": "2022-07-29T12:28:18.654530Z",
     "iopub.status.idle": "2022-07-29T12:28:19.186841Z",
     "shell.execute_reply": "2022-07-29T12:28:19.186149Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy\n",
    "import pybryt\n",
    "from lecture import ok, pybryt_reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python\n",
    "\n",
    "# Lecture 1: Hello world, conditional expressions, loops, and lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Learning objectives:\n",
    "\n",
    "At the end of this lecture, you will:\n",
    "\n",
    "* Know that Python will help you defy gravity.\n",
    "* Execute Python *statements* from within Jupyter.\n",
    "* Explain what a *variable* is and express a mathematical formula in code.\n",
    "* Print program outputs.\n",
    "* Access mathematical functions from a Python module.\n",
    "* Write your own *function*.\n",
    "* Form a *condition* using a *boolean expression*.\n",
    "* Use a conditional expression in combination with a `while`-loop to perform repetitive tasks.\n",
    "* Store data elements within a Python `list`.\n",
    "* Use a `for`-loop to iterate, and perform some task over a sequence of elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "import antigravity\n",
    "```\n",
    "![import antigravity](https://imgs.xkcd.com/comics/python.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Programming a mathematical formula\n",
    "\n",
    "Here is a formula for the position of a ball, $y(t)$, in vertical motion, starting at ground level (i.e. at $y=0$) at time $t=0$:\n",
    "\n",
    "$$ y(t) = v_{0}t- \\frac{1}{2}gt^2, $$\n",
    "\n",
    "where:\n",
    "\n",
    "* $y(t)$ is the height (position) as a function of time $t$,\n",
    "* $v_0$ is the initial velocity (at $t=0$), and\n",
    "* $g$ is the acceleration due to gravity.\n",
    "\n",
    "The computational task we want to solve is: given the values of $v_0$, $g$, and $t$, compute the height $y$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**How do we program this task?** A program is a sequence of instructions given to the computer. However, while a programming language is much **simpler** than a natural language, it is more **pedantic**. Programs must have correct syntax, i.e. correct use of the computer language grammar rules, and no misprints.\n",
    "\n",
    "So let us execute a Python statement based on this example to evaluate $y(t) = v_0t- \\frac{1}{2}gt^2$ for $v_0 = 5 \\,\\text{ms}^{-1}$, $g = 9.81 \\,\\text{ms}^{-2}$ and $t = 0.6 \\,\\text{s}$. If you were doing this on paper, you would probably write something like this: $$y = 5\\cdot 0.6 - \\frac{1}{2}\\cdot 9.81 \\cdot 0.6^2.$$ Happily, writing this in Python is very similar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.191379Z",
     "iopub.status.busy": "2022-07-29T12:28:19.191045Z",
     "iopub.status.idle": "2022-07-29T12:28:19.195392Z",
     "shell.execute_reply": "2022-07-29T12:28:19.194756Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "# Comment: This is a 'code' cell within Jupyter notebook.\n",
    "# Press Shift-Enter to execute the code within it,\n",
    "# or click 'Run' in the Jupyter toolbar above.\n",
    "\n",
    "print(5*0.6 - 0.5*9.81*0.6**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You probably noticed that, in the code cell we just wrote, the first few lines start with the hash (`#`) character. In Python, we use `#` to tell the Python interpreter to ignore everything that comes after `#`. We call those lines **comments**, and we write them to help us (humans) understand the code. Besides, we used `print` and we enclosed our calculation within parentheses to display the output. We will explain *comments* and *print function* in more detail later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Exercise 1.1: Open a code cell and write some code.\n",
    "1. Navigate the [Jupyter](http://jupyter.org/) toolbar to \"Insert\"->\"Insert Cell Below\". Note from the toolbar that you can select a cell to be 'Code' (this is the default), 'Markdown' (the cell you are reading right now is written in [Markdown](https://en.wikipedia.org/wiki/Markdown) - double click this cell to investigate further), and 'Raw' (its content is not evaluated by the notebook).\n",
    "2. Copy&paste the code from the previous code cell into your newly created code cell below. Make sure it runs!\n",
    "3. To see how important it is to use the correct [syntax](https://en.wikipedia.org/wiki/Syntax), replace `**` with `^` in your code and try running the cell again. You should see something like the following:\n",
    "\n",
    "```python\n",
    "---------------------------------------------------------------------------\n",
    "TypeError                                 Traceback (most recent call last)\n",
    "<ipython-input-4-6e110a567f02> in <module>\n",
    "      3 # cell, or click on the 'Run' widget on the Jupyter toolbar above.\n",
    "      4 \n",
    "----> 5 print(5*0.6 - 0.5*9.81*0.6^2)\n",
    "\n",
    "TypeError: unsupported operand type(s) for ^: 'float' and 'int'\n",
    "```\n",
    "4. Undo that change so your code is working again; now change `print` to `write` and see what happens when you run the cell. You should see something like:\n",
    "\n",
    "```python\n",
    "---------------------------------------------------------------------------\n",
    "NameError                                 Traceback (most recent call last)\n",
    "<ipython-input-5-a3da902ceb19> in <module>\n",
    "      3 # cell, or click on the 'Run' widget on the Jupyter toolbar above.\n",
    "      4 \n",
    "----> 5 write(5*0.6 - 0.5*9.81*0.6**2)\n",
    "\n",
    "NameError: name 'write' is not defined\n",
    "```\n",
    "\n",
    "While a human might still understand these statements, they do not mean anything to the Python interpreter. Rather than throwing your hands up in the air whenever you get an error message like the above (you are going to see many during your course), train yourself to read error messages carefully to get an idea what it is complaining about, and re-read your code from the perspective of the Python interpreter.\n",
    "\n",
    "Error messages can look bewildering and even frustrating at first, but **it gets much easier with practise**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "print(5*0.6 - 0.5*9.81*0.6**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Storing numbers in variables\n",
    "\n",
    "From mathematics, you are already familiar with *variables* (e.g. $v_0 = 5$, $g = 9.81$, $t = 0.6$, $y = v_0t - \\frac{1}{2}gt^2$), and know how important they are for working out complicated problems. Similarly, you can use variables in a program to make it easier to read and understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.208225Z",
     "iopub.status.busy": "2022-07-29T12:28:19.208023Z",
     "iopub.status.idle": "2022-07-29T12:28:19.212078Z",
     "shell.execute_reply": "2022-07-29T12:28:19.211454Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "v0 = 5\n",
    "g = 9.81\n",
    "t = 0.6\n",
    "y = v0*t - 0.5*g*t**2\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This program performs the same calculations as the previous one and gives the same output. However, this program spans several lines and uses variables. \n",
    "\n",
    "We usually use one letter for a variable in mathematics, resorting to using the Greek alphabet and other characters for more clarity. The main reason for this is to avoid becoming exhausted from writing when working out long expressions or derivations. However, when programming, you should use more descriptive names for variables. This might not seem like an important consideration for the trivial example here. Still, it becomes increasingly important as the program gets more complicated and if someone else has to read your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Good variable names make a program easier to understand!\n",
    "\n",
    "Python *allows* variable names to include:\n",
    "* lowercase `a-z`, uppercase `A-Z`, underscore (`_`), and digits `0-9`, **but** the name cannot start with a digit or contain a whitespace.\n",
    "* \"textlike\" [Unicode](http://www.unicode.org/) characters from other languages are also allowed.\n",
    "\n",
    "Variable names are case-sensitive (strictly, character sensitive, i.e. `a` is different from `A`).\n",
    "\n",
    "**Good** variable names are often:\n",
    "* standard one-letter symbols,\n",
    "* words or abbreviations of words,\n",
    "* phrases joined together in [snake_case](https://en.wikipedia.org/wiki/Snake_case) or [camelCase](https://en.wikipedia.org/wiki/Camel_case).\n",
    "\n",
    "Let us rewrite the previous example using more descriptive variable names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.216592Z",
     "iopub.status.busy": "2022-07-29T12:28:19.216390Z",
     "iopub.status.idle": "2022-07-29T12:28:19.220483Z",
     "shell.execute_reply": "2022-07-29T12:28:19.219859Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "initial_velocity = 5\n",
    "acceleration_of_gravity = 9.81\n",
    "TIME = 0.6\n",
    "VerticalPositionOfBall = initial_velocity*TIME - 0.5*acceleration_of_gravity*TIME**2\n",
    "print(VerticalPositionOfBall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python, you can check if the name you would like to give to your variable is valid or not, i.e. check if it is a valid identifier. To do that, you can enclose the variable name in quotes (to form a string literal) and call its `isidentifier()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.224856Z",
     "iopub.status.busy": "2022-07-29T12:28:19.224656Z",
     "iopub.status.idle": "2022-07-29T12:28:19.230835Z",
     "shell.execute_reply": "2022-07-29T12:28:19.230207Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"initial_velocity\".isidentifier())  # snake_case-style variable name\n",
    "print(\"InitialVelocity\".isidentifier())  # CamelCase-style variable name\n",
    "print(\"initial velocity\".isidentifier())  # variable name contains space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Certain words have a **special meaning** in Python and **cannot be used as variable names**. We refer to them as **keywords**, and in Python 3.9 they are:\n",
    "\n",
    "`and`, `as`, `assert`, `async`, `await`, `break`, `class`, `continue`, `def`, `del`, `elif`, `else`, `except`, `finally`, `for`, `from`, `global`, `if`, `import`, `in`, `is`, `lambda`, `nonlocal`, `not`, `or`, `pass`, `raise`, `return`, `try`, `while`, `with`, and `yield`. \n",
    "\n",
    "Similarly, `True`, `False`, and `None` are keywords we use for the values of variables, and we cannot use them for variable names. Keywords are very important in programming and, in these lectures, we will learn how to use some of them.\n",
    "\n",
    "Finally, Python has some \"builtin\" functions which are always available. While Python will let you do it, it is usually a bad idea to use these names, since this would *overshadow* the builtin function and prevent us from calling it. The full list of builtin functions in Python 3.9 is `abs()`, `aiter()`, `all()`, `any()`, `anext()`, `ascii()`, `bin()`, `bool()`, `breakpoint()`, `bytearray()`, `bytes()`, `callable()`, `chr()`, `classmethod()`, `compile()`, `complex()`, `delattr()`, `dict()`, `dir()`, `divmod()`, `enumerate()`, `eval()`, `exec()`, `filter()`, `float()`, `format()`, `frozenset()`, `getattr()`, `globals()`, `hasattr()`, `hash()`, `help()`, `hex()`, `id()`, `input()`, `int()`, `isinstance()`, `issubclass()`, `iter()`, `len()`, `list()`, `locals()`, `map()`, `max()`, `memoryview()`, `min()`, `next()`, `object()`, `oct()`, `open()`, `ord()`, `pow()`, `print()`, `property()`, `range()`, `repr()`, `reversed()`, `round()`, `set()`, `setattr()`, `slice()`, `sorted()`, `staticmethod()`, `str()`, `sum()`, `super()`, `tuple()`, `type()`, `vars()`, and  `zip()`.\n",
    "\n",
    "Please note that the list of keywords and builtins may differ between different Python versions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Adding comments to code\n",
    "\n",
    "Not everything written in a computer program is intended for execution. In Python, anything on a line after the `#` character is ignored and is known as a **comment**. You can write whatever you want in a comment. Comments are intended to be used to explain what a snippet of code is intended for. It might, for example, explain the objective or provide a reference to the data or algorithm used. This is useful for you when you have to understand your code at some later stage, and indeed for whoever has to read and understand your code later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.238151Z",
     "iopub.status.busy": "2022-07-29T12:28:19.237586Z",
     "iopub.status.idle": "2022-07-29T12:28:19.244289Z",
     "shell.execute_reply": "2022-07-29T12:28:19.243735Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2342\n"
     ]
    }
   ],
   "source": [
    "# Program for computing the height of a ball in vertical motion.\n",
    "v0 = 5    # Set initial velocity in m/s.\n",
    "g = 9.81  # Set acceleration due to gravity in m/s^2.\n",
    "t = 0.6   # Time at which we want to know the height of the ball in seconds.\n",
    "y = v0*t - 0.5*g*t**2  # Calculate the vertical position.\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.2: Convert from metres to British length units\n",
    "\n",
    "Here in the UK, we are famous for our love of performing mental arithmetic. That is why we still use both imperial and metric measurement systems - hours of fun entertainment for the family switching back and forth between the two.\n",
    "\n",
    "Make a program where you set a length given in metres and then compute and write out the corresponding length measured in:\n",
    "* inches (one inch is 2.54 cm)\n",
    "* feet (one foot is 12 inches)\n",
    "* yards (one yard is 3 feet)\n",
    "* miles (one British mile is 1760 yards)\n",
    "\n",
    "**Note**: In this course, we are using [okpy](https://okpy.org/) and [pybryt](https://microsoft.github.io/pybryt/html/index.html) for automated assessment scoring. Therefore, while it is generally important to always carefully follow the instructions of a question, it is particularly important here so that *okpy* and *pybryt* can recognise the validity of your answer.\n",
    "\n",
    "*Uncomment* and modify the relevant lines in the following code cell. The conversion to inches is done for you to illustrate what is required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.247595Z",
     "iopub.status.busy": "2022-07-29T12:28:19.247078Z",
     "iopub.status.idle": "2022-07-29T12:28:19.251206Z",
     "shell.execute_reply": "2022-07-29T12:28:19.250658Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2099.737532808399\n",
      "699.912510936133\n",
      "0.3976775630318938\n"
     ]
    }
   ],
   "source": [
    "\n",
    "metres = 640\n",
    "\n",
    "# 1 inch = 2.54 cm. Remember to convert 2.54 cm to 0.0254 m here.\n",
    "inches = metres/0.0254\n",
    "\n",
    "# Uncomment and complete the following code. Do not change variable names for testing.\n",
    "feet = inches/12\n",
    "print(feet)\n",
    "\n",
    "yards = feet/3\n",
    "print(yards)\n",
    "\n",
    "miles = yards/1760\n",
    "print(miles)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.260752Z",
     "iopub.status.busy": "2022-07-29T12:28:19.260345Z",
     "iopub.status.idle": "2022-07-29T12:28:19.269135Z",
     "shell.execute_reply": "2022-07-29T12:28:19.268510Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_2\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Your conversion to feet is correct. Well done!\n",
      "  - SUCCESS: Amazing! Your calculation of yards is correct.\n",
      "  - SUCCESS: Wow! Your conversion to miles is right.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "with pybryt.check(pybryt_reference(1, 2)):\n",
    "    feet, yards, miles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.272113Z",
     "iopub.status.busy": "2022-07-29T12:28:19.271766Z",
     "iopub.status.idle": "2022-07-29T12:28:19.292949Z",
     "shell.execute_reply": "2022-07-29T12:28:19.292451Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 3\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    }
   ],
   "source": [
    "grade = ok.grade(\"exercise-1_2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Formatted printing style\n",
    "\n",
    "Often we want to print out results using a combination of text and numbers, e.g. `\"At t=0.6 s, y is 1.23 m\"`. In Python, we can do this using f-strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.305522Z",
     "iopub.status.busy": "2022-07-29T12:28:19.305205Z",
     "iopub.status.idle": "2022-07-29T12:28:19.310750Z",
     "shell.execute_reply": "2022-07-29T12:28:19.310223Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At t=0.6 s, y is 1.2342 m.\n"
     ]
    }
   ],
   "source": [
    "print(f\"At t={t} s, y is {y} m.\")  # f-string method - string literal begins with an f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We enclose our sentence in (single or double) quotes to denote a string literal and add `f` in front of it to tell Python to replace `{t}` and `{y}` with the values of `t` and `y`, respectively.\n",
    "\n",
    "When printing out floating-point numbers, we should **never** quote numbers to a higher accuracy than they were measured. Python provides a *printf formatting* syntax exactly for this purpose. We can see in the following example where the *format* `g` expresses the floating-point number with the minimum number of significant figures, and the *format* `.2f` specifies that only two digits are printed out after the decimal point. We specify the format inside `{}` and separate it from the variable name with `:`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.313426Z",
     "iopub.status.busy": "2022-07-29T12:28:19.313209Z",
     "iopub.status.idle": "2022-07-29T12:28:19.317091Z",
     "shell.execute_reply": "2022-07-29T12:28:19.316591Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At t=0.6 s, y is 1.23 m.\n"
     ]
    }
   ],
   "source": [
    "print(f\"At t={t:g} s, y is {y:.2f} m.\")  # f-string with specified formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Sometimes we want a multi-line output. This is achieved using a triple quotation, i.e. `\"\"\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.319853Z",
     "iopub.status.busy": "2022-07-29T12:28:19.319288Z",
     "iopub.status.idle": "2022-07-29T12:28:19.323588Z",
     "shell.execute_reply": "2022-07-29T12:28:19.322981Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At t=0.600000 s, a ball with\n",
      "initial velocity v0=5.000E+00 m/s\n",
      "is located at the height y=1.23 m.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f\"\"\"At t={t:f} s, a ball with\n",
    "initial velocity v0={v0:.3E} m/s\n",
    "is located at the height y={y:.2f} m.\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice in this example we used `f`, `.3E`, and `.2f` to define formats, into which we inserted the values of `t`, `v0`, and `y` respectively. You can find more details about the format specification mini-language in the Python [documentation](https://docs.python.org/3/library/string.html#format-specification-mini-language)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of using the f-string formatted printing, Python offers another two syntax alternatives: string's `format` method and the `%` operator. Let us have a look at how we can print `\"At t=0.6 s, y is 1.23 m\"` using these two alternative solutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.326524Z",
     "iopub.status.busy": "2022-07-29T12:28:19.325985Z",
     "iopub.status.idle": "2022-07-29T12:28:19.331246Z",
     "shell.execute_reply": "2022-07-29T12:28:19.330671Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At t=0.6 s, y is 1.23 m.\n",
      "At t=0.6 s, y is 1.23 m.\n"
     ]
    }
   ],
   "source": [
    "print(\"At t={:g} s, y is {:.2f} m.\".format(t, y))  # string's format method\n",
    "print(\"At t=%g s, y is %.2f m.\" % (t, y))  # % operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we defined slots in a string using curly braces `{}` where we also specified the formatting style in the same way we did before. We inserted the values into the slots by passing them to the `format()` method or by writing them in curly braces.\n",
    "\n",
    "The `%` operator expands out the input tuple place by place (so the first *slot* gets the first element, the second the second, and so on). If there is only one *slot* then using a tuple is optional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.3: Compute the air resistance on a football\n",
    "\n",
    "The drag force, due to air resistance, on an object can be expressed as\n",
    "$$F_d = \\frac{1}{2}C_D\\rho Av^2$$\n",
    "where:\n",
    "* $\\rho$ is the density of the air,\n",
    "* $v$ is the velocity of the object,\n",
    "* $A$ is the cross-sectional area (perpendicular to the velocity direction),\n",
    "* and $C_D$ is the drag coefficient, which depends on the shape of the object and the roughness of the surface.\n",
    "\n",
    "**Complete and fix** the following code that computes the drag force."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.334236Z",
     "iopub.status.busy": "2022-07-29T12:28:19.333702Z",
     "iopub.status.idle": "2022-07-29T12:28:19.337165Z",
     "shell.execute_reply": "2022-07-29T12:28:19.336555Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0380132711084365\n",
      "11.771828154393067\n"
     ]
    }
   ],
   "source": [
    "# Import pi (3.14159...) from Python's math library\n",
    "from math import pi\n",
    "\n",
    "density = 1.2       # units of kg/m^3\n",
    "ball_radius = 0.11  # units of m\n",
    "C_D = 0.2           # drag coefficient\n",
    "\n",
    "v = 50.8            # m/s (fastest recorded speed of football)\n",
    "\n",
    "# Uncomment, fix, and complete the following lines.\n",
    "A = pi*ball_radius**2  # cross sectional area of a sphere\n",
    "print(A)\n",
    "\n",
    "F_d = 0.5*C_D*density*A*v**2\n",
    "print(F_d)\n",
    "\n",
    "# Challenge yourself to use the formatted print statement\n",
    "# shown above to write out the force with one decimal in\n",
    "# units of Newton (1 N = 1 kgm/s^2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.346589Z",
     "iopub.status.busy": "2022-07-29T12:28:19.346386Z",
     "iopub.status.idle": "2022-07-29T12:28:19.353820Z",
     "shell.execute_reply": "2022-07-29T12:28:19.353278Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_3\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Computed cross-sectional area is correct. Great!\n",
      "  - SUCCESS: Your calculation of the drag force is correct.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 3)):\n",
    "    A, F_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.356449Z",
     "iopub.status.busy": "2022-07-29T12:28:19.356241Z",
     "iopub.status.idle": "2022-07-29T12:28:19.371723Z",
     "shell.execute_reply": "2022-07-29T12:28:19.371204Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    }
   ],
   "source": [
    "grade = ok.grade(\"exercise-1_3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How are arithmetic expressions evaluated?\n",
    "Consider the random mathematical expression:\n",
    "\n",
    "$$ \\frac{5}{9} + \\frac{3a^4}{2} $$\n",
    "\n",
    "implemented in Python as `5/9 + 3 * a**4 / 2`. The rules for evaluating the expression are the same as in mathematics: proceed term by term (additions/subtractions) from the left, compute powers first, then multiplication and division. Therefore in this example the order of evaluation will be:\n",
    "\n",
    "1. `r1 = 5/9`\n",
    "2. `r2 = a**4`\n",
    "3. `r3 = 3*r2`\n",
    "4. `r4 = r3/2`\n",
    "5. `r5 = r1 + r4`\n",
    "\n",
    "We use parenthesis to override these default rules. Indeed, many programmers use parenthesis for greater clarity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.4: Compute the growth of money in a bank\n",
    "\n",
    "Let $p$ be a bank's annual interest rate in per cent. After $n$ years, an initial amount $A_0$ has then grown to\n",
    "\n",
    "$$A_n = A_0\\left(1+\\frac{p}{100}\\right)^n.$$\n",
    "\n",
    "Write a program for computing how much money 1000 euros have grown to after three years with a 5% annual interest rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.382165Z",
     "iopub.status.busy": "2022-07-29T12:28:19.381956Z",
     "iopub.status.idle": "2022-07-29T12:28:19.384457Z",
     "shell.execute_reply": "2022-07-29T12:28:19.383993Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The amount of money in the account after 3 years is 1157.63 euros\n"
     ]
    }
   ],
   "source": [
    "# Uncomment and complete the code below (and, as always, don't change variable names)\n",
    "\n",
    "p = 5\n",
    "A_0 = 1000\n",
    "n = 3\n",
    "\n",
    "A_n = A_0*(1+p/100)**n\n",
    "\n",
    "print(f\"The amount of money in the account after {n:d} years is {A_n:.2f} euros\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.396388Z",
     "iopub.status.busy": "2022-07-29T12:28:19.396187Z",
     "iopub.status.idle": "2022-07-29T12:28:19.404154Z",
     "shell.execute_reply": "2022-07-29T12:28:19.403610Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_4\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: You set the value of the annual interest rate (p) correctly.\n",
      "  - SUCCESS: You set the value of the initial amount (A_0) correctly.\n",
      "  - SUCCESS: You set the number of years (n) correctly.\n",
      "  - SUCCESS: Amazing! Your final solution (A_n) is correct.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 4)):\n",
    "    p, A_0, n, A_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.406792Z",
     "iopub.status.busy": "2022-07-29T12:28:19.406589Z",
     "iopub.status.idle": "2022-07-29T12:28:19.417564Z",
     "shell.execute_reply": "2022-07-29T12:28:19.417203Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    }
   ],
   "source": [
    "grade = ok.grade(\"exercise-1_4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Standard mathematical functions\n",
    "\n",
    "What if we need to compute $\\sin x$, $\\cos x$, $\\ln x$, $e^x$ etc., in a program? Such functions are available in Python's `math` module. In fact, there is a vast universe of functionality for Python available in modules. We just `import` in whatever we need for the task at hand.\n",
    "\n",
    "In this example, we compute $\\sqrt{2}$ using the `sqrt` function from the `math` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.432800Z",
     "iopub.status.busy": "2022-07-29T12:28:19.432286Z",
     "iopub.status.idle": "2022-07-29T12:28:19.438771Z",
     "shell.execute_reply": "2022-07-29T12:28:19.438223Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Since we imported library (import math),\n",
    "# we access the sqrt function using math.sqrt.\n",
    "r = math.sqrt(2)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "or:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.441620Z",
     "iopub.status.busy": "2022-07-29T12:28:19.441203Z",
     "iopub.status.idle": "2022-07-29T12:28:19.445582Z",
     "shell.execute_reply": "2022-07-29T12:28:19.444973Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "# This time, we did not import the entire library -\n",
    "# we imported only sqrt function.\n",
    "# Therefore, we can use it directly.\n",
    "r = sqrt(2)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us now have a look at a more complicated expression, such as\n",
    "\n",
    "$$\\sin x \\cos x + 4\\ln x$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.448327Z",
     "iopub.status.busy": "2022-07-29T12:28:19.447918Z",
     "iopub.status.idle": "2022-07-29T12:28:19.452247Z",
     "shell.execute_reply": "2022-07-29T12:28:19.451742Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0670178174513938\n"
     ]
    }
   ],
   "source": [
    "from math import sin, cos, log\n",
    "\n",
    "x = 1.2\n",
    "print(sin(x)*cos(x) + 4*log(x))   # log is ln (base e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.5: Evaluate a Gaussian function\n",
    "\n",
    "The bell-shaped Gaussian function,\n",
    "\n",
    "$$f(x)=\\frac{1}{s\\sqrt{2\\pi}}\\exp\\left(-\\frac{1}{2} \\left(\\frac{x-m}{s}\\right)^2\\right)$$\n",
    "\n",
    "is one of the most widely used functions in science and engineering. The mean $m$ and standard deviation $s$ are real numbers, and $s$ must be greater than zero. Write a program for evaluating the Gaussian function when $m = 0$, $s = 2$, and $x = 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.454992Z",
     "iopub.status.busy": "2022-07-29T12:28:19.454587Z",
     "iopub.status.idle": "2022-07-29T12:28:19.458347Z",
     "shell.execute_reply": "2022-07-29T12:28:19.457791Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.17603266338214976\n"
     ]
    }
   ],
   "source": [
    "# Uncomment and complete the code below (don't change variable names)\n",
    "\n",
    "import math\n",
    "\n",
    "m = 0\n",
    "s = 2\n",
    "x = 1\n",
    "\n",
    "f_x = (1/(s*math.sqrt(2*pi)))*math.exp(-1/2*((x-m)/s)**2)\n",
    "#(1/(s*sqrt(2*pi))*exp(-1/2*((x-m)/s)**2)\n",
    "       \n",
    "print(f_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.466679Z",
     "iopub.status.busy": "2022-07-29T12:28:19.466275Z",
     "iopub.status.idle": "2022-07-29T12:28:19.474316Z",
     "shell.execute_reply": "2022-07-29T12:28:19.473759Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_5\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Great! You computed the value of the Gaussian function correctly.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 5)):\n",
    "    f_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.477019Z",
     "iopub.status.busy": "2022-07-29T12:28:19.476610Z",
     "iopub.status.idle": "2022-07-29T12:28:19.491449Z",
     "shell.execute_reply": "2022-07-29T12:28:19.491007Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    }
   ],
   "source": [
    "grade = ok.grade(\"exercise-1_5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.6: Find and fix errors in the coding of a formula\n",
    "\n",
    "Roots of a quadratic equation $ax^2 + bx + c = 0$ are:\n",
    "\n",
    "$$x_1 = \\frac{−b + \\sqrt{b^2 −4ac}}{2a},$$\n",
    "and\n",
    "$$x_2 = \\frac{−b − \\sqrt{b^2 −4ac}}{2a}.$$\n",
    "\n",
    "Uncomment and fix the errors in the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.501431Z",
     "iopub.status.busy": "2022-07-29T12:28:19.500772Z",
     "iopub.status.idle": "2022-07-29T12:28:19.503694Z",
     "shell.execute_reply": "2022-07-29T12:28:19.503092Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.123105625617661\n",
      "0.7807764064044151\n",
      "-1.2807764064044151\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "#\n",
    "a = 2\n",
    "b = 1\n",
    "c = -2\n",
    "#\n",
    "q = sqrt(b*b - 4*a*c)\n",
    "x1 = (-b + q)/(2*a)\n",
    "x2 = (-b - q)/(2*a)\n",
    "print(q)\n",
    "print(x1)\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.512918Z",
     "iopub.status.busy": "2022-07-29T12:28:19.512503Z",
     "iopub.status.idle": "2022-07-29T12:28:19.521676Z",
     "shell.execute_reply": "2022-07-29T12:28:19.521100Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_6\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: You compute the square root of the discriminant (q) correctly.\n",
      "  - SUCCESS: Root x1 is correct.\n",
      "  - SUCCESS: Root x2 is correct.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 6)):\n",
    "    q, x1, x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.524661Z",
     "iopub.status.busy": "2022-07-29T12:28:19.524161Z",
     "iopub.status.idle": "2022-07-29T12:28:19.545921Z",
     "shell.execute_reply": "2022-07-29T12:28:19.545362Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 3\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    }
   ],
   "source": [
    "grade = ok.grade(\"exercise-1_6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "We have already used Python functions above, e.g. `sqrt` from the `math` module. In general, a function is a collection of statements we can execute wherever and whenever we want. For example, consider any of the formulae we implemented above. \n",
    "\n",
    "Functions can take any number of inputs (called *arguments* or *parameters*) to produce outputs. Functions help to organise programs, make them more understandable, shorter, and easier to extend. Wouldn't it be nice to implement it just once and then be able to use it again any time you need it, rather than having to write out the whole formula again?\n",
    "\n",
    "For our first example, we will reuse the formula for the position of a ball in a vertical motion, which we have seen earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.555801Z",
     "iopub.status.busy": "2022-07-29T12:28:19.555347Z",
     "iopub.status.idle": "2022-07-29T12:28:19.558858Z",
     "shell.execute_reply": "2022-07-29T12:28:19.558226Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def ball_height(v0, t, g=9.81):\n",
    "    \"\"\"Function to calculate and return height of the ball in vertical motion.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    v0 : float\n",
    "        Initial velocity (units, m/s).\n",
    "    t : float\n",
    "        Time at which we want to know the height of the ball (units, seconds).\n",
    "    g : float, optional\n",
    "        Acceleration due to gravity (units, m/s^2). By default 9.81 m/s^2.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        Height of the ball in metres.\n",
    "\n",
    "    \"\"\"\n",
    "    height = v0*t - 0.5*g*t**2\n",
    "\n",
    "    return height"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us break this example down:\n",
    "* Function *signature* (header):\n",
    "    * Functions start with `def` followed by the name we want to give the function (`ball_height` in this case). Just like with variables, function names must be valid identifiers.\n",
    "    * Following the name, we have parentheses followed by a colon `(...):` containing zero or more function *arguments*.\n",
    "    * In this case, `v0` and `t` are *positional arguments*, while `g` is known as a *keyword argument* (more about this later).\n",
    "* Function *body*:\n",
    "    * The first thing to notice is that the body of the function is indented one level. All code that is indented with respect to `def`-line belongs to a function.\n",
    "    * Best practice is to include a [docstring](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_numpy.html) to explain to others (or remind our future self) how to use the function. Docstring is defined as a multi-line string literal (enclosed in triple quotes \"\"\").\n",
    "    * The function output is passed back via the `return` statement.\n",
    " \n",
    "Notice that this just defines the function. Nothing is executed until we actually *call* the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.561640Z",
     "iopub.status.busy": "2022-07-29T12:28:19.561300Z",
     "iopub.status.idle": "2022-07-29T12:28:19.567183Z",
     "shell.execute_reply": "2022-07-29T12:28:19.566542Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ball height: 1.2342 metres.\n"
     ]
    }
   ],
   "source": [
    "# We pass 5 and 0.6 to v0 and t, respectively.\n",
    "# Since we do not pass a value for g,\n",
    "# a default value we defined in function's signature is used.\n",
    "# The value function returns (height) is put in variable h.\n",
    "h = ball_height(5, 0.6)\n",
    "\n",
    "print(f\"Ball height: {h:g} metres.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No return value implies that `None` is returned. `None` is a special Python object (singleton) that semantically often represents an ”empty” or undefined value. It is surprisingly useful, and we will use it a lot later.\n",
    "\n",
    "Functions can also return multiple values. Let us extend the previous example to calculate the ball's velocity as well as its height:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.570277Z",
     "iopub.status.busy": "2022-07-29T12:28:19.569755Z",
     "iopub.status.idle": "2022-07-29T12:28:19.577988Z",
     "shell.execute_reply": "2022-07-29T12:28:19.577402Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ball height: 1.2342 metres.\n",
      "Ball velocity: -0.886 m/s.\n"
     ]
    }
   ],
   "source": [
    "def ball_height_velocity(v0, t, g=9.81):\n",
    "    \"\"\"Function to calculate ball's height and its velocity.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    v0 : float\n",
    "        Initial velocity (units, m/s).\n",
    "    t : float\n",
    "        Time at which we want to know the height of the ball (units, seconds).\n",
    "    g : float, optional\n",
    "        Acceleration due to gravity (units, m/s^2). By default 9.81 m/s^2.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        Height of ball in metres.\n",
    "    float\n",
    "        Velocity of ball in m/s.\n",
    "\n",
    "    \"\"\"\n",
    "    height = v0*t - 0.5*g*t**2\n",
    "    velocity = v0 - g*t\n",
    "\n",
    "    return height, velocity\n",
    "\n",
    "\n",
    "# We pass 5 and 0.6 to v0 and t, respectively.\n",
    "# The first value function returns (height) is put into variable h,\n",
    "# whereas the second one (velocity) is placed in v - iterable unpacking.\n",
    "h, v = ball_height_velocity(5, 0.6)\n",
    "\n",
    "print(\"Ball height: %g metres.\" % h)\n",
    "print(\"Ball velocity: %g m/s.\" % v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope: Local and global variables\n",
    "\n",
    "Variables defined within a function are said to have *local scope*. That is to say that we can only reference them within that function. Consider the example function defined above where we used the *local* variable *height*. You can see that if you try to print the variable height outside the function, you will get an error.\n",
    "\n",
    "```python\n",
    "print(height)\n",
    "\n",
    "---------------------------------------------------------------------------\n",
    "NameError                                 Traceback (most recent call last)\n",
    "<ipython-input-50-aa6406a13920> in <module>\n",
    "----> 1 print(height)\n",
    "\n",
    "NameError: name 'height' is not defined\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keyword arguments and default input values\n",
    "\n",
    "Besides *positional arguments*, functions can have arguments of the form `argument_name=value` and they are called *keyword arguments*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.581078Z",
     "iopub.status.busy": "2022-07-29T12:28:19.580648Z",
     "iopub.status.idle": "2022-07-29T12:28:19.585116Z",
     "shell.execute_reply": "2022-07-29T12:28:19.584512Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg1: Hello, arg2: [1, 2], kwarg1: True, kwarg2: 0\n"
     ]
    }
   ],
   "source": [
    "def somefunc(arg1, arg2, kwarg1=True, kwarg2=0):\n",
    "    print(f\"arg1: {arg1}, arg2: {arg2}, kwarg1: {kwarg1}, kwarg2: {kwarg2}\")\n",
    "\n",
    "\n",
    "# Note that we have not specified inputs for kwarg1 and kwarg2.\n",
    "somefunc(\"Hello\", [1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.588648Z",
     "iopub.status.busy": "2022-07-29T12:28:19.588448Z",
     "iopub.status.idle": "2022-07-29T12:28:19.592315Z",
     "shell.execute_reply": "2022-07-29T12:28:19.591691Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg1: Hello, arg2: [1, 2], kwarg1: Hi, kwarg2: 0\n"
     ]
    }
   ],
   "source": [
    "# Note that we replace the default value for kwarg1.\n",
    "somefunc(\"Hello\", [1, 2], kwarg1=\"Hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.596436Z",
     "iopub.status.busy": "2022-07-29T12:28:19.596236Z",
     "iopub.status.idle": "2022-07-29T12:28:19.600078Z",
     "shell.execute_reply": "2022-07-29T12:28:19.599448Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg1: Hello, arg2: [1, 2], kwarg1: True, kwarg2: Hi\n"
     ]
    }
   ],
   "source": [
    "# Note that we replace the default value for kwarg2.\n",
    "somefunc(\"Hello\", [1, 2], kwarg2=\"Hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.604016Z",
     "iopub.status.busy": "2022-07-29T12:28:19.603809Z",
     "iopub.status.idle": "2022-07-29T12:28:19.607511Z",
     "shell.execute_reply": "2022-07-29T12:28:19.607052Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg1: Hello, arg2: [1, 2], kwarg1: 6, kwarg2: Hi\n"
     ]
    }
   ],
   "source": [
    "# Here, we replace both default values for keyword arguments kwarg1 and kwarg2.\n",
    "somefunc(\"Hello\", [1, 2], kwarg2=\"Hi\", kwarg1=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we use `argument_name=value` for all arguments, their sequence in the function call can be in any order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.610688Z",
     "iopub.status.busy": "2022-07-29T12:28:19.610239Z",
     "iopub.status.idle": "2022-07-29T12:28:19.614591Z",
     "shell.execute_reply": "2022-07-29T12:28:19.613931Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg1: Hi, arg2: [2], kwarg1: 6, kwarg2: Hello\n"
     ]
    }
   ],
   "source": [
    "somefunc(kwarg2=\"Hello\", arg1=\"Hi\", kwarg1=6, arg2=[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.7: Implement a Gaussian function\n",
    "\n",
    "Write a Python function `gaussian` to compute the Gaussian function:\n",
    "\n",
    "$$f(x)=\\frac{1}{s\\sqrt{2\\pi}}\\exp\\left(-\\frac{1}{2} \\left(\\frac{x-m}{s}\\right)^2\\right)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.618305Z",
     "iopub.status.busy": "2022-07-29T12:28:19.618096Z",
     "iopub.status.idle": "2022-07-29T12:28:19.620532Z",
     "shell.execute_reply": "2022-07-29T12:28:19.620074Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete this code - keep the function name the same for testing purposes.\n",
    "from math import pi\n",
    "def gaussian(x, m=0, s=1):\n",
    "    f_x = (1/(s*math.sqrt(2*pi)))*math.exp(-1/2*((x-m)/s)**2)\n",
    "\n",
    "    return f_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.628644Z",
     "iopub.status.busy": "2022-07-29T12:28:19.628424Z",
     "iopub.status.idle": "2022-07-29T12:28:19.636373Z",
     "shell.execute_reply": "2022-07-29T12:28:19.635796Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_7\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Your implementation of the Gaussian function is correct. Well done!\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 7)):\n",
    "    gaussian(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.638971Z",
     "iopub.status.busy": "2022-07-29T12:28:19.638769Z",
     "iopub.status.idle": "2022-07-29T12:28:19.670026Z",
     "shell.execute_reply": "2022-07-29T12:28:19.669372Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 11\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 11, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_7\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.8: How to cook the perfect egg\n",
    "\n",
    "You just started University and moved away from home. You're trying to impress your new flatmates by cooking brunch. Write a Python script to help you cook the perfect egg! \n",
    "\n",
    "You know from A-levels that, when the temperature exceeds a critical point, the proteins in the egg first denature and then coagulate. The process becomes faster as the temperature increases. In the egg white, the proteins start to coagulate for temperatures above 63$^\\circ$C, while in the yolk the proteins start to coagulate for temperatures above 70$^\\circ$C. \n",
    "\n",
    "The time $t$ (in seconds) it takes for the centre of the yolk to reach the temperature $T_y$ (in degrees Celsius) can be expressed as: \n",
    "\n",
    "$$t = \\frac{M^{2/3}c \\rho^{1/3}}{K \\pi^2 (4 \\pi /3)^{2/3} } ln \\left[0.76 \\frac{T_0-T_w}{T_y-T_w}\\right]$$\n",
    "\n",
    "where:\n",
    "* $M$ is the mass of the egg;\n",
    "* $\\rho$ is the density;\n",
    "* $c$ is the specific heat capacity;\n",
    "* $K$ is thermal conductivity;\n",
    "* $T_w$ temperature of the boiling water (in $^\\circ$C);\n",
    "* $T_0$ is the initial temeprature of the egg (in $^\\circ$C), before being put in the water.\n",
    "\n",
    "Write a function that returns the time $t$ needed for the egg to cook, knowing that $T_w = 100^\\circ\\text{C}$, $M = 50\\,\\text{g}$, $\\rho = 1.038\\,\\text{gcm}^{−3}$, $c = 3.7\\,\\text{Jg}^{−1}\\text{K}^{−1}$, and $K = 5.4 \\cdot 10^{−3}\\,\\text{Wcm}^{−1}\\text{K}^{−1}$. Find $t$ for an egg taken from the fridge ($T_0 = 4^\\circ\\text{C}$) and for one at room temperature ($T_0 = 20^\\circ\\text{C}$). $T_y = 70^\\circ\\text{C}$ for a perfect soft-boiled egg.\n",
    "\n",
    "**Hint**: You do not need to do any unit conversion. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.680293Z",
     "iopub.status.busy": "2022-07-29T12:28:19.679943Z",
     "iopub.status.idle": "2022-07-29T12:28:19.682529Z",
     "shell.execute_reply": "2022-07-29T12:28:19.681931Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete this code - keep the names the same for testing purposes.\n",
    "\n",
    "from math import pi,log\n",
    "\n",
    "def perfect_egg(T0=4, M=50, rho=1.038, Tw=100, c=3.7, K=5.4e-3, Ty=70):\n",
    "    \n",
    "    t = ((M**(2/3)*c*rho**(1/3))/(K*pi**2*(4*pi/3)**(2/3)))*log(0.76*((T0-Tw)/(Ty-Tw)))\n",
    "    \n",
    "    return t\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.691760Z",
     "iopub.status.busy": "2022-07-29T12:28:19.691535Z",
     "iopub.status.idle": "2022-07-29T12:28:19.701678Z",
     "shell.execute_reply": "2022-07-29T12:28:19.701090Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_8\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Your function computes correct time for an egg at the fridge temperature to be perfectly cooked. Well done!\n",
      "  - SUCCESS: The time for an egg at the room temperature to be perfectly cooked is correct. Well done!\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 8)):\n",
    "    perfect_egg(T0=4, M=50, rho=1.038, Tw=100, c=3.7, K=5.4e-3, Ty=70)\n",
    "    perfect_egg(T0=20, M=50, rho=1.038, Tw=100, c=3.7, K=5.4e-3, Ty=70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.704286Z",
     "iopub.status.busy": "2022-07-29T12:28:19.704084Z",
     "iopub.status.idle": "2022-07-29T12:28:19.716108Z",
     "shell.execute_reply": "2022-07-29T12:28:19.715731Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 1, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_8\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.9: Kepler's third law\n",
    "\n",
    "You were selected to be the next astronaut to go to Mars. Congratulations! \n",
    "\n",
    "Kepler's third law expresses the relationship between the distance of planets from the Sun, $a$, and their orbital periods, $P$:\n",
    "\n",
    "$$ P^2 = \\frac{4\\pi^2}{G(M + m)}a^3  $$\n",
    "\n",
    "where\n",
    "* $P$ is the period (in seconds);\n",
    "* $G$ is the gravitational constant ($G = 6.67 \\cdot 10^{-11} \\,\\text{m}^3\\text{kg}^{-1}\\text{s}^{-2}$);\n",
    "* $M$ is the mass of the Sun ($M = 2 \\cdot 10^{30} \\text{kg}$);\n",
    "* $m$ is the mass of the planet (in kg);\n",
    "* $a$ is the distance between the planet and the Sun (in m).\n",
    "\n",
    "How many Earth birthdays will you celebrate during your 10-years Mars mission? Write a Python function `period` that calculates the period of a planet. Using `period` function, calculate the period of the Earth, `P_earth`, and the period of Mars, `P_mars`. Finally, calculate `birthdays` which is how many Earth years are equivalent to 10 years on Mars.\n",
    "\n",
    "We know that:\n",
    "* The average distance between the Earth and the Sun is $a = 1.5 \\cdot 10^{11} \\,\\text{m}$;\n",
    "* The average distance between Mars and the Sun is 0.5 larger than the Earth-Sun distance;\n",
    "* The mass of the Earth is $m_1 = 6 \\cdot 10^{24} \\,\\text{kg}$;\n",
    "* Mars's mass is about 10% of the Earth's mass.\n",
    "\n",
    "**Hint**: You do not need to do any unit conversion. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.732072Z",
     "iopub.status.busy": "2022-07-29T12:28:19.731868Z",
     "iopub.status.idle": "2022-07-29T12:28:19.735695Z",
     "shell.execute_reply": "2022-07-29T12:28:19.735123Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "58059817.3950661\n",
      "31603718.929927427\n"
     ]
    }
   ],
   "source": [
    "from math import pi, sqrt\n",
    "\n",
    "def period(a, m_planet, m_sun=2e30, G=6.67e-11):\n",
    "    plant = 4*pi**2*a**3/(G*(m_sun+m_planet))\n",
    "    print(sqrt(plant))\n",
    "    return sqrt(plant)\n",
    "\n",
    "m_earth = 6e24\n",
    "m_mars = 6e24*0.1\n",
    "a_earth = 1.5e11\n",
    "a_mars = 1.5*1.5e11\n",
    "\n",
    "P_mars = period(a_mars, m_mars)\n",
    "P_earth = period(a_earth, m_earth)\n",
    "birthdays = P_mars*10/P_earth\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.745259Z",
     "iopub.status.busy": "2022-07-29T12:28:19.745057Z",
     "iopub.status.idle": "2022-07-29T12:28:19.753707Z",
     "shell.execute_reply": "2022-07-29T12:28:19.753169Z"
    },
    "scrolled": true,
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17202907.13750725\n",
      "REFERENCE: exercise-1_9\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Your function computes the period correctly.\n",
      "  - SUCCESS: You computed the Earth's period correctly.\n",
      "  - SUCCESS: You computed Mars's period correctly.\n",
      "  - SUCCESS: Wow! Your computed birthdays value is correct!\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 9)):\n",
    "    period(a=1e11, m_planet=1e24),P_mars, P_earth, birthdays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.756374Z",
     "iopub.status.busy": "2022-07-29T12:28:19.756172Z",
     "iopub.status.idle": "2022-07-29T12:28:19.770902Z",
     "shell.execute_reply": "2022-07-29T12:28:19.770523Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 1, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_9\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean expressions\n",
    "\n",
    "An expression with value `True` or `False` is called a boolean expression. Example expressions for what you would write mathematically as\n",
    "$C = 40$, $C \\ne 40$, $C \\ge 40$, $C \\gt 40$ and $C \\lt 40$ are:\n",
    "\n",
    "```python\n",
    "C == 40  # Note: the double == checks for equality!\n",
    "C != 40  # This could also be written as \"not C == 4\"\n",
    "C >= 40\n",
    "C > 40\n",
    "C < 40\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us now test some boolean expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.786100Z",
     "iopub.status.busy": "2022-07-29T12:28:19.785505Z",
     "iopub.status.idle": "2022-07-29T12:28:19.803566Z",
     "shell.execute_reply": "2022-07-29T12:28:19.802987Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C != 40:  True\n",
      "C < 40:  False\n",
      "C == 41:  True\n"
     ]
    }
   ],
   "source": [
    "C = 41\n",
    "\n",
    "print(\"C != 40: \", C != 40)\n",
    "print(\"C < 40: \", C < 40)\n",
    "print(\"C == 41: \", C == 41)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Several conditions can be combined with keywords `and` and `or` into a single boolean expression:\n",
    "\n",
    "* **Rule 1**: (`C1 and C2`) is `True` only if both `C1` and `C2` are `True`.\n",
    "* **Rule 2**: (`C1 or C2`) is `True` if either `C1` or `C2` are `True`.\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.806654Z",
     "iopub.status.busy": "2022-07-29T12:28:19.806206Z",
     "iopub.status.idle": "2022-07-29T12:28:19.813663Z",
     "shell.execute_reply": "2022-07-29T12:28:19.813061Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x >= 0 and y < 1: False\n",
      "x >= 0 or y < 1: True\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "y = 1.2\n",
    "\n",
    "print(\"x >= 0 and y < 1:\", x >= 0 and y < 1)\n",
    "print(\"x >= 0 or y < 1:\", x >= 0 or y < 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.10: Values of boolean expressions\n",
    "Add a comment to the code below to explain the outcome of each of the boolean expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.821226Z",
     "iopub.status.busy": "2022-07-29T12:28:19.821024Z",
     "iopub.status.idle": "2022-07-29T12:28:19.847422Z",
     "shell.execute_reply": "2022-07-29T12:28:19.847001Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Case 1:  False\n",
      "Case 2:  False\n",
      "Case 3:  True\n",
      "Case 4:  True\n",
      "Case 5:  False\n",
      "Case 6:  True\n",
      "Case 7:  True\n",
      "Case 8:  False\n",
      "Case 9:  True\n",
      "Case 10:  False\n",
      "Case 11:  False\n",
      "Case 12:  True\n"
     ]
    }
   ],
   "source": [
    "C = 41\n",
    "\n",
    "print(\"Case 1: \", C == 40)  # False because C is not equal to 40\n",
    "print(\"Case 2: \", C != 40 and C < 41)  # False because C should both not equal to 40 and not less than 41\n",
    "print(\"Case 3: \", C != 40 or C < 41)   # True because either C is not equal to 40 or C is not less than 41 is ok\n",
    "print(\"Case 4: \", not C == 40)         # True because C is not equal to 40\n",
    "print(\"Case 5: \", not C > 40)          # False because C is not large than 40\n",
    "print(\"Case 6: \", C <= 41)             # True because C is equal to 41\n",
    "print(\"Case 7: \", not False)          # True because not False is true\n",
    "print(\"Case 8: \", True and False)    # False because 'and' means both side should be satisfied\n",
    "print(\"Case 9: \", False or True)     # True because 'or' means either side be satisfied is ok\n",
    "print(\"Case 10: \", False or False or False)  # False because 'or' means either side be satisfied is ok, all flase here\n",
    "print(\"Case 11: \", True and True and False)  # False because 'and' means both side should be satisfied\n",
    "print(\"Case 12: \", (True and True) or 1 == 2) # True because 'True and True' is true and 'or' means either side be satisfied is ok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Loops\n",
    "Suppose we want to make the following table of Celsius and Fahrenheit degrees:\n",
    "```\n",
    " -20  -4.0\n",
    " -15   5.0\n",
    " -10  14.0\n",
    "  -5  23.0\n",
    "   0  32.0\n",
    "   5  41.0\n",
    "  10  50.0\n",
    "  15  59.0\n",
    "  20  68.0\n",
    "  25  77.0\n",
    "  30  86.0\n",
    "  35  95.0\n",
    "  40 104.0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "How do we write a program that prints out such a table? We know that $F = \\frac{9}{5}C + 32$, and a single line in this table is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.864474Z",
     "iopub.status.busy": "2022-07-29T12:28:19.863839Z",
     "iopub.status.idle": "2022-07-29T12:28:19.871557Z",
     "shell.execute_reply": "2022-07-29T12:28:19.870842Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-20 -4.0\n"
     ]
    }
   ],
   "source": [
    "C = -20\n",
    "F = 9/5*C + 32\n",
    "\n",
    "print(C, F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now, we can just repeat these statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.875181Z",
     "iopub.status.busy": "2022-07-29T12:28:19.874599Z",
     "iopub.status.idle": "2022-07-29T12:28:19.911028Z",
     "shell.execute_reply": "2022-07-29T12:28:19.910555Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-20 -4.0\n",
      "-15 5.0\n",
      "-10 14.0\n",
      "-5 23.0\n",
      "0 32.0\n",
      "5 41.0\n",
      "10 50.0\n",
      "15 59.0\n",
      "20 68.0\n",
      "25 77.0\n",
      "30 86.0\n",
      "35 95.0\n",
      "40 104.0\n"
     ]
    }
   ],
   "source": [
    "C = -20; F = 9/5*C + 32; print(C, F)\n",
    "C = -15; F = 9/5*C + 32; print(C, F)\n",
    "C = -10; F = 9/5*C + 32; print(C, F)\n",
    "C = -5; F = 9/5*C + 32; print(C, F)\n",
    "C = 0; F = 9/5*C + 32; print(C, F)\n",
    "C = 5; F = 9/5*C + 32; print(C, F)\n",
    "C = 10; F = 9/5*C + 32; print(C, F)\n",
    "C = 15; F = 9/5*C + 32; print(C, F)\n",
    "C = 20; F = 9/5*C + 32; print(C, F)\n",
    "C = 25; F = 9/5*C + 32; print(C, F)\n",
    "C = 30; F = 9/5*C + 32; print(C, F)\n",
    "C = 35; F = 9/5*C + 32; print(C, F)\n",
    "C = 40; F = 9/5*C + 32; print(C, F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can see that works but it is **very boring** to write and very easy to introduce a misprint.\n",
    "\n",
    "**You really should not be doing boring repetitive tasks like this.** Spend your time instead looking for a smarter solution. When programming becomes boring, there is usually a construct that automates the writing. Computers are very good at performing repetitive tasks. For this purpose we use **loops**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The `while` loop\n",
    "\n",
    "A `while`-loop executes repeatedly a set of statements as long as a boolean `condition` is `True`\n",
    "\n",
    "```python\n",
    "while condition:\n",
    "    <statement 1>\n",
    "    <statement 2>\n",
    "    ...\n",
    "\n",
    "<first statement after the loop>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Note that all statements to be executed within the loop must be indented by the same amount! The loop ends when an unindented statement is encountered."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python, indentations are very important. For instance, when writing a `while` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.933664Z",
     "iopub.status.busy": "2022-07-29T12:28:19.932998Z",
     "iopub.status.idle": "2022-07-29T12:28:19.937703Z",
     "shell.execute_reply": "2022-07-29T12:28:19.937276Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "counter = 0\n",
    "while counter <= 10:\n",
    "    counter = counter + 1\n",
    "\n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us take a look at what happens when we forget to indent correctly:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "counter = 0\n",
    "while counter <= 10:\n",
    "counter = counter + 1\n",
    "print(counter)\n",
    "\n",
    "\n",
    "  File \"<ipython-input-86-d8461f52562c>\", line 3\n",
    "    counter = counter + 1\n",
    "    ^\n",
    "IndentationError: expected an indented block\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us now use the `while`-loop to create the table above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.940871Z",
     "iopub.status.busy": "2022-07-29T12:28:19.940667Z",
     "iopub.status.idle": "2022-07-29T12:28:19.959513Z",
     "shell.execute_reply": "2022-07-29T12:28:19.959125Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-20 -4.0\n",
      "-15 5.0\n",
      "-10 14.0\n",
      "-5 23.0\n",
      "0 32.0\n",
      "5 41.0\n",
      "10 50.0\n",
      "15 59.0\n",
      "20 68.0\n",
      "25 77.0\n",
      "30 86.0\n",
      "35 95.0\n",
      "40 104.0\n"
     ]
    }
   ],
   "source": [
    "C = -20                 # Initialise C\n",
    "dC = 5                  # Increment for C within the loop\n",
    "while C <= 40:          # Loop heading with condition (C <= 40)\n",
    "    F = (9/5)*C + 32  # 1st statement inside loop\n",
    "    print(C, F)         # 2nd statement inside loop\n",
    "    C = C + dC          # Increment C for the next iteration of the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.11: Compute the number of digits in a positive integer $a$\n",
    "\n",
    "Write a Python function `num_digits(a)` that uses a `while` loop to compute how many decimal digits we need to write a positive integer $a$. For instance, we need 2 digits to write 73, whereas we need 5 digits to write 12345."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.984477Z",
     "iopub.status.busy": "2022-07-29T12:28:19.983775Z",
     "iopub.status.idle": "2022-07-29T12:28:19.987572Z",
     "shell.execute_reply": "2022-07-29T12:28:19.986957Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete the code below. Do not change the names of variables!\n",
    "\n",
    "def num_digits(a): \n",
    "    num = 0 \n",
    "    while a >= 1:  \n",
    "        a = a//10\n",
    "        num = num+1\n",
    "      \n",
    "    return num\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:19.996997Z",
     "iopub.status.busy": "2022-07-29T12:28:19.996587Z",
     "iopub.status.idle": "2022-07-29T12:28:20.009826Z",
     "shell.execute_reply": "2022-07-29T12:28:20.009236Z"
    },
    "scrolled": true,
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_11\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: You are incrementing the number of digits in each iteration. Well done!\n",
      "  - SUCCESS: Wow! Your function computes the number of digits correctly.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 11)):\n",
    "    num_digits(999_999_999)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.012616Z",
     "iopub.status.busy": "2022-07-29T12:28:20.012203Z",
     "iopub.status.idle": "2022-07-29T12:28:20.033394Z",
     "shell.execute_reply": "2022-07-29T12:28:20.032896Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 1, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_11\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.12: Write an approximate Fahrenheit-Celsius conversion table\n",
    "\n",
    "Instead of using an exact formula for converting Fahrenheit ($F$) to Celsius ($C$) degrees:\n",
    "\n",
    "$$C = \\frac{5}{9}(F - 32),$$\n",
    "\n",
    "many people use an approximate formula for quicker conversion:\n",
    "\n",
    "$$C \\approx \\hat{C} = \\frac{F − 30}{2}.$$\n",
    "\n",
    "Write a Python function `conversion_table` using a `while` loop that prints the conversion table consisting of three columns: $F$, $C$, and the approximate value $\\hat{C}$, for $F = 0, 10, 20, \\ldots, 100$. Besides, using the same while loop, count the number of rows printed and return the count. Ensure that all numbers in the conversion table are printed with two decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.044523Z",
     "iopub.status.busy": "2022-07-29T12:28:20.044064Z",
     "iopub.status.idle": "2022-07-29T12:28:20.047319Z",
     "shell.execute_reply": "2022-07-29T12:28:20.046789Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete the code below. Do not change the names of variables.\n",
    "\n",
    "def conversion_table():\n",
    "    global F, count\n",
    "    F = 0.00\n",
    "    count = 0\n",
    "    while F <= 100: \n",
    "        count = count + 1 \n",
    "        C = 5/9*(F - 32)\n",
    "        C_d = (F - 30)/2\n",
    "        print(format(F,'.2f'),format(C,'.2f'),format(C_d,'.2f'))\n",
    "        F = F + 10  \n",
    "        \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.056976Z",
     "iopub.status.busy": "2022-07-29T12:28:20.056443Z",
     "iopub.status.idle": "2022-07-29T12:28:20.150746Z",
     "shell.execute_reply": "2022-07-29T12:28:20.150105Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00 -17.78 -15.00\n",
      "10.00 -12.22 -10.00\n",
      "20.00 -6.67 -5.00\n",
      "30.00 -1.11 0.00\n",
      "40.00 4.44 5.00\n",
      "50.00 10.00 10.00\n",
      "60.00 15.56 15.00\n",
      "70.00 21.11 20.00\n",
      "80.00 26.67 25.00\n",
      "90.00 32.22 30.00\n",
      "100.00 37.78 35.00\n",
      "REFERENCE: exercise-1_12\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Great! In each iteration, you are increasing F by 10.\n",
      "  - SUCCESS: Your computation of C is correct. Well done!\n",
      "  - SUCCESS: Your computation of approximate C is correct.\n",
      "  - SUCCESS: You are incrementing the number of rows in each iteration. Great!\n",
      "  - SUCCESS: Wow! Your function returns the correct number of rows.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 12)):\n",
    "    conversion_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.153980Z",
     "iopub.status.busy": "2022-07-29T12:28:20.153285Z",
     "iopub.status.idle": "2022-07-29T12:28:20.170225Z",
     "shell.execute_reply": "2022-07-29T12:28:20.169763Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 1, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_12\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists\n",
    "So far, one variable has referred to one number (or string). Sometimes, however, we naturally have a collection of numbers, e.g. degrees −20, −15, −10, −5, 0, ..., 40. One way to store these values in a computer program would be to have one variable per value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.197931Z",
     "iopub.status.busy": "2022-07-29T12:28:20.197719Z",
     "iopub.status.idle": "2022-07-29T12:28:20.202125Z",
     "shell.execute_reply": "2022-07-29T12:28:20.201570Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "C1 = -20\n",
    "C2 = -15\n",
    "C3 = -10\n",
    "...\n",
    "C13 = 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is clearly a terrible solution, particularly if we have lots of values. A better way of doing this is to collect values together in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.204889Z",
     "iopub.status.busy": "2022-07-29T12:28:20.204684Z",
     "iopub.status.idle": "2022-07-29T12:28:20.208900Z",
     "shell.execute_reply": "2022-07-29T12:28:20.208340Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "C = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now, there is just one variable, `C`, holding all the values. We access elements in a list via an index. List indices are always *zero-indexed*, i.e. they are numbered as 0, 1, 2, and so forth up to the number of elements minus one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.211753Z",
     "iopub.status.busy": "2022-07-29T12:28:20.211528Z",
     "iopub.status.idle": "2022-07-29T12:28:20.224304Z",
     "shell.execute_reply": "2022-07-29T12:28:20.223815Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First element: 4\n",
      "Second element: 6\n",
      "Third element: -3.5\n"
     ]
    }
   ],
   "source": [
    "mylist = [4, 6, -3.5]\n",
    "print(\"First element:\", mylist[0])\n",
    "print(\"Second element:\", mylist[1])\n",
    "print(\"Third element:\", mylist[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here are a few examples of operations that you can perform on lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.227091Z",
     "iopub.status.busy": "2022-07-29T12:28:20.226884Z",
     "iopub.status.idle": "2022-07-29T12:28:20.233642Z",
     "shell.execute_reply": "2022-07-29T12:28:20.233088Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10, -5, 0, 5, 10, 15, 20, 25, 30, 35]\n"
     ]
    }
   ],
   "source": [
    "C = [-10, -5, 0, 5, 10, 15, 20, 25, 30]\n",
    "C.append(35)  # add new element 35 at the end\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.236244Z",
     "iopub.status.busy": "2022-07-29T12:28:20.236046Z",
     "iopub.status.idle": "2022-07-29T12:28:20.241131Z",
     "shell.execute_reply": "2022-07-29T12:28:20.240496Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45]\n"
     ]
    }
   ],
   "source": [
    "C = C + [40, 45]  # And another list to the end of C\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.244125Z",
     "iopub.status.busy": "2022-07-29T12:28:20.243919Z",
     "iopub.status.idle": "2022-07-29T12:28:20.247850Z",
     "shell.execute_reply": "2022-07-29T12:28:20.247210Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45]\n"
     ]
    }
   ],
   "source": [
    "C.insert(0, -15)  # Insert -15 as index 0\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.251846Z",
     "iopub.status.busy": "2022-07-29T12:28:20.251639Z",
     "iopub.status.idle": "2022-07-29T12:28:20.255590Z",
     "shell.execute_reply": "2022-07-29T12:28:20.254948Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-15, -10, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45]\n"
     ]
    }
   ],
   "source": [
    "del C[2]  # delete 3rd element\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.259531Z",
     "iopub.status.busy": "2022-07-29T12:28:20.259328Z",
     "iopub.status.idle": "2022-07-29T12:28:20.263228Z",
     "shell.execute_reply": "2022-07-29T12:28:20.262595Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-15, -10, 5, 10, 15, 20, 25, 30, 35, 40, 45]\n"
     ]
    }
   ],
   "source": [
    "del C[2]  # delete what is now 3rd element\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.267440Z",
     "iopub.status.busy": "2022-07-29T12:28:20.267060Z",
     "iopub.status.idle": "2022-07-29T12:28:20.271125Z",
     "shell.execute_reply": "2022-07-29T12:28:20.270510Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "print(len(C))  # length of list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.275374Z",
     "iopub.status.busy": "2022-07-29T12:28:20.274918Z",
     "iopub.status.idle": "2022-07-29T12:28:20.279041Z",
     "shell.execute_reply": "2022-07-29T12:28:20.278428Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(C.index(10))  # Find the index of the element with the value 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.282560Z",
     "iopub.status.busy": "2022-07-29T12:28:20.282357Z",
     "iopub.status.idle": "2022-07-29T12:28:20.288045Z",
     "shell.execute_reply": "2022-07-29T12:28:20.287484Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(10 in C)  # True only if the value 10 is stored in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.290921Z",
     "iopub.status.busy": "2022-07-29T12:28:20.290530Z",
     "iopub.status.idle": "2022-07-29T12:28:20.295949Z",
     "shell.execute_reply": "2022-07-29T12:28:20.295348Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "print(C[-1])  # The last value in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.298739Z",
     "iopub.status.busy": "2022-07-29T12:28:20.298364Z",
     "iopub.status.idle": "2022-07-29T12:28:20.302460Z",
     "shell.execute_reply": "2022-07-29T12:28:20.302003Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "print(C[-2])  # The second last value in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can also extract sublists using `:`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.305128Z",
     "iopub.status.busy": "2022-07-29T12:28:20.304685Z",
     "iopub.status.idle": "2022-07-29T12:28:20.308592Z",
     "shell.execute_reply": "2022-07-29T12:28:20.308117Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 25, 30, 35, 40, 45]\n"
     ]
    }
   ],
   "source": [
    "print(C[5:])  # From index 5 to the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.311344Z",
     "iopub.status.busy": "2022-07-29T12:28:20.310796Z",
     "iopub.status.idle": "2022-07-29T12:28:20.316490Z",
     "shell.execute_reply": "2022-07-29T12:28:20.315924Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 25]\n"
     ]
    }
   ],
   "source": [
    "print(C[5:7])  # From index 5 up to, but NOT including index 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.319199Z",
     "iopub.status.busy": "2022-07-29T12:28:20.318811Z",
     "iopub.status.idle": "2022-07-29T12:28:20.325566Z",
     "shell.execute_reply": "2022-07-29T12:28:20.324852Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30, 35, 40]\n"
     ]
    }
   ],
   "source": [
    "print(C[7:-1])  # From index 7 up to the second last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.328310Z",
     "iopub.status.busy": "2022-07-29T12:28:20.327972Z",
     "iopub.status.idle": "2022-07-29T12:28:20.333767Z",
     "shell.execute_reply": "2022-07-29T12:28:20.333150Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-15, -10, 5, 10, 15, 20, 25, 30, 35, 40, 45]\n"
     ]
    }
   ],
   "source": [
    "print(C[:])  # [:] specifies the whole list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can also *unpack* the elements of a list into separate variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.336749Z",
     "iopub.status.busy": "2022-07-29T12:28:20.336339Z",
     "iopub.status.idle": "2022-07-29T12:28:20.340666Z",
     "shell.execute_reply": "2022-07-29T12:28:20.340059Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stooge1: Curly, stooge2: Larry, stooge3: Moe\n"
     ]
    }
   ],
   "source": [
    "somelist = [\"Curly\", \"Larry\", \"Moe\"]\n",
    "stooge1, stooge2, stooge3 = somelist\n",
    "print(f\"stooge1: {stooge1}, stooge2: {stooge2}, stooge3: {stooge3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.13: Store odd numbers in a list\n",
    "\n",
    "Write a Python function `odd_numbers(n)` that uses a `while`-loop, and generates and returns a list of all odd numbers from $1$ to $n$. (Make sure that if $n$ is an even number, the largest generated odd number is $n-1$.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.345010Z",
     "iopub.status.busy": "2022-07-29T12:28:20.344604Z",
     "iopub.status.idle": "2022-07-29T12:28:20.347328Z",
     "shell.execute_reply": "2022-07-29T12:28:20.346702Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete code. Do not change the variable names.\n",
    "\n",
    "def odd_numbers(n):\n",
    "    num = 1\n",
    "    odd = []\n",
    "    while num < n:\n",
    "        if(num <= n):      \n",
    "            odd.append(num)\n",
    "            num += 2\n",
    "        else:\n",
    "            break\n",
    "    return odd  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.355725Z",
     "iopub.status.busy": "2022-07-29T12:28:20.355507Z",
     "iopub.status.idle": "2022-07-29T12:28:20.422154Z",
     "shell.execute_reply": "2022-07-29T12:28:20.421518Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_13\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Great! In each iteration, you are appending an odd number to the list.\n",
      "  - SUCCESS: In each iteration, you are increasing the number by 2.\n",
      "  - SUCCESS: Before the loop, you begin with an empty list. Well done!\n",
      "  - SUCCESS: Before the loop, you start with 1.\n",
      "  - SUCCESS: Your function returns the correct solution.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 13)):\n",
    "    odd_numbers(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.425341Z",
     "iopub.status.busy": "2022-07-29T12:28:20.424764Z",
     "iopub.status.idle": "2022-07-29T12:28:20.448426Z",
     "shell.execute_reply": "2022-07-29T12:28:20.447829Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 2\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 2, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_13\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `for`-loops\n",
    "We can visit each element in a list and process it with some statements using a `for`-loop, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.460264Z",
     "iopub.status.busy": "2022-07-29T12:28:20.459864Z",
     "iopub.status.idle": "2022-07-29T12:28:20.478919Z",
     "shell.execute_reply": "2022-07-29T12:28:20.478504Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list element: 0\n",
      "list element: 10\n",
      "list element: 20\n",
      "list element: 40\n",
      "list element: 100\n",
      "The list has 5 elements.\n"
     ]
    }
   ],
   "source": [
    "degrees = [0, 10, 20, 40, 100]\n",
    "for C in degrees:\n",
    "    print(\"list element:\", C)\n",
    "print(f\"The list has {len(degrees)} elements.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Notice again how the statements to be executed within the loop must be indented! Let us now revisit the conversion table example using the `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.487217Z",
     "iopub.status.busy": "2022-07-29T12:28:20.486752Z",
     "iopub.status.idle": "2022-07-29T12:28:20.511845Z",
     "shell.execute_reply": "2022-07-29T12:28:20.511442Z"
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-20 -4.0\n",
      "-15 5.0\n",
      "-10 14.0\n",
      "-5 23.0\n",
      "0 32.0\n",
      "5 41.0\n",
      "10 50.0\n",
      "15 59.0\n",
      "20 68.0\n",
      "25 77.0\n",
      "30 86.0\n",
      "35 95.0\n",
      "40 104.0\n"
     ]
    }
   ],
   "source": [
    "Cdegrees = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n",
    "for C in Cdegrees:\n",
    "    F = (9/5)*C + 32\n",
    "    print(C, F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can easily beautify the table using the *printf syntax* we encountered previously:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.531284Z",
     "iopub.status.busy": "2022-07-29T12:28:20.530843Z",
     "iopub.status.idle": "2022-07-29T12:28:20.552169Z",
     "shell.execute_reply": "2022-07-29T12:28:20.551717Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  -20  -4.0\n",
      "  -15   5.0\n",
      "  -10  14.0\n",
      "   -5  23.0\n",
      "    0  32.0\n",
      "    5  41.0\n",
      "   10  50.0\n",
      "   15  59.0\n",
      "   20  68.0\n",
      "   25  77.0\n",
      "   30  86.0\n",
      "   35  95.0\n",
      "   40 104.0\n"
     ]
    }
   ],
   "source": [
    "for C in Cdegrees:\n",
    "    F = (9.0/5)*C + 32\n",
    "    print(f\"{C:5d} {F:5.1f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "It is also possible to rewrite the `for` loop as a `while` loop, i.e.\n",
    "\n",
    "```python\n",
    "for element in somelist:\n",
    "    # process element\n",
    "```\n",
    "\n",
    "can always be transformed to a `while` loop\n",
    "```python\n",
    "index = 0\n",
    "while index < len(somelist):\n",
    "    element = somelist[index]\n",
    "    # process element\n",
    "    index += 1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us see how a previous example would look like if we used `while` instead of `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.561229Z",
     "iopub.status.busy": "2022-07-29T12:28:20.560999Z",
     "iopub.status.idle": "2022-07-29T12:28:20.578712Z",
     "shell.execute_reply": "2022-07-29T12:28:20.578227Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  -20  -4.0\n",
      "  -15   5.0\n",
      "  -10  14.0\n",
      "   -5  23.0\n",
      "    0  32.0\n",
      "    5  41.0\n",
      "   10  50.0\n",
      "   15  59.0\n",
      "   20  68.0\n",
      "   25  77.0\n",
      "   30  86.0\n",
      "   35  95.0\n",
      "   40 104.0\n"
     ]
    }
   ],
   "source": [
    "Cdegrees = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n",
    "index = 0\n",
    "while index < len(Cdegrees):\n",
    "    C = Cdegrees[index]\n",
    "    F = (9.0/5)*C + 32\n",
    "    print(f\"{C:5d} {F:5.1f}\")\n",
    "    index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Rather than just printing out the Fahrenheit values, let us also store these computed values in a list of their own:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.589655Z",
     "iopub.status.busy": "2022-07-29T12:28:20.589118Z",
     "iopub.status.idle": "2022-07-29T12:28:20.596534Z",
     "shell.execute_reply": "2022-07-29T12:28:20.595950Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-4.0, 5.0, 14.0, 23.0, 32.0, 41.0, 50.0, 59.0, 68.0, 77.0, 86.0, 95.0, 104.0]\n"
     ]
    }
   ],
   "source": [
    "Cdegrees = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n",
    "Fdegrees = []  # start with empty list\n",
    "for C in Cdegrees:\n",
    "    F = (9/5)*C + 32\n",
    "    Fdegrees.append(F)  # add new element to Fdegrees\n",
    "print(Fdegrees)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python, `for` loops usually loop over list values (elements), i.e.\n",
    "\n",
    "```python\n",
    "for element in somelist:\n",
    "    # process variable element\n",
    "```\n",
    "\n",
    "However, we can also loop over list indices:\n",
    "\n",
    "```python\n",
    "for i in range(0, len(somelist), 1):\n",
    "    element = somelist[i]\n",
    "    # process element or somelist[i] directly\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The statement `range(start, stop, increment)` generates a list of integers *start*, *start+increment*, *start+2\\*increment*, and so on up to, but not including, *stop*. We can also write `range(stop)` as an abbreviation for `range(0, stop, 1)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.599500Z",
     "iopub.status.busy": "2022-07-29T12:28:20.599088Z",
     "iopub.status.idle": "2022-07-29T12:28:20.609500Z",
     "shell.execute_reply": "2022-07-29T12:28:20.608957Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):  # same as range(0, 3, 1)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.612232Z",
     "iopub.status.busy": "2022-07-29T12:28:20.611821Z",
     "iopub.status.idle": "2022-07-29T12:28:20.616942Z",
     "shell.execute_reply": "2022-07-29T12:28:20.616307Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 8, 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List comprehensions\n",
    "Consider this example where we compute two lists in a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.622125Z",
     "iopub.status.busy": "2022-07-29T12:28:20.621625Z",
     "iopub.status.idle": "2022-07-29T12:28:20.629837Z",
     "shell.execute_reply": "2022-07-29T12:28:20.628961Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cdegrees =  [-5.0, -4.5, -4.0, -3.5, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5]\n",
      "Fdegrees =  [23.0, 23.9, 24.8, 25.7, 26.6, 27.5, 28.4, 29.3, 30.2, 31.1, 32.0, 32.9, 33.8, 34.7, 35.6, 36.5]\n"
     ]
    }
   ],
   "source": [
    "n = 16\n",
    "\n",
    "# empty lists\n",
    "Cdegrees = []\n",
    "Fdegrees = []\n",
    "\n",
    "for i in range(n):\n",
    "    Cdegrees.append(-5 + i*0.5)\n",
    "    Fdegrees.append((9/5)*Cdegrees[i] + 32)\n",
    "\n",
    "print(\"Cdegrees = \", Cdegrees)\n",
    "print(\"Fdegrees = \", Fdegrees)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "As constructing lists is a very common task, the above way of doing it can become very tedious both to write and read. Therefore, Python has a compact construct, called *list comprehension* for generating lists from a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.637024Z",
     "iopub.status.busy": "2022-07-29T12:28:20.636598Z",
     "iopub.status.idle": "2022-07-29T12:28:20.644877Z",
     "shell.execute_reply": "2022-07-29T12:28:20.644360Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cdegrees =  [-5.0, -4.5, -4.0, -3.5, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5]\n",
      "Fdegrees =  [23.0, 23.9, 24.8, 25.7, 26.6, 27.5, 28.4, 29.3, 30.2, 31.1, 32.0, 32.9, 33.8, 34.7, 35.6, 36.5]\n"
     ]
    }
   ],
   "source": [
    "n = 16\n",
    "Cdegrees = [-5 + i*0.5 for i in range(n)]\n",
    "Fdegrees = [(9/5)*C + 32 for C in Cdegrees]\n",
    "print(\"Cdegrees = \", Cdegrees)\n",
    "print(\"Fdegrees = \", Fdegrees)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The most general form of a list comprehension is:\n",
    "```python\n",
    "somelist = [expression for element in somelist if condition]\n",
    "```\n",
    "\n",
    "Here the `condition` can be used to pick out elements which satisfy a specific property."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercise 1.14: Create a list of even numbers ranging from 0 to $n$ using a `for` loop.\n",
    "\n",
    "Write a function `even_numbers(n)` using a `for` loop, which generates and returns a list of all even numbers from 0 to $n$. For instance, `even_numbers(10)` should return list `[0, 2, 4, 6, 8]`. In this exercise, do not use list comprehensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.651076Z",
     "iopub.status.busy": "2022-07-29T12:28:20.650517Z",
     "iopub.status.idle": "2022-07-29T12:28:20.654163Z",
     "shell.execute_reply": "2022-07-29T12:28:20.653623Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete code. Do not change the variable names.\n",
    "\n",
    "def even_numbers(n):\n",
    "    even = []\n",
    "    for i in range(0,n,2):\n",
    "        if(n%2 == 0):\n",
    "            even.append(i+2)\n",
    "        else:\n",
    "            even.append(i)     \n",
    "    return even\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.663698Z",
     "iopub.status.busy": "2022-07-29T12:28:20.663325Z",
     "iopub.status.idle": "2022-07-29T12:28:20.680610Z",
     "shell.execute_reply": "2022-07-29T12:28:20.680059Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_14\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Great! In each iteration, you are appending an even number to the list.\n",
      "  - SUCCESS: You are iterating over the correct list.\n",
      "  - SUCCESS: Before the loop, you begin with an empty list. Well done!\n",
      "  - SUCCESS: Your function returns the correct solution.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 14)):\n",
    "    even_numbers(11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.683563Z",
     "iopub.status.busy": "2022-07-29T12:28:20.683232Z",
     "iopub.status.idle": "2022-07-29T12:28:20.700955Z",
     "shell.execute_reply": "2022-07-29T12:28:20.700423Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 2\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 2, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_14\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.15: Implement the sum function\n",
    "\n",
    "The built-in Python function [sum](https://docs.python.org/3/library/functions.html#sum) takes a list as an argument and computes the sum of the elements in the list:\n",
    "```python\n",
    ">> sum([1, 3, 5, -5])\n",
    "4\n",
    "```\n",
    "Implement your own version of the sum function and name it `my_sum`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.713265Z",
     "iopub.status.busy": "2022-07-29T12:28:20.713036Z",
     "iopub.status.idle": "2022-07-29T12:28:20.715702Z",
     "shell.execute_reply": "2022-07-29T12:28:20.715074Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete this code - keep the names the same for testing purposes.\n",
    "import numpy as np\n",
    "\n",
    "def my_sum(x):\n",
    "    num = 0\n",
    "    for i in x:\n",
    "        num += i\n",
    "    return num\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.724451Z",
     "iopub.status.busy": "2022-07-29T12:28:20.723957Z",
     "iopub.status.idle": "2022-07-29T12:28:20.738774Z",
     "shell.execute_reply": "2022-07-29T12:28:20.738194Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_15\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Great! In each iteration, you are adding a list element to the sum variable.\n",
      "  - SUCCESS: You are iterating over the list elements instead over indices.\n",
      "  - SUCCESS: Before the loop, you set the sum to be zero. Well done!\n",
      "  - SUCCESS: Your function returns the correct solution.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 15)):\n",
    "    my_sum([2.1, 98, -451, 273, 1111, 23.98])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.741709Z",
     "iopub.status.busy": "2022-07-29T12:28:20.741271Z",
     "iopub.status.idle": "2022-07-29T12:28:20.757050Z",
     "shell.execute_reply": "2022-07-29T12:28:20.756415Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 3\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 3, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_15\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.16: Position of the ball in a vertical motion.\n",
    "\n",
    "Write a function `distance` that returns a `list` of $y$ values calculated using the formula:\n",
    "\n",
    "$$y(t) = v_0t − {1\\over2} gt^2,$$\n",
    "\n",
    "for `n` number of values $t$ ranging from `t_start` to `t_end`. Specify the keyword arguments `v0=6.0` and `g=9.81`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.772708Z",
     "iopub.status.busy": "2022-07-29T12:28:20.772280Z",
     "iopub.status.idle": "2022-07-29T12:28:20.775146Z",
     "shell.execute_reply": "2022-07-29T12:28:20.774514Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0, -15.65625, -92.625, -230.90625, -430.5]"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Uncomment and complete this code - keep the names the same for testing purposes.\n",
    "\n",
    "def distance(t_start, t_end, n, v0=6.0, g=9.81):\n",
    "    t_1 = (t_end-t_start)/(n-1)\n",
    "    t = t_start\n",
    "    y = []\n",
    "    while t <= t_end:\n",
    "        y.append(v0*t-0.5*g*t**2)\n",
    "        t = t + t_1\n",
    "    return y\n",
    "distance(0, 10, 5)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.784456Z",
     "iopub.status.busy": "2022-07-29T12:28:20.784051Z",
     "iopub.status.idle": "2022-07-29T12:28:20.801206Z",
     "shell.execute_reply": "2022-07-29T12:28:20.800617Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_16\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: Great! You are iterating over the correct values of t.\n",
      "  - SUCCESS: You are appending the positions to a list. Well done!\n",
      "  - SUCCESS: Before the loop, you start with an empty list. Amazing!\n",
      "  - SUCCESS: Your time step value is correct.\n",
      "  - SUCCESS: Your function returns the correct solution.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 16)):\n",
    "    distance(0, 10, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.804170Z",
     "iopub.status.busy": "2022-07-29T12:28:20.803727Z",
     "iopub.status.idle": "2022-07-29T12:28:20.820097Z",
     "shell.execute_reply": "2022-07-29T12:28:20.819413Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 3\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 3, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_16\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.17: Cumulative sum\n",
    "\n",
    "Write a function that returns the cumulative sum of the numbers in a list. The function should return a list, whose `i`-th element is the sum of the input list up to and including the `i`-th element.\n",
    "\n",
    "For example, for the list `[1, 4, 2, 5, 3]` should return `[1, 5, 7, 12, 15]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.836014Z",
     "iopub.status.busy": "2022-07-29T12:28:20.835428Z",
     "iopub.status.idle": "2022-07-29T12:28:20.839194Z",
     "shell.execute_reply": "2022-07-29T12:28:20.838613Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete this code - keep the names the same for testing purposes.\n",
    "\n",
    "def my_cumsum(x):\n",
    "    cumsum = []\n",
    "    y = 0\n",
    "    for i in x:\n",
    "        y = i+y\n",
    "        cumsum.append(y)\n",
    "    return cumsum\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.848171Z",
     "iopub.status.busy": "2022-07-29T12:28:20.847968Z",
     "iopub.status.idle": "2022-07-29T12:28:20.862825Z",
     "shell.execute_reply": "2022-07-29T12:28:20.862258Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_17\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: You are appending the correct cumulative sum to a list. Well done!\n",
      "  - SUCCESS: Before the loop, you start with an empty list. Amazing!\n",
      "  - SUCCESS: Wow! Your function returns the correct solution.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 17)):\n",
    "    my_cumsum([55, 111, -33, 65])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.865582Z",
     "iopub.status.busy": "2022-07-29T12:28:20.865371Z",
     "iopub.status.idle": "2022-07-29T12:28:20.885527Z",
     "shell.execute_reply": "2022-07-29T12:28:20.885018Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 2\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 2, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_17\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.18: Bouncing ball\n",
    "\n",
    "A rubber ball is dropped from a height `h_0`. After each bounce, the height it rebounds to decreases by 10%, i.e. after one bounce, it reaches `0.9*h_0`, after two bounces it reaches `0.9*0.9*h_0`, etc. Write a Python function `compute_heights` that returns a list of the maximum heights of the ball after each bounce (including after 0 bounces, i.e. its initial height), until either the ball has bounced `n` times *or* its maximum height falls below `h1`. The function should take `h_0`, `h_1` and `n` as keyword arguments, with default values of `1.0`, `0.3` and `10`, respectively.\n",
    "\n",
    "**HINT:** If `n` bounces of the ball are not reached, the last value of height in the list should be the first height at which the ball fell below `h1`. More precisely, the last value is less than `h1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.899998Z",
     "iopub.status.busy": "2022-07-29T12:28:20.899778Z",
     "iopub.status.idle": "2022-07-29T12:28:20.902153Z",
     "shell.execute_reply": "2022-07-29T12:28:20.901639Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0,\n",
       " 0.9,\n",
       " 0.81,\n",
       " 0.7290000000000001,\n",
       " 0.6561000000000001,\n",
       " 0.5904900000000002,\n",
       " 0.5314410000000002,\n",
       " 0.47829690000000014,\n",
       " 0.43046721000000016,\n",
       " 0.38742048900000015,\n",
       " 0.34867844010000015]"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Uncomment and complete this code - keep the names the same for testing purposes.\n",
    "\n",
    "def compute_heights(h_0=1.0, h_1=0.3, n=10):\n",
    "    h = h_0\n",
    "    h_n = []\n",
    "    h_n.append(h) \n",
    "\n",
    "    for i in range(n):\n",
    "        h = 0.9*h\n",
    "        h_n.append(h)\n",
    "        if h < h_1:\n",
    "            break\n",
    "        \n",
    "  #  if h > h_1:    \n",
    "    while h > h_1:\n",
    "        h = 0.9*h\n",
    "        n += 1\n",
    "   \n",
    "    return h_n\n",
    "compute_heights(h_0=1.0, h_1=0.3, n=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.911722Z",
     "iopub.status.busy": "2022-07-29T12:28:20.911491Z",
     "iopub.status.idle": "2022-07-29T12:28:20.938039Z",
     "shell.execute_reply": "2022-07-29T12:28:20.937435Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_18\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: You are appending the correct height to a list. Well done!\n",
      "  - SUCCESS: You are counting the bounces correctly. Well done!\n",
      "  - SUCCESS: Before the loop, you start with an empty list. Amazing!\n",
      "  - SUCCESS: Before the loop, you set the ounter to zero. Great!\n",
      "  - SUCCESS: Wow! Your function returns the correct solution.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 18)):\n",
    "    compute_heights(h_0=1.0, h_1=0.3, n=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.941090Z",
     "iopub.status.busy": "2022-07-29T12:28:20.940874Z",
     "iopub.status.idle": "2022-07-29T12:28:20.961473Z",
     "shell.execute_reply": "2022-07-29T12:28:20.960983Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 4\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 4, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 298,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_18\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.19: Calculate $\\pi$\n",
    "\n",
    "A formula for $\\pi$ is given by the *Gregory-Leibniz series*:\n",
    "\n",
    "$$\\pi = 4 \\left(\\frac{1}{1} - \\frac{1}{3} + \\frac{1}{5} - \\frac{1}{7} + \\frac{1}{9} + ...  \\right)$$\n",
    "\n",
    "Note that the denominators of the terms in this series are the positive odd numbers. Write a Python function `calculate_pi(n)` following the guidelines below; each of the first three steps can be completed using a single list comprehension.\n",
    "\n",
    "**Step 1**:\n",
    "\n",
    "Produce a list of the first `n` odd numbers, for `n=100`.\n",
    "\n",
    "**Step 2**:\n",
    "\n",
    "Make a list of the signs of each term, i.e. `[1, -1, 1, -1, ...]`. Hint: think about the value of $(-1)^i$ for integer $i$.\n",
    "\n",
    "**Step 3**:\n",
    "\n",
    "Using the results of steps 1 and 2, make a list of the first `n` terms in the above series.\n",
    "\n",
    "**Step 4**:\n",
    "\n",
    "Use your `my_sum` function to sum this series, multiply by 4, and return the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.974179Z",
     "iopub.status.busy": "2022-07-29T12:28:20.973971Z",
     "iopub.status.idle": "2022-07-29T12:28:20.976572Z",
     "shell.execute_reply": "2022-07-29T12:28:20.975949Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Uncomment and complete this code - keep the names the same for testing purposes.\n",
    "import numpy as np\n",
    "def calculate_pi(n):\n",
    "    s1 = list(range(0,2*n)[1::2])\n",
    "    s2 = [(-1)**i for i in range(n)]\n",
    "    s4 = [j/i for i,j in zip(s1,s2)]\n",
    "    pi = 4 * sum(s4)\n",
    "    return pi    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:20.985779Z",
     "iopub.status.busy": "2022-07-29T12:28:20.985579Z",
     "iopub.status.idle": "2022-07-29T12:28:21.044068Z",
     "shell.execute_reply": "2022-07-29T12:28:21.043405Z"
    },
    "tags": [
     "pybryt"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "REFERENCE: exercise-1_19\n",
      "SATISFIED: True\n",
      "MESSAGES:\n",
      "  - SUCCESS: You generated odd integers correctly. Amazing!\n",
      "  - SUCCESS: You generated the signs list correctly. Well done!\n",
      "  - SUCCESS: Great! You computed series terms correctly.\n",
      "  - SUCCESS: Wow! Your function returns the correct solution.\n"
     ]
    }
   ],
   "source": [
    "with pybryt.check(pybryt_reference(1, 19)):\n",
    "    calculate_pi(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:21.046975Z",
     "iopub.status.busy": "2022-07-29T12:28:21.046757Z",
     "iopub.status.idle": "2022-07-29T12:28:21.067839Z",
     "shell.execute_reply": "2022-07-29T12:28:21.067220Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Running tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Test summary\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'passed': 1, 'failed': 0, 'locked': 0}"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.grade(\"exercise-1_19\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-29T12:28:21.080491Z",
     "iopub.status.busy": "2022-07-29T12:28:21.079975Z",
     "iopub.status.idle": "2022-07-29T12:28:21.252129Z",
     "shell.execute_reply": "2022-07-29T12:28:21.251611Z"
    },
    "tags": [
     "okpy"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
      "Scoring tests\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.2\n",
      "    Passed: 3\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.3\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.4\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.5\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.5\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.7\n",
      "    Passed: 2\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.8\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.9\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.11\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.12\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.13\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.14\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.15\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.16\n",
      "    Passed: 2\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.17\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.18\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "question 1.19\n",
      "    Passed: 1\n",
      "    Failed: 0\n",
      "[ooooooooook] 100.0% passed\n",
      "\n",
      "---------------------------------------------------------------------\n",
      "Point breakdown\n",
      "    question 1.2: 1.0/1\n",
      "    question 1.3: 1.0/1\n",
      "    question 1.4: 1.0/1\n",
      "    question 1.5: 1.0/1\n",
      "    question 1.7: 1.0/1\n",
      "    question 1.8: 1.0/1\n",
      "    question 1.9: 1.0/1\n",
      "    question 1.11: 1.0/1\n",
      "    question 1.12: 1.0/1\n",
      "    question 1.13: 1.0/1\n",
      "    question 1.14: 1.0/1\n",
      "    question 1.15: 1.0/1\n",
      "    question 1.16: 1.0/1\n",
      "    question 1.17: 1.0/1\n",
      "    question 1.18: 1.0/1\n",
      "    question 1.19: 1.0/1\n",
      "\n",
      "Score:\n",
      "    Total: 16.0\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Total': 16.0}"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ok.score()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.9.12"
  },
  "metadata": {
   "interpreter": {
    "hash": "09160679218cef01ff15815045f22f73847c787608cecc83e75aba7b6298eccd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}