day6_reading_journal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 6 Reading Journal\n",
    "\n",
    "This journal includes several required exercises, but it is meant to encourage active reading more generally.  You should use the journal to take detailed notes, catalog questions, and explore the content from Think Python deeply.\n",
    "\n",
    "Reading: Think Python Chapter 5.8-5.14, 6.5-6.11\n",
    "\n",
    "**Due: Monday, February 6 at 12 noon**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 5.8 - 5.14](http://www.greenteapress.com/thinkpython2/html/thinkpython2006.html)\n",
    "\n",
    "[Python Tutor](http://pythontutor.com/) can be helpful for visualizing stack diagrams, including for recursive execution.\n",
    "\n",
    "Chapter 5 leads into Chapter 6, and all the required exercises for this reading are in the Chapter 6 section.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 6.5 - 6.11](http://www.greenteapress.com/thinkpython2/html/thinkpython2007.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 6.4"
   },
   "source": [
    "### Exercise 6.1  \n",
    "\n",
    "Draw a stack diagram for the following program. What does the program print? \n",
    "\n",
    "You can do this on paper or using [Python Tutor](http://pythontutor.com/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "solution": "Exercise 6.4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 90\n",
      "8100\n"
     ]
    }
   ],
   "source": [
    "def b(z):\n",
    "    prod = a(z, z)\n",
    "    print(z, prod)\n",
    "    return prod\n",
    "\n",
    "def a(x, y):\n",
    "    x = x + 1\n",
    "    return x * y\n",
    "\n",
    "def c(x, y, z):\n",
    "    total = x + y + z\n",
    "    square = b(total)**2\n",
    "    return square\n",
    "\n",
    "x = 1\n",
    "y = x + 1\n",
    "\n",
    "print(c(x, y+3, x+y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "<Global Frame>\n",
    "x=1, y=2\n",
    "<c>\n",
    "x=1\n",
    "y=5\n",
    "z=3\n",
    "total = 9\n",
    "<b>\n",
    "z=9\n",
    "<a>\n",
    "x=9\n",
    "y=9\n",
    "<a>\n",
    "x=10\n",
    "y=9\n",
    "return 90\n",
    "<b>\n",
    "z=9\n",
    "prod 90\n",
    "Return value 90\n",
    "\n",
    "square = 8100\n",
    "return square = 8100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 6.6"
   },
   "source": [
    "### Exercise 6.3  \n",
    "\n",
    "A palindrome is a word that is spelled the same backward and forward, like “noon” and “redivider”. Recursively, a word is a palindrome if the first and last letters are the same and the middle is a palindrome.\n",
    "\n",
    "You can use the `first`, `last`, and `middle` helper functions defined in Think Python, or do the string slices inside your function directly. Be sure to think about your base cases.\n",
    "    \n",
    "Write a function called `is_palindrome` that takes a string argument and returns `True` if it is a palindrome and `False` otherwise. Remember that you can use the built-in function `len` to check the length of a string.\n",
    "\n",
    "Write some unit tests for your function (optionally using doctest) to show that it works as intended."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "solution": "Exercise 6.6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def first(word):\n",
    "    #first letter of the word\n",
    "    return word[0]\n",
    "\n",
    "def last(word):\n",
    "    #last letter of the word\n",
    "    return word[-1]\n",
    "\n",
    "def middle(word):\n",
    "    #middle letters of the word\n",
    "    return word[1:-1]\n",
    "\n",
    "def is_palindrome(word):\n",
    "    if len(word) <= 1:\n",
    "        return True\n",
    "    if first(word) != last(word):\n",
    "        #if first word is not equal to last word\n",
    "        return False\n",
    "    return is_palindrome(middle(word))\n",
    "\n",
    "print(is_palindrome('kiiik'))\n",
    "print(is_palindrome('ksq'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 6.6 challenge"
   },
   "source": [
    "### Challenge (optional)\n",
    "\n",
    "Use the word list from [Chapter 9.1](http://www.greenteapress.com/thinkpython2/html/thinkpython2010.html) Exercise 1 to find all of the palindromes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "Exercise 6.6 challenge"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 6.7"
   },
   "source": [
    "### Exercise 6.4  \n",
    "\n",
    "A number `a` is a power of `b` if it is divisible by `b` and `a/b` is a power of `b`. Write a function called `is_power` that takes parameters `a` and `b` and returns `True` if `a` is a power of `b`. Note: you will have to think about the base case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "solution": "Exercise 6.7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_power(a,b):\n",
    "    if b!=0 and a / b == 1:\n",
    "        #If b is not equal to 0 and a/b = 1\n",
    "        return True\n",
    "    elif b!=0 and a % b==0:\n",
    "        #IF b is not equal to 0 and the remainder of a/b is equal to 0, recurse the function\n",
    "        return is_power(a/b,b)\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "print(is_power(12,2))\n",
    "print(is_power(4,2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 6.8"
   },
   "source": [
    "### Challenge (optional) - Exercise 6.5  \n",
    "\n",
    "The greatest common divisor (GCD) of `a` and `b` is the largest number that divides both of them with no remainder.\n",
    "\n",
    "One way to find the GCD of two numbers is based on the observation that if `r` is the remainder when `a` is divided by `b`, then `gcd(a, b) = gcd(b, r)`. As a base case, we can use `gcd(a, 0) = a`.\n",
    "\n",
    "Write a function called `gcd` that takes parameters `a` and `b` and returns their greatest common divisor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "problem": "Exercise 6.8"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading Journal feedback\n",
    "\n",
    "[Please complete this short survey](https://docs.google.com/forms/d/e/1FAIpQLScQekhUrf6YYjpfQiAAbavLIA-IJklv_PX1BWbGgxj7JPolmw/viewform?c=0&w=1)\n",
    "\n",
    "If you have any comments on this Reading Journal, feel free to leave them in the survey linked above. This could include suggestions to improve the exercises, topics you'd like to see covered in class next time, or other feedback.\n",
    "\n",
    "If you have Python questions or run into problems while completing the reading, you should post them to Piazza instead so you can get a quick response before your journal is submitted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "feedback_response": true
   },
   "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
}