DSA_2023_Entry.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# Initialize Otter\n",
    "import otter\n",
    "grader = otter.Notebook(\"DSA_2023_Entry.ipynb\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B1DroRwx3ENZ"
   },
   "source": [
    "## DSA 2023 Summer School Admittance Check\n",
    "\n",
    "Thanks for your interest in attending DSA Kigali 2023. To attend the summer school you have to have some level of basic Python proficiency. Completing the following notebook should ensure you have the right kind of background to benefit maximally from the Summer School. See you in Kigali!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7Upwjh9U3ENa"
   },
   "outputs": [],
   "source": [
    "# Run these once ... Just in case \n",
    "# !pip install nose \n",
    "# !pip install otter-grader\n",
    "import IPython\n",
    "from IPython import get_ipython\n",
    "# Import the good stuff\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import math\n",
    "from nose.tools import assert_equal\n",
    "import otter\n",
    "grader = otter.Notebook()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6ibmmx8r3ENc"
   },
   "source": [
    "**Question 1:** Write a Python function to return a tuple of primes and non primes given an integer input "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CWjGPqaO3ENc",
    "tags": []
   },
   "outputs": [],
   "source": [
    "#function to return a tuple of primes and non primes given an integer input \n",
    "def sieve(num):\n",
    "    # Create a boolean list of size num+1 and initialize all values to True\n",
    "    prime = [True for i in range(num + 1)]\n",
    "    p = 2\n",
    "    while (p * p <= num):\n",
    "        # If prime[p] is not changed, then it is a prime\n",
    "        if (prime[p] == True):\n",
    "            # Update all multiples of p\n",
    "            for i in range(p * 2, num + 1, p):\n",
    "                prime[i] = False\n",
    "        p += 1\n",
    "    # Create a list of primes\n",
    "    primes = []\n",
    "    # Create a list of non primes\n",
    "    non_primes = []\n",
    "    for p in range(2, num + 1):\n",
    "        if prime[p]:\n",
    "            primes.append(p)\n",
    "        else:\n",
    "            non_primes.append(p)\n",
    "    return (tuple(primes), tuple(non_primes))\n",
    "num = 30\n",
    "print(\"Following are the prime and non prime numbers smaller than or equal to\", num)\n",
    "print(sieve(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ntYqVxEQ3ENd"
   },
   "source": [
    "**Question 2:** Create a dictionary to store the type and number of unique characters in the paragraph provided"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LlZ8GC4J3ENe",
    "tags": []
   },
   "outputs": [],
   "source": [
    "paragraph = \"The following is sample text I used to practice special characters using keybr.com: 112233445566778899 Saturn V rocket’s first stage carries 203,400 gallons (770,000 liters) of kerosene fuel and 318,000 gallons (1.2 million liters) of liquid oxygen needed for combustion. At liftoff, the stage’s five F-1 rocket engines ignite and produce 7.5 million pounds of thrust. To replace those goofy quantities with the far less retarded metric system (even though liters are considered part of the metric system they are the same as cubic deci-meters) you would say 770 cubic meters of kerosene {abbreviated as m3} and 1,204 m3 of liquid O2 [O2 is the symbol for oxygen]. We would also say it produced 33,600,000 newtons of force <abbreviated as N>. To add scientific notation {a way of writing numbers that allows you to write only as many digits `of specificity` as you would like} you can write 7.7 * 10 ^ 2 m3 of kerosene 1.204 * 10 ^ 3 m3 of O2 and 3.3 * 10 ^ 7 newtons. Another way to write scientific notation is to replace the “* 10 ^” with ‘E’ -/capital e\\-. So our numbers would look like:s\"\n",
    "# initialize the dictionary.\n",
    "dictionary = {}\n",
    "\n",
    "# loop that iterates through each character in a string \n",
    "for char in paragraph:\n",
    "       # if the character is not already in the dictionary, add it with a count of 1\n",
    "    if char not in dictionary:\n",
    "        dictionary[char] = 1\n",
    "\n",
    "    # if the character is already in the dictionary, increment its count by 1\n",
    "    else:\n",
    "        dictionary[char] += 1\n",
    "\n",
    "print(dictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ylvPVW8m3ENe"
   },
   "source": [
    "**Question 3:** Extract the values from the dictionary above into a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "I50ccd1SJMn4",
    "tags": []
   },
   "outputs": [],
   "source": [
    "keysList = list(dictionary.values())\n",
    "print (keysList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hucvAvprJMn5"
   },
   "source": [
    "**Question 4:** Extract the keys from the dictionary above into a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wLHoBNERJMn5",
    "tags": []
   },
   "outputs": [],
   "source": [
    "valuesList = list(dictionary.keys())\n",
    "print (valuesList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9PpnMsGpJMn5"
   },
   "source": [
    "**Question 5:** Merge the two lists into a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UDWWh3vQJMn5",
    "tags": []
   },
   "outputs": [],
   "source": [
    "valueList_tuple = tuple(valuesList)\n",
    "keyList_tuple = tuple(keysList)\n",
    "#  merge the two tuples\n",
    "final_tuple = (valueList_tuple, keyList_tuple)\n",
    "print(final_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 6:**  Write a function `greatest_common_divisor` that takes two inputs `a` and `b` and returns the greatest common divisor of the two numbers. E.g. input `(10, 15)` would return `5`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def greatest_common_divisor(a, b):\n",
    "    # if b is 0, return a\n",
    "    if b == 0:\n",
    "        return a\n",
    "    # otherwise, return the GCD of b and the remainder of a/b\n",
    "    else:\n",
    "        return greatest_common_divisor(b, a % b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 7:**  Write a function `get_nearest_farthest` that takes in a point of interest (pt) and a list of points and returns the nearest point and the farthest point from the point of intest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_nearest_farthest(pt, ptlist):\n",
    "    # initialize the nearest and farthest points to the first point in the list\n",
    "    nearest = farthest = ptlist[0]\n",
    "    # initialize the nearest and farthest distances to the distance between the first point and the point we are comparing it to\n",
    "    nearest_dist = farthest_dist = math.sqrt((nearest[0] - pt[0]) ** 2 + (nearest[1] - pt[1]) ** 2)\n",
    "    # loop through the list of points\n",
    "    for point in ptlist:\n",
    "        # calculate the distance between the point and the point we are comparing it to\n",
    "        dist = math.sqrt((point[0] - pt[0]) ** 2 + (point[1] - pt[1]) ** 2)\n",
    "        # if the distance is less than the nearest distance, update the nearest distance and nearest point\n",
    "        if dist < nearest_dist:\n",
    "            nearest_dist = dist\n",
    "            nearest = point\n",
    "        # if the distance is greater than the farthest distance, update the farthest distance and farthest point\n",
    "        if dist > farthest_dist:\n",
    "            farthest_dist = dist\n",
    "            farthest = point\n",
    "    # return the nearest and farthest points\n",
    "    return (nearest, farthest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q7\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 8:**  Write a function `perfectly_divisible` to return a list of numbers between 0 and a number $N$ that are perfectly divisible by $q$ (with out leaving a remainder). <br>\n",
    "**Hint**: $N$ should also be inclusive in the numbers being considered. If N is negative use N == 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def perfectly_divisible(N, q):\n",
    "    # initialize the list of numbers\n",
    "    nums = []\n",
    "    # loop through the numbers between 0 and N\n",
    "    for i in range(0, N + 1):\n",
    "        # if the number is perfectly divisible by q, add it to the list\n",
    "        if i % q == 0:\n",
    "            nums.append(i)\n",
    "    # return the list of numbers\n",
    "    return nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q8\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 9:**  Write a function `flatten_lists` that takes in a list of lists and outputs a sorted list of elements of sublists of the input list (confusing right?) <br>\n",
    "Example: given `flatten_lists([[2,13,44], [6,7]])` it should return `[2,6,7,13,44]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def flatten_lists(lists):\n",
    "    # initialize the list of elements\n",
    "    elements = []\n",
    "    # loop through the list of lists\n",
    "    for lst in lists:\n",
    "        # loop through the list\n",
    "        for element in lst:\n",
    "            # add the element to the list of elements\n",
    "            elements.append(element)\n",
    "    # sort the list of elements\n",
    "    elements.sort()\n",
    "    # return the list of elements\n",
    "    return elements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "grader.check(\"q9\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The Extra Mile!** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_egf664jJMn5"
   },
   "source": [
    "**Download the dataset \"Nakuru Sensor Data for February 2023 from https://open.africa/dataset/sensorsafrica-airquality-archive-nakuru/resource/14165682-37dd-4f40-914e-eb24619e4ef8\"**\n",
    "\n",
    "Load the 'timestamp','value_type' and 'value' collumns into a pandas dataframe "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r2lE0yrPJMn5"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from functools import reduce\n",
    "\n",
    "#Load the 'timestamp','value_type' and 'value' collumns into a pandas dataframe \n",
    "\n",
    "df = pd.read_csv(r'tmpc57lj4n6.csv',usecols=['timestamp','value_type','value'],delimiter=';')\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Er6lemMeJMn5"
   },
   "source": [
    "**Question E1:** Create a new collumn 'timestamp_new' from 'timestamp' rounded off to the second "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sQq3JIaVJMn5",
    "tags": []
   },
   "outputs": [],
   "source": [
    "df['timestamp_new'] = pd.to_datetime(df['timestamp']).dt.round('S')\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_HM8DysCJMn6"
   },
   "source": [
    "**Question E2:** Split the dataframe based on the 'value_type' collumn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "z3NUYMOZJMn6",
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped = df.groupby('value_type')\n",
    "df_temperature = grouped.get_group('temperature')\n",
    "df_humidity = grouped.get_group('humidity')\n",
    "df_P1 = grouped.get_group('P1')\n",
    "df_P2 = grouped.get_group('P2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YAEsAuUvJMn6"
   },
   "source": [
    "**Question E3:** Find the mean, mode and median of the humidity, temperature, P1 and P2 values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "14T6jzZ_JMn6",
    "tags": []
   },
   "outputs": [],
   "source": [
    "mu_temp = df_temperature['value'].mean()\n",
    "med_temp = df_temperature['value'].median()\n",
    "sd_temp = df_temperature['value'].std()\n",
    "print(\"Temperature\")\n",
    "print(\"Mean = \",mu_temp, \"Median = \", med_temp, \"Standard Deviation = \", sd_temp)\n",
    "\n",
    "mu_humidity = df_humidity['value'].mean()\n",
    "med_humidity = df_humidity['value'].median()\n",
    "sd_humidity = df_humidity['value'].std()\n",
    "print(\"Humidity\")\n",
    "print(\"Mean = \",mu_humidity, \"Median = \", med_humidity, \"Standard Deviation = \", sd_humidity)\n",
    "\n",
    "mu_P1 = df_P1['value'].mean()\n",
    "med_P1 = df_P1['value'].median()\n",
    "sd_P1 = df_P1['value'].std()\n",
    "print(\"P1\")\n",
    "print(\"Mean = \",mu_P1, \"Median = \", med_P1, \"Standard Deviation = \", sd_P1)\n",
    "\n",
    "mu_P2 = df_P2['value'].mean()\n",
    "med_P2 = df_P2['value'].median()\n",
    "sd_P2 = df_P2['value'].std()\n",
    "print(\"P2\")\n",
    "print(\"Mean = \",mu_P2, \"Median = \", med_P2, \"Standard Deviation = \", sd_P2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EKWBykh-JMn6"
   },
   "source": [
    "**Question E4:** Merge the grouped dataframes into one dataframe and save it as newdata.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4mQSIPfhJMn6",
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_merged = pd.merge(df_temperature, df_humidity, on='timestamp_new')\n",
    "df_merged = pd.merge(df_merged, df_P1, on='timestamp_new')\n",
    "df_merged = pd.merge(df_merged, df_P2, on='timestamp_new')\n",
    "print(df_merged)\n",
    "\n",
    "from pathlib import Path  \n",
    "filepath = Path('newdata.csv')  \n",
    "filepath.parent.mkdir(parents=True, exist_ok=True)  \n",
    "df_merged.to_csv(filepath)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PNLVvAvbJMn6"
   },
   "source": [
    "**Question E5:** Open the new data file and select only 'timestamp_new','value_temperature','value_humidity','value_P1' and 'value_P2' collunms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4fyxaLq2JMn6",
    "tags": []
   },
   "outputs": [],
   "source": [
    "new_df = pd.read_csv(r'newdata.csv',usecols=['timestamp_new','value_x','value_y','value_x.1','value_y.1'],delimiter=',')\n",
    "new_df = new_df.rename(columns={'value_x':'value_temperature','value_y':'value_humidity','value_x.1':'value_P1','value_y.1':'value_P2'})\n",
    "new_df "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fh5va_ODJMn6"
   },
   "source": [
    "**Question E6:** Replace the missing values in collumns 'value_P1' and 'value_P2' with the mean of the same collumns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RAm29MW0JMn7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Check for missing values \n",
    "missing_values = new_df.isnull().sum()\n",
    "\n",
    "# displaying data only with NaN\n",
    "new_df[new_df.isnull().any(axis=1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JJ2zFruYJMn7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(\"The mean of P1\",new_df['value_P2'].mean())\n",
    "print(\"The mean of P2\",new_df['value_P1'].mean())\n",
    "\n",
    "#replace missing values with the mean \n",
    "new_df['value_P1'].fillna(new_df['value_P1'].mean(), inplace=True)\n",
    "new_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "syjHmz-AJMn7"
   },
   "source": [
    "**Question E7:** Compute the correlations between temperature and humidity; P1 and P2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "agvSVKsEJMn7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Correlation between temperature and humidity\n",
    "corr_temp_hum = new_df['value_temperature'].corr(new_df['value_humidity'])\n",
    "\n",
    "print (\"Correlation between temparature and humidity\",corr_temp_hum)\n",
    "\n",
    "#Correlation between P1 and P2\n",
    "corr_p1_p2 = new_df['value_P1'].corr(new_df['value_P2'])\n",
    "\n",
    "print (\"Correlation between P1 and P2\",corr_p1_p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bIy00VyKJMn7"
   },
   "source": [
    "**Question E8:** Create a new dataframe comprising of the average values of the variables by day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qb_G74GPJMn7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_merged['date'] = df_merged['timestamp_new'].dt.date\n",
    "\n",
    "means_feb = df_merged.groupby('date').mean()\n",
    "means_feb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jXrFVTUPJMn7"
   },
   "source": [
    "**Question E9:** Download the dataset \"Nakuru Sensor Data for November 2021 from https://open.africa/dataset/sensorsafrica-airquality-archive-nakuru/resource/1f11351e-156b-4e4c-a063-b86a6ee07c4a\"\n",
    "\n",
    "Load the data into a pandas dataframe and develop a dataframe similar to what you have just done in Question no's 6 - 13 above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ooqx8xuoJMn7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Load the data into a pandas dataframe and develop a dataframe similar to what you have just done in Question no's 6 - 13 above\n",
    "df2 = pd.read_csv(r'november_2021_sensor_data_archive.csv',usecols=['timestamp','value_type','value'],delimiter=';')\n",
    "df2['timestamp_new'] = pd.to_datetime(df2['timestamp']).dt.round('S')\n",
    "grouped2 = df2.groupby('value_type')\n",
    "df2_temperature = grouped2.get_group('temperature')\n",
    "df2_humidity = grouped2.get_group('humidity')\n",
    "df2_P1 = grouped2.get_group('P1')\n",
    "df2_P2 = grouped2.get_group('P2')\n",
    "df2_merged = pd.merge(df2_temperature, df2_humidity, on='timestamp_new')\n",
    "df2_merged = pd.merge(df2_merged, df2_P1, on='timestamp_new')\n",
    "df2_merged = pd.merge(df2_merged, df2_P2, on='timestamp_new')\n",
    "df2_merged['date'] = df2_merged['timestamp_new'].dt.date\n",
    "means_nov = df2_merged.groupby('date').mean()\n",
    "means_nov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gS7RRkZpnYqa"
   },
   "source": [
    "**Question E10:** Convert the means_feb and means_nov to numpy arrays ... and then compute the average of each collumn\n",
    "\n",
    "Hint: The results are numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hbgK6RQ8nDXw",
    "tags": []
   },
   "outputs": [],
   "source": [
    "feb_numpy_array = means_feb.to_numpy()\n",
    "feb_average = feb_numpy_array.mean(axis=0)\n",
    "feb_average"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r6-iwnWSoIDE",
    "tags": []
   },
   "outputs": [],
   "source": [
    "nov_numpy_array = means_nov.to_numpy()\n",
    "nov_average = nov_numpy_array.mean(axis=0)\n",
    "nov_average"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zc6tiksMqSb0"
   },
   "source": [
    "**Question E11:** Write a function to compute the difference in the average temperature, humidity, P1 and P2 between November 2021 and February 2023\n",
    "\n",
    "Hint: The result is a vector of the form [w,x,y,z]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AWCrhXpKqPJQ",
    "tags": []
   },
   "outputs": [],
   "source": [
    "def sub():\n",
    "    diff_temp = feb_average[0] - nov_average[0]\n",
    "    diff_humidity =  feb_average[1] - nov_average[1]\n",
    "    diff_P1 = feb_average[2] - nov_average[2]\n",
    "    diff_P2 = feb_average[3] - nov_average[3]\n",
    "    diff = [diff_temp,diff_humidity,diff_P1,diff_P2]\n",
    "    return diff\n",
    " \n",
    "# Print the result of the subtraction\n",
    "difference = sub()\n",
    "print(difference)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Submission\n",
    "\n",
    "Make sure you have run all cells in your notebook in order before running the cell below, so that all images/graphs appear in the output. The cell below will generate a zip file for you to submit. **Please save before exporting!**\n",
    "\n",
    "Upload the generated zip file to the Google sheet please. Uploading work which is not yours will lead to non admittance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import rcParams\n",
    "rcParams['font.family'] = 'sans-serif'\n",
    "rcParams['font.sans-serif'] = ['Arial']\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\usepackage[no-math]{fontspec}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nbformat\n",
    "\n",
    "#  convert the notebook to a utf-8 encoded string\n",
    "with open('DSA_2023_Entry.ipynb') as f:\n",
    "    nb = nbformat.read(f, as_version=4)\n",
    "    nb.cells = nb.cells[0:63]\n",
    "    nbformat.write(nb, 'Assignment_1.ipynb')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# Save your notebook first, then run this cell to export your submission.\n",
    "\n",
    "grader.export(run_tests=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.15"
  },
  "otter": {
   "OK_FORMAT": true,
   "tests": {
    "q1": {
     "name": "q1",
     "points": 2,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> # BEGIN TEST CONFIG\n>>> points: 2\n>>> # END TEST CONFIG\n>>> def test_primes(sieve):\n...     assert sieve(30) == ((2, 3, 5, 7, 11, 13, 17, 19, 23, 29), (4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30))\n>>> test_primes(sieve)  \n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q2": {
     "name": "q2",
     "points": null,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> # BEGIN TEST CONFIG\n>>> points: 2\n>>> # END TEST CONFIG\n>>> def test_dictionary(Counter):\n...     assert Counter(paragraph) == {' ': 192, 'e': 89, 'o': 68, 't': 65, 'i': 60, 's': 57, 'a': 48, 'r': 45, 'n': 42, 'l': 35, 'c': 31, 'd': 27, 'f': 26, 'u': 26, '0': 22, 'm': 20, 'y': 19, 'h': 17, 'w': 16, 'g': 14, '3': 13, '.': 12, 'p': 11, 'b': 11, '1': 11, '2': 10, '7': 10, 'k': 9, ',': 7, '4': 5, 'v': 4, '-': 4, '*': 4, '^': 4, 'T': 3, 'x': 3, '5': 3, '6': 3, '8': 3, '’': 3, '(': 3, ')': 3, 'q': 3, 'O': 3, ':': 2, '9': 2, 'S': 2, 'A': 2, '{': 2, '}': 2, '`': 2, 'I': 1, 'V': 1, 'F': 1, '[': 1, ']': 1, 'W': 1, '<': 1, 'N': 1, '>': 1, '“': 1, '”': 1, '‘': 1, 'E': 1, '/': 1, '\\\\': 1}\n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q3": {
     "name": "q3",
     "points": null,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> # BEGIN TEST CONFIG\n>>> points: 2\n>>> # END TEST CONFIG\n>>> def test_keyslist():\n...     assert list(dictionary.keys()) == ['T', 'h', 'e', ' ', 'f', 'o', 'l', 'w', 'i', 'n', 'g', 's', 'a', 'm', 'p', 't', 'x', 'I', 'u', 'd', 'r', 'c', 'k', 'y', 'b', '.', ':', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'S', 'V', '’', '0', ',', '(', ')', 'q', 'A', 'v', 'F', '-', '{', '}', 'O', '[', ']', 'W', '<', 'N', '>', '`', '*', '^', '“', '”', '‘', 'E', '/', '\\\\']\n>>> test_keyslist() \n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q4": {
     "name": "q4",
     "points": null,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> # BEGIN TEST CONFIG\n>>> points: 2\n>>> # END TEST CONFIG\n>>> def test_valueslist():\n...     assert list(dictionary.values()) == [3, 17, 89, 192, 26, 68, 35, 16, 60, 42, 14, 57, 48, 20, 11, 65, 3, 1, 26, 27, 45, 31, 9, 19, 11, 12, 2, 11, 10, 13, 5, 3, 3, 10, 3, 2, 2, 1, 3, 22, 7, 3, 3, 3, 2, 4, 1, 4, 2, 2, 3, 1, 1, 1, 1, 1, 1, 2, 4, 4, 1, 1, 1, 1, 1, 1]\n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q5": {
     "name": "q5",
     "points": null,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> # BEGIN TEST CONFIG\n>>> points: 2\n>>> # END TEST CONFIG\n>>> def test_tuple():\n...     assert final_tuple == (('T', 'h', 'e', ' ', 'f', 'o', 'l', 'w', 'i', 'n', 'g', 's', 'a', 'm', 'p', 't', 'x', 'I', 'u', 'd', 'r', 'c', 'k', 'y', 'b', '.', ':', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'S', 'V', '’', '0', ',', '(', ')', 'q', 'A', 'v', 'F', '-', '{', '}', 'O', '[', ']', 'W', '<', 'N', '>', '`', '*', '^', '“', '”', '‘', 'E', '/', '\\\\'), (3, 17, 89, 192, 26, 68, 35, 16, 60, 42, 14, 57, 48, 20, 11, 65, 3, 1, 26, 27, 45, 31, 9, 19, 11, 12, 2, 11, 10, 13, 5, 3, 3, 10, 3, 2, 2, 1, 3, 22, 7, 3, 3, 3, 2, 4, 1, 4, 2, 2, 3, 1, 1, 1, 1, 1, 1, 2, 4, 4, 1, 1, 1, 1, 1, 1))\n>>> test_tuple() \n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q6": {
     "name": "q6",
     "points": 10,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> assert_equal(greatest_common_divisor(10, 15), 5)\n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q7": {
     "name": "q7",
     "points": 10,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> assert_equal(get_nearest_farthest((3, 8), [(9, 3), (8,5), (7,6)]), ((7, 6), (9, 3)))\n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q8": {
     "name": "q8",
     "points": 5,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> assert_equal(perfectly_divisible(10,2), [0,2,4,6,8,10])\n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    },
    "q9": {
     "name": "q9",
     "points": 4,
     "suites": [
      {
       "cases": [
        {
         "code": ">>> assert_equal(flatten_lists([[2,13,44], [6,7]]), [2, 6, 7, 13, 44])\n",
         "hidden": false,
         "locked": false
        }
       ],
       "scored": true,
       "setup": "",
       "teardown": "",
       "type": "doctest"
      }
     ]
    }
   }
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}