labs/python-basics-quiz.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ecb48229-31b1-4d7f-93b7-a049b389dcc2",
   "metadata": {},
   "source": [
    "# Python basics practice quiz\n",
    "\n",
    "This quiz test your basic knowledge of Python syntax/semantics and its built-in data structures.  The solutions do not appear if you view this file from github, so download the notebook to your laptop and view it in Jupyter. Clicking on the ▶`Solution` button opens up the solution for each question."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41911013-7c77-4a6d-97b9-2457c91e9cfe",
   "metadata": {},
   "source": [
    "## Types and assignments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1e4872b-aae2-4f0a-aab8-00ae455e60e7",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?\n",
    "\n",
    "```python\n",
    "a = 3.2\n",
    "a = 99\n",
    "print(a)\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The output is 99 because the value of `a` is overwritten by the second assignment; the sequence of operations is important.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2f36bcc-e486-4f38-8e94-48bc11f9545e",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What are the types of the variables after the execution of the following program?\n",
    "\n",
    "```python\n",
    "a = \"hi\"\n",
    "b = 3.14\n",
    "c = [1, 2, 3]\n",
    "d = 99\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The types are a:string, b:float, c:list, d:int\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efdd22bd-83c9-4e36-a451-6e3c7d0b90a9",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the value of `x` after this program executes?\n",
    "\n",
    "```python\n",
    "x = 5\n",
    "x = x + 10\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The value of x is 15 since the second assignment adds 10 to its previous value.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e807047-cd62-469d-8f26-929177cd6510",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the value of `x` after this program executes?\n",
    "\n",
    "```python\n",
    "x = \"5\"\n",
    "x = x * 10\n",
    "```\n",
    " \n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The value of x is '5555555555'. Types really matter and the type of x is string.  The multiply operator, star, is overloaded for strings to mean replicate.</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5357ef4c-8df0-4e82-ab5c-d3b26ac245c8",
   "metadata": {},
   "source": [
    "## Conditional execution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a52c372-77d8-45be-af2f-71c1f44a25eb",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?\n",
    " \n",
    "```python\n",
    "x = -5\n",
    "if x < 0:\n",
    "    print(\"foo\")\n",
    "print(\"bar\")\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The output is:\n",
    "<pre>\n",
    "foo\n",
    "bar\n",
    "</pre>\n",
    "because x is negative.  If it were greater than or equal to zero, we would only see output bar.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4df4eb7d-40c4-4f85-a05e-9459c938cd42",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?\n",
    "\n",
    "```python\n",
    "x = 3.14159\n",
    "mode = \"iterative\"\n",
    "print(\"---\")\n",
    "if mode==\"iterative\":\n",
    "    if x < 3.0:\n",
    "        print(\"A\")\n",
    "    else:\n",
    "        print(\"B\")\n",
    "else:\n",
    "    if x < 3.0:\n",
    "        print(\"C\")\n",
    "    else:\n",
    "        print(\"D\")    \n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The output is:\n",
    "<pre>\n",
    "---\n",
    "B\n",
    "</pre>\n",
    "    because \"---\" is always printed and we know that the mode is interactive, which let's us totally ignore the C and D stuff in the else clause of the outer conditional. Then we evaluate the inner conditional to check x to see if it's less than 3.0, which it is not. Therefore we evaluate the else clause and print \"B\".\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c37308eb-7360-4b44-a5d6-b74fa116681a",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    " What is the output of the following program?\n",
    " \n",
    "```python\n",
    "x = 3.14159\n",
    "if x >= 0:\n",
    "    if x < 1:\n",
    "        print(\"A\")\n",
    "    elif x < 2: # elif means \"else if\"\n",
    "        print(\"B\")\n",
    "    elif x < 3:\n",
    "        print(\"C\")\n",
    "    elif x < 4:\n",
    "        print(\"D\")\n",
    "    else:\n",
    "        print(\"E\")\n",
    "else:\n",
    "    print(\"F\")\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The output is \"D\" because after the succession of conditional tests, we find that x is greater than or equal to zero and less than four.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03185ff8-2c5e-4b17-914b-a9226b4e5151",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Alter the following code to remove the inner conditional statement while keeping the same functionality. Hint: we can combine conditional expressions using `and` and `or` operators.\n",
    "\n",
    "```python\n",
    "x = 3.14159\n",
    "if x >= 0:\n",
    "    if x < 1:\n",
    "        print(\"A\")\n",
    "    elif x < 2: # elif means \"else if\"\n",
    "        print(\"B\")\n",
    "    elif x < 3:\n",
    "        print(\"C\")\n",
    "    elif x < 4:\n",
    "        print(\"D\")\n",
    "else:\n",
    "    print(\"E\")\n",
    "```\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    We need to replicate the conditional of the outer IF statement with the conditionals of the inner so that the logic is the same.\n",
    "<pre>\n",
    "x = 3.14159\n",
    "if x >= 0 and  x < 1:\n",
    "    print(\"A\")\n",
    "elif x >= 0 and x < 2:\n",
    "    print(\"B\")\n",
    "elif x >= 0 and x < 3:\n",
    "    print(\"C\")\n",
    "elif x >= 0 and x < 4:\n",
    "    print(\"D\")\n",
    "elif x < 0:\n",
    "    print(\"E\")\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d3ec4e-f037-4df3-8e7d-b2f87cade6fb",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Given the following assignment, write an IF statement that prints the value of x if it's length is greater than 4. Hint: `len(...)` returns the length of string or list.\n",
    "\n",
    "```python\n",
    "x = \"hi\"\n",
    "```\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "x = \"hi\"\n",
    "if len(x)>4:\n",
    "    print(x)\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba98d20e-f0db-4e05-aa46-1844c64a6af3",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59718158-7328-4273-b16a-960c94ceb2a5",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?\n",
    " \n",
    "```python\n",
    "for i in range(3):\n",
    "    print(\"A\")\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "A\n",
    "A\n",
    "A\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f35e1b95-9574-405b-967d-d1b7b88c412f",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?\n",
    " \n",
    "```python\n",
    "for i in range(3):\n",
    "    print(i)\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The `range(3)` expression is the same as `range(0, 3)` where the first value is the inclusive starting valuet and the second value is the exclusive stopping value. The output is therefore:\n",
    "<pre>\n",
    "0\n",
    "1\n",
    "2\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b36d88d-27e4-4204-a334-ae94e792f754",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the value of `x` after the program executes?\n",
    "\n",
    "```python\n",
    "x = 0\n",
    "for i in range(5):\n",
    "    x += i   # same as x = x + i\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "x is 10 because 0+1+2+3+4=10.   It's the same as evaluating sum(range(5)).\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "524a2106-e8f4-45a5-9785-33614cb2a6a5",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the value of `x` after the program executes?\n",
    "\n",
    "```python\n",
    "x = 0\n",
    "for i in range(8):\n",
    "    if i >=5:\n",
    "        x += i   # same as x = x + i\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "The conditional statement limits when we execute the accumulation statement to when i is greater than or equal to 5. Consequently, we some the numbers 5+6+7 so x is 18.   It's the same as evaluating sum(range(5,8)).\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52248561-f3f4-44de-be11-06684080de5e",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Write a loop that multiplies the numbers 1 and 5 inclusively and leaves the value in variable `x`.\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "We need the loop to go inclusively 1..5 but range() is exclusive on the right side so we use range(1,5+1), which gives us a sequence like [1, 2, 3, 4, 5].  Then we need to initialize a variable, x, to 1 so that we can multiply those numbers together.\n",
    "<pre>\n",
    "x = 1\n",
    "for i in range(1,5+1):\n",
    "    x *= i   # same as x = x * i\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "869fecfd-4111-45ca-8c7e-8546adc4a278",
   "metadata": {},
   "source": [
    "## Representing data in memory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "897886c6-4e13-4a43-afc4-d839868ec5bd",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Is 5,000 kilobytes the same, smaller, or bigger than 5 megabytes?\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "5,000k is the same as 5M  because 1M is 1000k.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1170e19f-10d4-40a6-a673-16c51bbbc7da",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the total size of your laptop's disk?\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "Go to the \"About this Mac\" under the Apple icon and click the Storage tab. That will tell you something like 512G (gigabytes) or 1TB (terabytes).\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f51554c-4921-487b-8641-b9486290ad3b",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of this program?\n",
    "```python\n",
    "x = [5,2,\"hi\",99]\n",
    "print(len(x), x[0], x[2])\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "There are four elements in the list and, since we index arrays starting at zero, so the output is \"4 5 hi\".\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12159914-5870-4af6-8197-6cd23ee856a1",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?\n",
    " \n",
    "```python\n",
    "x = [[\"parrt\", \"admin\"],\n",
    "     [\"tombu\", \"user\"]]\n",
    "print(x[1])\n",
    "print(x[0][1])\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "     Because x[1] gives us the second row of x and x[0][1] gives us the first row second column, the output is:\n",
    "<pre>\n",
    "['tombu', 'user']\n",
    "admin\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f48c0c51-48dc-402d-9382-c13b15ac6b7d",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?\n",
    " \n",
    "```python\n",
    "x = {\"apple\", \"banana\"}\n",
    "y = {\"banana\", \"kumquat\", \"orange\"}\n",
    "print(x.union(y))\n",
    "print(x.intersection(y))\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "{'orange', 'kumquat', 'banana', 'apple'}\n",
    "{'banana'}\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65b8ae4f-c26c-40e5-b001-c2adb48cd2cb",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the output of the following program?  Hint: the `in` operator checks set membership.\n",
    "\n",
    "```python\n",
    "x = \"apple\"\n",
    "y = {\"banana\", \"kumquat\", \"orange\"}\n",
    "if x in y:\n",
    "    print(\"A\")\n",
    "else:\n",
    "    print(\"B\")    \n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "Since \"x in y\" evaluates to False, the output is B not A.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f21fc5ee-088c-4f87-9469-e4574661c08d",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Given the following tuple in `x`, what are the values of `x[1]` and `x[3]`?\n",
    "\n",
    "```python\n",
    "x = (42, 500, 99)\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "x[1] is the second element and so is 500. Index 3 is beyond the end of the topple since there are only three elements, so we get an IndexError from Python.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27363d5-85d5-4bad-b7df-64ea3b913d60",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Given the following dictionary, what is the output of the following program?\n",
    "\n",
    "```python\n",
    "x = {\"bonkers\":\"cat\", \"rex\":\"dog\"}\n",
    "print(x['rex'])\n",
    "print(x.keys())\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "     The array index notation used on a dictionary looks up the index as the key and returns the associated value. If we ask for the keys with x.keys() we get an object that represents a list of the keys from the dictionary. The output is therefore:\n",
    "<pre>\n",
    "dog\n",
    "dict_keys(['bonkers', 'rex'])\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ce28bba-84fd-4df1-9fae-41626ee5234b",
   "metadata": {},
   "source": [
    "## Looping through data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4baba9ef-a605-4227-9c92-a7a4e02c3eff",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Given the following dictionary, write a for-each loop that iterates through the keys and prints them out.\n",
    "\n",
    "```python\n",
    "x = {\"bonkers\":\"cat\", \"rex\":\"dog\"}\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "x = {\"bonkers\":\"cat\", \"rex\":\"dog\"}\n",
    "for key in x:\n",
    "    print(key)\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f681aaa-1c10-439f-87f8-fa41e0500768",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Write a for-each loop to iterate through the elements of this list, accumulating a string that concatenates all of the names in the list and prints that out. The output should be `bonkersbooboorexking`. Hint: `\"a\"+\"b\"` is `\"ab\"`.\n",
    "\n",
    "```python\n",
    "names = [\"bonkers\", \"booboo\", \"rex\", \"king\"]\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "s = \"\"\n",
    "names = [\"bonkers\", \"booboo\", \"rex\", \"king\"]\n",
    "for name in names:\n",
    "    s += name\n",
    "print(s)\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c116b629-765a-4039-a9dc-73b50996b172",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Using an indexed for-loop (that iterates loop variable `i` through the indexes of the list length), print a tuple for each pair of values from `names` and `ages`.\n",
    "\n",
    "```python\n",
    "names = [\"bonkers\", \"booboo\", \"rex\", \"king\"]\n",
    "ages = [13, 13, 7, 9]\n",
    "```\n",
    "\n",
    " The desired output is:\n",
    " \n",
    "<pre>\n",
    "('bonkers', 13)\n",
    "('booboo', 13)\n",
    "('rex', 7)\n",
    "('king', 9)\n",
    "</pre>\n",
    "\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "names = [\"bonkers\", \"booboo\", \"rex\", \"king\"]\n",
    "ages = [13, 13, 7, 9]\n",
    "for i in range(len(names)):\n",
    "    print((names[i],ages[i]))\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5830e2b5-1bb4-4d0b-9b55-99b187612cc4",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Using a for-each loop that iterates through `zip(names,ages)`, print the *name* `->` *age* for each pair of values from `names` and `ages`.\n",
    "\n",
    "```python\n",
    "names = [\"bonkers\", \"booboo\", \"rex\", \"king\"]\n",
    "ages = [13, 13, 7, 9]\n",
    "```\n",
    "\n",
    " The desired output is:\n",
    " \n",
    "<pre>\n",
    "bonkers -> 13\n",
    "booboo -> 13\n",
    "rex -> 7\n",
    "king -> 9\n",
    "</pre>\n",
    "\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "names = [\"bonkers\", \"booboo\", \"rex\", \"king\"]\n",
    "ages = [13, 13, 7, 9]\n",
    "for n,a in zip(names,ages):\n",
    "    print(n,'->',a)\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15213989-e960-4923-a20d-f476e7f73d71",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Given the following two vectors, compute and print the value indicated by formula $\\sum_{i=1}^{|x|} (x_i - y_i)^2$ using a for-loop where $|x|$ means `len(x)`.\n",
    "```python\n",
    "x = [9, 2, 150, 24]\n",
    "y = [0, 1, 9, -3]\n",
    "```\n",
    "\n",
    "The computation result should be 20,692.\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "x = [9, 2, 150, 24]\n",
    "y = [0, 1, 9, -3]\n",
    "s = 0\n",
    "for i in range(0,len(x)):\n",
    "    s += (x[i]-y[i])**2\n",
    "print(s)\n",
    "</pre>\n",
    "    \n",
    "Or, using numpy when doing this for real\n",
    "    \n",
    "<pre>\n",
    "import numpy as np\n",
    "x = np.array([9, 2, 150, 24])\n",
    "y = np.array([0, 1, 9, -3])\n",
    "print( np.sum((x-y)**2) )\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fda7cfb-2a69-42ea-87d7-a2763c74ba49",
   "metadata": {},
   "source": [
    "## List comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e912ddc-6fe6-4d9f-89e4-bf3d7b2a6b2a",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Using a list comprehension, give an expression that computes a new list containing the string length of names in the following list.\n",
    "\n",
    "```python\n",
    "names = ['Sophia', 'Olivia', 'Xue', 'Shruti']\n",
    "```\n",
    "\n",
    "The expected list should be `[6, 6, 3, 6]`.\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "names = ['Sophia', 'Olivia', 'Xue', 'Shruti']\n",
    "[len(name) for name in names]\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39356b43-4688-4f08-9f48-dde7683daf5b",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Given the following list of numbers, write a list comprehension that filters for only those numbers greater than 20.\n",
    "\n",
    "```python\n",
    "x = [9, 2, 150, 24]\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "x = [9, 2, 150, 24]\n",
    "[v for v in x if v > 20]\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd774c62-0096-4dea-b4ba-8103bb3f0137",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Write a list comprehension that uses `zip()` to iterate through the following two lists to compute the product of the elements in the two lists.\n",
    "\n",
    "```python\n",
    "x = [9, 2, 150, 24]\n",
    "y = [0, 1, 9, -3]\n",
    "```\n",
    "\n",
    "The expected list value is `[0, 2, 1350, -72]`.\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "x = [9, 2, 150, 24]\n",
    "y = [0, 1, 9, -3]\n",
    "[a*b for a,b in zip(x,y)]\n",
    "</pre>\n",
    "</details>"
   ]
  }
 ],
 "metadata": {
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}