lab2_exercises_ANSWERS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Bootcamp 2016\n",
    "# Lesson 2 Exercises -- ANSWERS\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1. Guess the output: conditionals practice (1pt)\n",
    "\n",
    "For the following blocks of code, first try to guess what the output will be, and then run the code yourself. Points will be given for filling in the guesses; guessing wrong won't be penalized.\n",
    "\n",
    "**NOTE: The first cell below holds the variables that will be used in the problems. Since variables are shared across cells in Jupyter notebooks, you just need to run this cell once and then those variables can be used in any other code cell. **\n",
    "\n",
    "(However, remember that closing the notebook or restarting the kernel clears all the variables, so you will need to re-run the cell to re-populate those variables after doing that.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# RUN THIS BLOCK FIRST TO SET UP VARIABLES!\n",
    "a = True\n",
    "b = False\n",
    "x = 2\n",
    "y = -2\n",
    "cat = \"Mittens\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(^^ you might find it helpful to copy these variables somewhere you can easily see them when doing the problems. e.g. a piece of paper or a text file.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print (not a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print (a == b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (a != b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print (x == y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (x > y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-8-6fbc2415a06a>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-8-6fbc2415a06a>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print (x = 2)\u001b[0m\n\u001b[1;37m             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print (x = 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> A single = means assignment, and you can't do assignment within a print statement (assignments are always done on their own line). What we want here is: `print (x == 2)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print (a and b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (a and not b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (a or b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (not b or a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print not (b or a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (not b and a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print not (b and a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (x == abs(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print len(cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "cannot concatenate 'str' and 'int' objects",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-36807e9f20b2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mcat\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: cannot concatenate 'str' and 'int' objects"
     ]
    }
   ],
   "source": [
    "print cat + x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mittens2\n"
     ]
    }
   ],
   "source": [
    "print cat + str(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print float(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (\"i\" in cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print (\"g\" in cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print (\"Mit\" in cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> What is \"`in`\"? This is just another Python operator that you can use in your conditionals. As you may have guessed, `(x in y)` evaluates to `True` if `x` is found in `y`. This can be used to check if a string is contained in another string (e.g. `\"Mit\" in \"Mittens\"`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 2. Guess the output: if statement practice (1pt)\n",
    "\n",
    "Same directions as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# RUN THIS BLOCK FIRST TO SET UP VARIABLES!\n",
    "x = 2\n",
    "y = -2\n",
    "cat = \"Mittens\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is even\n"
     ]
    }
   ],
   "source": [
    "if (x % 2) == 0:\n",
    "    print \"x is even\"\n",
    "else:\n",
    "    print \"x is odd\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid!\n"
     ]
    }
   ],
   "source": [
    "if (y - 4*x) < 0:\n",
    "    print \"Invalid!\"\n",
    "else:\n",
    "    print \"Banana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey Mits!\n"
     ]
    }
   ],
   "source": [
    "if \"Mit\" in cat:\n",
    "    print \"Hey Mits!\"\n",
    "else:\n",
    "    print \"Where's Mits?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "x = \"C\"\n",
    "if x == \"A\" or \"B\":\n",
    "    print \"yes\"\n",
    "else:\n",
    "    print \"no\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> See below for explanation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no\n"
     ]
    }
   ],
   "source": [
    "x = \"C\"\n",
    "if (x == \"A\") or (x == \"B\"):\n",
    "    print \"yes\"\n",
    "else:\n",
    "    print \"no\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Surprised by the last two? It's important to note that when you want compare a variable against multiple things, you can only compare it to one thing at a time. Although it makes sense in English to say \"is x equal to A or B?\", in Python you must write: ((x == \"A\") or (x == \"B\")) to accomplish this. The same goes for e.g. ((x > 5) and (x < 10)) and anything along those lines.\n",
    "\n",
    "> So why does the first version give the answer \"yes\"? Basically, anything that isn't `False` or the literal number 0 is considered to be `True` in Python. When you say '`x == \"A\" or \"B\"`', Python reads it as '`(x == \"A\") or (B)`', which evaluates to '`(False) or (True)`', which is `True`! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3. On your own (2pts)\n",
    "\n",
    "Write code to accomplish the following tasks using the concepts we went over in the lecture. \n",
    "\n",
    "Use the following variables in your code. You must actually use the variables; pretend you don't know their values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# RUN THIS BLOCK FIRST!\n",
    "num1 = 3.14159\n",
    "num2 = 6\n",
    "num3 = 100\n",
    "num4 = 6 * -5 - 4 * 2 + -7 * -8 + 3\n",
    "motif = \"GTAAGTCGGTAACGTAAGTCGGTAAC\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Check if `num3` is greater than `num4`. Print \"yes\" if it is, and \"no\" if it isn't."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes\n"
     ]
    }
   ],
   "source": [
    "if num3 > num4:\n",
    "    print \"Yes\"\n",
    "else:\n",
    "    print \"No\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Print a random integer between `num2` and `num3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "82"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random.randint(num2, num3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C)** Check if the length of the string stored in `motif` is less than or equal to 25. Print \"yes\" if it is, and \"no\" if it isn't."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No\n"
     ]
    }
   ],
   "source": [
    "if len(motif) <= 25:\n",
    "    print \"Yes\"\n",
    "else:\n",
    "    print \"No\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(D)** Round `num1` to the nearest hundredth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(num1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(E)** Check if num4 is positive or negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's positive\n"
     ]
    }
   ],
   "source": [
    "if num4 >= 0:\n",
    "    print \"It's positive\"\n",
    "else:\n",
    "    print \"It's negative\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 4. Quadratic formula: checking for negative roots (1pt)\n",
    "\n",
    "Recall that when calculating the quadratic formula, you will get an error if $b^2 - 4ac$ is negative, since you can't take the square root of a negative number. \n",
    "\n",
    "Edit the code below so that it checks for this potential error before it occurs: \n",
    "- If the error is going to occur, print a message saying \"non-real answer\" and **do not** calculate the values of x. \n",
    "- If the error is not going to occur, calculate and print the values of x.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter value for a: 2\n",
      "Enter value for b: 2\n",
      "Enter value for c: 2\n",
      "non-real answer\n"
     ]
    }
   ],
   "source": [
    "a = float(raw_input(\"Enter value for a: \"))\n",
    "b = float(raw_input(\"Enter value for b: \"))\n",
    "c = float(raw_input(\"Enter value for c: \"))\n",
    "\n",
    "underRoot = (b**2 - 4*a*c)\n",
    "\n",
    "if underRoot >= 0:\n",
    "    x1 = ( (-b) + underRoot ** 0.5 ) / float(2*a)\n",
    "    x2 = ( (-b) - underRoot ** 0.5 ) / float(2*a)\n",
    "    print \"x =\", x1, \"or\", x2\n",
    "else:\n",
    "    print \"non-real answer\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[ Check your answer ]** \n",
    "- If a=1, b=4, and c=1, expected output is:\n",
    "```\n",
    "x = -0.267949192431 or -3.73205080757\n",
    "```\n",
    "- If a=2, b=2, and c=2, expected output is:\n",
    "```\n",
    "non-real answer\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 5. Motif checker (2pts)\n",
    "\n",
    "Using `raw_input()`, prompt the user for a DNA sequence and a motif to search for (the sequence and motif can be any string of A/T/G/C's; see below for examples)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Find the length of the motif and length of the DNA sequence and check if the motif is longer than the sequence. If it is, print \"Motif is too long\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a DNA sequence: ATTGCGCGA\n",
      "Enter a motif to search for: TTGAGCTGCGGATGCGAT\n",
      "Motif is too long.\n"
     ]
    }
   ],
   "source": [
    "dnaSeq = raw_input(\"Enter a DNA sequence: \")\n",
    "motif = raw_input(\"Enter a motif to search for: \")\n",
    "\n",
    "if len(motif) > len(dnaSeq):\n",
    "    print \"Motif is too long.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Adding to your code from part (A): If and only if the motif is shorter than the sequence, go on to check if the motif can be found somewhere within the sequence (hint: use \"`in`\"). If it is found, print \"Motif found\". If it is not found, print \"Motif not found\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a DNA sequence: AGCTAGCCTGCTAGAAATCGATTGGCTAGCAATCTTATTGTGTTCTACG\n",
      "Enter a motif to search for: ATG\n",
      "Motif not found.\n"
     ]
    }
   ],
   "source": [
    "dnaSeq = raw_input(\"Enter a DNA sequence: \")\n",
    "motif = raw_input(\"Enter a motif to search for: \")\n",
    "\n",
    "if len(motif) > len(dnaSeq):\n",
    "    print \"Motif is too long.\"\n",
    "else:\n",
    "    if motif in dnaSeq:\n",
    "        print \"Motif found.\"\n",
    "    else:\n",
    "        print \"Motif not found.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[ Check your answer ]** Try running your code above using the following input and make sure your results match the expected output.\n",
    "\n",
    "\n",
    "> **Sequence:** `AGCTAGCCTGCTAGAAATCGATTGGCTAGCAATCTTATTGTGTTCTACG` <br>\n",
    "> **Motif:** `ATG` <br>\n",
    "> **Expected output:**\n",
    "> ```\n",
    "Motif not found\n",
    "```\n",
    "> \n",
    "> **Sequence:** `AGCTAGCCTGCTAGAAATCGATTGGCTAGCAATCTTATTGTGTTCTACG` <br>\n",
    "> **Motif:** `ATCGA` <br>\n",
    "> **Expected output:**\n",
    "> ```\n",
    "Motif found\n",
    "```\n",
    "> \n",
    "> **Sequence:** `CTAGCC` <br>\n",
    "> **Motif:** `ATGGCTAGCTA` <br>\n",
    "> **Expected output:**\n",
    "> ```\n",
    "Motif is too long\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 6. Password protection (3pts)\n",
    "\n",
    "Write code that prompts the user to guess a password and checks whether the password is correct. \n",
    "\n",
    "- First create a variable called `password` and set it equal to whatever you want the password to be (any string). \n",
    "- Then prompt the user to guess the password, and read their input from the terminal. \n",
    "- Check if what they entered matches your password, and print a message saying whether or not the guess was correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Do this giving the user only one chance to guess. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the password: Mottens456\n",
      "Incorrect password. Access denied.\n"
     ]
    }
   ],
   "source": [
    "password = \"Mittens123\"\n",
    "guess = raw_input(\"Enter the password: \")\n",
    "\n",
    "if guess == password:\n",
    "    print \"Correct!\"\n",
    "else:\n",
    "    print \"Incorrect password. Access denied.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Do this giving the user 3 chances to guess. Only prompt for another guess if the previous guess was incorrect. When they guess correctly, print a confirmation message and end the program. If they don't guess correctly in 3 tries, print \"Access denied!\" and end the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the password: Muttens777\n",
      "Incorrect password. Try again: Mottens123\n",
      "Incorrect password. Try again: Muppins321\n",
      "Incorrect password. Access denied.\n"
     ]
    }
   ],
   "source": [
    "password = \"Mittens123\"\n",
    "guess = raw_input(\"Enter the password: \")\n",
    "\n",
    "if guess == password:\n",
    "    print \"Correct!\"\n",
    "else:\n",
    "    guess = raw_input(\"Incorrect password. Try again: \")\n",
    "    if guess == password:\n",
    "        print \"Correct!\"\n",
    "    else:\n",
    "        guess = raw_input(\"Incorrect password. Try again: \")\n",
    "        if guess == password:\n",
    "            print \"Correct!\"\n",
    "        else:\n",
    "            print \"Incorrect password. Access denied.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 7. Coin flip simulation (2pts)\n",
    "For this problem, we will simulate a coin flip using the random number generator in the `random` module. \n",
    "\n",
    "Try running the following code several times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "randNum = random.randint(0,1)\n",
    "print randNum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see that you always get either 0 or 1. We will pretend that each time we run `random.randint(0,1)` we are flipping a coin, where 1 represents heads and 0 represents tails.\n",
    "\n",
    "**Write code that \"flips a coin\" 10 times and counts how many times it comes up heads. At the end, print how many of the flips were heads.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 of 10 flips were heads\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "headsCount = 0\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,1) == 1:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "print headsCount, \"of 10 flips were heads\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "## Extra problems (0pt)\n",
    "\n",
    "The following problems are for people who would like more practice. They will not be counted for points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Following from the coin flip problem above:\n",
    "\n",
    "Change your code so that the coin is now \"unfair\" (i.e. the chance of heads is not equal to the chance of tails). See if you can make it so the probability of heads is 75%. \n",
    "\n",
    "*Hint: There are several ways to do this, but one simple way involves using a larger range of random ints and assigning heads/tails differently.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 of 10 flips were heads\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "headsCount = 0\n",
    "\n",
    "# random.randint(0,3) gives a 0, 1, 2, or 3\n",
    "# if it's 0, 1, or 2, call it heads\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "if random.randint(0,3) < 3:\n",
    "    headsCount = headsCount + 1\n",
    "\n",
    "print headsCount, \"of 10 flips were heads\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Using `raw_input()`, prompt the user for a number. Check if that number is between 50 and 100, and print different messages depending on the outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 55\n",
      "Your number is between 50 and 100\n"
     ]
    }
   ],
   "source": [
    "num = int(raw_input(\"Enter a number: \"))\n",
    "if (num >= 50) and (num <= 100):\n",
    "    print \"Your number is between 50 and 100\"\n",
    "else:\n",
    "    print \"Your number is not between 50 and 100\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C)** Using `raw_input()`, prompt the user for an integer. Check if the integer is a multiple of 7, and print different messages depending on the outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 42\n",
      "Your number is a multiple of 7\n"
     ]
    }
   ],
   "source": [
    "num = int(raw_input(\"Enter a number: \"))\n",
    "if (num % 7) == 0:\n",
    "    print \"Your number is a multiple of 7\"\n",
    "else:\n",
    "    print \"Your number is not a multiple of 7\""
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.12"
  },
  "name": "Lesson2.ipynb"
 },
 "nbformat": 4,
 "nbformat_minor": 0
}