hw2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f89c1d3b98ae9e592637aeaf05b31dbe",
     "grade": false,
     "grade_id": "cell-341626df9780dcd2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Homework 2 (40 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "name: Robert Frazier\n",
    "\n",
    "email: robertcf@umich.edu\n",
    "\n",
    "This homework assignment took me 4 hours in total to complete. (Please help us to gauge the difficulty of the assignment.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "dcd41b0916cd2e2b3552fd65ff6fd51f",
     "grade": false,
     "grade_id": "cell-9fc8abaaecff0e9a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Collaboration Disclosure\n",
    "\n",
    "In the cell below, please list *everyone* with whom you discussed any of the homework problems, excluding only the GSIs and the course instructor. \n",
    "\n",
    "If you did not discuss the homework with anyone else, write __\"I did not discuss this homework with anyone.\"__\n",
    "\n",
    "Even if you discuss questions with other, the code you submit must be only yours. All work is checked with the [MOSS plagiarism detector](https://theory.stanford.edu/~aiken/moss/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I discussed XX with XX. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0baec036ecc22da97dbc14e5e1656aad",
     "grade": false,
     "grade_id": "submission",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Submission Instructions\n",
    "Your homework solutions should be written entirely in this Jupyter notebook file. Once it contains your solutions, you should submit this notebook through Canvas. Before submitting, please make sure make sure __Cells->Run__ executes without errors; errors in your code cause problems for our auto-grader. Thus, even though we may ask you to check for errors in your functions, you should not include in your submission any examples of your functions actually raising those errors.\n",
    "\n",
    "## Nbgrader\n",
    "\n",
    "We will be using `nbgrader` to grade your jupyter notebook. Additional tests will be used at grading time, you are encouraged to read the problem carefully and verify your code covers all appropriate cases.\n",
    "\n",
    "**Be careful:** If a jupyter notebook cell takes longer than `60s` to run, the autograder will not grade it and you will receive zero credit for that question.\n",
    "\n",
    "## Error checking\n",
    "\n",
    "You do not need to do error checking (raising errors, etc.) in your code unless we explicitly ask you to so in a problem. <b>In this homework, if there is an element is an incorrect type within a correct type, you can raise either a ValueError or a TypeError</b>. For example, if a question asks for a tuple of ints and the input tuple is `(2,2,'s')`, either error is acceptable.Note: The tests shown are not comprehensive, so you are encouraged to read the problem carefully and verify your code covers all possible cases.\n",
    "Homework tips\n",
    "Start early! If you run into trouble installing things or importing packages, it’s best to find those problems well in advance, not the night before your assignment is due when we cannot help you!\n",
    "\n",
    "Make sure you back up your work! At a minimum, do your work in a Dropbox folder. Better yet, use git, which is well worth your time and effort to learn.\n",
    "\n",
    "Be careful to follow directions! Remember that Python is case sensitive. If you are ask you to define a function called my_function and you define a function called My_Function, you will not receive full credit. You may want to copy-paste the function names below to make sure that the functions in your notebook match.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7a6d523d63a7eaa50415ac24a79d1c6f",
     "grade": false,
     "grade_id": "cell-052806e16f938b13",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Problem 1: Severance textbook exercises (11 points)\n",
    "\n",
    "- Ch 7, Exercises 1,2\n",
    "- Ch 8, Exercises 2,3,5 \n",
    "- Ch 9, Exercises 3,4\n",
    "- Ch 10, Exercises 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "0lSVBdY-REem",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fca5597d6bffda23ce519b071c6117f1",
     "grade": false,
     "grade_id": "cell-d15e3b06a5d44dd3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### (1 point) Chapter 6, Exercise 5: Use find and string slicing to extract the portion of the string after the colon character and then use the float function to convert the extracted string into a floating point number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "4-SzXxvCREen",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "be034b6b76754c1846bcbcf17edd9b77",
     "grade": false,
     "grade_id": "6_5",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Finish the question based on the string below:\n",
    "string_example = 'X-DSPAM-Confidence:  0.8475'\n",
    "\n",
    "# You final result should be defined as number, i.e.\n",
    "# number = ?\n",
    "# YOUR CODE HERE\n",
    "for i in string_example: #iterates through elements of the string\n",
    "    if i == ':': #finds where in the string the semi colon is\n",
    "        number = float(string_example[string_example.index(i)+1:]) #will return a float of everything past the colon (which is just empty space and the number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "wSW5yVgkREeu",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5aebca20019c92f2616ddc9fa6f40fd2",
     "grade": false,
     "grade_id": "cell-36fad7bce2571599",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### (1 point) Chapter 7, Exercises 1: Write a program to read through a file and print the contents of the file (line by line) all in upper case. Executing the program for the first 5 lines of *mbox-short.txt* will look as follows:\n",
    "\n",
    "FROM STEPHEN.MARQUARD@UCT.AC.ZA SAT JAN  5 09:14:16 2008\n",
    "\n",
    "RETURN-PATH: \\<POSTMASTER@COLLAB.SAKAIPROJECT.ORG\\>\n",
    "\n",
    "RECEIVED: FROM MURDER (MAIL.UMICH.EDU \\[141.211.14.90\\])\n",
    "\n",
    "> BY FRANKENSTEIN.MAIL.UMICH.EDU (CYRUS V2.3.8) WITH LMTPA;\n",
    "     \n",
    "> SAT, 05 JAN 2008 09:14:16 -0500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "WvXW38UmREev",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ae0fea2dc64ec9f3d059104effc458e7",
     "grade": false,
     "grade_id": "cell-db52ee6479e35ee3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def file_print(filepath = \"mbox-short.txt\", number = 5):\n",
    "    file = open(filepath)\n",
    "    i = 0 #initialize counter\n",
    "    for line in file: #iterates through each line in the file\n",
    "        i += 1 \n",
    "        if i <= number: #checks to see im below the number of lines I want to print\n",
    "            print(line.upper()) #prints the line in uppercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FROM STEPHEN.MARQUARD@UCT.AC.ZA SAT JAN  5 09:14:16 2008\n",
      "\n",
      "RETURN-PATH: <POSTMASTER@COLLAB.SAKAIPROJECT.ORG>\n",
      "\n",
      "RECEIVED: FROM MURDER (MAIL.UMICH.EDU [141.211.14.90])\n",
      "\n",
      "\t BY FRANKENSTEIN.MAIL.UMICH.EDU (CYRUS V2.3.8) WITH LMTPA;\n",
      "\n",
      "\t SAT, 05 JAN 2008 09:14:16 -0500\n",
      "\n"
     ]
    }
   ],
   "source": [
    "file_print() #prints the first 5 lines of the file mbox-short.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "aab277c2303fa5408da65ea067153a6f",
     "grade": true,
     "grade_id": "cell-a1bc8449f489f8dc",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open( \"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "VIXv57wTREez",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "d2b3cbab774550d06f497da8e7abadd9",
     "grade": false,
     "grade_id": "cell-7a59431e1ea02157",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### (2 points) Chapter 7, Exercises 2: Write a program that uses (or takes in if you decide to write a function) a file name, and then read through the file and look for lines of the form:\n",
    "\n",
    "X-DSPAM-Confidence: 0.8475\n",
    "\n",
    "#### When you encounter a line that starts with “X-DSPAM-Confidence:” pull apart the line to extract the floating-point number on the line. Count these lines and then compute the total of the spam confidence values from these lines. When you reach the end of the file, print out the average spam confidence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "8LJQVqttREe1",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ec108926c3e8100b9a0f15ae3bae96e9",
     "grade": false,
     "grade_id": "X-DSPAM",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "82ccca0e-d106-4cae-b96e-85df7557d77d"
   },
   "outputs": [],
   "source": [
    "def file_spam(filepath = \"mbox-short.txt\"): \n",
    "    file = open(filepath) #opens file I want\n",
    "    spam_levels = [] #a list where I will be appending the spam confidence values \n",
    "    for line in file:\n",
    "        if \"X-DSPAM-Confidence\" in line: #checks to see that the line has the spam confidence value\n",
    "            for i in line: #iterates through elements of the string\n",
    "                if i == ':': #finds where in the string the semi colon is\n",
    "                    spam_levels.append(float(line[line.index(i)+1:])) #will return a float of everything past the colon (which is just empty space and the number)\n",
    "    average = sum(spam_levels)/len(spam_levels) #calculates the average of the spam confidence values\n",
    "    print(\"Average Spam Confidence level is {:.5f}\".format(average))\n",
    "    return spam_levels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Spam Confidence level is 0.75072\n"
     ]
    }
   ],
   "source": [
    "a = file_spam()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fb1e900d041a45f578bea8e9e2eb8cf1",
     "grade": true,
     "grade_id": "cell-19ec1ef61fa7331f",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open( \"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "0dJzJF2TREe6",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e1009d589372bc558b9eb13a7fb2d6de",
     "grade": false,
     "grade_id": "cell-79a188ffe05bf4a8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### Chapter 8, Exercises 2: \n",
    "fhand = open('mbox-short.txt')\n",
    "\n",
    "\n",
    "count = 0\n",
    "\n",
    "\n",
    "for line in fhand:\n",
    "    words = line.split()\n",
    "    # print 'Debug:', words\n",
    "    if len(words) == 0 : continue\n",
    "    if words[0] != 'From' : continue\n",
    "    print words[2]\n",
    "\n",
    "#### (2 points) Figure out which line of the above program is still not properly guarded. See if you can construct a text file which causes the program to fail and then modify the program so that the line is properly guarded and test it to make sure it handles your new text file.  You do not need to include your text file in your submission, and you should comment out any lines of code which refer to this file.\n",
    "\n",
    "user_data = \"mbox-short.txt\"\n",
    "\n",
    "\n",
    "fhand = open(user_data, 'r')\n",
    "\n",
    "\n",
    "count = 0\n",
    "\n",
    "<b>The start of the for loop would be line 1 for the next question.</b><br>\n",
    "```for line in fhand:\n",
    "    words = line.split()\n",
    "    # print 'Debug:', words\n",
    "    if len(words) == 0 : continue\n",
    "    if words[0] != 'From' : continue\n",
    "    print words[2]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n"
     ]
    }
   ],
   "source": [
    "#This is the original code that was given\n",
    "fhand = open('mbox-short.txt') \n",
    "for line in fhand:\n",
    "    words = line.split() \n",
    "    # print('Debug:', words)\n",
    "    if len(words) == 0 : continue\n",
    "    if words[0] != 'From' : continue\n",
    "    print(words[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Original code fails if there is a line that consists only of the word \"From\". \n",
    "\n",
    "Here is my fixed version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n"
     ]
    }
   ],
   "source": [
    "fhand = open('mbox-short.txt')\n",
    "for line in fhand:\n",
    "    words = line.split()\n",
    "    if len(words) <= 1 : continue #modified this so it skips if the line is only 0 or 1 words long because originally only checked if it was 0 words long. \n",
    "    if words[0] != 'From' : continue\n",
    "    print(words[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "xB352pS1REe7",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "14f25653afcc3ae635108447e11bebab",
     "grade": false,
     "grade_id": "cell-9ef0746e6cea5fe4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "__If the first line of the for loop line number 1, which line of the above program is still not properly guarded? Leave your answer as an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "066d9ad9678ad7b92e78594026ddd451",
     "grade": true,
     "grade_id": "cell-05cd887839065f23",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Make sure that you assigned your int answer to the variable unguarded_line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "_2u9VUBgREe9",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "93407b377366fa02e2fb2462e06e9224",
     "grade": false,
     "grade_id": "cell-7770687564fc26ec",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "c58ea779-bfc2-43d0-88ca-2e155104b843"
   },
   "outputs": [],
   "source": [
    "unguarded_line = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5d3944629d8423e30e93759cc604b04e",
     "grade": true,
     "grade_id": "cell-00d1e2a3da84a79a",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open(\"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tTqzkULcREfC"
   },
   "source": [
    "#### (1 point) Chapter 8, Exercises 3: Rewrite the guardian code in the above example without two $if$ statements. Instead, use a compound logical expression using the $or$ logical operator with a single if statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "rBiYVzWjREfD",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5e04d2c76d882c8d9a97ef80979719d7",
     "grade": false,
     "grade_id": "cell-f9593bd8e0e0bb9b",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "e90a27cb-f13f-4ec9-e0fb-a4c26f1a48d5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Fri\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n",
      "Thu\n"
     ]
    }
   ],
   "source": [
    "fhand = open('mbox-short.txt')\n",
    "for line in fhand:\n",
    "    words = line.split()\n",
    "    # print('Debug:', words)\n",
    "    if len(words) <= 1  or words[0] != 'From': continue #combined the two if statements into one using or \n",
    "    print(words[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "36afd8a4f41a6ea0dc557764c2592cb6",
     "grade": true,
     "grade_id": "cell-2953b11558c103c8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open(\"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "ISSbTTU6REfG",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1ae987d6900c7d6ee0343c97af03b240",
     "grade": false,
     "grade_id": "cell-28fd87b08896c1b9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### (1 point) Chapter 8, Exercises 5: Write a program to read through the mail box data and when you find a line that starts with “From”, you will split the line into words using the split function. We are interested in who sent the message, which is the second word on the From line.\n",
    "From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008\n",
    "\n",
    "#### You will parse the From line and print out the second word for each From line, then you will also count the number of From (not From:) lines and print out a count at the end.\n",
    "This is a good sample output with a few lines removed:\n",
    "\n",
    "\n",
    "python fromcount.py\n",
    "\n",
    "\n",
    "Enter a file name: mbox-short.txt\n",
    "\n",
    "\n",
    "stephen.marquard@uct.ac.za\n",
    "\n",
    "\n",
    "louis@media.berkeley.edu\n",
    "\n",
    "\n",
    "zqian@umich.edu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "_Y0DuWM9REfH",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0bdcf20e80bc27ef5d7cf91e80246e52",
     "grade": false,
     "grade_id": "cell-62e3962a1fb2bf0a",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "c22e2cc5-1235-41a1-9bbb-26881856e72d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stephen.marquard@uct.ac.za\n",
      "louis@media.berkeley.edu\n",
      "zqian@umich.edu\n",
      "rjlowe@iupui.edu\n",
      "zqian@umich.edu\n",
      "rjlowe@iupui.edu\n",
      "cwen@iupui.edu\n",
      "cwen@iupui.edu\n",
      "gsilver@umich.edu\n",
      "gsilver@umich.edu\n",
      "zqian@umich.edu\n",
      "gsilver@umich.edu\n",
      "wagnermr@iupui.edu\n",
      "zqian@umich.edu\n",
      "antranig@caret.cam.ac.uk\n",
      "gopal.ramasammycook@gmail.com\n",
      "david.horwitz@uct.ac.za\n",
      "david.horwitz@uct.ac.za\n",
      "david.horwitz@uct.ac.za\n",
      "david.horwitz@uct.ac.za\n",
      "stephen.marquard@uct.ac.za\n",
      "louis@media.berkeley.edu\n",
      "louis@media.berkeley.edu\n",
      "ray@media.berkeley.edu\n",
      "cwen@iupui.edu\n",
      "cwen@iupui.edu\n",
      "cwen@iupui.edu\n",
      "There were 27 lines in the file with From as the first word\n"
     ]
    }
   ],
   "source": [
    "fhand = open('mbox-short.txt')\n",
    "count = 0 #this is how I count the number of lines that have 'From' as the first word\n",
    "for line in fhand:\n",
    "    words = line.split()\n",
    "    # print('Debug:', words)\n",
    "    if len(words) == 0 : continue\n",
    "    if words[0] != 'From' : continue \n",
    "    count += 1 #adding one if there's a line with count as first word \n",
    "    print(words[1]) #I am now printing just the second word from the line \n",
    "print(\"There were\", count, \"lines in the file with From as the first word\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e196027ad1b9d657729e028046e63a70",
     "grade": true,
     "grade_id": "cell-972bcb771fa1da2f",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open(\"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "CgvHfbLXREfK",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "db305a2790a05772f76784e180334314",
     "grade": false,
     "grade_id": "cell-5a81efde95cab697",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### (1 point) Chapter 9, Exercises 3: Write a program to read through a mail log, build a histogram using a dictionary to count how many messages have come from each email address, and print the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "rS-CPHCWREfL",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "20638021a80d16e16fa4e1f261c4b9fc",
     "grade": false,
     "grade_id": "cell-0111fc1a5d93c960",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "8d30704b-99aa-4e06-d3d2-be9e913a577d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'stephen.marquard@uct.ac.za': 2, 'louis@media.berkeley.edu': 3, 'zqian@umich.edu': 4, 'rjlowe@iupui.edu': 2, 'cwen@iupui.edu': 5, 'gsilver@umich.edu': 3, 'wagnermr@iupui.edu': 1, 'antranig@caret.cam.ac.uk': 1, 'gopal.ramasammycook@gmail.com': 1, 'david.horwitz@uct.ac.za': 4, 'ray@media.berkeley.edu': 1}\n"
     ]
    }
   ],
   "source": [
    "fhand = open('mbox-short.txt')\n",
    "mail = dict() #a dictionary where I'll be storing the email addresses and the number of times they appear\n",
    "for line in fhand:\n",
    "    words = line.split()\n",
    "    # print('Debug:', words)\n",
    "    if len(words) == 0 : continue\n",
    "    if words[0] != 'From' : continue\n",
    "    if words[1] not in mail: #if the email address is not already in the dict add it with a value of 1\n",
    "        mail[words[1]] = 1 \n",
    "    else: #if it already is increase the valut in the dict by 1 \n",
    "        mail[words[1]] += 1\n",
    "print(mail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4c84e03cbad8fd0a0035f0223d5af9b2",
     "grade": true,
     "grade_id": "cell-d251268af54f0baa",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open(\"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "H5UDx1bWREfP",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "93c2a16951a1021c25c02b28b2ec2466",
     "grade": false,
     "grade_id": "cell-cdff7e4e77ccad56",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### (1 point) Chapter 9, Exercises 4: Add code to the above program to figure out who has the most messages in the file. After all the data has been read and the dictionary has been created, look through the dictionary using a maximum loop (see Chapter 5: Maximum and minimum loops) to find who has the most messages and print how many messages the person has."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "IPRDy1R9REfQ",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3d4c556fbe1f34551bcdd7b04a487140",
     "grade": false,
     "grade_id": "cell-1567629def5bd621",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "3065db5f-3524-46e8-95de-2d4f56cd96c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The user with the most emails is cwen@iupui.edu with 5 emails\n"
     ]
    }
   ],
   "source": [
    "fhand = open('mbox-short.txt')\n",
    "mail = dict()\n",
    "for line in fhand:\n",
    "    words = line.split()\n",
    "    # print('Debug:', words)\n",
    "    if len(words) == 0 : continue\n",
    "    if words[0] != 'From' : continue\n",
    "    if words[1] not in mail:\n",
    "        mail[words[1]] = 1\n",
    "    else:\n",
    "        mail[words[1]] += 1\n",
    "largest = 0 #initialize the largest number of emails\n",
    "for key in mail: #goes through the emails in the dictionary\n",
    "    if mail[key] > largest: #if the number of emails is larger than the current largest number of emails\n",
    "        largest = mail[key] #set largest number to the number of emails\n",
    "        email = key #set email to be the current key of the dictionary\n",
    "print(\"The user with the most emails is\", email, \"with\", largest, \"emails\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c4d20f038e9f9eef53447a7d8fd4fdef",
     "grade": true,
     "grade_id": "cell-ebfd8a271904d30d",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open(\"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "SLymHtPmREfT",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "41763125c7295e733915dfe13b7999a8",
     "grade": false,
     "grade_id": "cell-33d923c8c18023a4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### (1 point) Chapter 10, Exercises 1: Read and parse the “From” lines and pull out the addresses from the line. Count the number of messages from each person using a dictionary. After all the data has been read, print the person with the most commits by creating a list of (count, email) tuples from the dictionary. Then sort the list in reverse order and print out the person who has the most commits (you'll print the person with the most commits twice)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "Yj_dCQ0RREfU",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "331c95395691658580457003e0701933",
     "grade": false,
     "grade_id": "cell-a8164b4b9647cf09",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    },
    "outputId": "8d45dcc6-ecfb-44dc-d592-b0dbe0c2e636"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The user with the most emails is cwen@iupui.edu with 5 emails\n",
      "The user with the most emails is cwen@iupui.edu with 5 emails\n"
     ]
    }
   ],
   "source": [
    "fhand = open('mbox-short.txt')\n",
    "mail = dict()\n",
    "for line in fhand:\n",
    "    words = line.split()\n",
    "    # print('Debug:', words)\n",
    "    if len(words) == 0 : continue\n",
    "    if words[0] != 'From' : continue\n",
    "    if words[1] not in mail:\n",
    "        mail[words[1]] = 1\n",
    "    else:\n",
    "        mail[words[1]] += 1\n",
    "email_list = [(v, k) for k, v in mail.items()]\n",
    "print(\"The user with the most emails is\", max(email_list)[1], \"with\", max(email_list)[0], \"emails\")\n",
    "email_list.sort(reverse = True) #sorts the list of emails in descending order\n",
    "print(\"The user with the most emails is\", email_list[0][1], \"with\", email_list[0][0], \"emails\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c23b2afffee0d2c40ff9c110a4629729",
     "grade": true,
     "grade_id": "cell-8573424abb14baa3",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    open(\"mbox-short.txt\")\n",
    "except FileNotFoundError:\n",
    "    raise AssertionError(\"The file cannot be opened.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "iz0ellhAREfY",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "40b482ec072ca3128a59c81ac9a7bbd7",
     "grade": false,
     "grade_id": "cell-1d0141fef35b0cd1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Problem 2: Fun with Strings (6 points)\n",
    "1. <b>(2 points)</b>  A palindrome is a word or phrase that reads the same backwards and forwards. Write a function called `is_palindrome`, which takes a string as its only argument, and returns a Boolean. Your function should ignore spaces and capitalization in assessing whether or not a string is a palindrome, so that \"tacocat\" and \"T A C O cat\" are both considered palindromes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "g-T3RywIREfZ",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ffecc6c0a1947fcb8b6c5da63aab5389",
     "grade": false,
     "grade_id": "hw2-2_1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def is_palindrome(word):\n",
    "    \"\"\"\n",
    "    word: a string\n",
    "    \"\"\"\n",
    "    if not isinstance(word,str): #throw an error if the input is not a string\n",
    "        raise TypeError(\"Only strings are accepted\")\n",
    "    word = word.lower() #makes the word lowercase\n",
    "    word = word.replace(\" \", \"\") #removes spaces from the word\n",
    "    return word == word[::-1] #checks to see if the word is the same backwards as it is forwards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "29aea86f14f20e22d80a040828d630e6",
     "grade": true,
     "grade_id": "cell-6f018e99d2dda393",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(is_palindrome('level')) == bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8192b29eddf40c59a836fbf7ca366672",
     "grade": true,
     "grade_id": "palindrome",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_palindrome('level') == True\n",
    "assert is_palindrome('WAS it a car or a cat I saw') == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3e4efb602531890b72552f946f53ed58",
     "grade": true,
     "grade_id": "space",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_palindrome('a') == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "2N10vKhTREfn",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8f3aab0c44031266046af252a01ac02e",
     "grade": false,
     "grade_id": "cell-780d06bd8fb69f76",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. <b>(2 points)</b>  Let us say that a word is “abecedarian” if its letters appear in alphabetical order(repeated  letters  are  okay).   So,  for  example,  “adder”  and  “beet”  are  abecedar-ian,  whereas  “dog”  and  “cat”  are  not.   Write  a  function `is_abecedarian`,  which takes a single argument in the form of a string and returns True if the argumentis abecedarian and False otherwise.  Here you may assume that the input consists only  of  alphabetic  characters  and  spaces.   Your  function  should  ignore  spaces,  so that the string \"abcd efgh xyz\" is considered abecedarian.  Your function should ignore capitalization, so that \"aA\",\"aa\" and \"aA\" are all considered abecedarian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "0SMFrCUWREfo",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9a2c5fa314ccf55961cf8bd8fa56d859",
     "grade": false,
     "grade_id": "hw2-2_2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "def is_abecedarian(word):\n",
    "    \"\"\"\n",
    "    word: a string\n",
    "    \"\"\"\n",
    "    if not isinstance(word,str): #throw an error if the input is not a string\n",
    "        raise TypeError(\"Only strings are accepted!\")\n",
    "    word = word.lower() #makes the word lowercase\n",
    "    word = word.replace(\" \", \"\") #removes spaces from the word\n",
    "    return word == \"\".join(sorted(word)) #checks to see if the word is the same as the word sorted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ce01ccb156b12c07b97252cccc392d47",
     "grade": true,
     "grade_id": "abc_blank",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(is_abecedarian(\"Ca T\")) == bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "60cb8f8efb23470302f2ee22fa0a10f8",
     "grade": true,
     "grade_id": "abc-basic",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_abecedarian(\"Ca T\") == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "865ff13e8e9df819480af21c928afe66",
     "grade": true,
     "grade_id": "abc",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_abecedarian(\"adder\") == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "888cd9d4a44854b46d89e39710c18012",
     "grade": true,
     "grade_id": "abc-caps",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_abecedarian(\"zYx\") == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "lNX9WVqBREfq",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "28c35094161dac911a6c10f5e8f26687",
     "grade": false,
     "grade_id": "cell-53128ff937d72294",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "3. <b>(2 points)</b> Write a function called `double_vowels` that takes a string as its only argument and returns that string with all the vowels duplicated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "SNIVjdYMREfr",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b0522791cfd434269363a208e2cffc30",
     "grade": false,
     "grade_id": "hw2-2_3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def double_vowels(word):\n",
    "    \"\"\"\n",
    "    word: a string\n",
    "    \"\"\"\n",
    "    if not isinstance(word,str): #throw an error if the input is not a string\n",
    "        raise TypeError(\"Only strings are accepted!\")\n",
    "    vowels = \"aeiou\" #list of vowels (sometimes y but not right now)\n",
    "    new_word = \"\" #initialize new word\n",
    "    for i in word: #iterates through the elements of the word\n",
    "        if i.lower() in vowels: #if the element is a vowel\n",
    "            new_word += i*2 #add the vowel twice\n",
    "        else:\n",
    "            new_word += i #if the element is not a vowel add it once\n",
    "    return new_word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bc03af9de7f24e8f55ecac69a8dabe43",
     "grade": true,
     "grade_id": "spaces",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert double_vowels('this should work') == 'thiis shoouuld woork'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "57afef84fe0fdba75c31ba425768e8db",
     "grade": true,
     "grade_id": "double_vowels",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert double_vowels('vowel') == \"vooweel\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "ulRVgeowREf4",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8c73220cc7481d4aae79776e68376ee2",
     "grade": false,
     "grade_id": "cell-81148f36ee7ebdb4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Problem 3: Fun with Lists (5 points)\n",
    "1. <b>(2 points)</b> Write a function `list_reverse` that takes a list as an argument and returns that list, reversed. Your function should perform error checking to ensure that the input is a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "8-HRXXsgREf5",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c5050122b673c864db2457ecc2f9f996",
     "grade": false,
     "grade_id": "hw2-3_1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def list_reverse(listicle):\n",
    "    \"\"\"\n",
    "    list: a list\n",
    "    \"\"\"\n",
    "    if not isinstance(listicle, list): #throw an error if the input is not a list\n",
    "        raise TypeError(\"Only lists are accepted!!!\")\n",
    "    return listicle[::-1] #returns the inverse of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6019d8105c78a93fac6873e251f8b182",
     "grade": true,
     "grade_id": "cell-1deca1a3bac64b18",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert list_reverse (['this should be the same list']) == ['this should be the same list']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c49187c7dd8623cdee791fec1c3884f2",
     "grade": true,
     "grade_id": "error",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(list_reverse([1,2,3,9])) == list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3c277ca0ca5be4d3ace34221588d117c",
     "grade": true,
     "grade_id": "list_reverse",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert list_reverse([1, 2, 3]) == [3, 2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "p621CcriREf-",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7595cc507ec5fdc05886bdb934cee54d",
     "grade": false,
     "grade_id": "cell-7e1f328702b5349e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. <b>(1 point)</b> Write a function `is_sorted` that takes a sequence `seq` as its only argument and returns True if the sequence is sorted in ascending order and returns False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "GIdjPSe_REf-",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "34b7e4ca02377e2bad2a57a957fdab4a",
     "grade": false,
     "grade_id": "hw2-3_2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def is_sorted(seq):\n",
    "    \"\"\"\n",
    "    seq: a sequence such as a list or tuple or string\n",
    "    \"\"\"\n",
    "    if not isinstance(seq, (list, tuple, str)): #throw an error if the input is not a list, tuple, or string\n",
    "        raise TypeError(\"Only lists, tuples, and strings are accepted!!!\")\n",
    "    return list(seq) == sorted(seq) #checks to see is the sorted list from the sequence = the list of the sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "262b6a061c510a0449bb92cd5cb6bd38",
     "grade": true,
     "grade_id": "is_sorted",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_sorted('abbde') == True\n",
    "assert is_sorted([1, 2, 3, 3, 5]) == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "G1wqpqaQREgE",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "557551ddbceaa9b36c822b89d7c348e1",
     "grade": false,
     "grade_id": "cell-c9b27e07eac40ba7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "3. <b>(2 points)</b> Write a function called `binary_search` that takes two arguments, a list of integers `t`(which is guaranteed to be sorted in ascending order) and an integer `elmt`, and returns True if `elmt` appears in list `t` and False otherwise. The binary search algorithm works as follows: \n",
    "\n",
    "    Search a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than the item in the middle of the interval, narrow the interval to the lower half. Otherwise narrow it to the upper half. Repeatedly check until the value is found or the interval is empty. (Source: https://www.geeksforgeeks.org/binary-search/)\n",
    "    \n",
    "    __Note:__ No credit will be given if binary search is not implemented. A simple for loop checking that the element is in the list will not qualify as a binary search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binary_search(t, elmt):\n",
    "    start = 0\n",
    "    end = len(t) - 1\n",
    "    while start <= end:\n",
    "        middle = (start + end) // 2\n",
    "        if t[middle] == elmt:\n",
    "            return True\n",
    "        elif t[middle] < elmt:\n",
    "            start = middle + 1\n",
    "        else:\n",
    "            end = middle - 1\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e75b1558cd2ecf721c8b1ec9a60cc884",
     "grade": true,
     "grade_id": "empty_list",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(binary_search([1,3], 0)) == bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "038f34d09e84979ee310e1ce7fceb87d",
     "grade": true,
     "grade_id": "binary_search",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert binary_search ([1, 3, 5, 7, 9], 9) == True\n",
    "assert binary_search ([1, 3, 5, 7, 9], 1) == True\n",
    "assert binary_search ([1, 3, 5, 7, 9], 7) == True\n",
    "assert binary_search ([1, 3, 5, 7, 9], 0) == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "pRxI9OLUREgK",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ef503d06a87b139fd25ab1320646b590",
     "grade": false,
     "grade_id": "cell-3640a8aa6830ca77",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Problem 4: More Fun with Strings (4 points)\n",
    "1. <b>(2 points)</b> Write a function called `char_hist` that takes a string as its argument and returns a dictionary whose keys are characters and values are the number of times each character appeared in the input. The inputted string should be converted to have exclusively lowercase letters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "m-m3TNquREgL",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1dc18ec83723482afc5ed19a98889f91",
     "grade": false,
     "grade_id": "hw2-4_1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def char_hist(input):\n",
    "    text = input.lower()\n",
    "    char = dict()\n",
    "    for i in text:\n",
    "        if i not in char:\n",
    "            char[i] = 1\n",
    "        else:\n",
    "            char[i] += 1\n",
    "    return char "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "158dec26a605e86e250c5cda4ccfc979",
     "grade": true,
     "grade_id": "empty_char",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(char_hist('This should return a dictionary.')) == dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0b3b09d1f6ce3a181ac3fbcc7f46fe2b",
     "grade": true,
     "grade_id": "char_hist",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert char_hist('gattaca') == {'g': 1, 'a': 3, 't': 2, 'c': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "D8L3ykBAREgb",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "dde116b3f843368fd4cb8d29c0e9bbaa",
     "grade": false,
     "grade_id": "cell-f0eb106f96726b9e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. <b>(2 points)</b> Write a function called `bigram_hist` that takes a string as its argument and returns a dictionary whose keys are 2-tuples of characters and values are the number of times that pair of characters appeared in the string. Your function should convert the string to have exclusive lowercase letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "qc_7ctBXREgc",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3253677c476f2222e7de0d46acbcb443",
     "grade": false,
     "grade_id": "hw2-4_2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def bigram_hist(input):\n",
    "    text = input.lower()\n",
    "    char = dict()\n",
    "    for i in range(len(text)-1):\n",
    "        if (text[i],text[i+1]) not in char:\n",
    "            char[(text[i],text[i+1])] = 1\n",
    "        else:\n",
    "            char[(text[i],text[i+1])] += 1\n",
    "    return char "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "364e78bab435e7c6d5427cdebb0fb630",
     "grade": true,
     "grade_id": "bigram_hist",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert bigram_hist(\"mississippi\") == {('i','p'):1,('i','s'):2,('m','i'):1,('p','i'):1,('p','p'):1,('s','i'):2,('s','s'):2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4ae67f7b872a89ff8f669df021e22dc1",
     "grade": true,
     "grade_id": "empty_hist",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert bigram_hist('') == {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "GIRzOFhVREgl",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "89a32cdeb90cff1c77cbd08cbfbaf66b",
     "grade": false,
     "grade_id": "cell-5316da91ff114931",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Problem 5: Tuples as Vectors (6 points)\n",
    "1. <b>(2 points)</b> Implement a function called `vec_scalar_mult`, which takes two arguments: a tuple of numbers (floats and/or integers) `t` and a number (float or integer) `s` and returns a tuple of the same length as `t`, with its entries equal to the entries of `t` multiplied by `s`. Your function should do appropriate error checking about the types of the arguments and the types within the vector. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "d_-z3E7zREgm",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1f6403555998f1d83c5f61b74fc0350e",
     "grade": false,
     "grade_id": "hw2-5_1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def vec_scalar_mult(t, s):\n",
    "    if not isinstance(t, tuple):\n",
    "        raise TypeError(\"t must be a tuple\")\n",
    "    if not all(isinstance(x, (float, int)) for x in t):\n",
    "        raise TypeError(\"t must consist of floats or ints \")\n",
    "    if not isinstance(s, (float,int)):\n",
    "        raise TypeError(\"s must be a float or int\")\n",
    "    vec = []\n",
    "    for i in t:\n",
    "        vec.append(i*s)\n",
    "    return tuple(vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4b2322d9da0e8d155e8bb6b506bc0272",
     "grade": true,
     "grade_id": "vec_scalar_mult",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert vec_scalar_mult ((1.0, 2), 4.0) == (4.0, 8.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "076508abd2fb013b3c9d76e7843045e1",
     "grade": true,
     "grade_id": "empty_mult",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert vec_scalar_mult ((1.0, 2), 4.0) == (4.0, 8.0)\n",
    "assert vec_scalar_mult ((1.0, 2, 3), -2.0) == (-2.0, -4.0, -6.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "qWofnY0fREgu",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7f81d9115179cc681235a786f8496ee6",
     "grade": false,
     "grade_id": "cell-1c3f330aabcd46e5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. <b>(2 points)</b> Implement a function called `vec_inner_product` which takes two vectors (i.e., tuples of foats and/or ints) as its inputs and outputs a float corresponding to the inner product of these two vectors. Your function should do appropriate error checking regarding the types and lengths of the arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "aVok0FNQREgv",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "67ab7cdcd60d5866c77b6f0c12ab607f",
     "grade": false,
     "grade_id": "hw2-5_2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def vec_inner_product(t1,t2):\n",
    "    if not isinstance(t1, tuple):\n",
    "        raise TypeError(\"t1 must be a tuple\")\n",
    "    if not all(isinstance(x, (float, int)) for x in t1):\n",
    "        raise TypeError(\"t1 must consist of floats and inits \")\n",
    "    if not isinstance(t2, tuple):\n",
    "        raise TypeError(\"t2 must be a tuple\")\n",
    "    if not all(isinstance(x, (float, int)) for x in t2):\n",
    "        raise TypeError(\"t2 must consist of floats and inits \")\n",
    "    if not len(t1) == len(t2):\n",
    "        raise ValueError(\"t2 and t1 must be the same length\")\n",
    "    scalar = 0.0\n",
    "    for i in range(len(t1)):\n",
    "        scalar += t1[i]*t2[i]\n",
    "    return scalar \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f65d2ff3a5b043c76d436f267dd05123",
     "grade": true,
     "grade_id": "inner_product",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert vec_inner_product((1,1),(1,2)) == 3.0\n",
    "assert vec_inner_product((1,1),(-1,2)) == 1.0\n",
    "assert vec_inner_product((1.0, 2.0), (1, 2)) == 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "39e9b5243b435ebd3b49b798cf429fdc",
     "grade": true,
     "grade_id": "inner-product-empty",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert vec_inner_product((), ()) == 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "09ae1c7632109f8b1b18c01d940b1d7f",
     "grade": true,
     "grade_id": "inner-pr",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert vec_inner_product((1,5,9,4.5), (7,-2,3,-4)) == 6.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "219cdcd44ce7b2902c9722165aa023f6",
     "grade": true,
     "grade_id": "error_handling",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    vec_inner_product((1.0, 2.0), (1.0,))\n",
    "\n",
    "except ValueError:\n",
    "    pass\n",
    "except TypeError:\n",
    "    pass\n",
    "\n",
    "else:\n",
    "    raise AssertionError(\"Dimensions don't line up.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "rfnD_nosREg0",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e544e0e809b05aaf5a2fa217a149fe3e",
     "grade": false,
     "grade_id": "cell-4dd20a4384c7b20f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "3. <b>(1 point)</b> Write a function `check_valid_mx` that takes a single argument and returns a Boolean, which is True if the given argument is a tuple that validly represents a matrix, and returns False otherwise. A valid matrix is a tuple of tuples that has exclusively numeric values (floats or ints). Additionally, each innermost tuple must have the same length. If the length of the first tuple is 5, then all other inner tuples must have length 5 in order for the structure to be considered a valid matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "hi3WFhPbREg1",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "88be07e6cd40e0306e7f118b141ff462",
     "grade": false,
     "grade_id": "hw2-5_3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def check_valid_mx(matrix):\n",
    "    if not isinstance(matrix, tuple):\n",
    "        return False \n",
    "    if not all(isinstance(x, tuple) for x in matrix):\n",
    "        return False\n",
    "    if not all(len(x) == len(matrix[0]) for x in matrix):\n",
    "        return False\n",
    "    for i in matrix:\n",
    "        if not all(isinstance(x,(float,int)) for x in i):\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9827d35c98d3483878ebfb4a8333496b",
     "grade": true,
     "grade_id": "check_valid_mx",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert check_valid_mx('s') == False\n",
    "assert check_valid_mx(((1.0, 2.0), (2.0,))) == False\n",
    "assert check_valid_mx(((1.0, 2.0), (2.0, 4.0))) == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8712faaf9102e891a4f943c5092b44cb",
     "grade": true,
     "grade_id": "cell-b66e8d0741a7c7c4",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert check_valid_mx(((1.0, 2.0), (2.0, 's'))) == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "FCs-qwJvREhB",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1fac28cefec775d1c55cf6b442cb21a3",
     "grade": false,
     "grade_id": "cell-dd2b9e164b75960b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "4. <b>(1 point)</b> Write a function `mx_vec_mult` that takes a matrix (i.e., tuple of tuples) and a vector (i.e., a tuple) as its arguments, and returns a vector (i.e., a tuple of numbers) that is the result of multiplying the given vector by the given matrix (you are multiplying B(matrix)*a(vector)). Your function should check that all of the types of the parameters are correct and that they are all valid with matching dimensions for matrix-vector multiplication. __Hint:__ Think carefully about what type of error should be raised in each situation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "T8RONfEsREhC",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "267c3441a609375643d55f2d3ff8ff24",
     "grade": false,
     "grade_id": "hw2-5_4",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def mx_vec_mult(matrix,vector):\n",
    "    if check_valid_mx(matrix) == False:\n",
    "        raise TypeError(\"Matrix is incorrect\")\n",
    "    if not isinstance(vector,tuple):\n",
    "        raise TypeError(\"Vector is not a tuple\")\n",
    "    if not all(isinstance(x, (float,int)) for x in vector):\n",
    "        raise TypeError(\"Vector is not a tuple\")\n",
    "    if len(vector) != len(matrix[0]):\n",
    "        raise ValueError(\"Vector must be same length as tuple in matrix\")\n",
    "    vec = []\n",
    "    for x in range(len(matrix)):\n",
    "        value = 0.0\n",
    "        for i in range(len(vector)):\n",
    "            value += vector[i] * matrix[i][x]\n",
    "        vec.append(value)\n",
    "    return tuple(vec)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f643c0d606d0620c80736869a2edca95",
     "grade": true,
     "grade_id": "mx_vec_mult",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert mx_vec_mult(((1.0, 2.0), (2.0, 3.0)), (1.0, 2.0)) == (5.0, 8.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "58bd57880711ba273ac589ac50326a95",
     "grade": true,
     "grade_id": "cell-0bf79440f86eb75b",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    mx_vec_mult(((1.0, 2.0), (2.0, 's')), (1.0, 2.0))\n",
    "\n",
    "except ValueError:\n",
    "    pass\n",
    "    \n",
    "except TypeError:\n",
    "    pass\n",
    "\n",
    "else:\n",
    "    raise AssertionError(\"The matrix is invalid.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "FsLwiEHPREhG",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "18ea4e51941bdaf1ac09ff74865827e7",
     "grade": false,
     "grade_id": "cell-e8d90b1ce5e0ed42",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "###  Problem 6: More Fun with Vectors (3 points)\n",
    "1. <b>(1 point)</b> A sparse vector (or matrix) is one that is represented by only the storage of its non-zero entries, with (index, value) pairs. Write a function `is_valid_sparse_vector` that takes one argument, and returns True if and only if the input is a valid sparse vector, and returns False otherwise. Note: your function should not assume that the input is a dictionary. A valid sparse vector will be a dictionary that has the properties that \n",
    "    1. all its indices are positive integers, and \n",
    "    2. all its values are floats. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "mWVhSoH-REhI",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d90ca7e873b261665fb9637ff4c9597b",
     "grade": false,
     "grade_id": "hw2-6_1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def is_valid_sparse_vector(sparse):\n",
    "    if not isinstance(sparse, dict):\n",
    "        return False\n",
    "    for x in sparse:\n",
    "        if not isinstance(x, int):\n",
    "            return False\n",
    "        if x < 0:\n",
    "            return False\n",
    "        if not isinstance(sparse[x], float):\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6d41324ffd1720a76ba850e127e0f9f5",
     "grade": true,
     "grade_id": "is_valid_sparse_vector",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_valid_sparse_vector({1:2.,6:1.,5:3.5,7:4.0}) == True\n",
    "assert is_valid_sparse_vector({-2:1.2,3:2.5,5:4.1}) == False\n",
    "assert is_valid_sparse_vector({1: 1.0, 3: 2.0, 5: 3.0, 7: 4.0}) == True\n",
    "assert is_valid_sparse_vector({-1: 1.0, 3: 2.0, 5: 3.0}) == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2f9b4a365e2c2ae8fbb7c6206324e7c9",
     "grade": true,
     "grade_id": "is-valid-sparse-vector-empty",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_valid_sparse_vector({1}) == False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "7AaWdvugREhP",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ded7e66185cbb385db090a296fd63d54",
     "grade": false,
     "grade_id": "cell-11de3fbe2964000e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. <b>(2 points)</b> Write a function `sparse_inner_product` that takes two sparse vectors as its inputs, and returns a float that is the value of the inner product of the vectors that the inputs represent. Note that by our definition, a sparse vector has no specified dimension, so there is no need to check that the dimensions of the arguments agree. Your function should do the appropriate error checking for ensuring that both inputs are valid sparse vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "Vu9c07iCREhR",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "67d7d757811b184c841fdf5508336d5b",
     "grade": false,
     "grade_id": "hw2-6_2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def sparse_inner_product(s1,s2):\n",
    "    if not is_valid_sparse_vector(s1):\n",
    "        raise TypeError(\"s1 is not a valid sparse vector\")\n",
    "    if not is_valid_sparse_vector(s2):\n",
    "        raise TypeError(\"s2 is not a valid sparse vector\")\n",
    "    scaler = 0\n",
    "    for x in s1:\n",
    "        if x in s2:\n",
    "            scaler += (s1[x] *s2[x])\n",
    "    return scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "074ce17e565031ecfa48542f34ff63a6",
     "grade": true,
     "grade_id": "cell-ab54723e53513a3c",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert sparse_inner_product({1: 1.0, 2: 2.0, 3: 3.0}, {1: 1.0, 3: 3.0, 5: 5.0}) == 10.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fe55ae75d4a5dc51a5e38654aa17202f",
     "grade": true,
     "grade_id": "cell-cde1f885231cf4bd",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert sparse_inner_product({1: 1.0, 2: 2.0, 3: 3.0}, {}) == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ea1381030f647c75779b3fdaaaec966d",
     "grade": true,
     "grade_id": "cell-e8d82c1c87291d19",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert sparse_inner_product({1: 1.0, 4: -3.5, 3: -3.5}, {1: 10.0, 3: 1.5, 5: 3.14}) == 4.75"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f3dcacb71fb3070b3ec6c565e53d7fcc",
     "grade": true,
     "grade_id": "cell-d4d7e89ace52b2c4",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert sparse_inner_product({6: 1.0, 4: 2.0, 37: 3.0}, {2: 1.0, 1: 3.0, 55: 5.0}) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "8hRSaKe2REhV",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7306b8402aa7bb4b8fd1d5e69ae9876d",
     "grade": false,
     "grade_id": "cell-6daf8a3fbef40487",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Problem 7: More Fun with Tuples (5 points)\n",
    "1. <b>(2 points)</b> Write a function called `my_sum` that takes any number of numeric (ints and floats) arguments, and returns the sum of its arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "BnH-0-2rREhX",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bd874ae6dba0cb077bf3644b9d19866e",
     "grade": false,
     "grade_id": "hw2-7_1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def my_sum(*args):\n",
    "    if not all(isinstance(x,(float,int)) for x in args):\n",
    "        raise TypeError(\"Args must be ints and/or floats\")\n",
    "    sum = 0.0\n",
    "    for i in args:\n",
    "        sum += i\n",
    "    return(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c732b8522b2d7aa9cfc9bcfb260f478b",
     "grade": true,
     "grade_id": "star-args",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "## Please make sure this cell is directly beneath the cell with your my_sum function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e3da4e59378e14c32992f10529d0c655",
     "grade": true,
     "grade_id": "my_sum",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert my_sum(3.2,4.1,-3) == 4.3\n",
    "assert my_sum(3,4) == 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "51677e5bf3bb74bfc2bf24dc5384d595",
     "grade": true,
     "grade_id": "cell-2c0a2ace639c9c61",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert my_sum(-0) == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "ah3HTYViREhg",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9b026826a253a8c83ac971fb3e7f3955",
     "grade": false,
     "grade_id": "cell-35388ed532368a9d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "2. <b>(1 point)</b> Write a function called `reverse_tuple` that takes a tuple as its only argument and returns a tuple that is the reverse of the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "LOv2F-m7REhh",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0b2eb488eafee0591a74b8baeae67644",
     "grade": false,
     "grade_id": "hw2-7_2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def reverse_tuple(tup):\n",
    "    if not isinstance(tup,tuple):\n",
    "        raise TypeError(\"tup must be a tuple\")\n",
    "    return tup[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f1f562f08f38c704f69ce377453ebf47",
     "grade": true,
     "grade_id": "cell-9aa079959f08d94e",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(reverse_tuple((4,5,6))) == tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f1c3d34f0f62b61297c081e36bcaec6e",
     "grade": true,
     "grade_id": "cell-66e2cb2b968800d1",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert reverse_tuple((3,4,1)) == (1,4,3)\n",
    "assert reverse_tuple((4,1)) == (1,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "deletable": false,
    "editable": false,
    "id": "f2Rnkfw2REhi",
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "dc10a75316c80fe47e4e2d8e751c8d27",
     "grade": false,
     "grade_id": "cell-7bb365ff79f7e4c3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "3. <b>(2 points)</b> Write a function called `rotate_tuple` that takes two arguments: a tuple and an integer, in that order. Letting $n$ be the integer given in the input, your function should return a tuple of the same length as the input tuple, but with its entries “rotated” by n. If n is positive, this should mean to “push forward” all the entries of the input tuple by n entries, with entries that “go off the end” of the tuple being wrapped around to the beginning, so that the $i^{th}$ entry of the input tuple becomes the $(i + n)^{th}$ entry of the output, wrapping around to the beginning of the tuple if this index goes off the end. If n is negative, then this corresponds to rotating the entries in the other direction, with entries of the input tuple being “pushed backward”. Your function should perform error checking to ensure that the inputs are of appropriate types. If the user supplies a non-integer, print a message to alert the user that the input was not as expected, and try to recover by casting it to an integer. __Hint__: a try/catch statement will likely be useful here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "deletable": false,
    "id": "RWHyYX0-REhj",
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c493efa6f96ee3099fb16a680470595d",
     "grade": false,
     "grade_id": "hw2-7_3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def rotate_tuple(tup,inte):\n",
    "    if not isinstance(tup, tuple):\n",
    "        raise TypeError(\"tup must be a tuple\")\n",
    "    if isinstance(inte, float):\n",
    "        inte = int(inte)\n",
    "    elif not isinstance(inte,int):\n",
    "        raise TypeError(\"inte must be an integer\")\n",
    "    hold = list(tup)\n",
    "    store = 0\n",
    "\n",
    "    for i in range(len(tup)):\n",
    "        if (i + inte) <= len(tup) - 1:\n",
    "            hold[i+inte] = tup[i]\n",
    "        else:\n",
    "            hold[store] = tup[i]\n",
    "            store += 1\n",
    "    return tuple(hold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8a5a8cb91eca5cecdd6212d788d5be7c",
     "grade": true,
     "grade_id": "floats_and_empty",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert type(rotate_tuple((1,2,3,4), 5)) == tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e96fda7a2ed84fbfb01f3cb81de4df00",
     "grade": true,
     "grade_id": "neg_and_large_index",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert rotate_tuple((1,2,3,4,5,6,7),2) == (6,7,1,2,3,4,5)\n",
    "assert rotate_tuple((1,2,3,4,5,6,7),-2) == (3,4,5,6,7,1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c094c0d9679e8a6a4742b550c8f7959b",
     "grade": true,
     "grade_id": "cell-8eefa6355b206775",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert rotate_tuple((1,2,3,4,5,6,7),-2.0) == (3,4,5,6,7,1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "HW2 Template.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "general",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}