Week4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice Quiz: Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The is_palindrome function checks if a string is a palindrome. A palindrome is a string that can be equally read from left to right or right to left, omitting blank spaces, and ignoring capitalization. Examples of palindromes are words like kayak and radar, and phrases like \"Never Odd or Even\". Fill in the blanks in this function to return True if the passed string is a palindrome, False if not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_palindrome(input_string):\n",
    "\t# We'll create two strings, to compare them\n",
    "\tnew_string = \"\"\n",
    "\treverse_string = \"\"\n",
    "\t# Traverse through each letter of the input string\n",
    "\tfor letter in input_string:\n",
    "\t\t# Add any non-blank letters to the \n",
    "\t\t# end of one string, and to the front\n",
    "\t\t# of the other string. \n",
    "\t\tif letter != \" \":\n",
    "\t\t\tnew_string += letter.lower() \n",
    "\t\t\treverse_string = letter.lower() + reverse_string\n",
    "\t# Compare the strings\n",
    "\t\n",
    "\tif new_string == reverse_string:\n",
    "\t\treturn True\n",
    "\treturn False\n",
    "\n",
    "print(is_palindrome(\"Never Odd or Even\")) # Should be True\n",
    "print(is_palindrome(\"abc\")) # Should be False\n",
    "print(is_palindrome(\"kayak\")) # Should be True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the format method, fill in the gaps in the convert_distance function so that it returns the phrase \"X miles equals Y km\", with Y having only 1 decimal place. For example, convert_distance(12) should return \"12 miles equals 19.2 km\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 miles equals 19.2 km\n",
      "5.5 miles equals 8.8 km\n",
      "11 miles equals 17.6 km\n"
     ]
    }
   ],
   "source": [
    "def convert_distance(miles):\n",
    "\tkm = miles * 1.6 \n",
    "\tresult = \"{} miles equals {:.1f} km\".format(miles,km)\n",
    "\treturn result\n",
    "\n",
    "print(convert_distance(12)) # Should be: 12 miles equals 19.2 km\n",
    "print(convert_distance(5.5)) # Should be: 5.5 miles equals 8.8 km\n",
    "print(convert_distance(11)) # Should be: 11 miles equals 17.6 km"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fill in the gaps in the nametag function so that it uses the format method to return first_name and the first initial of last_name followed by a period. For example, nametag(\"Jane\", \"Smith\") should return \"Jane S.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jane S.\n",
      "Francesco R.\n",
      "Jean-Luc G.\n"
     ]
    }
   ],
   "source": [
    "def nametag(first_name, last_name):\n",
    "\treturn(\"{} {}.\".format(first_name, last_name[0]))\n",
    "\n",
    "print(nametag(\"Jane\", \"Smith\")) \n",
    "# Should display \"Jane S.\" \n",
    "print(nametag(\"Francesco\", \"Rinaldi\")) \n",
    "# Should display \"Francesco R.\" \n",
    "print(nametag(\"Jean-Luc\", \"Grand-Pierre\")) \n",
    "# Should display \"Jean-Luc G.\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The replace_ending function replaces the old string in a sentence with the new string, but only if the sentence ends with the old string. If there is more than one occurrence of the old string in the sentence, only the one at the end is replaced, not all of them. For example, replace_ending(\"abcabc\", \"abc\", \"xyz\") should return abcxyz, not xyzxyz or xyzabc. The string comparison is case-sensitive, so replace_ending(\"abcabc\", \"ABC\", \"xyz\") should return abcabc (no changes made)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's raining cats and dogs\n",
      "She sells seashells by the seashore\n",
      "The weather is nice in May\n",
      "The weather is nice in April\n"
     ]
    }
   ],
   "source": [
    "def replace_ending(sentence, old, new):\n",
    "\t# Check if the old string is at the end of the sentence \n",
    "\tif old[:] == sentence[-len(old):]:\n",
    "\t\t# Using i as the slicing index, combine the part\n",
    "\t\t# of the sentence up to the matched string at the \n",
    "\t\t# end with the new string\n",
    "\t\ti = len(old)\n",
    "\t\tnew_sentence = sentence[:-i] + new\n",
    "\t\treturn new_sentence\n",
    "\n",
    "\t# Return the original sentence if there is no match \n",
    "\treturn sentence\n",
    "\t\n",
    "print(replace_ending(\"It's raining cats and cats\", \"cats\", \"dogs\")) \n",
    "# Should display \"It's raining cats and dogs\"\n",
    "print(replace_ending(\"She sells seashells by the seashore\", \"seashells\", \"donuts\")) \n",
    "# Should display \"She sells seashells by the seashore\"\n",
    "print(replace_ending(\"The weather is nice in May\", \"may\", \"april\")) \n",
    "# Should display \"The weather is nice in May\"\n",
    "print(replace_ending(\"The weather is nice in May\", \"May\", \"April\")) \n",
    "# Should display \"The weather is nice in April\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice Quiz: Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a list of filenames, we want to rename all the files with extension hpp to the extension h. To do this, we would like to generate a new list called newfilenames, consisting of the new filenames. Fill in the blanks in the code using any of the methods you’ve learned thus far, like a for loop or a list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('program.c', 'program.c'), ('stdio.hpp', 'stdio.h'), ('sample.hpp', 'sample.h'), ('a.out', 'a.out'), ('math.hpp', 'math.h'), ('hpp.out', 'hpp.out')]\n"
     ]
    }
   ],
   "source": [
    "filenames = [\"program.c\", \"stdio.hpp\", \"sample.hpp\", \"a.out\", \"math.hpp\", \"hpp.out\"]\n",
    "newfilenames = []\n",
    "for file in filenames:\n",
    "  if '.hpp' in file:\n",
    "    newfilenames.append((file,file[:-2]))\n",
    "  else:\n",
    "    newfilenames.append((file,file))\n",
    "\n",
    "print (newfilenames) # Should be [('program.c', 'program.c'), ('stdio.hpp', 'stdio.h'), ('sample.hpp', 'sample.h'), ('a.out', 'a.out'), ('math.hpp', 'math.h'), ('hpp.out', 'hpp.out')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The permissions of a file in a Linux system are split into three sets of three permissions: read, write, and execute for the owner, group, and others. Each of the three values can be expressed as an octal number summing each permission, with 4 corresponding to read, 2 to write, and 1 to execute. Or it can be written with a string using the letters r, w, and x or - when the permission is not granted. For example: 640 is read/write for the owner, read for the group, and no permissions for the others; converted to a string, it would be: \"rw-r-----\" 755 is read/write/execute for the owner, and read/execute for group and others; converted to a string, it would be: \"rwxr-xr-x\" Fill in the blanks to make the code convert a permission in octal format into a string format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rwxr-xr-x\n",
      "rw-r--r--\n",
      "rwxr-x---\n",
      "rw-------\n"
     ]
    }
   ],
   "source": [
    "def octal_to_string(octal):\n",
    "    result = \"\"\n",
    "    value_letters = [(4,\"r\"),(2,\"w\"),(1,\"x\")]\n",
    "    # Iterate over each of the digits in octal\n",
    "    for digit in [int(n) for n in str(octal)]:\n",
    "        # Check for each of the permissions values\n",
    "        for value, letter in value_letters:\n",
    "            if digit >= value:\n",
    "                result += letter\n",
    "                digit -= value\n",
    "            else:\n",
    "                result += '-'\n",
    "    return result\n",
    "    \n",
    "print(octal_to_string(755)) # Should be rwxr-xr-x\n",
    "print(octal_to_string(644)) # Should be rw-r--r--\n",
    "print(octal_to_string(750)) # Should be rwxr-x---\n",
    "print(octal_to_string(600)) # Should be rw-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a function that turns text into pig latin: a simple text transformation that modifies each word moving the first character to the end and appending \"ay\" to the end. For example, python ends up as ythonpay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ellohay owhay reaay ouyay\n",
      "rogrammingpay niay ythonpay siay unfay\n"
     ]
    }
   ],
   "source": [
    "def pig_latin(text):\n",
    "  say = \"\"\n",
    "  # Separate the text into words\n",
    "  words = text.split()\n",
    "  for word in words:\n",
    "    # Create the pig latin word and add it to the list\n",
    "    say += word[1:]+word[0]+'ay'\n",
    "    if word != words[len(words)-1]:\n",
    "      say +=' '\n",
    "    # Turn the list back into a phrase\n",
    "  return say\n",
    "\t\t\n",
    "print(pig_latin(\"hello how are you\")) # Should be \"ellohay owhay reaay ouyay\"\n",
    "print(pig_latin(\"programming in python is fun\")) # Should be \"rogrammingpay niay ythonpay siay unfay\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice Quiz: Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The email_list function receives a dictionary, which contains domain names as keys, and a list of users as values. Fill in the blanks to generate a list that contains complete email addresses (e.g. diana.prince@gmail.com)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['clark.kent@gmail.com', 'diana.prince@gmail.com', 'peter.parker@gmail.com', 'barbara.gordon@yahoo.com', 'jean.grey@yahoo.com', 'bruce.wayne@hotmail.com']\n"
     ]
    }
   ],
   "source": [
    "def email_list(domains):\n",
    "\temails = []\n",
    "\tfor domain,users in domains.items():\n",
    "\t  for user in users:\n",
    "\t    emails.append(user+'@'+domain)\n",
    "\treturn(emails)\n",
    "\n",
    "print(email_list({\"gmail.com\": [\"clark.kent\", \"diana.prince\", \"peter.parker\"], \"yahoo.com\": [\"barbara.gordon\", \"jean.grey\"], \"hotmail.com\": [\"bruce.wayne\"]}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The groups_per_user function receives a dictionary, which contains group names with the list of users. Users can belong to multiple groups. Fill in the blanks to return a dictionary with the users as keys and a list of their groups as values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'admin': ['local', 'public', 'administrator'], 'userA': ['local'], 'userB': ['public']}\n"
     ]
    }
   ],
   "source": [
    "def groups_per_user(group_dictionary):\n",
    "\tuser_groups = {}\n",
    "\t# Go through group_dictionary\n",
    "\tfor group in group_dictionary.keys():\n",
    "\t\t# Now go through the users in the group\n",
    "\t\tfor users in group_dictionary[group]:\n",
    "\t\t  lst = []\n",
    "\t\t  for group in group_dictionary.keys():\n",
    "\t\t    if users in group_dictionary[group] and users not in lst:\n",
    "\t\t      lst.append(group)\n",
    "\t\t  user_groups[users] = lst\n",
    "\treturn user_groups\n",
    "\t\t\t# Now add the group to the the list of\n",
    "# groups for this user, creating the entry\n",
    "# in the dictionary if necessary\n",
    "\n",
    "\n",
    "print(groups_per_user({\"local\": [\"admin\", \"userA\"],\n",
    "\t\t\"public\":  [\"admin\", \"userB\"],\n",
    "\t\t\"administrator\": [\"admin\"] }))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module 4 Graded Assessment\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The format_address function separates out parts of the address string into new strings: house_number and street_name, and returns: \"house number X on street named Y\". The format of the input string is: numeric house number, followed by the street name which may contain numbers, but never by themselves, and could be several words long. For example, \"123 Main Street\", \"1001 1st Ave\", or \"55 North Center Drive\". Fill in the gaps to complete this function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "house number 123 on street named Main Street\n",
      "house number 1001 on street named 1st Ave\n",
      "house number 55 on street named North Center Drive\n"
     ]
    }
   ],
   "source": [
    "def format_address(address_string):\n",
    "  # Declare variables\n",
    "  words = address_string.split()\n",
    "  num = \"\"\n",
    "  nam = \"\"\n",
    "  # Separate the address string into parts\n",
    "\n",
    "  # Traverse through the address parts\n",
    "  for i,word in enumerate(words):\n",
    "    if i == 0:\n",
    "      num += word\n",
    "    elif i != len(words)-1:\n",
    "      nam += word +\" \"\n",
    "    else:\n",
    "      nam += word\n",
    "    # Determine if the address part is the\n",
    "    # house number or part of the street name\n",
    "\n",
    "  # Does anything else need to be done \n",
    "  # before returning the result?\n",
    "  \n",
    "  # Return the formatted string  \n",
    "  return \"house number {} on street named {}\".format(num,nam)\n",
    "\n",
    "print(format_address(\"123 Main Street\"))\n",
    "# Should print: \"house number 123 on street named Main Street\"\n",
    "\n",
    "print(format_address(\"1001 1st Ave\"))\n",
    "# Should print: \"house number 1001 on street named 1st Ave\"\n",
    "\n",
    "print(format_address(\"55 North Center Drive\"))\n",
    "# Should print \"house number 55 on street named North Center Drive\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The highlight_word function changes the given word in a sentence to its upper-case version. For example, highlight_word(\"Have a nice day\", \"nice\") returns \"Have a NICE day\". Can you write this function in just one line?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Have a NICE day\n",
      "Shhh, don't be so LOUD!\n",
      "Automating with Python is FUN\n"
     ]
    }
   ],
   "source": [
    "def highlight_word(sentence, word):\n",
    "  ret = \"\"\n",
    "  l = len(word)\n",
    "  words = sentence.split()\n",
    "  for i,w in enumerate(words):\n",
    "    if w[:l] == word:\n",
    "      ret += w[:l].upper()+w[l:]\n",
    "    else:\n",
    "      ret += w\n",
    "    if i != len(words)-1:\n",
    "      ret += \" \"\n",
    "  return ret\n",
    "\n",
    "print(highlight_word(\"Have a nice day\", \"nice\"))\n",
    "print(highlight_word(\"Shhh, don't be so loud!\", \"loud\"))\n",
    "print(highlight_word(\"Automating with Python is fun\", \"fun\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A professor with two assistants, Jamie and Drew, wants an attendance list of the students, in the order that they arrived in the classroom. Drew was the first one to note which students arrived, and then Jamie took over. After the class, they each entered their lists into the computer and emailed them to the professor, who needs to combine them into one, in the order of each student's arrival. Jamie emailed a follow-up, saying that her list is in reverse order. Complete the steps to combine them into one list as follows: the contents of Drew's list, followed by Jamie's list in reverse order, to get an accurate list of the students as they arrived."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mike', 'Carol', 'Greg', 'Marcia', 'Peter', 'Jan', 'Bobby', 'Cindy', 'Alice']\n"
     ]
    }
   ],
   "source": [
    "def combine_lists(list1, list2):\n",
    "  # Generate a new list containing the elements of list2\n",
    "  for i in range(len(list1)-1,-1,-1):\n",
    "    list2.append(list1[i])\n",
    "  return list2\n",
    "  # Followed by the elements of list1 in reverse order\n",
    "  \n",
    "\t\n",
    "Jamies_list = [\"Alice\", \"Cindy\", \"Bobby\", \"Jan\", \"Peter\"]\n",
    "Drews_list = [\"Mike\", \"Carol\", \"Greg\", \"Marcia\"]\n",
    "\n",
    "print(combine_lists(Jamies_list, Drews_list))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use a list comprehension to create a list of squared numbers (n*n). The function receives the variables start and end, and returns a list of squares of consecutive numbers between start and end inclusively. For example, squares(2, 3) should return [4, 9]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 9]\n",
      "[1, 4, 9, 16, 25]\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "def squares(start, end):\n",
    "\treturn [x*x for x in range(start,end+1)]\n",
    "\n",
    "print(squares(2, 3)) # Should be [4, 9]\n",
    "print(squares(1, 5)) # Should be [1, 4, 9, 16, 25]\n",
    "print(squares(0, 10)) # Should be [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complete the code to iterate through the keys and values of the car_prices dictionary, printing out some information about each one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kia Soul costs 19000 dollars\n",
      "Lamborghini Diablo costs 55000 dollars\n",
      "Ford Fiesta costs 13000 dollars\n",
      "Toyota Prius costs 24000 dollars\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def car_listing(car_prices):\n",
    "  result = \"\"\n",
    "  for car,price in car_prices.items():\n",
    "    result += \"{} costs {} dollars\".format(car,price) + \"\\n\"\n",
    "  return result\n",
    "\n",
    "print(car_listing({\"Kia Soul\":19000, \"Lamborghini Diablo\":55000, \"Ford Fiesta\":13000, \"Toyota Prius\":24000}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taylor and Rory are hosting a party. They sent out invitations, and each one collected responses into dictionaries, with names of their friends and how many guests each friend is bringing. Each dictionary is a partial list, but Rory's list has more current information about the number of guests. Fill in the blanks to combine both dictionaries into one, with each friend listed only once, and the number of guests from Rory's dictionary taking precedence, if a name is included in both dictionaries. Then print the resulting dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'David': 1, 'Nancy': 1, 'Robert': 4, 'Adam': 2, 'Samantha': 3, 'Chris': 5, 'Brenda': 3, 'Jose': 3, 'Charlotte': 2, 'Terry': 1}\n"
     ]
    }
   ],
   "source": [
    "def combine_guests(guests1, guests2):\n",
    "  # Combine both dictionaries into one, with each key listed\n",
    "  # only once, and the value from guests1 taking precedence\n",
    "  for key,val in guests1.items():\n",
    "    guests2[key] = val\n",
    "  return guests2\n",
    "\n",
    "Rorys_guests = { \"Adam\":2, \"Brenda\":3, \"David\":1, \"Jose\":3, \"Charlotte\":2, \"Terry\":1, \"Robert\":4}\n",
    "Taylors_guests = { \"David\":4, \"Nancy\":1, \"Robert\":2, \"Adam\":1, \"Samantha\":3, \"Chris\":5}\n",
    "\n",
    "print(combine_guests(Rorys_guests, Taylors_guests))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use a dictionary to count the frequency of letters in the input string. Only letters should be counted, not blank spaces, numbers, or punctuation. Upper case should be considered the same as lower case. For example, count_letters(\"This is a sentence.\") should return {'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 2, 'b': 2, 'c': 2}\n",
      "{'m': 1, 'a': 1, 't': 1, 'h': 1, 'i': 1, 's': 1, 'f': 1, 'u': 1, 'n': 1}\n",
      "{'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}\n"
     ]
    }
   ],
   "source": [
    "def count_letters(text):\n",
    "  result = {}\n",
    "  # Go through each letter in the text\n",
    "  for letter in text:\n",
    "    # Check if the letter needs to be counted or not\n",
    "    letter = letter.lower()\n",
    "    if letter.isalpha():\n",
    "      if letter in result:\n",
    "        result[letter] += 1\n",
    "      else:\n",
    "        result[letter] = 1\n",
    "    # Add or increment the value in the dictionary\n",
    "  return result\n",
    "\n",
    "print(count_letters(\"AaBbCc\"))\n",
    "# Should be {'a': 2, 'b': 2, 'c': 2}\n",
    "\n",
    "print(count_letters(\"Math is fun! 2+2=4\"))\n",
    "# Should be {'m': 1, 'a': 1, 't': 1, 'h': 1, 'i': 1, 's': 1, 'f': 1, 'u': 1, 'n': 1}\n",
    "\n",
    "print(count_letters(\"This is a sentence.\"))\n",
    "# Should be {'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}