day1_reading_journal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 1 Reading Journal\n",
    "\n",
    "Hi everyone.  These are the exercises for the first set of readings from ThinkPython.  While this journal consists of several required exercises, it is meant to encourage active reading more generally.  You should use this journal to take detailed notes, catalog questions, and explore the content from ThinkPython deeply.\n",
    "\n",
    "For more information on using the Jupyter notebook, check out the documentation [here](https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook##UseJupyter).\n",
    "\n",
    "Additionally, in order to write text in this document, you will be making use of Markdown cells. A handy cheatsheet for Markdown is available [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 1\n",
    "\n",
    "Note: the exercise numbers below match up with the reading for ease of cross referencing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter One Notes\n",
    "    -Order of Operations\n",
    "    -Python uses + - * /\n",
    "    -Exponent = **\n",
    "    -print()\n",
    "    -function format\n",
    "        -def function_name(parameter):\n",
    "    -user input\n",
    "        -input(\"what shows up when you are prompted\")\n",
    "    -if statements\n",
    "        if:\n",
    "        else:\n",
    "        el if:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.4\n",
    "\n",
    "Start the Python interpreter and use it as a simple calculator. Python’s syntax for math operations is almost the same as standard mathematical notation. For example, the symbols +, - and / denote addition, subtraction and division, as you would expect. The symbol for multiplication is *\n",
    "\n",
    "* How many seconds are there in 42 minutes 42 seconds?\n",
    "* How many miles are there in 10 kilometers? Hint: there are 1.61 kilometers in a mile.\n",
    "* If you run a 10 kilometer race in 42 minutes 42 seconds, what is your average pace (time per mile in minutes and seconds)? What is your average speed in miles per hour?\n",
    "\n",
    "Please use the following markdown cell to provide your answers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2560 seconds\n",
      "6.211180124223602 miles\n",
      "\n",
      "6.0 minutes and 52.16 seconds\n",
      "8.73447204968944 miles per hour\n"
     ]
    }
   ],
   "source": [
    "print ((42*60)+40, \"seconds\")\n",
    "print (10/1.61, \"miles\")\n",
    "print()\n",
    "print ((((42*60)+40)/60)/(10/1.61)-.8693333333333333333333333333333333, \"minutes and\",(.86933333333333333333*60), \"seconds\")\n",
    "print((10/1.61)/(((42*60)+40)/3600), \"miles per hour\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Assume that we execute the following assignment statements:\n",
    "\n",
    "```\n",
    "width = 17\n",
    "height = 12.0\n",
    "delimiter = '.'\n",
    "```\n",
    "\n",
    "For each of the following expressions, write the value of the expression and the type (of the value of the expression).\n",
    "\n",
    "Example: `width * 2` <br/>\n",
    "Answer: 34, integer\n",
    "\n",
    "1. `width/2`\n",
    "2. `width/2.0`\n",
    "3. `height/3`\n",
    "4. `1 + 2 * 5`\n",
    "5. `delimiter * 5`\n",
    "\n",
    "Please use the following markdown cell to provide your answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 8\n",
    "2. 8.5\n",
    "3. 4.0\n",
    "4. 8\n",
    "5. ....."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.2\n",
    "\n",
    "Practice using the Python interpreter as a calculator.  For each of these provide Python code that computes each answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The volume of a sphere with radius r is $4/3 \\pi  r^3$. What is the volume of a sphere with radius 5? <br />\n",
    "Hint: 392.7 is wrong! You can approximate pi with 3.14 or import it through the Python math library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "523.5983333333332\n"
     ]
    }
   ],
   "source": [
    "print(4/3*3.14159*5*5*5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose the cover price of a book is \\$24.95, but bookstores get a 40% discount. Shipping costs \\$3 for the first copy and 75 cents for each additional copy. What is the total wholesale cost for 60 copies?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "945.4499999999999 dollars\n"
     ]
    }
   ],
   "source": [
    "print((24.95*.6+3)+(59*.6*24.95+59*.75), \"dollars\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If I leave my house at 6:52 am and run 1 mile at an easy pace (8:15 per mile), then 3 miles at tempo (7:12 per mile) and 1 mile at easy pace again, what time do I get home for breakfast? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 : 30 a.m. and 6 seconds\n"
     ]
    }
   ],
   "source": [
    "hour = 6\n",
    "minutes = 52+8+7+7+7+8-60\n",
    "hour = hour + 1\n",
    "seconds = 15+12+12+12+15-60\n",
    "minutes = minutes +1\n",
    "print(hour, \":\", minutes,\"a.m. and\", seconds, \"seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.1\n",
    "\n",
    "Write a function named `right_justify` that takes a string named s as a parameter and prints the string with enough leading spaces so that the last letter of the string is in column 70 of the display.\n",
    "\n",
    "```\n",
    ">>> right_justify('monty')\n",
    "                                                                 monty\n",
    "```\n",
    "Hint: Use string concatenation and repetition. Also, Python provides a built-in function called `len` that returns the length of a string, so the value of `len('monty')` is 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                 hello\n"
     ]
    }
   ],
   "source": [
    "def right_justify(s):\n",
    "    length = len(s)\n",
    "    print(\" \"*(70-length) + s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.3\n",
    "\n",
    "Note: This exercise should be done using only the statements and other features we have learned so far.\n",
    "\n",
    "1\\. Write a function that draws a grid like the following:\n",
    "\n",
    "```\n",
    "+ - - - - + - - - - +\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "+ - - - - + - - - - +\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "|         |         |\n",
    "+ - - - - + - - - - +\n",
    "```\n",
    "Note: There are four empty spaces between the vertical bars.\n",
    "\n",
    "To print more than one value on a line, you can print a comma-separated sequence of values:\n",
    "\n",
    "```\n",
    "print('+', '-')\n",
    "```\n",
    "\n",
    "By default, `print` advances to the next line, but you can override that behavior and put a space at the end, like this:\n",
    "\n",
    "```\n",
    "print('+', end=' ')\n",
    "print('-')\n",
    "```\n",
    "\n",
    "The output of these statements is '+ -'.\n",
    "\n",
    "A `print` statement with no argument ends the current line and goes to the next line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ - - - - + - - - - +\n",
      "|         |         |\n",
      "|         |         |\n",
      "|         |         |\n",
      "|         |         |\n",
      "+ - - - - + - - - - +\n",
      "|         |         |\n",
      "|         |         |\n",
      "|         |         |\n",
      "|         |         |\n",
      "+ - - - - + - - - - +\n"
     ]
    }
   ],
   "source": [
    "def one():\n",
    "    #set variable\n",
    "    pluses = \"+ - - - - + - - - - +\"\n",
    "    spaces = \"|         |         |\"\n",
    "    #print the variables\n",
    "    print(pluses)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(pluses)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(pluses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that draws a grid with 4 rows and 4 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ - - - - + - - - - + - - - - + - - - - +\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "+ - - - - + - - - - + - - - - + - - - - +\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "+ - - - - + - - - - + - - - - + - - - - +\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "+ - - - - + - - - - + - - - - + - - - - +\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "|         |         |         |         |\n",
      "+ - - - - + - - - - + - - - - + - - - - +\n"
     ]
    }
   ],
   "source": [
    "def one():\n",
    "    #setup variable\n",
    "    pluses = \"+ - - - - + - - - - \"*2+ \"+\"\n",
    "    spaces = \"|         |         \"*2+ \"|\"\n",
    "    #print variables\n",
    "    print(pluses)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(pluses)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(pluses)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(pluses)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(spaces)\n",
    "    print(pluses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 5.1 - 5.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5.2\n",
    "\n",
    "Fermat’s Last Theorem says that there are no positive integers $a$, $b$, and $c$ such that $$a^n + b^n = c^n$$ for any values of $n$ greater than 2.\n",
    "\n",
    "1\\. Write a function named `check_fermat` that takes four parameters – $a$, $b$, $c$ and $n$ – and that checks to see if Fermat’s theorem holds. If n is greater than 2 and it turns out to be true that\n",
    "$a^n + b^n = c^n$, then the program should print: \"Holy smokes, Fermat was wrong!\" Otherwise the program should print: \"No, that doesn’t work.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def check_fermat(a, b, c, n):\n",
    "    #calculate left and right sides\n",
    "    left = a**n + b**n\n",
    "    right = c**n\n",
    "    #check and see if equal\n",
    "    if left == right:\n",
    "        print(\"Holy smokes, Fermat was wrong!\")\n",
    "    else: \n",
    "        print(\"No, that doesn't work\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. Write a function that prompts the user to input values for $a$, $b$, $c$ and $n$, converts them to integers, and uses `check_fermat` to check whether they violate Fermat’s theorem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "b2\n",
      "c3\n",
      "n4\n",
      "No, that doesn't work\n"
     ]
    }
   ],
   "source": [
    "def check_fermat_two():\n",
    "    def check_fermat(a, b, c, n):\n",
    "        #evaluate left and right\n",
    "        left = a**n + b**n\n",
    "        right = c**n\n",
    "        #check and see if equal\n",
    "        if left == right:\n",
    "            print(\"Holy smokes, Fermat was wrong!\")\n",
    "        else: \n",
    "            print(\"No, that doesn't work\")\n",
    "    \n",
    "    #get user input\n",
    "    a = int(input(\"a\"))\n",
    "    b = int(input(\"b\"))\n",
    "    c = int(input(\"c\"))\n",
    "    n = int(input(\"n\"))\n",
    "    return check_fermat(a,b,c,n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 5.3 \n",
    "\n",
    "If you are given three sticks, you may or may not be able to arrange them in a triangle. For example, if one of the sticks is 12 inches long and the other two are one inch long, it is clear that you will not be able to get the short sticks to meet in the middle. For any three lengths, there is a simple test to see if it is possible to form a triangle:\n",
    "> If any of the three lengths is greater than the sum of the other two, then you cannot form a triangle. Otherwise, you can. (If the sum of two lengths equals the third, they form what is called a “degenerate” triangle.)\n",
    "\n",
    "1\\. Write a function named `is_triangle` that takes three integers as arguments, and that prints either \"Yes\" or \"No,\" depending on whether you can or cannot form a triangle from sticks with the given lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_triangle(one, two, three):\n",
    "    if (one > (two +three)) or (two > (one +three)) or (three > (one + two)):\n",
    "        print (\"No\")\n",
    "    else:\n",
    "        print(\"Yes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. Write a function that prompts the user to input three stick lengths, converts them to integers, and uses `is_triangle` to check whether sticks with the given lengths can form a triangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_triangle():\n",
    "    #get user input\n",
    "    one = input()\n",
    "    two = input()\n",
    "    three = input()\n",
    "    #convert to integer\n",
    "    one = int(one)\n",
    "    two = int(two)\n",
    "    three = int(three)\n",
    "    #see if equal\n",
    "    if (one > (two +three)) or (two > (one +three)) or (three > (one + two)):\n",
    "        print (\"No\")\n",
    "    else:\n",
    "        print(\"Yes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quick poll\n",
    "About how long did you spend working on this Reading Journal?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3 hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notes for the Instructors\n",
    "\n",
    "Please use the space below to write comments to help us plan the next class session.  For instance, if you want to see us go over an example of a particular type of problem, you can indicate that here.\n",
    "\n",
    "Please remember that the best way to get quick feedback from the instructors as well as your peers, is to use Piazza.  However, consider using this channel if it doesn't make sense to post your note to Piazza."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}