lab3_exercises_ANSWERS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Bootcamp 2016\n",
    "# Lesson 3 Exercises - ANSWERS\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1. Guess the output: loop 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10, 2):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range (5, 1, -1):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while (count < 5):\n",
    "    print count\n",
    "    count = count + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for i in range(4):\n",
    "    total = total + i\n",
    "print total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n",
      "i\n",
      "t\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "name = \"Mits\"\n",
    "for i in name:\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wilfred\n"
     ]
    }
   ],
   "source": [
    "name = \"Wilfred\"\n",
    "newName = \"\"\n",
    "for letter in name:\n",
    "    newName = newName + letter\n",
    "print newName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "derfliW\n"
     ]
    }
   ],
   "source": [
    "name = \"Wilfred\"\n",
    "newName = \"\"\n",
    "for letter in name:\n",
    "    newName = letter + newName\n",
    "print newName"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> This ends up reversed because we did\n",
    "```\n",
    "newName = letter + newName\n",
    "```\n",
    "> instead of\n",
    "```\n",
    "newName = newName + letter\n",
    "```\n",
    "So we're basically adding each new letter to the *beginning* of what's already in newName."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "seq = \"AGCTGATGC\"\n",
    "count = 0\n",
    "for letter in seq:\n",
    "    count = count + 1\n",
    "print count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "seq = \"AGCTGATGC\"\n",
    "count = 0\n",
    "for letter in seq:\n",
    "    if letter == \"T\":\n",
    "        count = count + 1\n",
    "print count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 2. Spot the endless loop (1pt)\n",
    "\n",
    "For the following examples, first guess whether or not the loop will be endless. Then run the code to find out (if it doesn't stop within a few seconds, you can assume it's endless).\n",
    "\n",
    "### NOTE: If you hit an endless loop, you will not be able to run anything else until you stop it! Use the kernel interrupt button (square button up top) to stop the execution of the loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "count = 0\n",
    "while count < 5:\n",
    "    print count\n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endless loop or not? **Yes**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while count > 0:\n",
    "    print count\n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endless loop or not? **No** - it never even enters the loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "count = 0\n",
    "while count < 10:\n",
    "    print count\n",
    "count = count + 1\n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endless loop or not? **Yes** - we didn't increment count inside the loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "count = 10\n",
    "while count > 0:\n",
    "    count = count - 1\n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endless loop or not? **No**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = True\n",
    "count = 0\n",
    "while a:\n",
    "    count = count + 1\n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endless loop or not? **Yes** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "while x != 100:\n",
    "    x = x + 5\n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endless loop or not? **Yes** - we skip right over x = 100!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "while x <= 100:\n",
    "    x = x + 5\n",
    "print \"Done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endless loop or not? **No**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3. Simple loop practice (4pts)\n",
    "\n",
    "Write code to accomplish each of the following tasks using a `for` loop or a `while` loop. Choose whichever type of loop you want for each problem (you can try both, if you want extra practice)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** (1pt) Print the integers between 8 and 33, **inclusive**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n"
     ]
    }
   ],
   "source": [
    "for i in range(8,34):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** (1pt) Starting with x = 1, double x until it's greater than 1000. Print each value of x as you go along."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n",
      "64\n",
      "128\n",
      "256\n",
      "512\n",
      "1024\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while x <= 1000:\n",
    "    x = x*2\n",
    "    print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C)** (1pt) Print the positive integers less than 500 that are multiples of 13."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "26\n",
      "39\n",
      "52\n",
      "65\n",
      "78\n",
      "91\n",
      "104\n",
      "117\n",
      "130\n",
      "143\n",
      "156\n",
      "169\n",
      "182\n",
      "195\n",
      "208\n",
      "221\n",
      "234\n",
      "247\n",
      "260\n",
      "273\n",
      "286\n",
      "299\n",
      "312\n",
      "325\n",
      "338\n",
      "351\n",
      "364\n",
      "377\n",
      "390\n",
      "403\n",
      "416\n",
      "429\n",
      "442\n",
      "455\n",
      "468\n",
      "481\n",
      "494\n"
     ]
    }
   ],
   "source": [
    "for i in range(13, 500, 13):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(D)** (1pt) Print each character of the string \"AGTAATCGCGATGAATACCATCGCAGCC\" on a separate line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "G\n",
      "T\n",
      "A\n",
      "A\n",
      "T\n",
      "C\n",
      "G\n",
      "C\n",
      "G\n",
      "A\n",
      "T\n",
      "G\n",
      "A\n",
      "A\n",
      "T\n",
      "A\n",
      "C\n",
      "C\n",
      "A\n",
      "T\n",
      "C\n",
      "G\n",
      "C\n",
      "A\n",
      "G\n",
      "C\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "nts = \"AGTAATCGCGATGAATACCATCGCAGCC\"\n",
    "for i in nts:\n",
    "    print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 4. File reading and processing (6pts)\n",
    "\n",
    "For these problems, use the file `sequences.txt` provided on Piazza. This file contains several DNA sequences of different lengths. You can assume each sequence is on a separate line.\n",
    "\n",
    "Note: I recommend saving `sequences.txt` in the same directory as this notebook to make things easier. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** (1pt) Using a loop, read in each sequence from the file and print it. Make sure to remove any newline characters (\\n) while reading in the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CTGTGCCTGATCTTGAGGTGCCAATGAGACTCAGCGA\n",
      "TAAATCACCGCCCAAGAAGTATAATGCTTGGGGGTGATAGGTTTTACATATTTTTAAGTTCGCTAGCTAAAAATTATCCGTATCATAGGCTGAA\n",
      "CAGTCCTGCCAATAAAAGAAATATCCCAAGACAGATTAAGCTTTAATCTTTGCTCAACCACGTCGTGGTTATGAATTCGCTAAATTAGTTGATCTCGTTGG\n",
      "TGAGGGCGAATTACCCAAGCACCGACTCACTTGTCACGGAAAAATACCGGACAATTTGTATAACTCAACAAAGTTTCGGA\n",
      "TAGCTATGTCAGCCGGAGACCAGAAAGACTCTCTTGTATTTAAGGTCAGGGCTATGGCTATCGAGT\n",
      "TACCGTTATTGCGTGAAACGGTGTAGCTATAGGGCTGAGTGTGTCTTTGTTTCTTCACTCCTATTGGGCTGACTACGATTGCCCTTAGGTTTTCATTTAGTTGTTAATAATCGCTACT\n",
      "TTCTTAAGACCGCCGAGCTTCGTCTTTTATGGCC\n",
      "GAACGACCAACATGCACGGTTAGGGGTTGGAATGCTATCGATTACGTCGGACCGAAAAGTCAGGAAAAAG\n",
      "ATGTGTTGGGGGTCTGGGACCGCGTCGACACCTAGCGCCTTCCACGTAGCATACAGCCTGGCTCACGCGGTTCTGCGGACCCTACATAGT\n",
      "GATCCGATTTGTTTCTACCGGAAGCTCCACGCAGGAGGGAGCAACGCAA\n",
      "CAATAATTAGCCTCTCCCCAGGGCTCACATGCCCCCATGGTTAAATAGCACAAAGCAGATCGGTGACTGGAACCCCCTTCGTTGATGTCCGCTAATCGATGAG\n",
      "CTAATTACCGCTGACTGCAGGGTGTTTCTGGTGTACACTATTCCTATATCGCAATCAATT\n",
      "ACAAGTGATCATCCCGGTCATGCTAAAACGGTGATTAAGGGTACTATGCGAAGTGTAGATATGCCCTGAGCCTCTGGCCGGGCCCATCTTGCA\n",
      "CCGGAACGTGGGAGCTGTTTAAAGGCCGAACATATAACGGATAAGTCTGTGTTAGCGACTAGGCCTGCAGATCAGTTTGAGCTAATAAATTCCA\n",
      "AAAGTGGACTTGAGTAGAGGTGTCGAACAATGATGAGGCCTCTATTTGAATATAAACTGAACGCCAGTAGGTCCAGG\n",
      "AGTCTTCAAAGAGCTGGGAAGGATCTCAGAGTGCGCCACCGACCAGCGTCCGTCCTTAGGTTGATTCTAACGCGAGGGTCTGTACATAACTTCTGTTTGACCTAAATGTATCACA\n",
      "TATTGAATATCAGGCTGAGCGTCCTGACCGGTAAAAAAAACATAAAT\n",
      "CAGAATAGGGGTCTTTCTCTCCCTGTTCATGTATTGTGCACACCTGGCAATGGTACTA\n",
      "CGTAACCTCATGGAAGTTGCCATTAATGTAGAGTCAGACTTGCCCAGCTTCTCGATCACCCAAAATG\n",
      "TTCGTAAGCCCTGACGTGTCTAGCTAAGTTTGTCCGCACGGAGCTA\n",
      "GCGCTGCCGCCATCGGTTGTGCGTCATCGCAATTAGTACCAGGACGGGCGTAGCTAA\n",
      "ACTCGGCCCAACGCTGGCGATATGGGGAAAAACACGGGTACAGGACGACCCTGCGAGCCTCGGAGACAGGCGATAGCGCCCGATCCTGAACT\n",
      "GACGATAATAGCGGCTTTTAAACCCATAGATGGGAAACGCAATGGGTGCGCACGGTGCAGGTAAAGAGTAACAACACGGTGAACGGA\n",
      "ACCCCAACCCTTCAACCCATCTTGGCCCACACTGATCAGTCCAGGTATGAACTGAGGAAGGATAAGGGCAGTGCTGTGTCATACGGGCACCCCACATAACGCCGAT\n",
      "TTACACTAGCCCCGCTATGTTAACACTCGCCCCCCGTGGGCTTTTGCTCCACTGATGTTCGATCTTGTCAGGTCGCGTCTAGGTGAGTGAGTGAAGAT\n"
     ]
    }
   ],
   "source": [
    "fileName = \"sequences.txt\"\n",
    "ins = open(fileName, 'r')\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\r\\n') #\\r is another potential line ending. I check for it just in case. \n",
    "    print line\n",
    "ins.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** (1pt) Now, instead of printing the sequences themselves, print the *length* of each sequence. At the end, print the average length of the sequences.\n",
    "\n",
    "*Hint: use the concept of an \"accumulator\" variable to help with computing the average, and watch out for integer division!*\n",
    "\n",
    "**[ Check your answer ]** You should get 77.56 as the average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37\n",
      "94\n",
      "101\n",
      "80\n",
      "66\n",
      "118\n",
      "34\n",
      "70\n",
      "90\n",
      "49\n",
      "103\n",
      "60\n",
      "93\n",
      "94\n",
      "77\n",
      "115\n",
      "47\n",
      "58\n",
      "67\n",
      "46\n",
      "57\n",
      "92\n",
      "87\n",
      "106\n",
      "98\n",
      "\n",
      "Avg len: 77.56\n"
     ]
    }
   ],
   "source": [
    "fileName = \"sequences.txt\"\n",
    "totalLen = 0\n",
    "numSeqs = 0\n",
    "\n",
    "ins = open(fileName, 'r')\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\r\\n')\n",
    "    print len(line)\n",
    "\n",
    "    totalLen = totalLen + len(line)\n",
    "    numSeqs = numSeqs + 1\n",
    "ins.close()\n",
    "\n",
    "print \"\"\n",
    "print \"Avg len:\", float(totalLen) / numSeqs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C)** (2pts) Instead of printing lengths, print the GC content of each sequence (GC content is the number of G's and C's in a DNA sequence divided by the total sequence length). At the end print the average GC content. \n",
    "\n",
    "**[ Check your answer ]** You should get ~0.48 as the average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.540540540541\n",
      "0.36170212766\n",
      "0.386138613861\n",
      "0.4375\n",
      "0.469696969697\n",
      "0.415254237288\n",
      "0.5\n",
      "0.485714285714\n",
      "0.611111111111\n",
      "0.551020408163\n",
      "0.514563106796\n",
      "0.416666666667\n",
      "0.516129032258\n",
      "0.457446808511\n",
      "0.441558441558\n",
      "0.486956521739\n",
      "0.36170212766\n",
      "0.465517241379\n",
      "0.462686567164\n",
      "0.521739130435\n",
      "0.59649122807\n",
      "0.619565217391\n",
      "0.494252873563\n",
      "0.547169811321\n",
      "0.530612244898\n",
      "\n",
      "Avg GC: 0.487669412538\n"
     ]
    }
   ],
   "source": [
    "fileName = \"sequences.txt\"\n",
    "totalGC = 0\n",
    "numSeqs = 0\n",
    "\n",
    "ins = open(fileName, 'r')\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\r\\n')\n",
    "\n",
    "    seqGC = 0 #this needs to be reset to 0 for each sequence\n",
    "    for nt in line:\n",
    "        if (nt == \"G\") or (nt == \"C\"):\n",
    "            seqGC = seqGC + 1\n",
    "\n",
    "    fractGC = float(seqGC) / len(line)\n",
    "    print fractGC\n",
    "\n",
    "    # add this fraction to the running total so we can compute the avg\n",
    "    totalGC = totalGC + fractGC\n",
    "    numSeqs = numSeqs + 1\n",
    "ins.close()\n",
    "\n",
    "print \"\"\n",
    "print \"Avg GC:\", float(totalGC) / numSeqs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(D)** (2pts) Convert each sequence to its reverse complement and print it. This means changing each nucleotide to its complement (A->T, T->A, G->C, C->G) and reversing the entire sequence. \n",
    "\n",
    "*Hint: we've already touched on everything you need to know to do this -- see problem 1 above for some clues!*\n",
    "\n",
    "**[ Check your answer ]** Spot check this by comparing at least one sequence from the file to its reverse complement and make sure it looks correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TCGCTGAGTCTCATTGGCACCTCAAGATCAGGCACAG\n",
      "TTCAGCCTATGATACGGATAATTTTTAGCTAGCGAACTTAAAAATATGTAAAACCTATCACCCCCAAGCATTATACTTCTTGGGCGGTGATTTA\n",
      "CCAACGAGATCAACTAATTTAGCGAATTCATAACCACGACGTGGTTGAGCAAAGATTAAAGCTTAATCTGTCTTGGGATATTTCTTTTATTGGCAGGACTG\n",
      "TCCGAAACTTTGTTGAGTTATACAAATTGTCCGGTATTTTTCCGTGACAAGTGAGTCGGTGCTTGGGTAATTCGCCCTCA\n",
      "ACTCGATAGCCATAGCCCTGACCTTAAATACAAGAGAGTCTTTCTGGTCTCCGGCTGACATAGCTA\n",
      "AGTAGCGATTATTAACAACTAAATGAAAACCTAAGGGCAATCGTAGTCAGCCCAATAGGAGTGAAGAAACAAAGACACACTCAGCCCTATAGCTACACCGTTTCACGCAATAACGGTA\n",
      "GGCCATAAAAGACGAAGCTCGGCGGTCTTAAGAA\n",
      "CTTTTTCCTGACTTTTCGGTCCGACGTAATCGATAGCATTCCAACCCCTAACCGTGCATGTTGGTCGTTC\n",
      "ACTATGTAGGGTCCGCAGAACCGCGTGAGCCAGGCTGTATGCTACGTGGAAGGCGCTAGGTGTCGACGCGGTCCCAGACCCCCAACACAT\n",
      "TTGCGTTGCTCCCTCCTGCGTGGAGCTTCCGGTAGAAACAAATCGGATC\n",
      "CTCATCGATTAGCGGACATCAACGAAGGGGGTTCCAGTCACCGATCTGCTTTGTGCTATTTAACCATGGGGGCATGTGAGCCCTGGGGAGAGGCTAATTATTG\n",
      "AATTGATTGCGATATAGGAATAGTGTACACCAGAAACACCCTGCAGTCAGCGGTAATTAG\n",
      "TGCAAGATGGGCCCGGCCAGAGGCTCAGGGCATATCTACACTTCGCATAGTACCCTTAATCACCGTTTTAGCATGACCGGGATGATCACTTGT\n",
      "TGGAATTTATTAGCTCAAACTGATCTGCAGGCCTAGTCGCTAACACAGACTTATCCGTTATATGTTCGGCCTTTAAACAGCTCCCACGTTCCGG\n",
      "CCTGGACCTACTGGCGTTCAGTTTATATTCAAATAGAGGCCTCATCATTGTTCGACACCTCTACTCAAGTCCACTTT\n",
      "TGTGATACATTTAGGTCAAACAGAAGTTATGTACAGACCCTCGCGTTAGAATCAACCTAAGGACGGACGCTGGTCGGTGGCGCACTCTGAGATCCTTCCCAGCTCTTTGAAGACT\n",
      "ATTTATGTTTTTTTTACCGGTCAGGACGCTCAGCCTGATATTCAATA\n",
      "TAGTACCATTGCCAGGTGTGCACAATACATGAACAGGGAGAGAAAGACCCCTATTCTG\n",
      "CATTTTGGGTGATCGAGAAGCTGGGCAAGTCTGACTCTACATTAATGGCAACTTCCATGAGGTTACG\n",
      "TAGCTCCGTGCGGACAAACTTAGCTAGACACGTCAGGGCTTACGAA\n",
      "TTAGCTACGCCCGTCCTGGTACTAATTGCGATGACGCACAACCGATGGCGGCAGCGC\n",
      "AGTTCAGGATCGGGCGCTATCGCCTGTCTCCGAGGCTCGCAGGGTCGTCCTGTACCCGTGTTTTTCCCCATATCGCCAGCGTTGGGCCGAGT\n",
      "TCCGTTCACCGTGTTGTTACTCTTTACCTGCACCGTGCGCACCCATTGCGTTTCCCATCTATGGGTTTAAAAGCCGCTATTATCGTC\n",
      "ATCGGCGTTATGTGGGGTGCCCGTATGACACAGCACTGCCCTTATCCTTCCTCAGTTCATACCTGGACTGATCAGTGTGGGCCAAGATGGGTTGAAGGGTTGGGGT\n",
      "ATCTTCACTCACTCACCTAGACGCGACCTGACAAGATCGAACATCAGTGGAGCAAAAGCCCACGGGGGGCGAGTGTTAACATAGCGGGGCTAGTGTAA\n"
     ]
    }
   ],
   "source": [
    "fileName = \"sequences.txt\"\n",
    "\n",
    "ins = open(fileName, 'r')\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\r\\n')\n",
    "\n",
    "    # Here I am reversing and complementing at the same time.\n",
    "    # You could also do it as separate steps, it will just be \n",
    "    # less efficient (not a big deal on a small dataset).\n",
    "    revCompl = \"\"\n",
    "    for nt in line:\n",
    "        if nt == \"A\":\n",
    "            revCompl = \"T\" + revCompl\n",
    "        elif nt == \"T\":\n",
    "            revCompl = \"A\" + revCompl\n",
    "        elif nt == \"G\":\n",
    "            revCompl = \"C\" + revCompl\n",
    "        elif nt == \"C\":\n",
    "            revCompl = \"G\" + revCompl\n",
    "        else:\n",
    "            # The below isn't strictly necessary, but it makes for more robust code.\n",
    "            # A good warning/error message should state: (1) the problem, (2) the data that \n",
    "            # caused the problem, and (3) what the code will do about the problem.\n",
    "            print \">> Warning: Encountered unknown nt:\", nt\n",
    "            print \"   Keeping unknown nt as-is.\"\n",
    "            revCompl = nt + revCompl \n",
    "\n",
    "    # We don't want to print until we've looped through the whole sequence.\n",
    "    # So this print statement should be outside of the sequence for-loop\n",
    "    # (but NOT outside the file for-loop)\n",
    "    print revCompl \n",
    "\n",
    "ins.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 5. Guessing game (2pts)\n",
    "\n",
    "Write code that plays a number guessing game with the user. The code will loop until the user gets the number right or quits. Follow the directions below.\n",
    "\n",
    "- First, have your program generate a random integer between 1 and 20 (the \"secret number\").\n",
    "- Then prompt the user `\"Guess a number between 1 and 20 (enter 0 to quit): \"` \n",
    "- Read in their answer with `raw_input()` (recall that you'll need to convert the return value to an `int`) and save it in a variable\n",
    "- Compare their guess to your \"secret number\":\n",
    "    - If the guess is correct, print `\"You got it!\"` and end the loop. \n",
    "    - If the guess is higher than the secret number, print `\"Too high!\"` and allow the user to keep guessing. \n",
    "    - If the guess is lower than the secret number, print `\"Too low!\"` and allow the user to keep guessing. \n",
    "    - If they entered 0, print `\"Ending program\"` and end the loop.\n",
    "\n",
    "*Tip: It will be easier for you to test your program if you initially set the secret number to be a number of your choosing instead of something random. Then when you run the program, you will know if the responses are correct. Make sure to test all possibilities (higher, lower, equal, zero). Once you're sure the logic is correct, you can change the secret number to random generation.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess a number between 1 and 20 (enter 0 to quit): 10\n",
      "Too low!\n",
      "Guess a number between 1 and 20 (enter 0 to quit): 15\n",
      "Too high!\n",
      "Guess a number between 1 and 20 (enter 0 to quit): 13\n",
      "Too low!\n",
      "Guess a number between 1 and 20 (enter 0 to quit): 14\n",
      "You got it!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "secretNum = random.randint(1,20)\n",
    "quitLoop = False\n",
    "\n",
    "while (quitLoop == False):\n",
    "    guess = int(raw_input(\"Guess a number between 1 and 20 (enter 0 to quit): \"))\n",
    "\n",
    "    if guess == 0:\n",
    "        print \"Ending program.\"\n",
    "        quitLoop = True\n",
    "\n",
    "    elif guess == secretNum:\n",
    "        print \"You got it!\"\n",
    "        quitLoop = True\n",
    "\n",
    "    elif guess > secretNum:\n",
    "        print \"Too high!\"\n",
    "\n",
    "    elif guess < secretNum:\n",
    "        print \"Too low!\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 6. Family simulation (5pts)\n",
    "\n",
    "Use a simulation to determine the average number of children in a family if all families had children until they had a girl (and then stopped). Assume equal probability of girls and boys and use a random generator to simulate each birth. Simulate 10,000 families and output the average number of children they had. Your answer should be close to 2.\n",
    "\n",
    "*Note: I'm purposely not giving any step by step instructions here because I'd like you to practice translating a word problem into code. It may help if you try break down the problem into smaller parts first. For example, see if you can simulate just one family first, then once that's working, add code to make it run through 10,000 families. Alternatively, you might feel more comfortable writing code to print \"hi\" 10,000 times, and then replace \"print hi\" with code for simulating each family. Do whatever makes the problem feel more manageable to you. Learning to break down big problems into smaller parts like this is an essential skill for programming, so I encourage you to work through this. If you get it, then I think it's safe to say you've mastered the material in this lesson and are well on your way to becoming a true programmer!*\n",
    "\n",
    "**I'll give partial credit for good efforts!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg kids per fam: 2.0132\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# By convention, variables with a set, pre-defined value (\"constants\")\n",
    "# are indicated by ALL_CAPS variable names and are defined at the top.\n",
    "# It's not really necessary to define GIRL = 1, but it will make\n",
    "# the code easier to read and understand, so it's considered good form.\n",
    "NUM_FAMS = 10000 \n",
    "GIRL = 1\n",
    "\n",
    "# regular variables, like this counter, are lower case/camelCase\n",
    "totalKidsAllFams = 0\n",
    "\n",
    "for i in range(NUM_FAMS):\n",
    "    numKids = 0\n",
    "    hadGirl = False\n",
    "\n",
    "    while not hadGirl:\n",
    "        numKids = numKids + 1\n",
    "        gender = random.randint(0,1) #the miracle of birth\n",
    "        if gender == GIRL:\n",
    "            hadGirl = True\n",
    "        \n",
    "    # once we exit the while loop, we must have had a girl.\n",
    "    # so add the number of kids this fam had to the running total, and\n",
    "    # move on to the next family\n",
    "    totalKidsAllFams = totalKidsAllFams + numKids\n",
    "\n",
    "# finally, divide the total number of kids by the number of families to get the avg\n",
    "print \"Avg kids per fam:\", float(totalKidsAllFams) / NUM_FAMS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Extra Problems (0pts)\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) Computing factorials.** The factorial of a number *n* is defined as: \n",
    "```\n",
    "n! = n * (n - 1) * (n - 2) * ... * 1\n",
    "```\n",
    "Prompt the user to enter a positive integer and then output the factorial of that number. Do not use any modules (i.e. don't use the factorial function in the math module)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a positive integer: 5\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "num = int(raw_input(\"Enter a positive integer: \"))\n",
    "factorial = 1\n",
    "for i in range(1, num+1):\n",
    "    factorial = factorial * i\n",
    "print factorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B) Fibonacci sequence.** The Fibonacci sequence is a series where each number is the sum of the previous two numbers. The first two numbers are always 0 and 1. So for example, the first 10 numbers of the series are: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34. Prompt the user to enter a positive integer, and then output that number of terms in the Fibonacci sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a positive integer: 15\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n"
     ]
    }
   ],
   "source": [
    "num = int(raw_input(\"Enter a positive integer: \"))\n",
    "fibA = 0\n",
    "fibB = 1\n",
    "fibCurr = 1\n",
    "\n",
    "# always print the first term\n",
    "print fibA\n",
    "\n",
    "# only print the second term if at least 2 terms are requested\n",
    "if num > 1:\n",
    "    print fibB\n",
    "\n",
    "# print num-2 additional terms (if num == 2, this won't run)\n",
    "for i in range(num-2):\n",
    "    fibCurr = fibA + fibB\n",
    "    print fibCurr\n",
    "    fibA = fibB\n",
    "    fibB = fibCurr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C) Counting mutations.** Prompt the user to input two DNA sequences of the same length. Count up the number of nucleotides that differ between the sequences and output this number. \n",
    "\n",
    "**[ Check your answer ]** Try the following to check that your program is correct: <br>\n",
    "Seq1 = `AAGTCGTACA` <br>\n",
    "Seq2 = `AAGTCGGACG` <br>\n",
    "Num differences: 2\n",
    "\n",
    "Seq1 = `GTGTGATGAGCGCGACA` <br>\n",
    "Seq2 = `GAAAGATGAGCGTGTCA` <br>\n",
    "Num differences: 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter seq1: GTGTGATGAGCGCGACA\n",
      "Enter seq2 (same length): GAAAGATGAGCGTGTCA\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "seq1 = raw_input(\"Enter seq1: \")\n",
    "seq2 = raw_input(\"Enter seq2 (same length): \")\n",
    "diffCount = 0\n",
    "\n",
    "for i in range(len(seq1)):\n",
    "    if seq1[i] != seq2[i]:\n",
    "        diffCount = diffCount + 1\n",
    "        \n",
    "print diffCount"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(D) Exact motif search.** Prompt the user to input a \"reference\" sequence (a longish DNA sequence) and a \"query\" (a shorter DNA sequence). Print out the locations (nt position) of all exact matches (if any) of the query within the reference.\n",
    "\n",
    "There are shortcuts for doing this in Python, such as the `.find()` function, but see if you can do it without such things.\n",
    "\n",
    "**[ Check your answer ]** <br>\n",
    "Reference: `ATGCGCTAAAGCGCTAGATCTCTAGCTAAAGCTAGCTTATTCGGATGGGCTAG` <br>\n",
    "Query: `AAAGC` <br>\n",
    "Matches at position 7 and 27 within the reference (counting starting at 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the reference sequence: ATGCGCTAAAGCGCTAGATCTCTAGCTAAAGCTAGCTTATTCGGATGGGCTAG\n",
      "Enter the query: AAAGC\n",
      "Match found at index 7 in reference.\n",
      "Match found at index 27 in reference.\n"
     ]
    }
   ],
   "source": [
    "refSeq = raw_input(\"Enter the reference sequence: \")\n",
    "querySeq = raw_input(\"Enter the query: \")\n",
    "\n",
    "refLength = len(refSeq)\n",
    "queryLength = len(querySeq)\n",
    "\n",
    "for i in range(refLength - queryLength + 1): \n",
    "    matchedPositions = 0\n",
    "    for j in range(queryLength):\n",
    "        if querySeq[j] == refSeq[i+j]:\n",
    "            matchedPositions += 1 \n",
    "    if matchedPositions == queryLength: \n",
    "        print \"Match found at index\", i, \"in reference.\"\n"
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}