Practical_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practical 2 - Loops and conditional statements\n",
    "\n",
    "In today's practical we are going to continue practicing working with loops whilst also moving on to the use of conditional statements.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Objectives:</b> The objectives of todays practical are:\n",
    "\n",
    " - 1) [Loops: FOR loops continued](#Part1)\n",
    "      * [Exercise 1: Cycling through arrays and modifying values](#Exercise1)\n",
    " - 2) [Conditional statements: IF, ELSE and ELIF](#Part2)\n",
    "      * [Exercise 2: Modify a loop to implement one of two equations according to a condition being met](#Exercise2)\n",
    " - 3) [Nested loops: Working with more than 1 dimension](#Part3)\n",
    "      * [Exercise 3: Print out the result from a nested loop according to a condition being met](#Exercise3)\n",
    "      * [Exercise 4: Print out which variables match a condition](#Exercise4)\n",
    "      * [Exercise 5: Repeat Bob Newby's code breaking nested loops to crack the code in the Hawkins lab](#Exercise5)\n",
    "\n",
    "Please note that you should not feel pressured to complete every exercise in class. These practicals are designed for you to take outside of class and continue working on them. Proposed solutions to all exercises can be found in the 'Solutions' folder.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Please note:</b> After reading the instructions and aims of any exercise, search the code snippets for a note that reads ------'INSERT CODE HERE'------ to identify where you need to write your code \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b> Using Google Colabs </b> Please note that the first code block ensures that we can install the module Cartopy IF we are running this example on Google Colab. Please run this code block and, if you are not on Google Colab, you will recieve a message that confirms this. If you are on Colabs, you will see messages regarding the status of the installation.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'google.colab' in str(get_ipython()):\n",
    "    from google.colab import drive\n",
    "    mount='/content/gdrive'\n",
    "    print(\"Colab: mounting Google drive on \", mount)\n",
    "    drive.mount(mount)\n",
    "    drive_root = mount + \"/My Drive/Colab Notebooks/DEES_first_year/DEES_programming_course\"\n",
    "    # Change to the directories to get data files\n",
    "    print(\"\\nColab: Changing directory to \", drive_root)\n",
    "    %cd $drive_root\n",
    "else:\n",
    "    print('Not running on CoLab')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Loops: FOR loops continued <a name=\"Part1\">\n",
    "\n",
    "Let us jump straight into our first exercise, following on from the previous practical.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 1: Cycling through arrays and modifying values. <a name=\"Exercise1\">  </b> Create a loop that implements the function:\n",
    "\n",
    "\\begin{eqnarray} \n",
    "Y = X^{2.8/X}\n",
    "\\end{eqnarray}\n",
    "\n",
    "Where <code> x </code> is an array of 75 values from 11 to 85. Print the final 4 values of the <code> x </code> and <code> Y </code> array one-by-one. Your output should be:\n",
    "\n",
    "```python\n",
    "The 72nd element of x is  82\n",
    "The 72nd element of y is  1.1623843156991178\n",
    "The 73rd element of x is  83\n",
    "The 73rd element of y is  1.1607534518329277\n",
    "The 74th element of x is  84\n",
    "The 74th element of y is  1.1591580160090038\n",
    "The 75th element of x is  85\n",
    "The 75th element of y is  1.157596831308393\n",
    "```\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 72nd element of x is  82\n",
      "The 72nd element of y is  1.1623843156991178\n",
      "The 73rd element of x is  83\n",
      "The 73rd element of y is  1.1607534518329277\n",
      "The 74th element of x is  84\n",
      "The 74th element of y is  1.1591580160090038\n",
      "The 75th element of x is  85\n",
      "The 75th element of y is  1.157596831308393\n"
     ]
    }
   ],
   "source": [
    "# Initiliase an empty list for both 'x' and 'y'\n",
    "x = []\n",
    "y = []\n",
    "\n",
    "# Now loop through 75 values and append each list accordingly.\n",
    "# One list contained values for 'x', the other 'y'.\n",
    "# Please note the operator ** is needed to raise one number to another [e.g 2**3]\n",
    "#------'INSERT CODE HERE'------\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#------------------------------\n",
    "    \n",
    "# Print the last four values from both our x and y arrays\n",
    "print(\"The 72nd element of x is \",x[71])\n",
    "print(\"The 72nd element of y is \",y[71])\n",
    "\n",
    "print(\"The 73rd element of x is \",x[72])\n",
    "print(\"The 73rd element of y is \",y[72])\n",
    "\n",
    "print(\"The 74th element of x is \",x[73])\n",
    "print(\"The 74th element of y is \",y[73])\n",
    "\n",
    "print(\"The 75th element of x is \",x[74])\n",
    "print(\"The 75th element of y is \",y[74])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Conditional statements: The IF, ELIF and ELSE statements  <a name=\"Part2\">\n",
    "\n",
    "Once we have information stored in an array, or wish to generate information iteratively, we start to use a combination of **loops** and **conditional statements**. Conditional statements allow us to develop software that can be responsive to certain conditions. For example, in the following control flow diagram we define a set of instructions that initiate a variable and start a loop that adds 3 to this variable at each iteration. However, at each iteration we also check the value of said variable and if it becomes equals or greater than 30, we stop the program.\n",
    "\n",
    "![](https://github.com/loftytopping/DEES_programming_course/blob/master/images/If_example.png?raw=true)\n",
    "\n",
    "The following table lists the Python equivalent of common mathematical symbols to check numerical values.\n",
    "\n",
    "| Meaning | Math Symbol | Python Symbols |\n",
    "| --- | --- | --- |\n",
    "| Less than\t | < | < | \n",
    "| Greater than\t | > | > | \n",
    "| Less than or equal | ≤ | <= | \n",
    "| Greater than or equal | ≥ | >= | \n",
    "| Equals | = | == | \n",
    "| Not equal | ≠ | != | \n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b> Warning </b> The obvious choice for equals, a single equal sign, is not used to check for equality. It is a common error to use only one equal sign when you mean to test for equality, and not make an assignment!\n",
    "</div>\n",
    "\n",
    "How do we implement checks using these symbols? This is where we use the <code> IF </code>, <code> ELIF </code> and <code> ELSE </code> statements. Let us start with an example. \n",
    "\n",
    "```python\n",
    "# Initialise two variables with integer values\n",
    "x=3\n",
    "y=5\n",
    "# Now use an IF statement to check the relative values of x and y, then act accordingly\n",
    "if x > y:\n",
    "    print(\"X is greater than Y\")\n",
    "...    \n",
    "if x < y:\n",
    "    print(\"X is less than Y\")\n",
    "...\"X is less than Y\"\n",
    "```\n",
    "\n",
    "Once again, notice how we have introduced a statement that ends with a colon : and thus requires the next line to be indented. We also use specific symbols to check whether one value is greater than [>] or less than [<] another. Within each condition check, depending on which is true, we print a message to the screen.\n",
    "\n",
    "Rather than use two <code> IF </code> statements, we could combine these checks using an <code> ELSE </code> statement as follows:\n",
    "\n",
    "```python\n",
    "# Initialise two variables with integer values\n",
    "x=3\n",
    "y=5\n",
    "# Now use an IF statement to check the relative values of x and y, then act accordingly\n",
    "if x > y:\n",
    "    print(\"X is greater than Y\")    \n",
    "else x < y:\n",
    "    print(\"X is less than Y\")\n",
    "\"X is less than Y\"\n",
    "```\n",
    "\n",
    "There are a huge number of examples we could work on here, but to begin let us build on the first exercise. In the following code we again have two variables <code> x </code> and <code> y </code>. Each has 50 elements. Let us assume that we want to implement two functions: one that is used if our <code> x </code> value is *less than or equal* to 20, the other if <code> x </code> is *greater than* 20. We can use a combination of the <code> IF </code> and <code> ELSE </code> statements.\n",
    "\n",
    " - If $X$ is *less than or equal* to 20, $ Y = \\frac{X}{12.5} $\n",
    " - Otherwise [else], $Y = X^{12.5} $\n",
    "\n",
    "Let us see this implemented as code below. Read through the syntax and if you do not understand, please ask. \n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Indexing </b> Once again, notice how we have introduced a statement that ends with a colon : and thus requires the next line to be indented. \n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 1st element of x is  1\n",
      "The 1st element of y is  0.08\n",
      "The 2nd element of x is  2\n",
      "The 2nd element of y is  0.16\n",
      "The 3rd element of x is  3\n",
      "The 3rd element of y is  0.24\n",
      "The 4th element of x is  4\n",
      "The 4th element of y is  0.32\n",
      "The 47th element of x is  47\n",
      "The 47th element of y is  7.965686757032835e+20\n",
      "The 48th element of x is  48\n",
      "The 48th element of y is  1.0363715136605023e+21\n",
      "The 49th element of x is  49\n",
      "The 49th element of y is  1.341068619663965e+21\n",
      "The 50th element of x is  50\n",
      "The 50th element of y is  1.7263349150062194e+21\n"
     ]
    }
   ],
   "source": [
    "# Initiliase an empty list for both 'x' and 'y'\n",
    "x = []\n",
    "y = []\n",
    "\n",
    "for step in range(50):\n",
    "\n",
    "    # Append a value to our x array\n",
    "    x.append(step+1)\n",
    "    \n",
    "    # Now add a conditional statement to check the value of x\n",
    "    # Notice our additional indentation\n",
    "    if x[step] <= 20:\n",
    "        # Append a value to our y array\n",
    "        y.append(x[step]/12.5)\n",
    "    else:\n",
    "        # Append a value to our y array\n",
    "        y.append(x[step]**12.5)\n",
    "    \n",
    "# Print the first and last four values from both our x and y arrays\n",
    "\n",
    "# First four\n",
    "print(\"The 1st element of x is \",x[0])\n",
    "print(\"The 1st element of y is \",y[0])\n",
    "\n",
    "print(\"The 2nd element of x is \",x[1])\n",
    "print(\"The 2nd element of y is \",y[1])\n",
    "\n",
    "print(\"The 3rd element of x is \",x[2])\n",
    "print(\"The 3rd element of y is \",y[2])\n",
    "\n",
    "print(\"The 4th element of x is \",x[3])\n",
    "print(\"The 4th element of y is \",y[3])\n",
    "\n",
    "# Last four\n",
    "print(\"The 47th element of x is \",x[46])\n",
    "print(\"The 47th element of y is \",y[46])\n",
    "\n",
    "print(\"The 48th element of x is \",x[47])\n",
    "print(\"The 48th element of y is \",y[47])\n",
    "\n",
    "print(\"The 49th element of x is \",x[48])\n",
    "print(\"The 49th element of y is \",y[48])\n",
    "\n",
    "print(\"The 50th element of x is \",x[49])\n",
    "print(\"The 50th element of y is \",y[49])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The AND statment\n",
    "\n",
    "Once we move beyond two mutually exclusive conditions, we can also use the <code> ELIF </code> statements. However we need to be careful that we are assigning correct boundaries on our conditions. For example, let us assume we have been tasked with creating an array <code> X </code> that contains values from 1 to 200 and we want to implement 3 equations according to the following rules:\n",
    "    \n",
    " - If X is less than 20, use: $ Y = \\frac{X}{1.56} $\n",
    " - If X is greater than or equal to 20, but less than 60 use: $ Y = X^{0.35} $ \n",
    " - If X is greater than or equal to 60 use: $ Y = 4.5*X $ \n",
    " \n",
    "Below we implement two different versions of a loop using the conditional statements introduced earlier:\n",
    "\n",
    "```python\n",
    "# Version 1\n",
    "if x[step] < 20:\n",
    "    <<action>>    \n",
    "elif x[step] >= 20:\n",
    "    <<action>>\n",
    "elif x[step] >= 60\n",
    "    <<action>>\n",
    "```\n",
    "```python\n",
    "# Version 2\n",
    "if x[step] < 20:\n",
    "    <<action>>    \n",
    "elif x[step] >= 20 and x[step] < 60:\n",
    "    <<action>>\n",
    "elif x[step] >= 60\n",
    "    <<action>>\n",
    "```\n",
    "\n",
    "The first version will work, but produce incorrect results. Why is that? If you follow the code instructions, as the Python interpreter would, once <code> x[step] </code> is greater than 20 the second conditional statement will always be true. As a result, it will never have to move to the third. In the second version however, the second conditional will no longer be true once <code> x[step] </code> is greater than or equal to 60. \n",
    "\n",
    "Let us run both versions and plot the results so you can see the difference. In the following code I will create two <code> Y </code> arrays, one for each loop variant. A line plot will be produced where you should see a step change in values according to these rules. Do not worry about the syntax or module used to create the plot, we will visit this throughout the course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initiliase an empty list for both 'x' and 'y'\n",
    "x = []\n",
    "y_version1 = []\n",
    "y_version2 = []\n",
    "\n",
    "for step in range(200):\n",
    "\n",
    "    # Append a value to our x array\n",
    "    x.append(step+1)\n",
    "    \n",
    "    # Version 1\n",
    "    if x[step] < 20:\n",
    "        # Append a value to our y array\n",
    "        y_version1.append(x[step]/1.56)\n",
    "    elif x[step] >= 20:\n",
    "        # Append a value to our y array\n",
    "        y_version1.append(x[step]**0.35)\n",
    "    elif x[step] >= 60:\n",
    "        y_version1.append(4.5*x[step])\n",
    "        \n",
    "    # Version 2\n",
    "    if x[step] < 20:\n",
    "        # Append a value to our y array\n",
    "        y_version2.append(x[step]/1.56)\n",
    "    elif x[step] >= 20 and x[step] < 60:\n",
    "        # Append a value to our y array\n",
    "        y_version2.append(x[step]**0.35)\n",
    "    elif x[step] >= 60:\n",
    "        y_version2.append(4.5*x[step])\n",
    "    \n",
    "# Plot results\n",
    "import matplotlib.pyplot as plt # Import Matplotlib so we can plot results\n",
    "import numpy as np # The Numpy package - more soon!!\n",
    "fig = plt.figure(figsize=(8,8))\n",
    "ax = plt.axes()\n",
    "ax.plot(np.array(x),np.log(y_version1),label='Version 1')\n",
    "ax.plot(np.array(x),np.log(y_version2),label='Version 2')\n",
    "ax.set_title('Y as a function of X')\n",
    "ax.legend(loc='upper left')\n",
    "ax.set_ylabel('Y')\n",
    "ax.set_xlabel('X')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 2: Modify a loop to implement one of three equations according to a condition being met.  <a name=\"Exercise2\"> </b> In this case, let us assume an array <code> X </code> contains values from 1 to 1000 and we want to implement 3 equations according to the following rules:\n",
    "    \n",
    " - If X is less than or equal to 250, $ Y = X^{1.03} $\n",
    " - If X is greater than 250, but less than 690 $ Y = X^{1.2} $ \n",
    " - If X is greater than or equal to 690, $ Y = X^{2.5} $ \n",
    "\n",
    "This is the first graph we have created. Do not worry about the syntax for now, we will produce graphs in every practical following this.\n",
    "\n",
    "Your output should look like the following:\n",
    "\n",
    "![Expected output from simulation](images/Practical2_example.png)\n",
    "\n",
    "\n",
    "</div>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initiliase an empty list for both 'x' and 'y'\n",
    "x = []\n",
    "y = []\n",
    "\n",
    "for step in range(1000):\n",
    "\n",
    "    # Append a value to our x array\n",
    "    x.append(step+1)\n",
    "    \n",
    "    #------'INSERT CODE HERE'------\n",
    "    # Now add a conditional statement to check the value of x\n",
    "    # Notice the additional indentation\n",
    "    \n",
    "    \n",
    "    \n",
    "    #------------------------------\n",
    "    \n",
    "# Print the first and last four values from both our x and y arrays\n",
    "\n",
    "#Import plotting package\n",
    "import matplotlib.pyplot as plt # Import Matplotlib so we can plot results\n",
    "import numpy as np # The Numpy package - more soon!!\n",
    "fig = plt.figure(figsize=(8,8))\n",
    "ax = plt.axes()\n",
    "ax.plot(np.array(x),np.log(y))\n",
    "ax.set_title('Y as a function of X')\n",
    "ax.set_ylabel('Y')\n",
    "ax.set_xlabel('X')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) Nested loops: Working with more than 1 dimension <a name=\"Part3\">\n",
    "\n",
    "In many applications we want to work with more than one variable at a time, often in a two [or more] dimensional setting. We can combine <code> FOR </code> loops on any number of levels. For example, take the following hypothetical example:\n",
    "\n",
    "```python\n",
    "for [first iterating variable] in [outer loop]: # Outer loop\n",
    "    [do something]  # Optional\n",
    "    for [second iterating variable] in [nested loop]:   # Nested loop\n",
    "        [do something]  \n",
    "```\n",
    "\n",
    "Notice how we have our first, or 'outer' loop cycling through our first iterating variable. As we cycle through this variable, we then 'do something' as a direct consequence. However, directly following this action, we cycle through a second iterating variable as part of our 'nested loop'. In other words, we have a loop that is nested within our first, or outer. \n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Indexing </b> Once again, notice how we have introduced a statement that ends with a colon : and thus requires the next line to be indented. \n",
    "</div>\n",
    "\n",
    "Let us run an example of cycling through a list of words. In this case we are not using the \n",
    "```python \n",
    "range() \n",
    "```\n",
    "function as we are not dealing with numeric examples or cycling through integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "George\n",
      "Hello\n",
      "Frank\n",
      "Hello\n",
      "Susan\n",
      "Hello\n",
      "Sarah\n",
      "Goodbye\n",
      "George\n",
      "Goodbye\n",
      "Frank\n",
      "Goodbye\n",
      "Susan\n",
      "Goodbye\n",
      "Sarah\n"
     ]
    }
   ],
   "source": [
    "# Create two lists of words\n",
    "list1 = ['Hello','Goodbye']\n",
    "list2 = ['George','Frank','Susan','Sarah']\n",
    "\n",
    "for word1 in list1:\n",
    "    for word2 in list2:\n",
    "        print(word1)\n",
    "        print(word2)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turns out we can make the output easier to read by adding each word together, with a space ' ' in between as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello George\n",
      "Hello Frank\n",
      "Hello Susan\n",
      "Hello Sarah\n",
      "Goodbye George\n",
      "Goodbye Frank\n",
      "Goodbye Susan\n",
      "Goodbye Sarah\n"
     ]
    }
   ],
   "source": [
    "# Create two lists of words\n",
    "list1 = ['Hello','Goodbye']\n",
    "list2 = ['George','Frank','Susan','Sarah']\n",
    "\n",
    "for word1 in list1:\n",
    "    for word2 in list2:\n",
    "        print(word1+' '+word2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will not be exploring the rich text processing power of Python in this course, but if you are interested there are some great examples to follow on the [internet](https://towardsdatascience.com/gentle-start-to-natural-language-processing-using-python-6e46c07addf3). The important lesson here is noticing how we deal with a nested loop. Please also note that we can use a <code> FOR </code> loop to iterate on members of any list, whether they are numeric or string values.\n",
    "\n",
    "Again we can use conditional statements to modify our output. What if we only wanted to output entries involving Susan? We can add a conditional statement as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Susan\n",
      "Goodbye Susan\n"
     ]
    }
   ],
   "source": [
    "# Create two lists of words\n",
    "list1 = ['Hello','Goodbye']\n",
    "list2 = ['George','Frank','Susan','Sarah']\n",
    "\n",
    "for word1 in list1:\n",
    "    for word2 in list2:\n",
    "        if word2 == \"Susan\":\n",
    "            print(word1+' '+word2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 3: Print out the result from a nested loop according to a condition being met  <a name=\"Exercise3\"> </b> \n",
    "    \n",
    "In this exercise we have three lists with the following entries:\n",
    "    \n",
    "```python\n",
    " list1 = ['Maths','Physics','Programming','Chemistry']\n",
    " list2 = ['is','can be','is not']    \n",
    " list3 = ['enjoyable','awful!','ok, I guess','....']    \n",
    "```\n",
    "    \n",
    "Your task is to create a triple nested loop and only print out when the word in list1 is 'Physics' and the entry in list2 is 'can be'.\n",
    "There are multiple ways to achieve this.\n",
    "\n",
    "Your results should look like the following:\n",
    "\n",
    "```python\n",
    "Physics can be enjoyable\n",
    "Physics can be awful!\n",
    "Physics can be ok, I guess\n",
    "Physics can be ....\n",
    "```\n",
    "\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Physics can be enjoyable\n",
      "Physics can be awful!\n",
      "Physics can be ok, I guess\n",
      "Physics can be ....\n"
     ]
    }
   ],
   "source": [
    "# Create three lists of words\n",
    "\n",
    "#------'INSERT CODE HERE'------\n",
    "list1 = ['Maths','Physics','Programming','Chemistry']\n",
    "list2 = ['is','can be','is not']    \n",
    "list3 = ['enjoyable','awful!','ok, I guess','....']    \n",
    "\n",
    "# First loop\n",
    " \n",
    "    # Second loop\n",
    "\n",
    "        # Third loop\n",
    "         \n",
    "            \n",
    "#------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 4: Print out which variables match a condition  <a name=\"Exercise4\"> </b> \n",
    "    \n",
    "In this exercise we have two variables, <code> x </code> and <code> y </code> taking on a value from two loops that cycle through 80 values.\n",
    "\n",
    "```python\n",
    "for x in range(80):\n",
    "    for y in range(80):\n",
    "        [do something]\n",
    "```\n",
    "\n",
    "Your task is to identify which combinations of <code> x </code> and <code> y </code> through the function:\n",
    "\n",
    "\\begin{eqnarray} \n",
    "Z = Y+X^{2}\n",
    "\\end{eqnarray}\n",
    "\n",
    "produce a value of <code> Z </code> = 80\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  1\n",
      "y =  79\n",
      "x =  2\n",
      "y =  76\n",
      "x =  3\n",
      "y =  71\n",
      "x =  4\n",
      "y =  64\n",
      "x =  5\n",
      "y =  55\n",
      "x =  6\n",
      "y =  44\n",
      "x =  7\n",
      "y =  31\n",
      "x =  8\n",
      "y =  16\n"
     ]
    }
   ],
   "source": [
    "#------'INSERT CODE HERE'------\n",
    "\n",
    "\n",
    "#------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 5: Repeat Bob Newby's code breaking nested loops to crack the code in the Hawkins lab <a name=\"Exercise5\"> </b> \n",
    "    \n",
    "In this exercise we imagine that we are tasked with finding the value of a password that is different everytime the program is executed. This will be generated by an internal Python function and used to create a string which has 5 numbers in it. We then have to create a 5 level nested loop to combine 5 different numbers into one word and when this matches the one generated by the internal Python function the attempted, thus correct, password is printed to the screen.\n",
    "\n",
    "The code box below provides you with indentend lines in which to enter the rest of the code required. The first loop is provided. As part of the 5th loop you will need to combine all of the individual numbers, as strings, into one word and then check if this is the same as the internally generated password. You can use the following commands for this, assuming that you call each letter as letter1, letter2 etc.\n",
    "\n",
    "```python\n",
    "password_attempt = letter1+letter2+letter3+letter4+letter5\n",
    "if password_attempt == password_string:\n",
    "    print(\"Passwords match!, attempted password = \",password_attempt)\n",
    "```\n",
    "\n",
    "Once you have finished, why not see how many steps have been taken to arrive at the correct password? Also, in the current version the loops will carry on even after the condition has been met.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "password =  84713\n",
      "Passwords match!, attempted password =  84713\n"
     ]
    }
   ],
   "source": [
    "# The following imports a module [see Practical 3] and then creates a string of a random number of 5 digits\n",
    "from random import randint\n",
    "n=5\n",
    "password_string = ''.join([\"{}\".format(randint(0, 9)) for num in range(0, 5)])\n",
    "print(\"password = \", password_string)\n",
    "\n",
    "# Now create a 5 level nested loop which prints when the successful password has been met\n",
    "\n",
    "#------'INSERT CODE HERE'------\n",
    "\n",
    "# First loop\n",
    "for step1 in range(10):\n",
    "    letter1 = str(step1) # Convert number to a string\n",
    "    # Second loop\n",
    "     \n",
    "        # Third loop\n",
    "         \n",
    "            # Fourth loop\n",
    "             \n",
    "                # Fifth loop\n",
    "                 \n",
    "                        \n",
    "#------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}