worksheets/worksheet7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Worksheet 7\n",
    "\n",
    "## MCS 260 Fall 2020 - Emily Dumas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instructions:\n",
    "* Complete the problems below in preparation for Quiz 7.\n",
    "* When working in discussion, please have someone in your work group share a screen.\n",
    "* Test your work to make sure it does what is asked!\n",
    "* While the Tue/Thu discussion meetings provided some dedicated time to work on these problems, completing all of these problems will take most students more than two hours.  This is expected, and the worksheet is meant to give you a good amount of total practice for one week.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a script that reads a file `integerlist.txt` that is supposed to contain a list of integers, one per line.  It prints:\n",
    "\n",
    "* The sum of the first five integers in the file\n",
    "* The sum of the last five integers in the file\n",
    "\n",
    "Note that to test this script, you'll need to save it to a `.py` file, and also create `integerlist.txt` in the same directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of first five: 15\n",
      "Sum of last five: 35\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Sum of first and last five in data file\"\"\"\n",
    "\n",
    "fin = open(\"integerlist.txt\")\n",
    "L = [ int(line) for line in fin ]\n",
    "fin.close()\n",
    "\n",
    "first_five_sum = 0\n",
    "last_five_sum = 0\n",
    "for i in range(5):\n",
    "    first_five_sum += L[i]\n",
    "    last_five_sum += L[-i-1]\n",
    "    \n",
    "print(\"Sum of first five: {}\".format(first_five_sum))\n",
    "print(\"Sum of last five: {}\".format(last_five_sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But there are some problems with this script.  It is not robust against various common errors, such as a missing or unreadable file, or malformed data in the file.\n",
    "\n",
    "**Modify the script so that it can handle**\n",
    "* The file `integerlist.txt` being missing or inaccessible\n",
    "* The file containing too little data, e.g. if its contents are\n",
    "```\n",
    "10\n",
    "12\n",
    "```\n",
    "* The file containing lines that cannot be converted to integers, e.g.\n",
    "```\n",
    "Shark\n",
    "Laser\n",
    "10000\n",
    "```\n",
    "\n",
    "without exiting due to an uncaught exception.  Instead it should print an informative message about what went wrong, and then exit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a script with no docstrings, no comments, and cryptic variable names.  Determine what it does.  Then add docstrings, comments, and choose better variable names.\n",
    "\n",
    "Finally, write a short README.txt file that describes the script's function in more detail than the docstring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "a = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "b = \"nopqrstuvwxyzabcdefghijklm\"\n",
    "\n",
    "def c(x):\n",
    "    if x in a:\n",
    "        return b[a.index(x)]\n",
    "    else:\n",
    "        return x\n",
    "\n",
    "def d(f):\n",
    "    return \"\".join([c(e) for e in f])\n",
    "\n",
    "print(d(\" \".join(sys.argv[1:])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step will of course be to experiment with the script.  Save it to a file `rotate.py` and then try:\n",
    "```\n",
    "python rotate.py hello world\n",
    "python rotate.py uryyb jbeyq\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function `common(s,t)` that returns True if the strings `s` and `t` have the same letter at some index, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "common(\"apple\",\"spring\") # True because both have \"p\" at index 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "common(\"heliotrope\",\"unsatisfying\") # False, no corresponding letters are the same"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are lots of ways to solve this problem.  Once you have a working solution, make sure you can write a one-line solution that uses some of the constructs from Lecture 18: `any`, `all`, `zip`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function `divisor_chain(L)` that takes a list `L` of positive integers and returns True if each integer in the list divides the next one, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divisor_chain([2,6,24,240])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divisor_chain([9,18,32,64])  # False, 18 does not divide 32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a more open-ended problem about text processing.  The following string contains a secret message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The problem as I see it is the lack of a mechanism to limit the number of sharks with access to laser weapons in the university research lab.  However, I admit that I have no better idea about how to conduct the necessary research.\n"
     ]
    }
   ],
   "source": [
    "s = \"The problem as I see it is the lack of a mechanism to limit the number of sharks with access to laser weapons in the university research lab.  However, I admit that I have no better idea about how to conduct the necessary research.\"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To extract the secret message, you take characters starting at index 25 and moving in steps of 46:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'south'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[25::46]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make your own secret message like this as follows:  Write a paragraph of text and store it in a string `s`.  Make sure its length is at least 200 characters.  Now, search for an offset `i` and stride `j` so that `s[i::j]` is a word.\n",
    "    \n",
    "To check that something is a word, you might use the word list from:\n",
    "\n",
    "* [5000 common english words](https://raw.githubusercontent.com/MichaelWehar/Public-Domain-Word-Lists/master/5000-more-common.txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extra challenge:  How would you approach the inverse problem, where you are given a word that you want to hide in a longer string using this offset-stride technique?  For example, is there a paragraph or sentence from [The Adventures of Sherlock Holmes](http://www.gutenberg.org/files/1661/1661-0.txt) that conceals the word \"laser\" in this way?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}