notebooks/Lecture 13.2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2e39e96a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# LECTURE 13.2.\n",
    "\n",
    "# DICTIONARIES CONTINUED\n",
    "\n",
    "# MONDAY, NOV 21"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ceed21f",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6812a84e",
   "metadata": {},
   "source": [
    "# _Class Participation Link: https://forms.gle/49TS4cWpD2WXtj2z9_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f16f3a6e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Quick Refresher on Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36d5e5a3",
   "metadata": {},
   "source": [
    "* Initializing Dictionaries with Key-Value Pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4064406",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "dictionary = {\"key1\": \"value1\", \"key2\": \"value2\"}\n",
    "print(dictionary[\"key1\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9789c810",
   "metadata": {},
   "source": [
    "<img src=\"https://i.ibb.co/h1J1vpR/Screen-Shot-2022-11-17-at-11-28-01-AM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db2edff0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Populating Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "516ee439",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eng2sp        = {}     # a dictionary to translate English words into Spanish\n",
    "eng2sp['one'] = 'uno'  # adding a new key \"one\" and mapping the value \"uno\" to it\n",
    "eng2sp['two'] = 'dos'  # adding yet another key \"one\" and mapping the value \"dos\" to it\n",
    "print(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da5749cd",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* Similar to sets, the **order** of the pairs is **unpredictable**. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "786abdfc",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0694303",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **Values** in a dictionary are **accessed** with **_Keys_**, with square brackets `[]` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "934e9070",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(eng2sp['one'])  # The key 'two' yields the value 'dos'."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf81ab33",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* The **`del`** statement **removes** a key-value pair from a dictionary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1254e660",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "print(\"Before deletion\", eng2sp)\n",
    "\n",
    "del eng2sp['two'] # Deleting key-value pair with key `two`\n",
    "\n",
    "print(\"After deletion\", eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d89ec2a2",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "126b2724",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **Change value associated with an existing key**: Override previous value mapped to the key, using the assignment operator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc8b834e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "print(\"Before change\", eng2sp)\n",
    "eng2sp['three'] = 'uno más dos'\n",
    "\n",
    "print(\"After change\", eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20c9a9aa",
   "metadata": {},
   "source": [
    "* **Getting length of a Dictionary**: The `len` function also works on dictionaries; it returns the number of key-value pairs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "912512fd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "len(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33456a59",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dbf5fe6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **Looping over Dictionaries**: When looping through a dictionary, the **target variable** of the `for` loop is **set to `keys`** of the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be617afd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "for random in eng2sp: \n",
    "    value = eng2sp[random]\n",
    "    print(random, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2261f60",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* `dictionary`**`.keys()`**: The `keys` method  returns the **list of its keys**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3ba1595",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "list(eng2sp.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5292225b",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a32ed512",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* `dictionary`**`.values()`**: The `values` method returns the **list of its values**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24ebfa14",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(list(eng2sp.keys()))\n",
    "print(list(eng2sp.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "239c9641",
   "metadata": {},
   "source": [
    "* `dictionary`**`.items()`**: The `items` method returns the **list of key-value pairs**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47f1d1a2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "list(eng2sp.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47c736b8",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1597f1a2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **Membership operator `in`** checks if **<u>a Key</u>** (_NOT VALUE_) **exists** in the dictionary \n",
    "\n",
    "    * returns `True` if the key is present in the dictionary and `False` otherwise"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f66b5b4c",
   "metadata": {},
   "source": [
    "value `in` structure "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d484fd94",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "\n",
    "'random' in eng2sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c43ab914",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "'deux' in eng2sp"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f40de7b9",
   "metadata": {},
   "source": [
    "* This method can be very useful, since looking up a non-existant key in a dictionary causes a runtime error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38df7dd5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eng2sp['dog']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63392947",
   "metadata": {},
   "source": [
    "<hr/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd4c4ef3",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Question 1. Create a Dictionary mapping Morse code to English letters\n",
    "\n",
    "<img src=\"https://thumbs.gfycat.com/SpryFlippantBichonfrise-size_restricted.gif\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb6ba897",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_morse2eng(morse_code, alphabet):\n",
    "        \n",
    "    return morse2eng\n",
    "\n",
    "morse_code = [\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\\\n",
    "              \"-.\",\"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"]\n",
    "\n",
    "alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "\n",
    "assert create_morse2eng(morse_code, alphabet) == {  '.-'   : 'a',\\\n",
    "                                                     '-...': 'b',\\\n",
    "                                                     '-.-.': 'c',\\\n",
    "                                                     '-..' : 'd',\\\n",
    "                                                     '.'   : 'e',\\\n",
    "                                                     '..-.': 'f',\\\n",
    "                                                     '--.' : 'g',\\\n",
    "                                                     '....': 'h',\\\n",
    "                                                     '..'  : 'i',\\\n",
    "                                                     '.---': 'j',\\\n",
    "                                                     '-.-' : 'k',\\\n",
    "                                                     '.-..': 'l',\\\n",
    "                                                     '--'  : 'm',\\\n",
    "                                                     '-.'  : 'n',\\\n",
    "                                                     '---' : 'o',\\\n",
    "                                                     '.--.': 'p',\\\n",
    "                                                     '--.-': 'q',\\\n",
    "                                                     '.-.' : 'r',\\\n",
    "                                                     '...' : 's',\\\n",
    "                                                     '-'   : 't',\\\n",
    "                                                     '..-' : 'u',\\\n",
    "                                                     '...-': 'v',\\\n",
    "                                                     '.--' : 'w',\\\n",
    "                                                     '-..-': 'x',\\\n",
    "                                                     '-.--': 'y',\\\n",
    "                                                     '--..': 'z'}, \"Test case failed\"\n",
    "print(\"All test cases passed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c715855",
   "metadata": {},
   "source": [
    "# Question 2. Create a Dictionary mapping English letters to Morse code "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a99dd682",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_eng2morse(alphabet, morse_code):\n",
    "        \n",
    "    return eng2morse\n",
    "\n",
    "morse_code = [\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\\\n",
    "              \"-.\",\"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"]\n",
    "\n",
    "alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "\n",
    "assert create_eng2morse(alphabet, morse_code) =={'a': '.-',\\\n",
    "                                                 'b': '-...',\\\n",
    "                                                 'c': '-.-.',\\\n",
    "                                                 'd': '-..',\\\n",
    "                                                 'e': '.',\\\n",
    "                                                 'f': '..-.',\\\n",
    "                                                 'g': '--.',\\\n",
    "                                                 'h': '....',\\\n",
    "                                                 'i': '..',\\\n",
    "                                                 'j': '.---',\\\n",
    "                                                 'k': '-.-',\\\n",
    "                                                 'l': '.-..',\\\n",
    "                                                 'm': '--',\\\n",
    "                                                 'n': '-.',\\\n",
    "                                                 'o': '---',\\\n",
    "                                                 'p': '.--.',\\\n",
    "                                                 'q': '--.-',\\\n",
    "                                                 'r': '.-.',\\\n",
    "                                                 's': '...',\\\n",
    "                                                 't': '-',\\\n",
    "                                                 'u': '..-',\\\n",
    "                                                 'v': '...-',\\\n",
    "                                                 'w': '.--',\\\n",
    "                                                 'x': '-..-',\\\n",
    "                                                 'y': '-.--',\\\n",
    "                                                 'z': '--..'}, \"Test case failed\"\n",
    "print(\"All test cases passed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a23a5a65",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Question 3. Convert English Text to Morse Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10a4ef59",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def convert_to_morse(txt):\n",
    "    \n",
    "    return converted\n",
    "\n",
    "\n",
    "assert convert_to_morse(\"what\")    == ['.--', '....', '.-', '-'],                       \"Test case 1 failed\"\n",
    "assert convert_to_morse(\"hath\")    == ['....', '.-', '-', '....'],                      \"Test case 2 failed\"\n",
    "assert convert_to_morse(\"god\")     == ['--.', '---', '-..'],                            \"Test case 3 failed\"\n",
    "assert convert_to_morse(\"wrought\") == ['.--', '.-.', '---', '..-', '--.', '....', '-'], \"Test case 4 failed\"\n",
    "\n",
    "print(\"All test cases passed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eccfc078",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Question 4. Sum currency notes\n",
    "\n",
    "Given `amount`, compute minimum number of bills needed to give back the change. \n",
    "\n",
    "Assume you have infinite banknotes for each denomination.\n",
    "\n",
    "\n",
    "U.S. currency denominations (implicit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9591d3c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_change(change_notes):\n",
    "    \n",
    "\n",
    "    return summ\n",
    "\n",
    "assert sum_change({100: 3, 50: 1, 20: 2, 10: 0, 5: 1, 1: 1}) == 396, \"Test case 1 failed\"\n",
    "assert sum_change({100: 0, 50: 0, 20: 0, 10: 1, 5: 1, 1: 3}) == 18,  \"Test case 2 failed\"\n",
    "assert sum_change({100: 0, 50: 0, 20: 0, 10: 0, 5: 0, 1: 0}) == 0,   \"Test case 3 failed\"\n",
    "assert sum_change({100: 0, 50: 0, 20: 1, 10: 1, 5: 1, 1: 4}) == 39,  \"Test case 4 failed\"\n",
    "assert sum_change({100: 1, 50: 1, 20: 2, 10: 0, 5: 1, 1: 4}) == 199, \"Test case 5 failed\"\n",
    "\n",
    "print(\"All test cases passed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3429a9ce",
   "metadata": {},
   "source": [
    "# Question 5. Change-making problem\n",
    "\n",
    "\n",
    "Given `amount`, compute minimum number of bills needed to give back the change. \n",
    "\n",
    "Assume you have infinite banknotes for each denomination.\n",
    "\n",
    "\n",
    "U.S. currency denominations (implicit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3796292",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_change(amount):\n",
    "\n",
    "    return counts\n",
    "\n",
    "assert make_change(396) == {100: 3, 50: 1, 20: 2, 10: 0, 5: 1, 1: 1}, \"Test case 1 failed\"\n",
    "assert make_change(18)  == {100: 0, 50: 0, 20: 0, 10: 1, 5: 1, 1: 3}, \"Test case 2 failed\"\n",
    "assert make_change(0)   == {100: 0, 50: 0, 20: 0, 10: 0, 5: 0, 1: 0}, \"Test case 3 failed\"\n",
    "assert make_change(39)  == {100: 0, 50: 0, 20: 1, 10: 1, 5: 1, 1: 4}, \"Test case 4 failed\"\n",
    "assert make_change(199) == {100: 1, 50: 1, 20: 2, 10: 0, 5: 1, 1: 4}, \"Test case 5 failed\"\n",
    "\n",
    "print(\"All test cases passed successfully\")"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}