HW2_Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Saniya Khullar;  Homework 2;  September 2015; Mathematical and Statistical Computing; Professor Pilcher"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Thank you so much!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SW: your code generally works, but your functions need to _return_ values, not just print them to screen. and be careful with your return types, if a function should return a Boolean value, then it cannot return a string. such functions will not work well together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 55 89 144\n"
     ]
    }
   ],
   "source": [
    "# Please Define a function ‘fib’ that takes a number, ‘n’, as a parameter \n",
    "#and prints all the Fibonacci numbers less than ‘n’ to the screen.\n",
    "\n",
    "\n",
    "def fib(n):  # here, please note that n is the parameter\n",
    "    \"\"\"\n",
    "   Please note that this code was taken from Professor Pilcher's code in the Mathematical/Statistical Computing course notebook. \n",
    "   The function ‘fib’  takes a number, ‘n’, as a parameter and prints all the Fibonacci numbers less than ‘n’ to the screen.\n",
    "   \"\"\"\n",
    "    a, b = 0, 1\n",
    "    while a < n:\n",
    "        print(a, end=' ')\n",
    "        a, b = b, a+b  #these are Fibbonacci (\"Fibonacci\")  numbers. \n",
    "    print(a)\n",
    "fib(100)  # 0 1 1 2 3 5 8 13 21 34 55 89 144\n",
    "\n",
    "# SW: your doc header is incorrectly indented, this code will not run as written. I've\n",
    "# modified the first line to demonstrate.\n",
    "# lost points: and, the function should print all Fibonacci numbers less than n, but this\n",
    "# function prints all numbers up to and including n. (-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Please note that both numbers are equal and are: -0.5\n",
      "2\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unorderable types: int() > NoneType()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-910bb56c1885>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0;31m# should work, but doesn't because there is no return value.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmymax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmymax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\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[0;32m<ipython-input-8-910bb56c1885>\u001b[0m in \u001b[0;36mmymax\u001b[0;34m(number1, number2)\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mPlease\u001b[0m \u001b[0mnote\u001b[0m \u001b[0mthat\u001b[0m \u001b[0mthis\u001b[0m \u001b[0mfunction\u001b[0m \u001b[0mmymax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnumber2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0mwill\u001b[0m \u001b[0mtake\u001b[0m \u001b[0many\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0mnumbers\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mwill\u001b[0m \u001b[0mtell\u001b[0m \u001b[0mwhich\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mlarger\u001b[0m \u001b[0mnumber\u001b[0m\u001b[0;34m.\u001b[0m  \u001b[0mFor\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0mnumbers\u001b[0m \u001b[0mthat\u001b[0m \u001b[0mare\u001b[0m \u001b[0mequal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mit\u001b[0m \u001b[0mwill\u001b[0m \u001b[0mjust\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0msame\u001b[0m \u001b[0mnumber\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \"\"\"\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mnumber1\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mnumber2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mnumber2\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mnumber1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unorderable types: int() > NoneType()"
     ]
    }
   ],
   "source": [
    "#Please define a function mymax() that takes 2 numbers as arguments and returns the largest of them. \n",
    "# Use the if-then-else construct available in Python. (It is true that Python has the max() function built in, but writing it yourself is nevertheless a good exercise.)\n",
    "\n",
    "\n",
    "def mymax(number1, number2):\n",
    "    \"\"\"\n",
    "    Please note that this function mymax(number1, number2) will take any 2 numbers and will tell which is the larger number.  For 2 numbers that are equal, it will just return the same number. \n",
    "    \"\"\"\n",
    "    if number1 > number2:\n",
    "        print(number1)\n",
    "    elif number2 > number1:\n",
    "        print(number2)\n",
    "    else: #here both numbers are equal\n",
    "        print(\"Please note that both numbers are equal and are:\", number1)  #equivalently, it could have been print(number2), since both numbers are equivalent.\n",
    "\n",
    "mymax(-22,3) #3\n",
    "mymax(-1/2, -1/2) #Please note that both numbers are equal and are: -0.5\n",
    "\n",
    "# SW: lost points: your function isn't actually returning anything, just printing to screen. \n",
    "# the below code should work, but doesn't because there is no return value. and, your function\n",
    "# needs to have a predictable return type. returning a number in two cases and a string in the\n",
    "# third case (equality) means that you will have a hard time combining this function with\n",
    "# others.\n",
    "# lost points: function doesn't return anything, 'intended' return values mix types (-3)\n",
    "\n",
    "print(mymax(3, mymax(1,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "145.5\n",
      "33\n",
      "56\n",
      "56\n",
      "20.4\n"
     ]
    }
   ],
   "source": [
    "#Please define a function max_of_three() that takes 3 numbers as arguments \n",
    "#and returns the largest of them.\n",
    "\n",
    "        #please note that these are the 3 numbers that will be used as arguments\n",
    "    #need for initialization?\n",
    "        \n",
    "def max_of_three(num1, num2, num3):  \n",
    "    if num1 > num2:\n",
    "        if num1 > num3:  #please note the order of big to small: num1 is greatest\n",
    "            print(num1)  #number 1 is the greatest number\n",
    "        else:   #order of big to small:  num3 >= num1 > num2\n",
    "            print(num3)  #number 3 can be greater than or equal to 1.  It is the greatest number, though. \n",
    "    else:\n",
    "        if num2 > num3:  #please note order from big to small: num2 is greatest\n",
    "            print(num2)\n",
    "        else: \n",
    "            print(num3) #then num3 is the greatest and the order is: num3 >= num2 > num1\n",
    "  \n",
    "max_of_three(1,-314,-5)        #1\n",
    "max_of_three(3, 3, 3)  #3\n",
    "max_of_three(291/2, 2, 4) #145.5\n",
    "max_of_three(10, 33, 4) #33\n",
    "max_of_three(56, 18, 20) #56\n",
    "max_of_three(22, 55, 56) #56\n",
    "max_of_three(18, 20, 20.4) #20.4\n",
    "\n",
    "# SW: lost points: function doesn't return anything, missing doc header comments (-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "7\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "#Please define a function mylen() that computes the length of a given list or string. \n",
    "# It is true that Python has the len() function built in, but writing it yourself is nevertheless a good exercise. \n",
    "\n",
    "def mylen(myLiString): #here, myLiString is Saniya's creative way of showing this works for both a list as well as string\n",
    "\n",
    "    stringLength = 0  #please note that we are initializing the value of string length\n",
    "    \n",
    "    for c in myLiString:  #we will go through each character in myLiString and will consider that as a unit of length. \n",
    "        stringLength = stringLength + 1  \n",
    "        #equivalently can be expressed as:\n",
    "        #stringLength += stringLength\n",
    "        \n",
    "    print(stringLength)\n",
    "\n",
    "mylen('Saniya')  #6\n",
    "mylen('Khullar')  #7\n",
    "mylen([1,2,3,4,5,10,11, 15, 18, 12])  #10 \n",
    "\n",
    "# SW: lost points: function doesn't return anything, missing doc header comments (-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "<class 'bool'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#Please write a function that takes a character (that is, a string of length 1) and\n",
    "#returns True if it is a vowel, and False otherwise. \n",
    "\n",
    "def vowelFinder(character):\n",
    "    \"\"\"\n",
    "    Please note that this is the documentation of the vowelFinder(character) function by Saniya. \n",
    "    \n",
    "    Here, we will take a character (that is, a string of length 1) and we will examine to see if the character is a vowel or not. \n",
    "    #If the character is a vowel, the vowelFinder will say that it is a vowel (True) and if it is NOT a vowel, then the vowelFinder will say that it is NOT a vowel.\n",
    "    \"\"\"\n",
    "    char = str(character) #please note that we are turning this character into a string so that we can work with it. \n",
    "    vowels = (\"a\", \"e\", \"i\", \"o\", \"u\", \"A\", \"E\", \"I\", \"O\", \"U\") #we please consider both lower and uppercase vowels\n",
    "    \n",
    "    #we also please consider both lower and uppercase consonants:\n",
    "    consonants = (\"b\", \"c\", \"d\", \"f\", \"g\", \"h\", \"j\", \"k\", \"l\", \"m\", \"p\", \"q\", \"r\", \"s\", \"t\", \"v\", \"w\", \"x\", \"y\", \"z\", \"B\", \"C\", \"D\", \"F\", \"G\", \"H\", \"J\", \"K\", \"L\", \"M\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"V\", \"W\", \"X\", \"Y\", \"Z\")\n",
    "\n",
    "    #instead of usinf if-else-elsif loops, we please use 2 different for loops.  Since the list of vowels and the list of consonants are disjoint (with NO overlaps), testing if the character is in either of the 2 lists will be the same as an if-else loop.\n",
    "    for vow in vowels:  #vow is considered an element in the list of all the vowels\n",
    "        if vow == char: #we are seeing if any vowels match with the character...that is, is that character a vowel?\n",
    "            print(\"True\") \n",
    "   \n",
    "    for conso in consonants:\n",
    "        if conso == char:  #we are seeing if any consonants match with the character...that is, is that character a consonant?\n",
    "            print(\"False\")  #That is, the number is NOT a vowel and is instead a consonant. \n",
    "    \n",
    "    #trying out the vowelFinder function:\n",
    "vowelFinder(\"z\") #False\n",
    "vowelFinder(\"A\") # True\n",
    "\n",
    "# SW: there is no need to check whether character is a consonant. if it is not a vowel, you\n",
    "# can return false and be done. also, be careful about Boolean types, see below.\n",
    "# lost points: function doesn't return anything (-2)\n",
    "print(type(True))\n",
    "print(type('True'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Momyoy Nonamome isos Sosanoniyoya Kokhohulollolaror\n",
      "tothohisos isos fofunon\n",
      "Tothohisos isos fofunonNonyoy\n",
      "Aaror momatoteyoy! I amom a popiroratote!\n"
     ]
    }
   ],
   "source": [
    "#Please write a function translate() that will translate a text into \"rovarspraket\".\n",
    "#That is, Swedish for robber's language.  That, is, double every consonant and place an occurrence of \"o\" in between. \n",
    "#For example, translate(\"this is fun\") should return the string: \"tothohisos isos fofunon\".\n",
    "\n",
    "def translate(text):\n",
    "    textList = list(text) #please note that we are turning the text string into a list!! Each character is broken into a new element, separated by commas. This will help us out!\n",
    "    allConsonants = (\"b\", \"c\", \"d\", \"f\", \"g\", \"h\", \"j\", \"k\", \"l\", \"m\", \"n\", \"p\", \"q\", \"r\", \"s\", \"t\", \"v\", \"w\", \"x\", \"y\", \"z\", \"B\", \"C\", \"D\", \"F\", \"G\", \"H\", \"J\", \"K\", \"L\", \"M\", \"N\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"V\", \"W\", \"X\", \"Y\", \"Z\")\n",
    "\n",
    "    #please note that this is case sensitive. That is, there is a difference between S and s.  \n",
    "    #Hence, we please specify this important difference between upper and lowercase letters by including the lowercase AND uppercase consonants in the allConsonants variable.  Then the uppercase letters will be recognized as being consonants as well. \n",
    "    robbersText = list()  #we are just specifying that we want the robbersText to be a list.  Right now it is empty, but we will start to fill it in with the append() function.\n",
    "\n",
    "    #we will go through each of the elements in the text list we created and will see if that is a consonant or not.  \n",
    "    for letter in textList: #here, Python understands that letter is just an element from the string List that we want to turn into Robber's language.\n",
    "        if letter in allConsonants:  #if the letter is a consonant then we will keep the letter, then will add an o, then will add the letter. \n",
    "            #example, when reading [...,z,...], since z is a consonant, the loop will say that letter is in allConsonants. \n",
    "            #Then the following will be done:  [...,z, o, z,...]  That is, we will keep the letter, then add an o element, then add the same letter again. \n",
    "            #If the letter is uppercase, then:  [...,B,...] will be turned into:  [...,B, o, b,...] and we are taking the lowercase version of B.  \n",
    "            #just to be safe, we specify letter.lower() so that regardless we will always guarantee that we are adding lowercase. \n",
    "            #for vowels like [...,u,...] we will just keep it as is as:  [...,u,...]\n",
    "            #Please thus note that this loop applies to a consonant\n",
    "            newletter = letter + \"o\" + letter.lower()   #please note that this letter.lower() is dealing with uppercase letters and has no effect on lowercase letters.\n",
    "            robbersText.append(newletter)  #here, we will append the original letter, the letter o, and the lowercase version of the letter (if the letter is uppercase to begin with)\n",
    "              #please note that the function .lower() allows us to convert the uppercase letter to a lowercase when it is repeated\n",
    "        else:  #that is the letter is NOT a consonant and is hence a vowel.  We please leave the vowels alone. \n",
    "            newletter = letter  \n",
    "            robbersText.append(newletter)  #please note that we add this term into the blank list robbersText, which we just created.\n",
    "\n",
    "    robbersTextString = ''.join(robbersText)  #please note that this will convert the robbersText list back into a string, by combining all of the elements in the list and joining them together...cutting and pasting. \n",
    "    print(robbersTextString) #we return the string output, the brand new Robbers language that we have\n",
    "    \n",
    "#Please note that here, we are applying the function and getting that respective output.  The function is like the formula. When we call the function, we are supplying the raw ingredients, namely the parameters. \n",
    "\n",
    "translate(\"My Name is Saniya Khullar\")\n",
    "#please note that the output will be and should be:  Moy Naome ios Sanioya Kohuololaor\n",
    "translate(\"this is fun\") \n",
    "#tothohisos isos fofunon\n",
    "translate(\"This is funNy\")  #Tothohisos isos fofunonNonyoy\n",
    "translate(\"Aar matey! I am a pirate!\")  #Aaror momatoteyoy! I amom a popiroratote!\n",
    "\n",
    "# SW: lost points: function doesn't return anything, missing doc header comments (-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please note that the total SUM of the list of numbers (2,) , is: 2\n",
      "Please note that the total SUM of the list of numbers (1, 2, 3, 4) , is: 10\n",
      "Please note that the total SUM of the list of numbers (4, 5, -1, 2, 33) , is: 43\n",
      "Please note that the total (multiplication) PRODUCT of the list of numbers (1, 2, 3, 4) , is: 24\n"
     ]
    }
   ],
   "source": [
    "#Please define these 2 functions:\n",
    "#a function sum() that sums all the numbers in a list of numbers.  For example, sum([1,2,3,4]), should return 10. \n",
    "#a function multiply() that multiplies all the numbers in a list of numbers.  For example, multiply([1,2,3,4]) should return 24.  \n",
    "\n",
    "\n",
    "def sum(*numbers):\n",
    "    \"\"\"\n",
    "    Please note that here, to enter a list of numbers, simply put the numbers with a comma within the parentheses of the sum() function. \n",
    "    For example, to sum the numbers [1, 2, 3, 4], please write it as just: sum(1,2,3,4)\n",
    "    Please note this key identifier of the single asterick (star: *): *numbers = any number of numbers separated by commas  (= indefinite amount...can even be empty)\n",
    "    \"\"\"\n",
    "    addSum = 0\n",
    "    #numberList = [numbers]\n",
    "    #numberList = [int(i) for i in numbers]\n",
    "    \n",
    "    for num in numbers:\n",
    "        addSum = addSum + num\n",
    "    print(\"Please note that the total SUM of the list of numbers\", numbers, \", is:\", addSum)\n",
    "    \n",
    "sum(1,2,3,4)\n",
    "#Please note that the total SUM of the list of numbers (1, 2, 3, 4) , is: 10\n",
    "\n",
    "sum(4,5, -1, 2, 33)\n",
    "#Please note that the total SUM of the list of numbers (4, 5, -1, 2, 33) , is: 43\n",
    "\n",
    "def multiply(*newNumbers):\n",
    "    multProduct = 1  #please note that we just set some initial value for the multProduct, just as we did for the initial sum. \n",
    "    #However, if we set this equal to 0, then we will get a false result!  We would wrongly get the value of 0 for our multiplication product, when instead we want the real product. \n",
    "    \n",
    "    for Num in newNumbers: \n",
    "        multProduct = Num * multProduct\n",
    "    print(\"Please note that the total (multiplication) PRODUCT of the list of numbers\", newNumbers, \", is:\", multProduct)\n",
    "\n",
    "multiply(1,2,3,4)\n",
    "#Please note that the total (multiplication) PRODUCT of the list of numbers (1, 2, 3, 4) , is: 24\n",
    "\n",
    "# SW: lost points: doesn't work for a list (see below); function doesn't return anything;\n",
    "# 'intended' return type should be a number, not a string (-6)\n",
    "l = [1,2,3,4]\n",
    "sum(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Question 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ayinaS\n",
      "ralluhK\n",
      ".gnitset ma I\n"
     ]
    }
   ],
   "source": [
    "# Please note this is Question 8:\n",
    "# Please define a function reverse() that computes the reversal of a string. \n",
    "# For example, reverse(\"I am testing\") should return the string:  \"gnitset ma I\". \n",
    "\n",
    "#Please note that some of the intuition was taken from Problem 4. \n",
    "\n",
    "def reverse(string):  #please note that this function will give the reverse of a string\n",
    "    stringLength = 0  #please note that we are initializing the value of string length\n",
    "    \n",
    "    for c in string:\n",
    "        stringLength = stringLength + 1 \n",
    "\n",
    "    i = stringLength\n",
    "    k = i - 1\n",
    "    ReverseStrList = list()\n",
    "    \n",
    "    j = 0  #please initialize\n",
    "    \n",
    "    while j < i:\n",
    "        newTerm = string[k - j]\n",
    "        ReverseStrList.append(newTerm)\n",
    "        j = j + 1\n",
    "    \n",
    "    ReverseString = ''.join(ReverseStrList) \n",
    "    \n",
    "    print(ReverseString)\n",
    "  \n",
    "\n",
    "reverse(\"Saniya\") # ayinaS\n",
    "reverse(\"Khullar\")  # ralluhK\n",
    "reverse(\"I am testing.\")  # .gnitset ma I\n",
    "\n",
    "# SW: function doesn't return anything, missing doc header comments (-3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True. Please note that this word: radar , is indeed a palindrome! (Example: radar is a palindrome since the word in reverse is the same!\n",
      "True. Please note that this word: Hannah , is indeed a palindrome! (Example: radar is a palindrome since the word in reverse is the same!\n",
      "False. Please note that this word: Saniya , is sadly NOT a palindrome! (Example: radar is a palindrome since the word in reverse is the same!)\n"
     ]
    }
   ],
   "source": [
    "#Please define a function is_palindrome() that recognizes palindromes (that is, words that look the same written backwards). \n",
    "# For example, is_palindrome(\"radar\") should return True. \n",
    "# For example, is_palindrome(\"Hannah\") is true too. \n",
    "\n",
    "def is_palindrome(palString):\n",
    "    \n",
    "    \"\"\"\n",
    "    Please note that this is_palindrome(palString) function recognizes palindromes (that is, words that look the same written backwards). \n",
    "    For example, is_palindrome(\"radar\") should return True. If you reverse radar, you should get radar.  \n",
    "    Even the word Hannah is a palindrome too.  \n",
    "    Other words like Saniya are NOT palindromes because in reverse, Saniya is Ayinas.  \n",
    "    To test if a given word is a palindrome, please simply type in the name of the word in the brackets where ye see the word palString. \n",
    "    The function is_palindrome will return a True if it is a palindrome and a false if it is NOT a palindrome. \n",
    "    \"\"\"\n",
    "    \n",
    "    palStringLower = palString.lower() #please note that this will hopefully get rid of any problems that arise from having an upper case letter. \n",
    "    stringLength = 0  #please assign stringLength as 0 so that we may please initialize it. \n",
    "\n",
    "    for c in palString:  #here, c is understood by Python to be a variable that is used in counting palString. \n",
    "        stringLength = stringLength + 1  #please note that this idea was taken from problem 4, the mylen() function.  Here, we are counting the number of elements in palString; that is the length of palString. \n",
    "        \n",
    "    #equivalently, we could have just taken:  stringLength = len(palString)  and we would have gotten the same results\n",
    "    \n",
    "    \n",
    "    i = stringLength   #here, the length of the string is assigned as a variable. \n",
    "    \n",
    "    #the key idea here is that for: \n",
    "        #odd palindromes like:  radar, there are 5 digits here.  However, what matters is ra-d-ar.  That is, we do Not really care if it is rasar or radar or ratar for instance.  We do Not care about the center letter.  \n",
    "        #We care that we have ra and ar here and then flipped around the both are equivalent.  Thus, we want to divide this word into 2 GROUPS:  ra  and ar.  \n",
    "        \n",
    "        #for even palindromes like: Hannah, there are 6 digits here.  Now, all letters matter.  Han-nah.  There are 2 groups here:  Han  and Nah.  We want the 2nd group, Nah, when reversed to be Han, which it is. \n",
    "        #Thus, for even palindromes as well, it matters that we divide the word into groups of 2. \n",
    "        \n",
    "        #***Please note that this is what we will try to do below with halfLength.  However, we must note that we do NOT want to have any 1/2 remainders when we divide by 2.  We want just to round down to the nearest integer. \n",
    "        #This is why we will use the int function.  Then, int(5/2) = 2 instead of 2.5 .  The 5 letter palindrome will be split into 2 groups of 2 letters each, as it should. \n",
    "        \n",
    "        \n",
    "    \n",
    "    halfLength = int(i/2) #this will get rid of the remainder and help us round down to the nearest integer.  This is really helpful for odd letter words. \n",
    "    #the name halfLength may be a bit misleading (Especially for odd # lettered words) but it is meant to signify dividing the original word into groups of 2. \n",
    "    indexHalfLength = halfLength - 1  #this is just 1 less than the half length we found. \n",
    "    \n",
    "    j = 0  #this is a counter variable\n",
    "    \n",
    "    firstWord = list()  #we are setting the stage for the 1st group to fall into a list. \n",
    "    \n",
    "    #for instance, Hannah will be split into 2 groups:   firstWord:  Han  ;  secondWord :  nah.\n",
    "    #Khullar will be split into 2 groups:  firstWord:  Khu ;  secondWord:  lar\n",
    "    #We will try to achieve this splitting of the word Hannah, by the while loops below\n",
    "    \n",
    "    #this loop here is for the 1st word.\n",
    "    while j < halfLength:  #this means when j is less than or equal to halfLength - 1.  We want to collect the number of words in the beginning of the word till we have the amount we need for the firstWord group.  This is 3 for Hannah, 2 for Chanu, 2 for radar, \n",
    "    \n",
    "        firstHalf = palStringLower[j] #we start with palStringLower[0] to get the 1st letter of the word.  We keep on collecting the beginning letters of the word till we have the # of words we should have in the firstWord group.\n",
    "        firstWord.append(firstHalf)\n",
    "        j = j + 1  #increment the loop please \n",
    "        \n",
    "    #this is for the 2nd part of the word:  for the nah in Hannah, the nu in Chanu, the ar in radar\n",
    "    #However, we want to collect the 2nd word so that it is in this proper order:  han, un, and ra respectively. \n",
    "    #Here, we please note that \n",
    "    \n",
    "   # s = \"spam\"\n",
    "    #there are 4 letters in this string\n",
    "   #print(s[0]) = \"s\"\n",
    "   # print(s[-1]) = print(s[3]]) = m\n",
    "    #print(s[-2]) = print(s[2]) = a\n",
    "    #print(s[-3]) = print(s[1])  = p\n",
    "    #print(s[-4]) = print(s[0]) = s\n",
    "    #That is, the first letter of the string starts with index: 0 and the last letter of the string with n letters has index: n-1. \n",
    "    #Equivalently, the first letter of the string with n starts with index: -n and the last letter of the string has index: -1. \n",
    "    #We please use the idea that the last letter of the string has index -1 and that the index DEcreases by 1 (that is goes up by: -1) as we move from right to left. \n",
    "    #We want to start from right to left from the second word. We want to collect the REVERSE of the 2nd word so that we can compare it properly with the 1st word. \n",
    "    \n",
    "    secondWord = list()\n",
    "    \n",
    "    k = 1\n",
    "    \n",
    "    while k < halfLength + 1: \n",
    "        \n",
    "        secondHalf = palStringLower[-k]  #we start with the last letter in the string and then move left by 1 with each loop until we collect the number of letters that we need for the 2nd group.  This is the same # of letters needed for the 1st group too. \n",
    "        secondWord.append(secondHalf)\n",
    "        k = k + 1\n",
    "      #this second word is collected in reverse so that we can properly compare it with the 1st word.  Both word lists should be identical and therefore should have the same elements in the same order if the word is a palindrome! \n",
    "        #the idea is that in reverse, the palindrome is the original word!\n",
    "        \n",
    "    if firstWord == secondWord: #then the word is indeed a palindrome\n",
    "        print(\"True. Please note that this word:\", palString,\", is indeed a palindrome! (Example: radar is a palindrome since the word in reverse is the same!\")\n",
    "    else:\n",
    "        print(\"False. Please note that this word:\", palString,\", is sadly NOT a palindrome! (Example: radar is a palindrome since the word in reverse is the same!)\")\n",
    "    \n",
    "    \n",
    "is_palindrome(\"radar\")\n",
    "is_palindrome(\"Hannah\")\n",
    "is_palindrome(\"Saniya\")\n",
    "\n",
    "#True. Please note that this word: radar , is indeed a palindrome! (Example: radar is a palindrome since the word in reverse is the same!\n",
    "#True. Please note that this word: Hannah , is indeed a palindrome! (Example: radar is a palindrome since the word in reverse is the same!\n",
    "#False. Please note that this word: Saniya , is sadly NOT a palindrome! (Example: radar is a palindrome since the word in reverse is the same!)\n",
    "  \n",
    "\n",
    "# SW: lost points: function doesn't return anything, 'intended' return type is a string, but\n",
    "# should be a Boolean, i.e., True or False (-4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Question 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True! The element is in the list! Hooray!\n",
      "True! The element is in the list! Hooray!\n",
      "False\n",
      "True! The element is in the list! Hooray!\n",
      "False\n",
      "True! The element is in the list! Hooray!\n"
     ]
    }
   ],
   "source": [
    "# Please write a function is_member() that takes a value (that is, a number, string, etc.) x and a list of values a, and:\n",
    "#returns True if x is a member of a, and False otherwise (if x is NOT a member of a)\n",
    "#Please note that this is exactly what the \"in\" operator does, but for the sake of the exercise you should please pretend Python did NOT have this operator. \n",
    "\n",
    "\n",
    "def is_member(x, a = list()):\n",
    "    \"\"\"\n",
    "    Please note that this is case sensitive.  That is, Hi is different from hi and Saniya is different from saniya. \n",
    "    \n",
    "    Here, this function is_member(x, list) will take a value x  (that is, the 1st parameter) and then it will see if x is a member of the list a. \n",
    "    Please note that we specified already what we wanted list a to be. If x is in list a then we will get a True.  Otherwise, if x is NOT in list a we will get a False. \n",
    "    Please note that here, we are pretending as though we do NOT have the \"in\" function. \n",
    "    \n",
    "    \"\"\"\n",
    "    matches = 0 #please note that matches here will see if there are any matches and if the element x is found in list a or not. \n",
    "    #since only 1 match can be found at most, we expect that matches will either be 0 or 1. \n",
    "    \n",
    "    i = 0 #please note that this is an index variable that will help us move through elements in list a.  The 1st element in list a is given by:  a[0].  If there are n elements in list a then we will have the last element in the list as a[n-1]\n",
    " \n",
    "    \n",
    "    while i < len(a):  #please note that the length function here, len(a) allows us to compute the length of the list a...that is it helps us determine the quantity of elements in the list\n",
    "        #we please use i as an index as we loop through.  \n",
    "        item = a[i]\n",
    "        if x == item: \n",
    "            matches = matches + 1  #if a match has been found between element x and the respective element in index i of list a, we please increment the match variable by 1. \n",
    "        i = i + 1  #here, we are incrementing the index by 1 and then will go to the next element in list a to see if that matches with variable x. \n",
    "    if matches == 0:  #here, please note that there are NO matches, and hence the matches variable is 0. \n",
    "        print(\"False\")\n",
    "    else: \n",
    "   \n",
    "        print(\"True! The element is in the list! Hooray!\")\n",
    "\n",
    "is_member(5, (51, 3, 2, 5, 31))  #true, since a = (51, 3, 2, 5, 31) and x = 5 is in a. \n",
    "\n",
    "is_member(\"hi\", (54, \"hi\", 3, \"Saniya\")) # True\n",
    "\n",
    "is_member(\"HI\", (54, \"hi\", 3, \"Saniya\")) # False\n",
    "\n",
    "is_member(\"Saniya says hi\", (23, \"Saniya says hi\", 232, -1, \"Santa\"))  #True\n",
    "\n",
    "is_member(\"Saniya says hi\", (23, \"Saniya says hi there kiddies\", 232, -1, \"Santa\"))  #False\n",
    "\n",
    "is_member(\"No no no\", (2, \"yes\", \"yay\", \"No no no\", \"Maybe\"))  #True! The element is in the list! Hooray!\n",
    "\n",
    "# SW: lost points: function doesn't return anything, 'intended' return type is a string, but\n",
    "# should be a Boolean (-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Question 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True!  There was at least 1 match between both lists! :)\n",
      "False!  Please note that sadly there were NO matches in the 2 lists! :(\n",
      "True!  There was at least 1 match between both lists! :)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#Please define a function overlapping() that takes 2 lists and returns True if they have at least 1 member in common, and False otherwise (if they do NOT have any member in common)\n",
    "#Please note that you may use your is_member() function, or the in operator, but for the sake of the exercise, you should (also) write it using 2 nested for-loops. \n",
    "\n",
    "\n",
    "def overlapping(firstList = list(), secondList = list()):\n",
    "\n",
    "    numMatches = 0\n",
    "    \n",
    "    #please note that i and j will be indexes that help us go through list1 and list2, respectively, inspecting each of the elements in the list. \n",
    "    i = 0\n",
    "    j = 0\n",
    "    \n",
    "    lenList1 = len(firstList)  #please note that this is essentially the mylen() function from problem 4.  Here, this makes lenList1 equal to the number of elements in the first list, (which is parameter1). \n",
    "    lenList2 = len(secondList) #Please note that this makes lenList2 equal to the number of elements in the 2nd list. \n",
    "    \n",
    "    #below, please note Saniya's 2 nested for-loops\n",
    "    \n",
    "    for i in range(0, lenList1): #this means that i has to be between 0 and the length of List 1.  This helps us make sure that we are going through all of the elements in the 1st list.  \n",
    "        List1item = firstList[i] #First, we start with one given element in the 1st list.  \n",
    "        #We then compare this given element in the 1st list with each and every element in the 2nd list:\n",
    "        for j in range(0, lenList2):  #for each element in the 1st list, we will be looping through the ENTIRE 2nd list to see if there is any match at all with any of the elements in the 2nd list. \n",
    "            List2item = secondList[j]  \n",
    "            if List1item == List2item:  #here, yay!  We found at least 1 match!  1 item in list2 matched up with the item in list1 that we had.  \n",
    "                numMatches = numMatches + 1  #we please increment this variable by 1.  This shows the number of matches we will end up finding between both lists. \n",
    "            j = j + 1  #we increment the index of the 2nd list by 1.  That is, we are going through element by element of the 2nd list and are comparing it with that same element with index i from the 1st list. \n",
    "                        #Unfortunately, even when a match has already been found between the element in index i in the 1st list and the element in list 2, we will still be looping through list 2 until we go through all of the elements in list 2. \n",
    "        i = i + 1  #after we have compared all the elements in list 2 with the element in index i for list 1, we then please increment the index of list 1 by 1, and therefore will once again start comparing all of the elements in list 2 with this new next element in list 1 that we are examining.  \n",
    "    \n",
    "    #please note that if ANY match at all has been found between list 1 and list 2, then numMatches will at least be 1. Otherwise, it will remain 00. \n",
    "    if numMatches == 0:  #this means that we checked all of the elements in list 1 and found NO matches with any of them in list 2.  Hence, numMatches remained 0. \n",
    "        print(\"False!  Please note that sadly there were NO matches in the 2 lists! :(\")\n",
    "    else:\n",
    "        print(\"True!  There was at least 1 match between both lists! :)\")\n",
    "    \n",
    "\n",
    "overlapping((1,2,3), (\"hi\", 2, 3))  #True!  There was at least 1 match between both lists! :)\n",
    "\n",
    "overlapping((\"hi\", \"Saniya\", \"Khullar\", \"1\", \"Python Programming\"), (\"Hi\", \"Chanu\"))   #False!  Please note that sadly there were NO matches in the 2 lists! :(\n",
    "\n",
    "overlapping((\"hi\", \"Saniya\", \"Khullar\", \"1\", \"Python Programming\"), (\"Hi\", \"Chanu\", 3, \"1\"))  #True!  There was at least 1 match between both lists! :)\n",
    "\n",
    "\n",
    "# SW: lost points: function doesn't return anything, 'intended' return type is a string, but\n",
    "# should be a Boolean, missing doc header comments (-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xxxxx\n",
      "hi there hi there hi there hi there \n"
     ]
    }
   ],
   "source": [
    "#Please define a function generate_n_chars() that takes an integer n and a character c and returns a string, n characters long consisting of only c:s\n",
    "\n",
    "#For example, generate_n_chars(5, \"x\") should return the string \"xxxxx\".  Here, n = 5\n",
    "#Please note that Python is unusual in that you can actually write an expression 5 * \"x\" that will evaluate to \"xxxxx\"\n",
    "#For the sake of the exercise please note that you should ignore that the problem can be solved in this manner. \n",
    "\n",
    "def generate_n_chars(n = int(), c = \"\"):\n",
    "    \"\"\"\n",
    "    Please note that this is the documentation for the function generate_n_chars.  \n",
    "    Here, there are 2 parameters: generate_n_chars(parameter1, parameter2).  For parameter1, we please first enter a number that is greater than 0.\n",
    "    This will be the number of times that the string (that is, parameter2) will repeat itself.  Parameter2 will be the string that we want to have repeated. \n",
    "    Hence, generate_n_chars(5, \"x\") will result in \"xxxxx\". Then, generate_n_chars(4, \"hi there \") results in \"hi there hi there hi there hi there\".  \n",
    "    \n",
    "    That is, generate_n_chars(parameter1, parameter2) results in a new string that prints out the parameter2 string the # of times mentioned by parameter1.\n",
    "   Moreover, here, n is the integer and c is the string. \n",
    "   \n",
    "   \"\"\"\n",
    "    generatedList = list()   #this is an empty list and we will soon fill it up with elements.  Each element will be the string c, and will be separated by a comma. \n",
    "     \n",
    "    i = 0  #please note that we are initializing the i variable by setting it equal to 0.  \n",
    "    \n",
    "    while i < n:   #here, since we are starting with 0, then ending at n-1 will still yield n units.  Thus, we can do while i < n. \n",
    "        letter = c  #here, letter is referring to the string that we wish to repeat n times in a row.  \n",
    "        generatedList.append(letter)  #each time, we are adding the string c as a new element in the list, generatedList\n",
    "        i = i + 1  #we increment the counter variable by 1, so that we will go into the loop again or exit as needed. \n",
    "        \n",
    "    generatedString = ''.join(generatedList)  #now, we essentially have:  generatedList = (\"c\", \"c\", \"c\",...n times...\"c\").  We want to please turn this list into a string and we can do that by joining the elements of the list into a jumbo string. \n",
    "    print(generatedString)  \n",
    "    \n",
    "    \n",
    "generate_n_chars(5,\"x\")  #xxxxx\n",
    "generate_n_chars(4, \"hi there \") #hi there hi there hi there hi there \n",
    "\n",
    "# SW: lost points: function doesn't return anything (-2)"
   ]
  },
  {
   "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
}