Section_08_Additional_Examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Additional Examples\n",
    "\n",
    "- [Overview](#Overview)\n",
    "- [Example - Guessing game](#Example---Guessing-game)\n",
    "- [Example - Approximation pi](#Example---Approximation-pi)\n",
    "- [Example - Water tank](#Example---Water-tank)\n",
    "- [Example - Finding Prime numbers](#Example---Finding-Prime-numbers)\n",
    "- [Example - Longest Collatz sequence](#Example---Longest-Collatz-sequence)\n",
    "- [Example - Loading cycles of a spring](#Example---Loading-cycles-of-a-spring)\n",
    "- [Example - Interpolation](#Example---Interpolation)\n",
    "- [Example - Goldbach's other conjecture](#Example---Goldbach%E2%80%99s-other-conjecture)\n",
    "- [Recap](#Recap)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "- Problem solving through using *Python* $\\to$ using and nesting functions and structures as required to solve the problem\n",
    "\n",
    "\n",
    "- Nested structures $\\to$ simple structure nested inside another simple structure $\\to$ for example: a for-loop nested inside a while-loop\n",
    "\n",
    "\n",
    "- Examples we have seen so far:\n",
    "    - Nested loops: for every outer loop iteration the nested inner loop (indented) is executed and does all of it's iterations\n",
    "    - Nested if statements: code inside inner if-elif statement executes only when both outer and inner conditions are True.\n",
    "\n",
    "\n",
    "- Nested structures needed to solve a given problem $\\to$ problem specific $\\to$ can vary from problem to problem\n",
    "\n",
    "\n",
    "- Different solution strategies $\\to$ lead to different nested structures needed to solve the given problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Guessing game\n",
    "\n",
    "- Write a program that throws 2 dice and adds their values together (`2 + 6 = 8`).\n",
    "\n",
    "\n",
    "- The program must then ask the user to guess what the answer is.\n",
    "\n",
    "\n",
    "- The program must give the user a max of three guesses to try answer correctly.\n",
    "\n",
    "\n",
    "- The program must also print to the screen if the user guessed too high or too low or correctly.\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Break the problem down into smaller pieces\n",
    "\n",
    "\n",
    "- Identify what structures are needed to solve the problem\n",
    "\n",
    "\n",
    "- Why a `while` loop and not a `for` loop?\n",
    "\n",
    "\n",
    "- Correctly implement nested structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def random_dice_sum():\n",
    "    die1 = np.random.randint(1, 7)\n",
    "    die2 = np.random.randint(1, 7)\n",
    "    return die1 + die2  # sum of 2 dice\n",
    "\n",
    "\n",
    "def print_info(guess, dice_sum):\n",
    "    if guess == dice_sum:\n",
    "        print(\"Correct\")\n",
    "    elif guess > dice_sum:\n",
    "        print(\"Too high\")\n",
    "    elif guess < dice_sum:\n",
    "        print(\"Too low\")\n",
    "\n",
    "\n",
    "def play_game(max_guess):\n",
    "    cnt = 0\n",
    "    guess = 0\n",
    "    dice_sum = random_dice_sum()\n",
    "    while (guess != dice_sum) and (cnt < max_guess):\n",
    "        # guess = int(input(\"Guess the sum of 2 dice: \"))\n",
    "        guess = np.random.randint(2, 13)\n",
    "        print('Current guess is ',guess)\n",
    "        print_info(guess, dice_sum)\n",
    "        cnt = cnt + 1\n",
    "    print(\"The answer was {}\".format(dice_sum))\n",
    "\n",
    "\n",
    "play_game(max_guess=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example - Approximation pi\n",
    "\n",
    "<img src=\"./figures/darts_pi_approx.svg\" alt=\"Pi Approximation Darts\" style=\"height: 300px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Areas: \n",
    "\n",
    "    $$ \\frac{Ac}{As} = \\frac{\\frac{\\pi R^2}{4}}{\\frac{4 R^2}{4}} = \\frac{\\pi}{4} $$\n",
    "\n",
    "\n",
    "- Approximation (Throwing darts):\n",
    "\n",
    "    $$\\frac{\\text{darts in circle}}{\\text{darts in square}} \\approx \\frac{\\pi}{4}$$\n",
    "    $$\\therefore \\; \\pi \\approx 4 \\left( \\frac{\\text{darts in circle}}{\\text{darts in square}} \\right)$$\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Break the problem down into smaller pieces\n",
    "\n",
    "\n",
    "- Identify what structures are needed to solve the problem\n",
    "\n",
    "\n",
    "- Correctly implement nested structures\n",
    "\n",
    "\n",
    "- Different radius -> `numpy.random.uniform(a, b)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def random_dart_position(radius):\n",
    "    x = np.random.uniform(-radius, radius)\n",
    "    y = np.random.uniform(-radius, radius)\n",
    "    return x, y  # random x and y dart coordinates\n",
    "\n",
    "\n",
    "def in_the_circle(x, y, radius):\n",
    "    # return True if the dart is in the circle else False\n",
    "    dist = (x**2 + y**2) ** 0.5\n",
    "    return (dist < radius)\n",
    "\n",
    "\n",
    "def pi_approx(radius, tol):\n",
    "    cnt_circle = 0\n",
    "    cnt_square = 0\n",
    "    error = 1\n",
    "    while (error >= tol):\n",
    "        x, y = random_dart_position(radius)\n",
    "        cnt_square = cnt_square + 1\n",
    "        if in_the_circle(x, y, radius):\n",
    "            cnt_circle = cnt_circle + 1\n",
    "        approx = 4.0 * cnt_circle / cnt_square\n",
    "        error = abs(np.pi - approx)\n",
    "    return approx, cnt_square\n",
    "\n",
    "\n",
    "approx, ndarts = pi_approx(radius=2, tol=1e-6)\n",
    "print(\"approx:\", approx)\n",
    "print(\"actual:\", np.pi)\n",
    "print(\"num darts:\", ndarts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Water tank\n",
    "\n",
    "- Consider an array called `inflows` that contains the volume of fluid ($m^3$) that will flow into a tank every hour of a day.\n",
    "\n",
    "\n",
    "- At the beginning of the day the tank is empty.\n",
    "\n",
    "\n",
    "- The water in the tank must be discharged at the beginning of an hour when the additional water that would flow into the tank in the comming hour would exceed the reservoir's capacity of 100 $m^3$.\n",
    "\n",
    "\n",
    "- The discharge empties the tank completely and is instantaneous.  When it happens, the valve writes a 1 to the list of valve readings for the comming hour, otherwise it remains closed and then writes a 0 to this list.\n",
    "\n",
    "\n",
    "- Write a program that generates\n",
    "  - the input array `inflows`,\n",
    "  - a list of the tank levels for every hour of the day,\n",
    "  - the list of valve readings for every hour of the day\n",
    "\n",
    "  and calculates how many times during the day the valve opened.\n",
    "\n",
    "\n",
    "- Use random inflows between 0 and 50 $m^3$ for every hour over a day."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Outcomes:\n",
    "\n",
    "- Break the problem down into smaller pieces\n",
    "\n",
    "\n",
    "- Identify what structures are needed to solve the problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext nbtutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%nbtutor -r -f\n",
    "from numpy import random\n",
    "\n",
    "def simulate_water_tank(capacity, flow_rates):\n",
    "    tank_level = 0\n",
    "    tank_history = []\n",
    "    valve_reading = []\n",
    "    for inflow in flow_rates:\n",
    "        if (tank_level + inflow) <= capacity:\n",
    "            # tank will not overflow -> valve stays closed\n",
    "            tank_level = tank_level + inflow\n",
    "            tank_history.append(tank_level)\n",
    "            valve_reading.append(0)\n",
    "\n",
    "        else:\n",
    "            # tank will overflow -> valve is opened\n",
    "            tank_level = inflow\n",
    "            tank_history.append(tank_level)\n",
    "            valve_reading.append(1)\n",
    "\n",
    "    return tank_history, valve_reading\n",
    "\n",
    "\n",
    "#inflows = np.random.randint(0, 51, 24)\n",
    "inflows = random.uniform(0, 51, 24)\n",
    "tank, valve = simulate_water_tank(capacity=100, flow_rates=inflows)\n",
    "print(\"Inflow rates:\\n\",inflows)\n",
    "print(\"Tank Level:\\n\", tank)\n",
    "print(\"Valve Readings:\\n\", valve)\n",
    "print(\"Number of discharges per day:\", sum(valve))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Finding Prime numbers\n",
    "\n",
    "- Write a program that finds the prime numbers from 2 to N.\n",
    "\n",
    "\n",
    "- The program must save the prime numbers in a list. Use `N = 120`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Outcomes:\n",
    "\n",
    "- Break the problem down into smaller pieces\n",
    "\n",
    "\n",
    "- Identify what structures are needed to solve the problem\n",
    "\n",
    "\n",
    "- Correctly implement nested structures\n",
    "\n",
    "\n",
    "- Can we improve the efficiency of the prime number test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def is_prime(num):\n",
    "    cnt_div = 0\n",
    "    for div in np.arange(2, num, 1):  # Note: for loop not entered if num is 1 or 2\n",
    "        #print(num,div)  # Use this print only to confirm that \"break\" statement in line 9 improves efficiency.\n",
    "        if num % div == 0:\n",
    "            cnt_div = cnt_div + 1\n",
    "            #break\n",
    "    return (cnt_div == 0)\n",
    "\n",
    "\n",
    "def primes_list(N):\n",
    "    primes = []\n",
    "    #primes = [1,2] # Use only when for loop below is run for odd numbers only.\n",
    "    for num in np.arange(1, N+1, 1):  # iterate over all numbers from 1 to N\n",
    "    #for num in np.arange(3, N+1, 2):  # iterate over all odd numbers from 3 to N\n",
    "        if is_prime(num):\n",
    "            # grow a list of only prime numbers\n",
    "            primes.append(num)\n",
    "    return primes\n",
    "\n",
    "\n",
    "primes = primes_list(N=120)\n",
    "print(\"The primes found are:\\n\", primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Longest Collatz sequence\n",
    "\n",
    "- The following iterative sequence is defined for the set of positive integers:\n",
    "    - $n \\to n/2$ (`n` is even)\n",
    "    - $n \\to 3n + 1$ (`n` is odd)\n",
    "\n",
    "\n",
    "- Using the rule above and starting with 13, we generate the following sequence:\n",
    "    - 13, 40, 20, 10, 5, 16, 8, 4, 2, 1\n",
    "\n",
    "\n",
    "- Which starting number, under 10000, produces the longest chain?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Outcomes:\n",
    "\n",
    "- Identify what structures are needed to solve the problem\n",
    "\n",
    "\n",
    "- Correctly implement nested structures\n",
    "\n",
    "\n",
    "- Break the problem down into smaller pieces\n",
    "\n",
    "\n",
    "- Test for and store a maximum or minimum number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def next_num(num):\n",
    "    if (num % 2) == 0:\n",
    "        return num / 2\n",
    "    else:\n",
    "        return 3*num + 1\n",
    "\n",
    "\n",
    "def collatze(num):\n",
    "    # return a list of collatze sequence terms\n",
    "    chain = [num]\n",
    "    while num > 1:\n",
    "        num = next_num(num)\n",
    "        chain.append(num)\n",
    "    return chain\n",
    "\n",
    "\n",
    "def longest_collatze(N):\n",
    "    longest = 0\n",
    "    for start_num in np.arange(1, N+1, 1):  # iterate over all numbers from 1 to N\n",
    "        chain = collatze(num=start_num)\n",
    "        if len(chain) > longest:\n",
    "            # keep track of the longest sequence\n",
    "            longest = len(chain)\n",
    "            sequence = chain\n",
    "    return longest, sequence\n",
    "\n",
    "\n",
    "nterms, sequence = longest_collatze(N=1000)\n",
    "print(\"Max chain length:\", nterms)\n",
    "print(\"Starting number:\", sequence[0])\n",
    "print(\"Sequence:\\n\", sequence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Loading cycles of a spring\n",
    "\n",
    "- You are given a list of values representing the force acting on a spring.\n",
    "\n",
    "\n",
    "- You need to compute the number of load and unload cycles where\n",
    "    - load cycle -> when the force is the same or consecutively increases\n",
    "    - unload cycle -> when force consecutively decreases\n",
    "\n",
    "\n",
    "- Use a list of 10 forces where each force is a random number between 0 and 20."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Outcomes:\n",
    "\n",
    "- Break the problem down into smaller pieces\n",
    "\n",
    "\n",
    "- Identify the required structures to solve the problem\n",
    "\n",
    "\n",
    "- Correctly implement nested structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "\n",
    "def plot_forces(forces):\n",
    "    from matplotlib import pyplot as plt\n",
    "    plt.plot(forces)\n",
    "    #plt.show()\n",
    "\n",
    "\n",
    "def cycle_start_counters(forces):\n",
    "    f0 = forces[0]\n",
    "    f1 = forces[1]\n",
    "    if f1 >= f0:\n",
    "        # starts with loading\n",
    "        return 1, 0\n",
    "    else:\n",
    "        # starts with unloading\n",
    "        return 0, 1\n",
    "\n",
    "\n",
    "def start_load_cycle(i, forces):\n",
    "    # return True if changes from unloading to loading else False\n",
    "    f0 = forces[i-1]\n",
    "    f1 = forces[i]\n",
    "    f2 = forces[i+1]\n",
    "    # gradient change from - to + (flat inclusive)\n",
    "    #return (f0 >= f1 and f1 <= f2) # Original line; seems incorrect.\n",
    "    return (f0 > f1 and f1 <= f2)\n",
    "\n",
    "\n",
    "def start_unload_cycle(i, forces):\n",
    "    # return True if changes from loading to unloading else False\n",
    "    f0 = forces[i-1]\n",
    "    f1 = forces[i]\n",
    "    f2 = forces[i+1]\n",
    "    # gradient change from + to - (flat exclusive)\n",
    "    #return (f0 < f1 and f1 > f2) # Original line; seems incorrect.\n",
    "    return (f0 <= f1 and f1 > f2)\n",
    "\n",
    "\n",
    "def count_cycles(forces):\n",
    "    load, unload = cycle_start_counters(forces)\n",
    "    for i in np.arange(1, len(forces)-1, 1):\n",
    "        if start_load_cycle(i, forces):\n",
    "            load = load + 1\n",
    "        elif start_unload_cycle(i, forces):\n",
    "            unload = unload + 1\n",
    "        # What about \"else\"?\n",
    "    return load, unload\n",
    "\n",
    "\n",
    "forces = np.random.uniform(0, 20, 10)\n",
    "plot_forces(forces)\n",
    "load_cycles, unload_cycles = count_cycles(forces)\n",
    "print(\"Loading cycles:\", load_cycles)\n",
    "print(\"Unloading cycles:\", unload_cycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Interpolation\n",
    "\n",
    "| $x$ data | $y$ data |\n",
    "|:--------:| --------:|\n",
    "|    0     |  0.0000  |\n",
    "|    1     |  0.8415  |\n",
    "|    2     |  0.9093  |\n",
    "|    3     |  0.1411  |\n",
    "|    4     | -0.7568  |\n",
    "|    5     | -0.9589  |\n",
    "|    6     | -0.2794  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What is the corresponding `y` values for the following:\n",
    "    - `x = [1.2, 2.1, 2.9, 3.5, 4.8, 5.3, 5.7]`\n",
    "\n",
    "\n",
    "- As we only have discrete data points and no known function to use, we have to estimate the y values\n",
    "\n",
    "\n",
    "- We will consider two ways to interpolate between the data points in order to determine the y values\n",
    "\n",
    "\n",
    "- Linear interpolation:\n",
    "    $$ y(x) = y_0 + (y_1 − y_0)\\frac{x − x_0}{x_1 − x_0} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./figures/Interpolation_example_linear.svg\" alt=\"Linear Interpolation\" style=\"height: 400px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Interpolation\n",
    "\n",
    "- Calculate the corresponding interpolated `y` values, from the data points, using the linear interpolation method\n",
    "\n",
    "\n",
    "\n",
    "### Outcomes:\n",
    "\n",
    "- Think about the problem in terms of functions\n",
    "\n",
    "\n",
    "- Test the function/s independently\n",
    "\n",
    "\n",
    "- Generic, reusable function $\\to$ interpolate for different `x` and `y` data points? $\\to$ input into the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def interpolate_single_point(x, x0, x1, y0, y1):   # single point x between x0 & x1\n",
    "    return y0 + (y1 - y0) * ((x - x0) / (x1 - x0))\n",
    "\n",
    "\n",
    "def interpolate(xval, xdata, ydata):    # single point xval somewhere inside xdata range\n",
    "    for i in np.arange(0, len(xdata)-1, 1):\n",
    "        print(i)\n",
    "        x0 = xdata[i]\n",
    "        x1 = xdata[i+1]\n",
    "        if x0 <= xval and xval <= x1:\n",
    "            y0 = ydata[i]\n",
    "            y1 = ydata[i+1]\n",
    "            y = interpolate_single_point(xval, x0, x1, y0, y1)\n",
    "            break\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "\n",
    "xdata = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0]\n",
    "ydata = [0.0, 0.8415, 0.9093, 0.1411, -0.7568, -0.9589, -0.2794]\n",
    "\n",
    "ylinear = []\n",
    "xvalues = [0.8, 1.2, 1.6, 2.1, 2.9, 3.5, 4.8, 5.3, 5.7]\n",
    "for xval in xvalues:\n",
    "    y = interpolate(xval, xdata, ydata)\n",
    "    ylinear.append(y)\n",
    "\n",
    "plt.plot(xdata, ydata, 'ro')\n",
    "plt.plot(xvalues, ylinear, 'b^')\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example - Goldbach’s other conjecture\n",
    "\n",
    "- It was proposed by Christian Goldbach that every odd composite number can be written as the sum of a prime and twice a square (any square).\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "     9 &= 7 + 2 × 1^2 \\\\\n",
    "    15 &= 7 + 2 × 2^2 \\\\\n",
    "    21 &= 3 + 2 × 3^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "\n",
    "- It turns out that the conjecture was false.\n",
    "\n",
    "\n",
    "- What is the smallest odd composite that cannot be written as the sum of a prime and twice a square?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Outcomes:\n",
    "\n",
    "- Think about the problem in terms of functions\n",
    "\n",
    "\n",
    "- Easier to understand and develop the code with functions than without functions\n",
    "\n",
    "\n",
    "- Test separate functionality of a problem independently"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def is_prime(num):\n",
    "    #midpoint = int(num**0.5) + 1  # This miscalculates 2 as a composite number\n",
    "    midpoint = int(num**0.5)\n",
    "    for div in np.arange(2, midpoint+1, 1):\n",
    "        if num % div == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "\n",
    "def is_square(num):\n",
    "    return num == (int(num**0.5))**2\n",
    "\n",
    "\n",
    "def primes_list(N):\n",
    "    primes = []\n",
    "    for num in np.arange(1, N+1, 1):\n",
    "        if is_prime(num):\n",
    "            primes.append(num)\n",
    "    return primes\n",
    "\n",
    "\n",
    "def conjecture_valid(num):\n",
    "    primes = primes_list(num)\n",
    "    for p in primes:\n",
    "        test_num = (num - p) / 2\n",
    "        if is_square(test_num):\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(primes_list(100))\n",
    "len(primes_list(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(primes_list(1000))\n",
    "len(primes_list(1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 1\n",
    "run = True\n",
    "\n",
    "while run:\n",
    "    if not is_prime(num):\n",
    "        run = conjecture_valid(num)\n",
    "    num = num + 2\n",
    "\n",
    "msg = \"The number {} cannot be expressed as [prime + 2*(num**2)].\"\n",
    "print(msg.format(num-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 1\n",
    "run = True\n",
    "\n",
    "while run:\n",
    "    if not is_prime(num):\n",
    "        run = conjecture_valid(num)\n",
    "        \n",
    "    if run:\n",
    "        num = num + 2\n",
    "\n",
    "msg = \"The number {} cannot be expressed as [prime + 2*(num**2)].\"\n",
    "print(msg.format(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Recap\n",
    "\n",
    "- Nested structures\n",
    "    - Nested structures needed to solve a given problem → problem specific → can vary from problem to problem\n",
    "    - Different solution strategies → lead to different nested structures needed to solve the given problem\n",
    "\n",
    "### Recap Quiz\n",
    "\n",
    "- How many times will Display be printed?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for number1 in range(1, 5, 1):\n",
    "    for number2 in range(1, 3, 1):\n",
    "        if number1 > number2:\n",
    "            print('Display')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- How many times will Display be printed?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for number1 in range(1, 5, 1):\n",
    "    for number2 in range(1, number1, 1):\n",
    "        print(\"Display\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "- How many mistakes can you spot? (5 in total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iseven(num):\n",
    "    even = True\n",
    "    if num % 2 == 0:\n",
    "        even = True\n",
    "    return num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 12\n",
    "b = \"13\"\n",
    "print(is_even(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What gets printed to the screen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_number(entries, num):\n",
    "    my_sum = 0\n",
    "    for val in entries:\n",
    "        if val == num:\n",
    "            my_sum = my_sum + num\n",
    "    return my_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 4, 3, 3, 6, 8, 3, 2, 1]\n",
    "a = 3\n",
    "print(sum_number(numbers, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Visualize",
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}