HW_3 Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Thank you so much!!  \n",
    "\n",
    "# By: Saniya Khullar\n",
    "#Homework 3, Python\n",
    "\n",
    "# Please note that I may need more time to submit this.  Thanking you. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SW: your functions need to return values, not just print them to screen. you wrote a few of them this way, but most don't return anything. points were not deducted if the instructions did not explicitly say to return a value, but this should be understood in general."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**\n",
      "***\n",
      "****\n",
      "***\n",
      "\n",
      "*\n",
      "**********\n"
     ]
    }
   ],
   "source": [
    "#1.  Please define a procedure histogram() that takes a list of integers and prints a histogram to the screen.  For example, \n",
    "#histogram([4,9,7]) should print the following: \n",
    "\n",
    "# ****\n",
    "# *********\n",
    "# *******\n",
    "\n",
    "def histogram(*NonNegIntegers):\n",
    "    \"\"\"\n",
    "    Please note that this is the histogram function and it will take a list of integers and print a histogram to the screen. \n",
    "    Please note that this is a sideways histogram.  The frequency will be plotted in terms of the asterisks (*), which are the stars. \n",
    "    Moreover, please do NOT enter in any negative integers in the list of NonNegIntegers.  Here, please note that this NonNegIntegers refers to a parameter that can host an endless (unspecified length) of numbers. \n",
    "    \"\"\"\n",
    "    i = 0\n",
    "    for num in NonNegIntegers: \n",
    "        i = i + 1\n",
    "    \n",
    "    NumOfIntegers = i  #please note that i will tell us how many elements are in the histogram\n",
    "    \n",
    "    #this is since the Indexing will go from 0 (for the 1st element) to (length - 1) for the last element\n",
    "    \n",
    "         \n",
    "        \n",
    "    index = 0\n",
    "    asteriskList = list()\n",
    "    while index < NumOfIntegers:\n",
    "        integerValue = NonNegIntegers[index]\n",
    "        #j = 0\n",
    "        #while j < integerValue:\n",
    "        newTerm = \"*\"*integerValue\n",
    "        print(newTerm)\n",
    "        index = index + 1  #incrementing the index and going on to the next value in the list. \n",
    "         \n",
    "\n",
    "    \n",
    "#histogram(1,2,3, 4)   \n",
    "\n",
    "# *\n",
    "# **\n",
    "# ***\n",
    "# ****\n",
    "\n",
    "histogram(2, 3, 4, 3, 0,1, 10)\n",
    "\n",
    "# **\n",
    "# ***\n",
    "# ****\n",
    "# ***\n",
    "#\n",
    "# *\n",
    "# **********"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "9\n",
      "912\n"
     ]
    }
   ],
   "source": [
    "#2.)  Please write a function max_in_list() that takes a list of numbers and returns the largest one. \n",
    "\n",
    "def max_in_list(*numbers):\n",
    "    \"\"\"\n",
    "    \n",
    "    Here *numbers refers to an endless, unspecified list of potential numbers that we can use; then, we can go through this list and see which number is the largest.  \n",
    "    Please note that this function builds up on the idea of these 2 functions max() and max_of_three() and will return the largest number from the list of numbers. \n",
    "    \"\"\"\n",
    "    \n",
    "    i = 0\n",
    "    for num in numbers: \n",
    "        i = i + 1\n",
    "    #please note that we will use i as an index please\n",
    "    \n",
    "    \n",
    "    index = 0 \n",
    "    max = numbers[0]\n",
    "    while index < i: \n",
    "        if max > numbers[index]:\n",
    "            index = index + 1  \n",
    "        else:\n",
    "            max = numbers[index]\n",
    "            index = index + 1  \n",
    "    print(max)\n",
    "      \n",
    "\n",
    "max_in_list(1, 2, 3)  #3\n",
    "\n",
    "max_in_list(1, 2, 3, 3, 4, -1, 9, 2, 3.3) #9\n",
    "\n",
    "max_in_list(1, 2, 3, 3, 41, 2, 92, 912, 99, 1, 0, -0.2) #9\n",
    "\n",
    "# SW: lost points: your function doesn't return anything, just prints to screen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 7, 2, 5]\n",
      "[6, 3, 2, 5]\n",
      "[4, 2, 1, 4, 8, 6, 3, 7]\n",
      "[0]\n"
     ]
    }
   ],
   "source": [
    "#3.)  Please write a program that maps a list of words into a list of integers representing the lengths of the corresponding words. \n",
    "#x, a = list())\n",
    "\n",
    "\n",
    "def WordToIntegerMap(a = list()): \n",
    "    \"\"\"\n",
    "    Please note that this WordToIntegerMap program will map a list of words into a list of integers that represent the lengths of the corresponding words. \n",
    "    Here, the list of words is specified by the parameter a.  \n",
    "    \"\"\"\n",
    "    \n",
    "    wordLengths = list()  #we are creating an empty list\n",
    "    i = 0\n",
    "    for numSpot in a: \n",
    "        i = i + 1  #i will be the number of elements in the list a\n",
    "    \n",
    "    index = 0 \n",
    "    while index < i: \n",
    "        currentWord = a[index]\n",
    "        j = 0 \n",
    "        for letter in currentWord:\n",
    "            j = j + 1 \n",
    "        wordLengths.append(j)\n",
    "        index = index + 1\n",
    "        \n",
    "    print(wordLengths)\n",
    "    \n",
    "WordToIntegerMap((\"Saniya\", \"Khullar\", \"Hi\", \"There\"))  #[6, 7, 2, 5]\n",
    "\n",
    "WordToIntegerMap((\"Chuyun\", \"Liu\", \"Hi\", \"There\")) #[6, 3, 2, 5]\n",
    "\n",
    "\n",
    "WordToIntegerMap((\"This\", \"is\", \"a\", \"neat\", \"function\", \"Saniya\", \"elf\", \"Poochie\")) #[4, 2, 1, 4, 8, 6, 3, 7]\n",
    "\n",
    "# SW: your function doesn't return anything, just prints to screen. even though it wasn't explicit in the \n",
    "#     instructions, you should write the function to return a list of the string lengths."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please note that in brackets [''], this is the longest word in the list: ['Saniya'] . It has 6 letters.\n",
      "Please note that in brackets [''], this is the longest word in the list: ['Khullar'] . It has 7 letters.\n",
      "Please note that there are 2 words in the list with the longest length: 6 letters. In brackets [''], these are those longest words: ['Saniya', 'longer']\n",
      "Please note that in brackets [''], this is the longest word in the list: ['icexpialid'] . It has 10 letters.\n",
      "Please note that in brackets [''], this is the longest word in the list: ['watermelons'] . It has 11 letters.\n"
     ]
    }
   ],
   "source": [
    "#4.)  Please write a function find_longest_word() that takes a list of words and returns the length of the longest one. #4.)  Please write a function find_longest_word() that takes a list of words and returns the length of the longest one. \n",
    "\n",
    "def find_longest_word(wordList = list()):\n",
    "    \"\"\"\n",
    "    Please note that this function will take a list of words and return the length of the longest one. \n",
    "    Here, wordList specifies the parameter, which will be a list of words with an unspecified # of elements. \n",
    "    Even if there is more than 1 maximum length word, Saniya's find_longest_word function will detect that and will return all of those maximum length words. \n",
    "    The function will also specify the length of the maximum length word(s).\n",
    "    \n",
    "    Please enter the words in the list in this format:\n",
    "    find_longest_word((\"apples\", \"oranges\", \"Saniya\", \"watermelons\")) \n",
    "    #Please note that in brackets [''], this is the longest word in the list: ['watermelons'] . It has 11 letters.\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    # Please note that the first step is to please define a way to go through the list of words and collect the respective lengths of each of the words. \n",
    "    \n",
    "    wordLengths = list()\n",
    "    numOfWords = 0\n",
    "    for numSpot in wordList: \n",
    "        numOfWords = numOfWords + 1\n",
    "        #please note that numOfWords will signify the number of words in the wordList.\n",
    "    \n",
    "    index = 0  #please note that index defines the position in the list array of the words. \n",
    "    #here, the first element (1st word) in the wordList is at position 0, while the last element (last word) is at the position: (numOfWord - 1)\n",
    "    while index < numOfWords:  #since index starts at 0 and ends at (numOfWords -1), it will have the length: numOfWords, which is what we want! :)\n",
    "        currentWord = wordList[index]\n",
    "        j = 0 \n",
    "        for letter in currentWord:\n",
    "            j = j + 1\n",
    "        wordLengths.append(j) #this will keep building the list, wordLengths, with the respective length of each word.  This list increases (and is appended to) every time we go through the loop. \n",
    "        index = index + 1\n",
    "        \n",
    "    #here, please note that the wordLengths list has been created\n",
    "    #Please note that the # of elements in the wordLengths list should equal the number of elements in the wordList list. :)\n",
    "    # Hence numOfWords should still apply here for the wordLengths list. \n",
    "    #print(wordLengths)\n",
    "    \n",
    "    \n",
    "    #please note that this below is an adaptation off of the max_in_list() function from Problem 2. \n",
    "   \n",
    "    #please note that we will use index2 as an index please\n",
    "    \n",
    "    #\n",
    "    \n",
    "    index2 = 0 \n",
    "    max = wordLengths[0]\n",
    "    while index2 < numOfWords: \n",
    "        if max > wordLengths[index2]:\n",
    "            index2 = index2 + 1  \n",
    "        else:\n",
    "            max = wordLengths[index2]\n",
    "            index2 = index2 + 1  \n",
    "    #print(max)\n",
    "      \n",
    "\n",
    "    \n",
    "        #hence, the maximum variable has been recorded as max. \n",
    "        \n",
    "    #Now we will please see the index where this maximum variable is in the list of words: \n",
    "    NumOfMaxes = 0\n",
    "    indexFinder = 0\n",
    "    maxWords = list()\n",
    "    while indexFinder < numOfWords: \n",
    "        currentNum = wordLengths[indexFinder]\n",
    "        if currentNum == max: \n",
    "            IndexOfMax = indexFinder\n",
    "            maxWords.append(wordList[indexFinder])\n",
    "            NumOfMaxes =  NumOfMaxes + 1\n",
    "        indexFinder = indexFinder + 1\n",
    "        #maxWordsString = ''.join(maxWords) \n",
    "    if NumOfMaxes == 1:\n",
    "        print(\"Please note that in brackets [''], this is the longest word in the list:\", maxWords, \". It has\", max, \"letters.\")\n",
    "    else:\n",
    "        print(\"Please note that there are\", NumOfMaxes, \"words in the list with the longest length:\", max, \"letters. In brackets [''], these are those longest words:\", maxWords)\n",
    "\n",
    "    \n",
    "    #This will be quite similar to the WordToIntegerMap() function that was used in Problem 3. \n",
    "    #Ultimately, a list of #'s will be collected. \n",
    "    #Example:  WordToIntegerMap((\"Saniya\", \"Khullar\", \"Hi\", \"There\")) ->  [6, 7, 2, 5]\n",
    "    \n",
    "    \n",
    "    \n",
    "    # The next step will be to then go through this new list of #'s and to determine the maximum number.  This is similar to Problem 2. \n",
    "    # Once we find the maximum number, we please go through to find the index of this maximum number. \n",
    "    #After finding the index of this maximum number, we will go back to the original list of words and will find the word that is in that index and we will please print out that word.  \n",
    "    #This printed out word should hopefully be the maximum word. \n",
    "\n",
    "#find_longest_word((\"hmmm\", \"maybe\")) #maybe\n",
    "find_longest_word((\"hmmm\", \"maybe\", \"Saniya\")) #Please note that in brackets [''], this is the longest word in the list: ['Saniya'] . It has 6 letters.\n",
    "\n",
    "\n",
    "find_longest_word((\"hmmm\", \"maybe\", \"Saniya\", \"Khullar\")) #Please note that in brackets [''], this is the longest word in the list: ['Khullar'] . It has 7 letters.\n",
    "\n",
    "find_longest_word((\"hmmm\", \"maybe\", \"Saniya\", \"longer\")) #Please note that there are 2 words in the list with the longest length: 6 letters. In brackets [''], these are those longest words: ['Saniya', 'longer']\n",
    "\n",
    "find_longest_word((\"supercali\", \"fragilist\", \"icexpialid\", \"ocious\", \"Santa\", \"Claus\", \"Python\"))\n",
    "find_longest_word((\"apples\", \"oranges\", \"Saniya\", \"watermelons\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# SW: lost points: your function doesn't return anything, just prints to screen. it should return the length of the\n",
    "#     longest string in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please note that from the list, in brackets [''], are the word(s) longer than 3 letters: ['there']\n",
      "Please note that from the list, in brackets [''], are the word(s) longer than 4 letters: ['maybe', 'Saniya', 'Santa', 'Python', 'Programming', 'happy']\n"
     ]
    }
   ],
   "source": [
    "# 5.)  Please write a function filter_long_words() that takes a list of words and an integer n and returns the list of words that are longer than n. \n",
    "\n",
    "def filter_long_words(n, ListOfWords = ()):\n",
    "    \"\"\"\n",
    "    Please note that this function: filter_long_words()  takes a list of words (that is called:  ListOfWords() ) and an integer n\n",
    "    It then returns the list of words that are longer than n. \n",
    "    \"\"\"\n",
    "    \n",
    "    #Please note that this function will go through all of the elements in the list of words and will calculate the respective length of each of those words in a new list:  LengthOfWords()\n",
    "    \n",
    "    wordLengths = list()\n",
    "    wordsCount = 0\n",
    "    for numSpot in ListOfWords: \n",
    "        wordsCount = wordsCount + 1\n",
    "        #please note that wordsCount will signify the number of words in the ListOfWords.\n",
    "    #print(wordsCount, n)\n",
    "    \n",
    "    \n",
    "    index = 0  #please note that index defines the position in the list array of the words. \n",
    "    #here, the first element (1st word) in the ListOfWords is at position 0, while the last element (last word) is at the position: (wordsCount - 1)\n",
    "    while index < wordsCount:  #since index starts at 0 and ends at (wordsCount -1), it will have the length: wordsCount, which is what we want! :)\n",
    "        currentWord = ListOfWords[index]\n",
    "        j = 0 \n",
    "        for letter in currentWord:\n",
    "            j = j + 1\n",
    "        wordLengths.append(j) #this will keep building the list, wordLengths, with the respective length of each word.  This list increases (and is appended to) every time we go through the loop. \n",
    "        index = index + 1\n",
    "        \n",
    "    \n",
    "    #print(wordLengths, n)\n",
    "    \n",
    "    Longerthan_n = list()\n",
    "    \n",
    "    indexDiscover = 0  #here, this will go through the wordLengths list and find the index(es)  of all words that have a length that is greater than n; n is the integer that the user specifies. \n",
    "    while indexDiscover < wordsCount:\n",
    "        currentValue = wordLengths[indexDiscover]\n",
    "        if currentValue > n:\n",
    "            Longerthan_n.append(ListOfWords[indexDiscover])\n",
    "        indexDiscover = indexDiscover + 1\n",
    "    print(\"Please note that from the list, in brackets [''], are the word(s) longer than\", n, \"letters:\", Longerthan_n)\n",
    "\n",
    "    \n",
    "    \n",
    "    #Then, it will go through the elements in the LengthOfWords() list and if an element in the list has a length longer than the integer n (that the user specified) then the word will be printed out. \n",
    "    \n",
    "    \n",
    "\n",
    "filter_long_words(3, (\"hi\", \"there\"))\n",
    "#Please note that from the list, in brackets [''], are the word(s) longer than 3 letters: ['there']\n",
    "\n",
    "filter_long_words(4, (\"maybe\", \"Saniya\", \"I\", \"Santa\", \"Python\", \"Programming\", \"cat\", \"be\", \"happy\"))\n",
    "#Please note that from the list, in brackets [''], are the word(s) longer than 4 letters: ['maybe', 'Saniya', 'Santa', 'Python', 'Programming', 'happy']\n",
    "\n",
    "# SW: lost points: your function doesn't return anything, just prints to screen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ":(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... hi there kid ...is different! :(\n",
      "This IS a palindrome! In reverse please note,... radar ..., is the same!\n",
      "This IS a palindrome! In reverse please note,... Was it a rat I saw? ..., is the same!\n",
      "This IS a palindrome! In reverse please note,... Step on no pets ..., is the same!\n",
      "This IS a palindrome! In reverse please note,... Sit on a potato pan, Otis ..., is the same!\n",
      ":(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... Otis ...is different! :(\n",
      "This IS a palindrome! In reverse please note,... Lisa Bonet ate no basil ..., is the same!\n",
      ":(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... Hopping over meadows ...is different! :(\n",
      ":(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... Lisa Bonet ate no basil or pasta ...is different! :(\n"
     ]
    }
   ],
   "source": [
    "# 6.)  Please write a version of a palindrome recognizer that also accepts phrase palindromes such as: \n",
    "# \"Go hang a salami I'm a lasagna hog.\", \"Was it a rat I saw?\", \"Step on no pets\", \"Sit on a potato pan, Otis\", \"Lisa Bonet ate no basil\", \"Rise to vote sir\", or  the exclamation, \"...I'm mad!\",\n",
    "#please note that punctuation, capitalization, and spacing are usually ignored\"\n",
    " \n",
    "def PhrasePalindrome(PalPhrase):   \n",
    "    \"\"\"\n",
    "    Please write a version of a palindrome recognizer that also accepts phrase palindromes such as: \n",
    "    \"Go hang a salami I'm a lasagna hog.\", \"Was it a rat I saw?\", \"Step on no pets\", \"Sit on a potato pan, Otis\", \"Lisa Bonet ate no basil\", \"Rise to vote sir\", or  the exclamation, \"...I'm mad!\".\n",
    "    Please note that punctuation, capitalization, and spacing are usually ignored\".\n",
    "    Please note that a palindrome is like radar or Hannah, since it is the same word when reversed. \n",
    "    \"\"\"\n",
    "    #print(PalPhrase)\n",
    "    #please create a list out of the Phrase\n",
    "\n",
    "    initialPalList = list(PalPhrase)\n",
    "    #print(initialPalList)\n",
    "    #please do not append it if it is NOT in the list of uppercase or lowercase letter\n",
    "\n",
    "    properCharacters = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\"]\n",
    "    # print(len(properCharacters)) # Please note that len is for the length function\n",
    "    \n",
    "    \n",
    "    #please go through palList\n",
    "    initialListLength = 0\n",
    "    for listItem in initialPalList:\n",
    "        initialListLength = initialListLength + 1\n",
    "    \n",
    "    index = 0\n",
    "    properCharsLength = len(properCharacters)\n",
    "    finalPalList = list()\n",
    "    \n",
    "    while index < initialListLength:\n",
    "        currentChar = initialPalList[index]\n",
    "        ProperCharIndex = 0\n",
    "        while ProperCharIndex < properCharsLength: \n",
    "            if currentChar == properCharacters[ProperCharIndex]:\n",
    "                lowerCurrentChar = currentChar.lower()\n",
    "                finalPalList.append(lowerCurrentChar)\n",
    "            ProperCharIndex = ProperCharIndex + 1\n",
    "        index = index +1\n",
    "    #print(finalPalList)\n",
    "    #please note that finalPalList has gotten rid of the spaces, punctuation, and other characters that are NOT alphabets. \n",
    "    #Therefore, please note that finalPalList can be used for proper analysis of the presence of a palindrome. \n",
    "    \n",
    "    finalListLength = 0\n",
    "    for listItem2 in finalPalList:\n",
    "        finalListLength = finalListLength + 1\n",
    "    #Please note this intuition below: \n",
    "    \n",
    "    a = \"spam\"\n",
    "    # print(a[0]) #s\n",
    "    # print(a[1]) #p\n",
    "    # print(a[2]) #a\n",
    "    # print(a[3]) #m\n",
    "\n",
    "    # print(a[-1]) #m\n",
    "    # print(a[-2]) #a\n",
    "    # print(a[-3]) #p\n",
    "    # print(a[-4]) #s\n",
    "\n",
    "    #thus please note that we start with the index 0 to the finalListLength - 1\n",
    "    \n",
    "    reverseIndex = 1\n",
    "    \n",
    "    reversePalList = list()\n",
    "    \n",
    "    finalListLength_Plus1 = finalListLength + 1\n",
    "    #please note that we will start with -1 and will go to -(finalListLength)\n",
    "    \n",
    "    while reverseIndex < finalListLength_Plus1:\n",
    "        reverseCharacter = finalPalList[-reverseIndex]\n",
    "        reversePalList.append(reverseCharacter)\n",
    "        reverseIndex = reverseIndex + 1\n",
    "        \n",
    "    #please note that both finalPalList and reversePalList both have the same length. \n",
    "    \n",
    "    indexCompare = 0\n",
    "    matches = 0\n",
    "    while indexCompare < finalListLength: \n",
    "        if finalPalList[indexCompare] == reversePalList[indexCompare]:\n",
    "            matches = matches + 1\n",
    "        indexCompare = indexCompare + 1\n",
    "    \n",
    "    if matches == finalListLength:\n",
    "        print(\"This IS a palindrome! In reverse please note,...\", PalPhrase, \"..., is the same!\")\n",
    "    else:\n",
    "        print(\":(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:...\", PalPhrase, \"...is different! :(\")\n",
    "    \n",
    "PhrasePalindrome(\"hi there kid\")  #:(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... hi there kid ...is different! :(\n",
    "PhrasePalindrome(\"radar\")  #This IS a palindrome! In reverse please note,... radar ..., is the same!\n",
    "PhrasePalindrome(\"Was it a rat I saw?\") #This IS a palindrome! In reverse please note,... Was it a rat I saw? ..., is the same!\n",
    "PhrasePalindrome(\"Step on no pets\") #This IS a palindrome! In reverse please note,... Step on no pets ..., is the same!\n",
    "\n",
    "PhrasePalindrome(\"Sit on a potato pan, Otis\") #This IS a palindrome! In reverse please note,... Sit on a potato pan, Otis ..., is the same!\n",
    "\n",
    "PhrasePalindrome(\"Otis\")  #:(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... Otis ...is different! :(\n",
    "PhrasePalindrome(\"Lisa Bonet ate no basil\")  #This IS a palindrome! In reverse please note,... Lisa Bonet ate no basil ..., is the same!\n",
    "\n",
    "PhrasePalindrome(\"Hopping over meadows\")  #:(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... Hopping over meadows ...is different! :(\n",
    "PhrasePalindrome(\"Lisa Bonet ate no basil or pasta\")  #:(  Sadly, this phrase (or word) is NOT a palindrome. In reverse please note that:... Lisa Bonet ate no basil or pasta ...is different! :(\n",
    "\n",
    "# SW: your function doesn't return anything, just prints to screen. even though it wasn't explicit in the \n",
    "#     instructions, you should write the function to return a Boolean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sadly, this is NOT a pangram. :(  There are not enough letters in the list to cover all 26 of the alphabets. Please note that here, there were only: 9 different letters. Please add more words with different letters too.\n",
      "Hooray!!! This IS indeed a pangram!  Please note that it contains ALL 26 letters of the alphabet!\n",
      "Hooray!!! This IS indeed a pangram!  Please note that it contains ALL 26 letters of the alphabet!\n",
      "Please note that sadly this is NOT a pangram!  It did NOT contain ALL 26 letters of the alphabet. :( . It only had: 24 different letters.\n",
      "Hooray!!! This IS indeed a pangram!  Please note that it contains ALL 26 letters of the alphabet!\n"
     ]
    }
   ],
   "source": [
    "# 7.)  For example:  The quick brown fox jumps over the lazy dog. \n",
    "#Your task here, is to please write a function to check a sentence to see if it is a pangram or not. \n",
    "\n",
    "\n",
    "def pangramChecker(sentence):\n",
    "    \"\"\"\n",
    "    Please note that a pangram is a sentence that contains all 26 of the letters of the English alphabet at least once. \n",
    "    For example:  The quick brown fox jumps over the lazy dog. \n",
    "    Your task here, is to please write a function to check a sentence to see if it is a pangram or not. \n",
    "Please note that this function also does error tracking and helps the user identify if they have entered in too few letters or how many different (unique) letters they have in their sentence. It also does NOT matter if there are any special characters. \n",
    "    \"\"\"\n",
    "    \n",
    "    #Please turn the sentence into a list with no special characters, spaces, or other punctuation.  Just pure words please. \n",
    "    initialSentenceList = list(sentence)\n",
    "   \n",
    "    #please do not append it if it is NOT in the list of uppercase or lowercase letter\n",
    "\n",
    "    properCharacters = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\"]\n",
    "    # print(len(properCharacters)) # Please note that len is for the length function\n",
    "    \n",
    "    \n",
    "    #please go through palList\n",
    "    initialListLength = 0\n",
    "    for listItem in initialSentenceList:\n",
    "        initialListLength = initialListLength + 1\n",
    "    \n",
    "    index = 0\n",
    "    properCharsLength = len(properCharacters)\n",
    "    finalSentenceList = list()\n",
    "    \n",
    "    while index < initialListLength:\n",
    "        currentChar = initialSentenceList[index]\n",
    "        ProperCharIndex = 0\n",
    "        while ProperCharIndex < properCharsLength: \n",
    "            if currentChar == properCharacters[ProperCharIndex]:\n",
    "                lowerCurrentChar = currentChar.lower()\n",
    "                finalSentenceList.append(lowerCurrentChar)\n",
    "            ProperCharIndex = ProperCharIndex + 1\n",
    "        index = index +1\n",
    "    #print(finalSentenceList)\n",
    "    \n",
    "    lowerCaseList = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\"]\n",
    "    lowerCasePopping = lowerCaseList\n",
    "    #please note that we will go through this finalSentenceList and see if has all of these 26 letters. \n",
    "    \n",
    "    finalSentenceList_Length = len(finalSentenceList)\n",
    "    \n",
    " \n",
    "    \n",
    "    \n",
    "    matches = 0\n",
    "    lowerCaseListIndex = 0\n",
    "    while lowerCaseListIndex < 26:  #equivalently, len(lowerCaseList), but since we know this is 26, we just put 26 to make things easier for the future. \n",
    "        CurrentLCletter = lowerCaseList[lowerCaseListIndex]\n",
    "        if CurrentLCletter in finalSentenceList:  #please note that this will help us identify only unique values\n",
    "            matches = matches + 1\n",
    "        lowerCaseListIndex = lowerCaseListIndex + 1\n",
    "        \n",
    "\n",
    "    \n",
    "  \n",
    "    #if the final sentence list does not even have 26 elements, then please say it is definitely not a pangram. \n",
    "    if finalSentenceList_Length < 26:\n",
    "        print(\"Sadly, this is NOT a pangram. :(  There are not enough letters in the list to cover all 26 of the alphabets. Please note that here, there were only:\", matches, \"different letters. Please add more words with different letters too.\")\n",
    "\n",
    "    elif  matches == 26: \n",
    "        print(\"Hooray!!! This IS indeed a pangram!  Please note that it contains ALL 26 letters of the alphabet!\")\n",
    "    \n",
    "    else: \n",
    "        print(\"Please note that sadly this is NOT a pangram!  It did NOT contain ALL 26 letters of the alphabet. :( . It only had:\", matches,\"different letters.\")\n",
    "    \n",
    "    #then go through the sentence and take the lowercase versions of it.  \n",
    "#pangramChecker(\"hi there buddy\")  #['h', 'i', 't', 'h', 'e', 'r', 'e', 'b', 'u', 'd', 'd', 'y']\n",
    "   \n",
    "pangramChecker(\"hi there buddy\")  # Sadly, this is NOT a pangram. :(  There are not enough letters in the list to cover all 26 of the alphabets. Please note that here, there were only: 9 different letters. Please add more words with different letters too.\n",
    "\n",
    "    \n",
    "pangramChecker(\"The quick brown fox jumps over the lazy dog. \")  #Hooray!!! This IS indeed a pangram!  Please note that it contains ALL 26 letters of the alphabet!\n",
    "\n",
    "#Please note that we just added an extra \"S\" here to the end to make it dogs and to test it out.  There still are only 26 unique matches\n",
    "pangramChecker(\"The quick brown fox jumps over the lazy dogS. \") #Hooray!!! This IS indeed a pangram!  Please note that it contains ALL 26 letters of the alphabet! 26\n",
    "pangramChecker(\"The quick brown fox jumps over the lazy cat . \")  #Please note that sadly this is NOT a pangram!  It did NOT contain ALL 26 letters of the alphabet. :( . It only had: 24 different letters.\n",
    "\n",
    "\n",
    "#here, we please play around with different punctuation. \n",
    "pangramChecker(\"The quick brown Fox jum'ps over the lazy dog . \") #Hooray!!! This IS indeed a pangram!  Please note that it contains ALL 26 letters of the alphabet!\n",
    "\n",
    "# SW: your function doesn't return anything, just prints to screen. even though it wasn't explicit in the \n",
    "#     instructions, you should write the function to return a Boolean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unindent does not match any outer indentation level (<ipython-input-19-78653838605a>, line 17)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-19-78653838605a>\"\u001b[0;36m, line \u001b[0;32m17\u001b[0m\n\u001b[0;31m    quant = NumOfBottles\u001b[0m\n\u001b[0m                        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unindent does not match any outer indentation level\n"
     ]
    }
   ],
   "source": [
    "def CokeBottles99(NumOfBottles = 99):\n",
    "       \"\"\"\n",
    "Please note that \"99 Bottles of Coke\" is a traditional song in the United States and Canada.  It is popular to sing on long trips, \n",
    "as it has a very repetitive format which is easy to memorize, and can take a long time to sing. \n",
    "The song's simple lyrics are as follows: \n",
    "\n",
    " 99 bottles of coke on the wall, 99 bottles of coke.  \n",
    " Take one down, pass it around, 98 bottles of coke on the wall. \n",
    " --\n",
    "\n",
    "The Same Verse is repeated, each time with 1 fewer bottle.  THe song is completed when the singer or singers reach 0.  \n",
    "\n",
    "Please write a Python program capable of generating all the verses of the song.  \n",
    "\n",
    "\n",
    "       \"\"\"\n",
    "    quant = NumOfBottles\n",
    "    i = 0\n",
    "    while i < quant:\n",
    "        if quant > 1:\n",
    "            print(quant, \"bottles of coke on the wall,\", quant, \"bottles of coke.\")\n",
    "            if quant > 2: \n",
    "                suffix = str(quant - 1) + \" bottles of coke on the wall.\"\n",
    "            else:\n",
    "                suffix = \"1 bottle of coke on the wall.\"\n",
    "        elif quant == 1: \n",
    "            print(\"1 bottle of coke on the wall, 1 bottle of coke.\")\n",
    "            suffix = \".  Please note no more coke on the wall! All gone :(\"\n",
    "        quant = quant - 1\n",
    "        print(\"Take one down, pass it around\", suffix)\n",
    "        print(\"--\")\n",
    "\n",
    "CokeBottles99(5)\n",
    "#\n",
    "#5 bottles of coke on the wall, 5 bottles of coke.\n",
    "#Take one down, pass it around 4 bottles of coke on the wall.\n",
    "#--\n",
    "#4 bottles of coke on the wall, 4 bottles of coke.\n",
    "#Take one down, pass it around 3 bottles of coke on the wall.\n",
    "#--\n",
    "#3 bottles of coke on the wall, 3 bottles of coke.\n",
    "#Take one down, pass it around 2 bottles of coke on the wall.\n",
    "#--\n",
    "#2 bottles of coke on the wall, 2 bottles of coke.\n",
    "#Take one down, pass it around 1 bottle of coke on the wall.\n",
    "#--\n",
    "#1 bottle of coke on the wall, 1 bottle of coke.\n",
    "#Take one down, pass it around .  Please note no more coke on the wall! All gone :(\n",
    "#--\n",
    "\n",
    "# SW: lost points: your function doesn't run as written, your indentation is off."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please note the Swedish Translation is:\n",
      "god jul och gott nytt ar \n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute 'split'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-7a5ae98fb65c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0;31m#god jul och gott nytt ar\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m \u001b[0mtranslate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'merry christmas'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m \u001b[0mtranslate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'merry'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'christmas'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-22-7a5ae98fb65c>\u001b[0m in \u001b[0;36mtranslate\u001b[0;34m(text)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtranslate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m     \u001b[0mwords\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m     \u001b[0mnew\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mwords\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'split'"
     ]
    }
   ],
   "source": [
    "def en_se(ChristmasWords):\n",
    "    \"\"\"\n",
    "    Please represent a small bilingual lexicon as a Python dictionary in the following fashion {\"merry\":\"god\", \"christmas\":\"jul\", \"and\":\"och\", \"happy\":gott\", \"new\":\"nytt\", \"year\":\"år\"} and\n",
    "    use it to translate your Christmas cards from English into Swedish. \n",
    "    That is, write a function translate() that takes a list of English words and returns a list of Swedish words.\n",
    "    \"\"\"\n",
    "    en_se={\"merry\":\"god\", \"christmas\":\"jul\", \"and\":\"och\", \"happy\":\"gott\", \"new\":\"nytt\", \"year\":\"ar\"}\n",
    "    # if word is not in the dictionary, please return the original word\n",
    "    if ChristmasWords in en_se:\n",
    "        return en_se.get(ChristmasWords)\n",
    "    else:\n",
    "        return ChristmasWords\n",
    "\n",
    "def translate(text):\n",
    "    words = text.split( );\n",
    "    new = \"\"\n",
    "    for i in words:\n",
    "        new = new + en_se(i) + \" \"\n",
    "    return new\n",
    "\n",
    "print (\"Please note the Swedish Translation is:\")\n",
    "print(translate(\"merry christmas and happy new year\"))\n",
    "#Please note the Swedish Translation is:\n",
    "#god jul och gott nytt ar \n",
    "# SW: lost points: your function should take a list parameter and return a list, but yours handles only a single\n",
    "#     string.\n",
    "translate(['merry','christmas'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please note these word counts for ( Hi there ) are:  {'t': 1, 'e': 2, ' ': 1, 'H': 1, 'h': 1, 'r': 1, 'i': 1}\n",
      "Please note these word counts for ( abbabcbdbabdbdbabababcbcbab ) are:  {'b': 14, 'd': 3, 'c': 3, 'a': 7}\n",
      "Please note these word counts for ( Armaan and Chanu and Poochie! ) are:  {'n': 4, 'e': 1, 'd': 2, 'u': 1, 'A': 1, 'r': 1, 'm': 1, 'i': 1, 'P': 1, ' ': 4, 'c': 1, 'a': 5, 'h': 2, '!': 1, 'C': 1, 'o': 2}\n"
     ]
    }
   ],
   "source": [
    "def char_freq(word):\n",
    "    \"\"\"\n",
    "    Please write a function char_freq() that takes a string and builds a frequency listing of the characters contained in it. \n",
    "    Please represent the frequency listing as a Python dictionary. \n",
    "    Please try it with something like: \n",
    "    char_freq(\"abbabcbdbabdbdbabababcbcbab\")\n",
    "    \"\"\"\n",
    "        \n",
    "    Letterdict = {}\n",
    "    \n",
    "    for letter in word:\n",
    "        Letterdict[letter] = Letterdict.get(letter,0) + 1\n",
    "    print(\"Please note these word counts for (\", word, \") are: \", Letterdict)\n",
    "\n",
    "char_freq(\"Hi there\")  #Please note these word counts for ( Hi there ) are:  {'H': 1, 'i': 1, ' ': 1, 'h': 1, 'r': 1, 'e': 2, 't': 1}\n",
    "\n",
    "char_freq(\"abbabcbdbabdbdbabababcbcbab\") #Please note these word counts for ( abbabcbdbabdbdbabababcbcbab ) are:  {'d': 3, 'a': 7, 'b': 14, 'c': 3}\n",
    "\n",
    "char_freq(\"Armaan and Chanu and Poochie!\") #Please note these word counts for ( Armaan and Chanu and Poochie! ) are:  {'n': 4, 'i': 1, 'a': 5, 'A': 1, 'e': 1, 'u': 1, 'o': 2, 'c': 1, ' ': 4, 'm': 1, 'd': 2, 'h': 2, 'C': 1, 'P': 1, '!': 1, 'r': 1}\n",
    "\n",
    "# SW: your function doesn't return anything, just prints to screen. even though it wasn't explicit in the \n",
    "#     instructions, you should write the function to return a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def alphabets(letter):\n",
    "    key = {'a':'n', 'b':'o', 'c':'p', 'd':'q', 'e':'r', 'f':'s', 'g':'t', 'h':'u', \n",
    "       'i':'v', 'j':'w', 'k':'x', 'l':'y', 'm':'z', 'n':'a', 'o':'b', 'p':'c', \n",
    "       'q':'d', 'r':'e', 's':'f', 't':'g', 'u':'h', 'v':'i', 'w':'j', 'x':'k',\n",
    "       'y':'l', 'z':'m', 'A':'N', 'B':'O', 'C':'P', 'D':'Q', 'E':'R', 'F':'S', \n",
    "       'G':'T', 'H':'U', 'I':'V', 'J':'W', 'K':'X', 'L':'Y', 'M':'Z', 'N':'A', \n",
    "       'O':'B', 'P':'C', 'Q':'D', 'R':'E', 'S':'F', 'T':'G', 'U':'H', 'V':'I', \n",
    "       'W':'J', 'X':'K', 'Y':'L', 'Z':'M'}\n",
    "    #please note that this is the key for the ROT13 function. \n",
    "    if letter in key:\n",
    "        return key.get(letter)  #please get the letter of the corresponding \n",
    "    else:      # if word is not in the dictionary, please return the original word.  Please note that this applies to special characters like ! and ? and *.   Those words will be returned. \n",
    "        return letter\n",
    "    \n",
    "#print(alphabets(\"x\")) # k\n",
    "#Please note that since x maps to k by ROT13, then the alphabets function will generate k. \n",
    "\n",
    "#print(alphabets(\"T\")) #G\n",
    "#Please note that since T maps to G by ROT13, then the alphabets function will generate G. \n",
    "\n",
    "    #print(key)  #\n",
    "    #{'J': 'W', 'Y': 'L', 'm': 'z', 'Q': 'D', 'B': 'O', 'b': 'o', 'A': 'N', 'h': 'u', 'Z': 'M', 'V': 'I', 'u': 'h', 'w': 'j', 'x': 'k', 'j': 'w', 'N': 'A', 'P': 'C', 'p': 'c', 'C': 'P', 'R': 'E', 'd': 'q', 'M': 'Z', 'G': 'T', 'K': 'X', 'r': 'e', 'D': 'Q', 'y': 'l', 'k': 'x', 'F': 'S', 's': 'f', 'o': 'b', 'v': 'i', 'i': 'v', 'l': 'y', 't': 'g', 'O': 'B', 'n': 'a', 'E': 'R', 'c': 'p', 'g': 't', 'T': 'G', 'S': 'F', 'a': 'n', 'f': 's', 'U': 'H', 'H': 'U', 'I': 'V', 'X': 'K', 'q': 'd', 'W': 'J', 'L': 'Y', 'e': 'r', 'z': 'm'}\n",
    "\n",
    "    #print(key['A'])  #N\n",
    "    #Please note that this returns N since A maps to N. \n",
    "\n",
    "    #print(key['z'])  #m\n",
    "    # Please note that this will return m since z maps to m.  \n",
    "\n",
    "    #print(key['S'])  #F\n",
    "    # Please note that this will return F since S maps to F.   \n",
    "\n",
    "    \n",
    "def ROT13(secretPhrase): \n",
    "    \"\"\"\n",
    "In cryptography, please note that a Caesar cipher is a very simple encryption techniques in which each letter in the plain text is replaced by a letter some fixed number of positions down the alphabet. \n",
    "For example, with a shift of 3, A would be replaced by D, B would become E, and so on. The method is named after Julius Caesar, who used it to communicate with his generals. ROT-13 (\"rotate by 13 places\") is a widely used example of a Caesar cipher where the shift is 13. \n",
    "In Python, the key for ROT-13 may be represented by means of the following dictionary:\n",
    "\n",
    "key = {'a':'n', 'b':'o', 'c':'p', 'd':'q', 'e':'r', 'f':'s', 'g':'t', 'h':'u', \n",
    "       'i':'v', 'j':'w', 'k':'x', 'l':'y', 'm':'z', 'n':'a', 'o':'b', 'p':'c', \n",
    "       'q':'d', 'r':'e', 's':'f', 't':'g', 'u':'h', 'v':'i', 'w':'j', 'x':'k',\n",
    "       'y':'l', 'z':'m', 'A':'N', 'B':'O', 'C':'P', 'D':'Q', 'E':'R', 'F':'S', \n",
    "       'G':'T', 'H':'U', 'I':'V', 'J':'W', 'K':'X', 'L':'Y', 'M':'Z', 'N':'A', \n",
    "       'O':'B', 'P':'C', 'Q':'D', 'R':'E', 'S':'F', 'T':'G', 'U':'H', 'V':'I', \n",
    "       'W':'J', 'X':'K', 'Y':'L', 'Z':'M'}\n",
    "\n",
    "Your task in this exercise is to implement an encoder/decoder of ROT-13. Once you're done, you will be able to read the following secret message:\n",
    "\n",
    "   Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!\n",
    "Note that since English has 26 characters, your ROT-13 program will be able to both encode and decode texts written in English.\n",
    "\n",
    "Please note that now we can send secret messages to each other! \n",
    "\n",
    "\"\"\"\n",
    "    \n",
    "    \n",
    "    key = {'a':'n', 'b':'o', 'c':'p', 'd':'q', 'e':'r', 'f':'s', 'g':'t', 'h':'u', \n",
    "       'i':'v', 'j':'w', 'k':'x', 'l':'y', 'm':'z', 'n':'a', 'o':'b', 'p':'c', \n",
    "       'q':'d', 'r':'e', 's':'f', 't':'g', 'u':'h', 'v':'i', 'w':'j', 'x':'k',\n",
    "       'y':'l', 'z':'m', 'A':'N', 'B':'O', 'C':'P', 'D':'Q', 'E':'R', 'F':'S', \n",
    "       'G':'T', 'H':'U', 'I':'V', 'J':'W', 'K':'X', 'L':'Y', 'M':'Z', 'N':'A', \n",
    "       'O':'B', 'P':'C', 'Q':'D', 'R':'E', 'S':'F', 'T':'G', 'U':'H', 'V':'I', \n",
    "       'W':'J', 'X':'K', 'Y':'L', 'Z':'M'}\n",
    "    words = list(secretPhrase) #please note that we are splitting up a string into a list of letters.  Each letter is a new element. \n",
    "    newPhrase = \"\"\n",
    "    for i in words: \n",
    "        newPhrase = newPhrase +  alphabets(i) + \"\"  #please note that here, we are calling the alphabets function that we created above. It will get the corresponding letter for the ROT13. \n",
    "    PhraseString = ''.join(newPhrase)\n",
    "    return PhraseString\n",
    "    \n",
    "##ROT13(\"Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!\")\n",
    "#'Caesar cipher? I much prefer Caesar salad!'\n",
    "\n",
    "\n",
    "#ROT13(\"Caesar cipher? I much prefer Caesar salad!\")\n",
    "#'Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!'\n",
    "\n",
    "#Therefore, please note that we can go back and forth between decoding (sending in ROT13 phrase and getting the normal phrase) and encoding (turning a random phrase into ROT13)\n",
    "#ROT13(\"Hi there Peter\")\n",
    "#'Uv gurer Crgre'\n",
    "\n",
    "ROT13(\"Uv gurer Crgre\")  #'Hi there Peter'\n",
    "ROT13(\"This is a letter from Santa!\")  #'Guvf vf n yrggre sebz Fnagn!'\n",
    "\n",
    "# SW: good, you are returning something."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Correct. a'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re #please note that re stands for regular expression\n",
    "\n",
    "\n",
    "def correct(string):\n",
    "    \n",
    "    \"\"\"\n",
    "Define a simple \"spelling correction\" function correct() that takes a string and sees to it that 1) two or more\n",
    "occurrences of the space character is compressed into one, and 2) inserts an extra space after a period if the period\n",
    "is directly followed by a letter. E.g. correct(\"This   is  very funny  and    cool.Indeed!\") should return\n",
    "\"This is very funny and cool. Indeed!\" Tip: Please use regular expressions!\n",
    "This is indeed a very cool and sweet spelling correction function.  It fixes spacing errors. \n",
    "    \"\"\"\n",
    "\n",
    "    string = re.sub(r'[.]([a-zA-Z])', r'. \\1', string) #please note that this is dealing with 1.) inserts an extra space after a period if the period is directly followed by a letter. \n",
    "    #please note that this will get rid of any extra spacing if there are 2 or more spaces in a row:\n",
    "    string = re.sub(r'( )+', r'\\1', string)\n",
    "    return string  #only returns 1 string at a time.  That is, please note that it will give the output for only 1 correct() run-through. \n",
    " # Please note that re (regular expressions) have methods for various operations such as searching for pattern matches or performing string substitutions.\n",
    "\n",
    "# Please note that here we will call the function, correct, entering in a string that may need some spacing corrections\n",
    "correct(\"This   is  very funny  and    cool.Indeed!\")  #'This is very funny and cool. Indeed!'\n",
    "#correct(\"This is very  funny.nice to meet ye!!\") #'This is very funny. nice to meet ye!!'\n",
    "#correct(\"I am very happy   to know about that.Please have a very happy holiday!\")  #'I am very happy to know about that. Please have a very happy holiday!'\n",
    "\n",
    "# SW: good."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tries\n",
      "brushes\n",
      "runs\n",
      "fixes\n",
      "funnies\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def make_3sg_form(verb):\n",
    "    \"\"\"\n",
    "The third person singular verb form in English is distinguished by the suffix -s, which is added to the stem of the\n",
    "infinitive form: run -> runs. A simple set of rules can be given as follows:\n",
    "    If the verb ends in y, remove it and add ies\n",
    "    If the verb ends in o, ch, s, sh, x or z, add es\n",
    "    By default just add s\n",
    "Your task in this exercise is to define a function make_3sg_form() which given a verb in infinitive form returns its\n",
    "third person singular form. Test your function with words like try, brush, run and fix. Note however that the rules must\n",
    "be regarded as heuristic, in the sense that you must not expect them to work for all cases.\n",
    "Tip: Check out the string method endswith().\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    es = ('o', 'ch', 's', 'sh', 'x', 'z')  #this is the list of verbs for which we would add an es to the end of the verb\n",
    "    if verb.endswith('y'):\n",
    "        print(re.sub('y$', 'ies', verb)) #please note that we will be substituting the y at the end of the verb with ies instead. \n",
    "    elif verb.endswith(es):  \n",
    "        print(verb + 'es')  #please note that for verbs that are in the list es; that is verbs that end with o, ch, s, sh, x, or z. \n",
    "    else:\n",
    "        print(verb + 's')\n",
    "\n",
    "make_3sg_form('try') # tries\n",
    "make_3sg_form('brush')  #brushes\n",
    "make_3sg_form('run')  #runs\n",
    "make_3sg_form('fix') #fixes\n",
    "#please note this example of a mistake, where we use an adjective instead of a verb:\n",
    "make_3sg_form('funny')  #funnies\n",
    "\n",
    "# SW: lost points: your function doesn't return anything, just prints to screen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "being\n",
      "lying\n",
      "seeing\n",
      "moving\n",
      "hugging\n",
      "watching\n",
      "playing\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# re is the python regular expression module. its very powerful and worth learning.\n",
    "import re\n",
    "# unittest is the built in testing module. good for simple use cases like this.\n",
    "from unittest import TestCase, TestLoader, TestResult\n",
    "\n",
    "# compiling the regex pattern ahead of time, which adds significant speed\n",
    "vowel_pattern = re.compile(r'[AEIOUaeiou]')\n",
    "\n",
    "def is_vowel(char):\n",
    "    # raising errors for invalid input is a good idea\n",
    "    # pythonic design principle: let the thing crash early and often, and with a helpful error message\n",
    "    if len(char) > 1:\n",
    "        raise ValueError('char had length greater than 1')\n",
    "\n",
    "    if vowel_pattern.match(char):\n",
    "        return True\n",
    "\n",
    "    return False\n",
    "\n",
    "\n",
    "def make_ing_form(verb):\n",
    "    \n",
    "    \"\"\"\n",
    "Problem 14.) \n",
    "In English, the present participle is formed by adding the suffix -ing to the infinite form: go -> going.\n",
    "A simple set of heuristic rules can be given as follows:\n",
    "(Please note that as heuristics, these may not always be true)\n",
    "    a. If the verb ends in e, drop the e and add ing (if not exception: be, see, flee, knee, etc.)\n",
    "    b. If the verb ends in ie, change ie to y and add ing\n",
    "    c. For words consisting of consonant-vowel-consonant, double the final letter before adding ing\n",
    "    d. By default just add ing\n",
    "Your task in this exercise is to define a function make_ing_form() which given a verb in infinitive form returns its\n",
    "present participle form. Test your function with words such as lie, see, move and hug. However, you must not expect such\n",
    "simple rules to work for all cases.\n",
    "    \"\"\"\n",
    "\n",
    "    if verb.endswith('y'):\n",
    "        print(verb + 'ing')  #For instance, the verb play will return playing.  \n",
    "\n",
    "    elif verb.endswith('ie'):\n",
    "        print(verb[:-2] + 'ying')  #Here, verb[-1] refers to the last letter of the verb;  also, verb[-2] refers to the second to last letter of the verb.  \n",
    "        # please note that : means all letters, while verb[:-2] means to include all letters of the verb except for the last 2 letters. \n",
    "    elif verb.endswith('e') and (verb[-2].endswith('e') or len(verb) == 2):\n",
    "        print(verb + 'ing')\n",
    "    elif verb.endswith('e'):\n",
    "        print(verb[:-1] + 'ing')  #this means to get rid of the last letter of the verb (if it ends in -e) and add -ing instead. \n",
    "    elif not is_vowel(verb[-1]) and is_vowel(verb[-2]) and not is_vowel(verb[-3]):\n",
    "        print(verb + verb[-1] + 'ing')\n",
    "    else:\n",
    "        print(verb + 'ing')\n",
    " \n",
    "make_ing_form('be')  #being\n",
    "make_ing_form('lie')  #lying\n",
    "make_ing_form('see') #seeing\n",
    "make_ing_form('move')  #moving\n",
    "make_ing_form('hug')  #hugging\n",
    "make_ing_form('watch')\n",
    "make_ing_form('play')\n",
    "\n",
    "# SW: lost points: your function doesn't return anything, just prints to screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}