Day0_FundamentalsOfPython_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.1.2: Calculate the value of the following expressions:**\n",
    "1. The sum of the numbers from 1 to 10\n",
    "2. The area of a triangle with base length 10 cm and height 5 cm\n",
    "3. The perimeter of a rectangle of width 20 cm and height 10 cm\n",
    "4. The amount of interest paid on a €100 balance in one year with an interest rate of 2%\n",
    "5. The sum of the first ten squares (i.e., $1^2 + 2^2 + \\cdots + 10^2$)\n",
    "6. The amount of interest paid on a €100 balance in 7 years with an interest rate of 2%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1. The sum of the numbers from 1 to 10\n",
    "1+2+3+4+5+6+7+8+9+10     # There's also a compact formula: (10*11)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2. The area of a triangle with base length 10 cm and height 5 cm\n",
    "(10*5)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3. The perimeter of a rectangle of width 20 cm and height 10 cm\n",
    "20+10+20+10   # or 2*(20+10) or 2*20 + 2*10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4. The amount of interest paid on a €100 balance in one year with an interest rate of 2%\n",
    "100 * 0.02   # Could also do this: 100 * (1.02**1 - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5. The sum of the first ten squares (i.e., $1^2 + 2^2 + \\cdots + 10^2$)\n",
    "1**2 + 2**2 + 3**2 + 4**2 + 5**2 + 6**2 + 7**2 + 8**2 + 9**2 + 10**2\n",
    "# There's also a compact formula: 10*(10+1)*(2*10+1)/6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14.868566764928005"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 6. The amount of interest paid on a €100 balance in 7 years with an interest rate of 2%\n",
    "100 * (1.02**7 - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.1.3. Calculate the sum of the numbers 1 to 5, showing each intermediate result**\n",
    "```\n",
    ">>> 1\n",
    "1\n",
    ">>> _+2\n",
    "3\n",
    ">>> _+3\n",
    "6\n",
    ">>> _+4\n",
    "10\n",
    ">>> _+5\n",
    "15\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Ex 0.6.1. How would you test if the value in `a` is odd?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 55\n",
    "(a % 2) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 12\n",
    "(a % 2) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a / 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a/2) != (a/2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.7.1. Classify the variable `a` as either odd or, if even, a multiple of 4 or not**  \n",
    "For example, 1 and 3 would be `\"odd\"`, 4 would be an `\"even and a multiple of 4\"` and 6 would be `\"even but not a multiple of 4\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a is even but not a multiple of 4'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 6\n",
    "if (a % 2) == 1:\n",
    "    description = \"odd\"\n",
    "else:\n",
    "    if (a % 4) == 0:\n",
    "        description = \"even and a multiple of 4\"\n",
    "    else:\n",
    "        description = \"even but not a multiple of 4\"\n",
    "\n",
    "\"a is \" + description"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.7.2. Rewrite your solution to Ex 0.7.1 more concisely using `elif`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a is even but not a multiple of 4'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 6\n",
    "if (a % 2) == 1:\n",
    "    description = \"odd\"\n",
    "elif (a % 4) == 0:\n",
    "    description = \"even and a multiple of 4\"\n",
    "else:\n",
    "    description = \"even but not a multiple of 4\"\n",
    "\n",
    "\"a is \" + description"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.7.3. Write a loop to calculate `10! = 10 * 9 * 8 * ... * 1`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10! = 3628800'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loop from 1 to 10\n",
    "i = 1\n",
    "result = 1\n",
    "while i <= 10:\n",
    "    result = result * i\n",
    "    i = i + 1\n",
    "\n",
    "\"10! = \" + str(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10! = 3628800'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loop from 10 to 1\n",
    "i = 10\n",
    "result = 1\n",
    "while i >= 1:\n",
    "    result = result * i\n",
    "    i = i - 1\n",
    "\n",
    "\"10! = \" + str(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.7.4. Implement Newton's algorithm to find the square root of 2 to 5 decimal places**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The square root of 2.0 is 1.41421568627 +/- 1e-05'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 2.0\n",
    "x = 1.0\n",
    "eps = 1e-5\n",
    "while not (n - eps) < (x*x) < (n + eps):\n",
    "    x = (x + n / x) / 2\n",
    "\n",
    "\"The square root of \" + str(n) + \" is \" + str(x) + \" +/- \" + str(eps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(!) Ex 0.7.5. Modify your code for Newton's method to show the value of the guess after each iteration, as well as the total number of iterations**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting with x = 1.0\n",
      "After 1 iteration(s), x = 1.5\n",
      "After 2 iteration(s), x = 1.41666666667\n",
      "After 3 iteration(s), x = 1.41421568627\n",
      "After 4 iteration(s), x = 1.41421356237\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'The square root of 2.0 is 1.41421356237 +/- 1e-10'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 2.0\n",
    "x = 1.0\n",
    "eps = 1e-10\n",
    "i = 0\n",
    "print \"Starting with x = \" + str(x)\n",
    "while not (n - eps) < (x*x) < (n + eps):\n",
    "    x = (x + n / x) / 2\n",
    "    i = i + 1\n",
    "    print(\"After \" + str(i) + \" iteration(s), x = \" + str(x))\n",
    "    \n",
    "\"The square root of \" + str(n) + \" is \" + str(x) + \" +/- \" + str(eps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(!) Ex 0.7.6. Write a loop to calculate the Collatz sequence for any number `n`.  Try it for `n=13` and `n=25`.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting with: 25\n",
      "Now at 76\n",
      "Now at 38\n",
      "Now at 19\n",
      "Now at 58\n",
      "Now at 29\n",
      "Now at 88\n",
      "Now at 44\n",
      "Now at 22\n",
      "Now at 11\n",
      "Now at 34\n",
      "Now at 17\n",
      "Now at 52\n",
      "Now at 26\n",
      "Now at 13\n",
      "Now at 40\n",
      "Now at 20\n",
      "Now at 10\n",
      "Now at 5\n",
      "Now at 16\n",
      "Now at 8\n",
      "Now at 4\n",
      "Now at 2\n",
      "Now at 1\n"
     ]
    }
   ],
   "source": [
    "n = 25\n",
    "print \"Starting with: \" + str(n)\n",
    "while n != 1:\n",
    "    if (n % 2) == 0:  # even\n",
    "        n = n / 2\n",
    "    else:\n",
    "        n = 3*n + 1\n",
    "    print \"Now at \" + str(n)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.8.1.  Rewrite your code for Collatz sequences to produce a list instead of printing the items in the sequence**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 76, 38, 19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "n = 25\n",
    "result = [n]\n",
    "while n != 1:\n",
    "    if (n % 2) == 0:  # even\n",
    "        n = n / 2\n",
    "    else:\n",
    "        n = 3*n + 1\n",
    "    result.append(n)\n",
    "\n",
    "print str(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.8.2. Calculate the sum of the numbers from 1 to 10 using a `for` loop with `range`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total = 0\n",
    "for i in range(1, 10+1):\n",
    "    total = total + i\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.8.3. Calculate the sum of the numbers from 1 to 10 using `sum` and `range`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(1,10+1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.8.4. How would you calculate the average of the value in the list?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26.666666666666668"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [3, 5, 72]\n",
    "sum(l) / float(len(l))  # Don't forget float(...)!\n",
    "                        # Otherwise you'll get truncating division\n",
    "                        # for integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.8.5. First, without list comprehensions, build a list of squares from $1^2$ to $10^2$ using a `for` loop and `range`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "squares = []\n",
    "for i in range(1,10+1):\n",
    "    squares.append(i*i)\n",
    "print(str(squares))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.8.6. Using list comprehension, make a list of all divisors of a number `n`, e.g. for n = 6, the list would be [1,2,3,6]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 6, 8, 12, 24]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 24\n",
    "[d for d in range(1,n+1) if (n % d) == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.9.1.  How would you classify a filename based on its extension as either a JPEG, a text file, a CSV, or something else?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myfile.csv: CSV file\n"
     ]
    }
   ],
   "source": [
    "filename = \"myfile.csv\"\n",
    "if filename[-4:] == \".jpg\":\n",
    "    filetype = \"JPEG\"\n",
    "elif filename[-4:] == \".txt\":\n",
    "    filetype = \"text file\"\n",
    "elif filename[-4:] == \".csv\":\n",
    "    filetype = \"CSV file\"\n",
    "else:\n",
    "    filetype = \"something else\"\n",
    "    \n",
    "print(filename + \": \" + filetype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.9.2. Given a string for a phone number, e.g. \"+32-123-456789\", count the number of hyphens in it**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+32-123-456789 has 2 hyphens\n"
     ]
    }
   ],
   "source": [
    "phone = \"+32-123-456789\"\n",
    "count = 0\n",
    "for c in phone:\n",
    "    if c == '-':\n",
    "        count = count + 1\n",
    "        \n",
    "print(phone + \" has \" + str(count) + \" hyphens\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.9.3. Repeat exercise 0.9.2 using list comprehensions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+32-123-456789 has 2 hyphens\n"
     ]
    }
   ],
   "source": [
    "phone = \"+32-123-456789\"\n",
    "count = sum([1 for c in phone if c == '-'])\n",
    "print(phone + \" has \" + str(count) + \" hyphens\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.9.4. Using `join` and a list comprehension, remove anything except the digits in the phone number \"+32-123-456789\"**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'32123456789'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phone = \"+32-123-456789\"\n",
    "\"\".join([c for c in phone if c.isdigit()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.9.5. Using `split`, `strip` and a list comprehension, take a line from a CSV and make a list of the fields in there, with leading and trailing spaces removed**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "csvline=\" one ,  two, three\"\n",
    "[f.strip() for f in csvline.split(\",\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Optional:* Given `csvline=\"  1, 2.4,5, 1000\"`, could you turn this into a list of `float`s?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2.4, 5.0, 1000.0]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "csvline=\"  1, 2.4,5, 1000\"\n",
    "[float(field.strip()) for field in csvline.split(\",\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.9.6. Look up the help string for `split`.  Now split the string \"one,two,three\" into two parts, one before the first command and then everything after that**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two,three']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"one,two,three\"\n",
    "s.split(\",\", 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.9.7. Look up the help string for `replace`.  Now replace every hyphen in the phone number \"+32-123-456789\" with a dot (`'.'`)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+32.123.456789'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phone = \"+32-123-456789\"\n",
    "phone.replace(\"-\", \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.10.1. Using list comprehension, take a number `n` and make a list of all the ways of expressing it as a product of two positive integers.**  \n",
    "For example, given 8, your list should read [(1,8), (2,4), (4,2), (8,1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 24), (2, 12), (3, 8), (4, 6), (6, 4), (8, 3), (12, 2), (24, 1)]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is the straightforward solution; you can optimize this a lto\n",
    "n = 24\n",
    "[(a, b) for a in range(1,n+1) for b in range(1,n+1) if a*b == n]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 24), (2, 12), (3, 8), (4, 6), (6, 4), (8, 3), (12, 2), (24, 1)]\n"
     ]
    }
   ],
   "source": [
    "n = 24\n",
    "l = []\n",
    "for a in range(1,n+1):\n",
    "    for b in range(1,n+1):\n",
    "        if a*b == n:\n",
    "            l.append((a, b))\n",
    "print l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(!) Ex 0.10.2. Given a list `l`, produce a list of tuples for the consecutive items in `l`.**  \n",
    "For example, given `l = ['a', 'g', 'x']`, your code would produce the list `[('a', 'g'), ('g', 'x')]`  \n",
    "_Hint_: You'll need to be creative with `zip` and slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'g'), ('g', 'x')]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['a', 'g', 'x']\n",
    "zip(l[:-1], l[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(!) Ex 0.11.1  Write some code to create a dictionary that maps each word in a sentence to the number of times it appears in it.  For simplicity, assume words are only separated by spaces.**  \n",
    "For example, given the sentence \"I love love love New York but I don't love York\", your code would output the dictionary\n",
    "```\n",
    "{'I': 2, 'love': 4, 'York': 2, 'but': 1, \"don't\": 1, \"New\": 1}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'I': 2, 'New': 1, 'York': 2, 'but': 1, \"don't\": 1, 'love': 4}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence = \"I love love love New York but I don't love York\"\n",
    "result = {}\n",
    "for word in sentence.split(\" \"):\n",
    "    if word in result:\n",
    "        result[word] = result[word] + 1\n",
    "    else:\n",
    "        result[word] = 1\n",
    "        \n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An alternate solution that works for small inputs but will struggle with larger inputs is given below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'love': 4, \"don't\": 1, 'I': 2, 'but': 1, 'York': 2, 'New': 1}\n"
     ]
    }
   ],
   "source": [
    "sentence = \"I love love love New York but I don't love York\"\n",
    "result = {}\n",
    "words = sentence.split(\" \")\n",
    "for word in words:\n",
    "    if word not in result:\n",
    "        result[word] = words.count(word)\n",
    "print result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.12.1  Using functions in `math`, calculate $\\sin(30^\\circ)$, $\\sqrt(5)$ and $e^{2.5}$**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sin(30 degrees) = 0.5\n",
      "sqrt(5) = 2.2360679775\n",
      "e^2.5 = 12.1824939607\n",
      "e^2.5 = 12.1824939607\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(\"sin(30 degrees) = {0}\".format(math.sin(math.radians(30))))\n",
    "print(\"sqrt(5) = {0}\".format(math.sqrt(5)))\n",
    "print(\"e^2.5 = {0}\".format(math.e ** 2.5))\n",
    "print(\"e^2.5 = {0}\".format(math.exp(2.5)))  # Same as above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.12.2 Create a script `squaresum.py` that takes a number `n` as parameter and prints out the sum of the first `n` squares.**  \n",
    "For example, running `python squaresum.py 10` prints out `385`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "```\n",
    "import sys\n",
    "if len(sys.argv) != 2:\n",
    "    print(\"Usage: python squaresum.py n\")\n",
    "else:\n",
    "    _, nstr = sys.argv\n",
    "    n = int(nstr)\n",
    "    print(sum([i*i for i in range(1, n+1)]))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex 0.13.1.  Previously, we wrote some code to count the frequencies of words in a string.  Turn it into a function that you can invoke like this: freqs_of_words(\"I love love love New York\")**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def freqs_of_words(sentence):\n",
    "    result = {}\n",
    "    for word in sentence.split(\" \"):\n",
    "        if word in result:\n",
    "            result[word] = result[word] + 1\n",
    "        else:\n",
    "            result[word] = 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'I': 1, 'New': 1, 'York': 1, 'love': 3}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freqs_of_words(\"I love love love New York\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(!) Ex 0.13.2. Write a function to calculate the $n$th Fibonacci number, defined recursively as follows:**\n",
    "\n",
    "$$\n",
    "F(n) = F(n-1) + F(n-2).\n",
    "$$\n",
    "\n",
    "**It's customary to specify $F(0)$ and $F(1)$ explicitly.  Accept keyword arguments for these edge cases, with a default value of $1$ for both.**\n",
    "\n",
    "**What's the value of $F(8)$ when $F(0) = F(1) = 1$?  What about when $F(0) = 10$ and $F(1) = 15$?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fib(n, fib_zero=1, fib_one=1):\n",
    "    if n == 0:\n",
    "        return fib_zero\n",
    "    elif n == 1:\n",
    "        return fib_one\n",
    "    else:\n",
    "        return fib(n-1, fib_zero, fib_one) + fib(n-2, fib_zero, fib_one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "445"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(8, fib_zero=10, fib_one=15)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}