Challenging_Practice_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Exercise:-space-age\" data-toc-modified-id=\"Exercise:-space-age-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Exercise: space age</a></span></li><li><span><a href=\"#Exercise:-last-word\" data-toc-modified-id=\"Exercise:-last-word-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Exercise: last word</a></span></li><li><span><a href=\"#Exercise:-make-a-headline\" data-toc-modified-id=\"Exercise:-make-a-headline-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Exercise: make a headline</a></span></li><li><span><a href=\"#Exercise:-&quot;pretty-string&quot;\" data-toc-modified-id=\"Exercise:-&quot;pretty-string&quot;-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Exercise: \"pretty string\"</a></span></li><li><span><a href=\"#Exercise:-grep\" data-toc-modified-id=\"Exercise:-grep-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Exercise: grep</a></span></li><li><span><a href=\"#Exercise:-unpopular-blog-posts\" data-toc-modified-id=\"Exercise:-unpopular-blog-posts-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Exercise: unpopular blog posts</a></span></li><li><span><a href=\"#Exercise:-Anagram\" data-toc-modified-id=\"Exercise:-Anagram-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Exercise: Anagram</a></span></li><li><span><a href=\"#Exercise:-Fibonacci-numbers\" data-toc-modified-id=\"Exercise:-Fibonacci-numbers-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Exercise: Fibonacci numbers</a></span></li><li><span><a href=\"#Exercise:-Christmas-tree\" data-toc-modified-id=\"Exercise:-Christmas-tree-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>Exercise: Christmas tree</a></span></li><li><span><a href=\"#Exercise:-darts\" data-toc-modified-id=\"Exercise:-darts-10\"><span class=\"toc-item-num\">10&nbsp;&nbsp;</span>Exercise: darts</a></span></li><li><span><a href=\"#Exercise:-Layman's-Histogram-II\" data-toc-modified-id=\"Exercise:-Layman's-Histogram-II-11\"><span class=\"toc-item-num\">11&nbsp;&nbsp;</span>Exercise: Layman's Histogram II</a></span></li><li><span><a href=\"#Exercise:-hangman-I\" data-toc-modified-id=\"Exercise:-hangman-I-12\"><span class=\"toc-item-num\">12&nbsp;&nbsp;</span>Exercise: hangman I</a></span></li><li><span><a href=\"#Exercise:-hangman-II\" data-toc-modified-id=\"Exercise:-hangman-II-13\"><span class=\"toc-item-num\">13&nbsp;&nbsp;</span>Exercise: hangman II</a></span></li><li><span><a href=\"#Exercise:-transpose-matrix\" data-toc-modified-id=\"Exercise:-transpose-matrix-14\"><span class=\"toc-item-num\">14&nbsp;&nbsp;</span>Exercise: transpose matrix</a></span></li><li><span><a href=\"#Exercise:-Cows-and-Bulls\" data-toc-modified-id=\"Exercise:-Cows-and-Bulls-15\"><span class=\"toc-item-num\">15&nbsp;&nbsp;</span>Exercise: Cows and Bulls</a></span></li><li><span><a href=\"#Exercise:-prime-numbers\" data-toc-modified-id=\"Exercise:-prime-numbers-16\"><span class=\"toc-item-num\">16&nbsp;&nbsp;</span>Exercise: prime numbers</a></span></li><li><span><a href=\"#Exercise:-random-password\" data-toc-modified-id=\"Exercise:-random-password-17\"><span class=\"toc-item-num\">17&nbsp;&nbsp;</span>Exercise: random password</a></span></li><li><span><a href=\"#Exercise:-check-password-security\" data-toc-modified-id=\"Exercise:-check-password-security-18\"><span class=\"toc-item-num\">18&nbsp;&nbsp;</span>Exercise: check password security</a></span></li><li><span><a href=\"#Exercise:-poker-I\" data-toc-modified-id=\"Exercise:-poker-I-19\"><span class=\"toc-item-num\">19&nbsp;&nbsp;</span>Exercise: poker I</a></span></li><li><span><a href=\"#Exercise:-poker-II\" data-toc-modified-id=\"Exercise:-poker-II-20\"><span class=\"toc-item-num\">20&nbsp;&nbsp;</span>Exercise: poker II</a></span></li><li><span><a href=\"#Exercise:-spiral-matrix\" data-toc-modified-id=\"Exercise:-spiral-matrix-21\"><span class=\"toc-item-num\">21&nbsp;&nbsp;</span>Exercise: spiral matrix</a></span></li><li><span><a href=\"#Exercise:-diamond\" data-toc-modified-id=\"Exercise:-diamond-22\"><span class=\"toc-item-num\">22&nbsp;&nbsp;</span>Exercise: diamond</a></span></li><li><span><a href=\"#Exercise:-Tic-Tac-Toe-draw\" data-toc-modified-id=\"Exercise:-Tic-Tac-Toe-draw-23\"><span class=\"toc-item-num\">23&nbsp;&nbsp;</span>Exercise: Tic Tac Toe draw</a></span></li><li><span><a href=\"#Exercise:-Tic-Tac-Toe-winner\" data-toc-modified-id=\"Exercise:-Tic-Tac-Toe-winner-24\"><span class=\"toc-item-num\">24&nbsp;&nbsp;</span>Exercise: Tic Tac Toe winner</a></span></li><li><span><a href=\"#Exercise:-sum-of-its-parts\" data-toc-modified-id=\"Exercise:-sum-of-its-parts-25\"><span class=\"toc-item-num\">25&nbsp;&nbsp;</span>Exercise: sum of its parts</a></span></li><li><span><a href=\"#Exercise:-change\" data-toc-modified-id=\"Exercise:-change-26\"><span class=\"toc-item-num\">26&nbsp;&nbsp;</span>Exercise: change</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practice: Solutions <a class=\"tocSkip\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: space age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "secs_in_earth_year = 60 * 60 * 24 * 365.25\n",
    "\n",
    "def space_age(age, planet):\n",
    "    periods = dict(\n",
    "        earth=1,\n",
    "        mercury=0.2408467,\n",
    "        venus=0.61519726,\n",
    "        mars=1.8808158,\n",
    "        jupiter=11.862615,\n",
    "        saturn=29.447498\n",
    "    )\n",
    "    \n",
    "    secs_in_planet_year = dict()\n",
    "    for k, v in periods.items():\n",
    "        secs_in_planet_year[k] = secs_in_earth_year * v\n",
    "  \n",
    "    return round(age / secs_in_planet_year[planet], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: last word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "given = 'without,hello,bag,world,cat'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'world'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(given.split(','))[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'world'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(given.split(','), reverse=True)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'world'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splitted = given.split(',')\n",
    "splitted.sort()\n",
    "splitted[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: make a headline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "virus = 'computer virus spreads to humans'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This version concatenates the string using previous string version, word and a space in the end. We have to remove trailing space symbol using `str.strip()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Computer Virus Spreads to Humans'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = ''\n",
    "for word in virus.split():\n",
    "    if word != 'to':\n",
    "        word = word.capitalize()\n",
    "        \n",
    "    result += word + ' '\n",
    "\n",
    "result.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using list to collect words and then join them with space symbol (e.g. no need for strip() call)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Computer Virus Spreads to Humans'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = []\n",
    "for word in virus.split():\n",
    "    if word != 'to':\n",
    "        word = word.capitalize()\n",
    "        \n",
    "    result.append(word)\n",
    "    \n",
    "' '.join(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehension equvalent of the code above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Computer Virus Spreads to Humans'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [word.capitalize() if word != 'to' else word for word in virus.split()]\n",
    "' '.join(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice here that you can skip list creation syntax `[...]` if you pass comprehension as a parameter to the next function, thus creating a tuple comprehension. Brackets `(...)` are assumed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Computer Virus Spreads to Humans'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "' '.join(word.capitalize() if word != 'to' else word for word in virus.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: \"pretty string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Apple today posted quarterly revenue of $53.3 billion, an increase of 18% from the year-ago quarter.'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{} today posted quarterly revenue of ${:.1f} billion, an increase of {:.0%} from the year-ago quarter.' \\\n",
    "    .format('Apple', 53.34, 0.1764)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: grep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"\"\"\n",
    "The diamond kata takes as its input a letter, and outputs it in a diamond shape. Given a letter, it prints a diamond starting with 'A', with the supplied letter at the widest point.\n",
    "\n",
    "Requirements:\n",
    " * The first row contains one 'A'.\n",
    " * The last row contains one 'A'.\n",
    " * All rows, except the first and last, have exactly two identical letters.\n",
    " * All rows have as many trailing spaces as leading spaces. (This might be 0).\n",
    " * The diamond is horizontally symmetric.\n",
    " * The diamond is vertically symmetric.\n",
    " * The diamond has a square shape (width equals height).\n",
    " * The letters form a diamond shape.\n",
    " * The top half has the letters in ascending order.\n",
    " * The bottom half has the letters in descending order.\n",
    " * The four corners (containing the spaces) are triangles.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you let Jupyter output `text` contents, like so: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nThe diamond kata takes as its input a letter, and outputs it in a diamond shape. Given a letter, it prints a diamond starting with 'A', with the supplied letter at the widest point.\\n\\nRequirements:\\n * The first row contains one 'A'.\\n * The last row contains one 'A'.\\n * All rows, except the first and last, have exactly two identical letters.\\n * All rows have as many trailing spaces as leading spaces. (This might be 0).\\n * The diamond is horizontally symmetric.\\n * The diamond is vertically symmetric.\\n * The diamond has a square shape (width equals height).\\n * The letters form a diamond shape.\\n * The top half has the letters in ascending order.\\n * The bottom half has the letters in descending order.\\n * The four corners (containing the spaces) are triangles.\\n\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice strange `\\n` symbol combinations. These are [**newlines** or **end of line** symbols](https://en.wikipedia.org/wiki/Carriage_return) or sometimes incorrectly called **carriage return** symbols. When you print this symbol with `print`, it will move current printing position to the next line. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I\n",
      "like\n",
      "Python!\n",
      "And programming too!\n"
     ]
    }
   ],
   "source": [
    "print \"I\\nlike\\nPython!\"\n",
    "print \"And programming too!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please notice that `print` adds newline character at the end of your string by default (after \"...Python!\"). To suppress this behaviour, please use `print` like so (notice comma symbol after the argument in the first `print` call):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Muzzy. I like clocks.\n"
     ]
    }
   ],
   "source": [
    "print \"My name is Muzzy.\",\n",
    "print \"I like clocks.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use this \"invisible\" `\\n` symbol to, for example, find out how many lines in a multiline string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text.count(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or use it to split mutliline string to a list of lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['',\n",
       " \"The diamond kata takes as its input a letter, and outputs it in a diamond shape. Given a letter, it prints a diamond starting with 'A', with the supplied letter at the widest point.\",\n",
       " '',\n",
       " 'Requirements:',\n",
       " \" * The first row contains one 'A'.\",\n",
       " \" * The last row contains one 'A'.\",\n",
       " ' * All rows, except the first and last, have exactly two identical letters.',\n",
       " ' * All rows have as many trailing spaces as leading spaces. (This might be 0).',\n",
       " ' * The diamond is horizontally symmetric.',\n",
       " ' * The diamond is vertically symmetric.',\n",
       " ' * The diamond has a square shape (width equals height).',\n",
       " ' * The letters form a diamond shape.',\n",
       " ' * The top half has the letters in ascending order.',\n",
       " ' * The bottom half has the letters in descending order.',\n",
       " ' * The four corners (containing the spaces) are triangles.',\n",
       " '']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text.split(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To `grep` a list as usual:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The diamond kata takes as its input a letter, and outputs it in a diamond shape. Given a letter, it prints a diamond starting with 'A', with the supplied letter at the widest point.\n",
      " * The diamond is horizontally symmetric.\n",
      " * The diamond is vertically symmetric.\n",
      " * The diamond has a square shape (width equals height).\n",
      " * The letters form a diamond shape.\n"
     ]
    }
   ],
   "source": [
    "grepped = []\n",
    "\n",
    "for line in text.split(\"\\n\"):\n",
    "    if 'diamond' in line:\n",
    "        grepped.append(line)\n",
    "    \n",
    "print '\\n'.join(grepped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same result using comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The diamond kata takes as its input a letter, and outputs it in a diamond shape. Given a letter, it prints a diamond starting with 'A', with the supplied letter at the widest point.\n",
      " * The diamond is horizontally symmetric.\n",
      " * The diamond is vertically symmetric.\n",
      " * The diamond has a square shape (width equals height).\n",
      " * The letters form a diamond shape.\n"
     ]
    }
   ],
   "source": [
    "print '\\n'.join(line for line in text.split(\"\\n\") if 'diamond' in line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: unpopular blog posts\n",
    "\n",
    "Set is the natural type for finding intersection or difference or any other possible set operation between two lists. For example:\n",
    "\n",
    " * `s1 & s2` where **\\&** reads like **and**, e.g. find elements that are in s1 **and** s2, e.g. find **intersection**\n",
    " * `s1 | s2` where **\\|** reasds like **or**, e.g. **union**\n",
    " * `s1 - s2` -- leave only **s1** elements that do not exist in **s2**, e.g. find **difference**\n",
    " * [and so on](https://docs.python.org/2/library/sets.html).\n",
    " \n",
    "Also remember, that coercing list to set also removes duplicate elements.\n",
    "\n",
    "Since `published` is the superset and `views` is the subset of `published`, we can easily find what elements of `published` never viewed by our site visitors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Annual ninja parade once again passes through town unnoticed',\n",
       " 'Brain-dead teen, only capable of rolling her eyes and texting, to be euthanised',\n",
       " 'Bridge closure date: Thursday or October',\n",
       " 'Child bankrupts make-a-wish foundation with wish for unlimited wishes',\n",
       " 'Goat accused of robbery',\n",
       " 'Man accused of killing lawyer receives a new attorney',\n",
       " 'Mayor Parris to homeless: go home',\n",
       " 'Missippi\\xe2\\x80\\x99s literacy program shows improvement',\n",
       " 'Standard deviation not enough for perverted statistician'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "published = [\n",
    "    \"Child bankrupts make-a-wish foundation with wish for unlimited wishes\",\n",
    "    \"Archaeological dig uncovers ancient race of skeleton people\",\n",
    "    \"Standard deviation not enough for perverted statistician\",\n",
    "    \"Annual ninja parade once again passes through town unnoticed\",\n",
    "    \"Brain-dead teen, only capable of rolling her eyes and texting, to be euthanised\",\n",
    "    \"Cows lose their jobs as milk prices drop\",\n",
    "    \"Man accused of killing lawyer receives a new attorney\",\n",
    "    \"Missippi’s literacy program shows improvement\",\n",
    "    \"Breathing oxygen linked to staying alive\",\n",
    "    \"Bridge closure date: Thursday or October\",\n",
    "    \"Most earthquake damage is caused by shaking\",\n",
    "    \"Federal agents raid gun shop, find weapons\",\n",
    "    \"Voters to vote on whether to vote\",\n",
    "    \"Goat accused of robbery\",\n",
    "    \"One-armed man applauds the kindness of strangers\",\n",
    "    \"Marijuana issue sent to a joint committee\",\n",
    "    \"Mayor Parris to homeless: go home\"\n",
    "]\n",
    "\n",
    "views = [\n",
    "    \"Most earthquake damage is caused by shaking\",    \n",
    "    \"Archaeological dig uncovers ancient race of skeleton people\",    \n",
    "    \"Cows lose their jobs as milk prices drop\",\n",
    "    \"Voters to vote on whether to vote\",    \n",
    "    \"Breathing oxygen linked to staying alive\",\n",
    "    \"Most earthquake damage is caused by shaking\",\n",
    "    \"One-armed man applauds the kindness of strangers\",\n",
    "    \"Breathing oxygen linked to staying alive\",    \n",
    "    \"Voters to vote on whether to vote\",\n",
    "    \"Breathing oxygen linked to staying alive\",\n",
    "    \"Federal agents raid gun shop, find weapons\",\n",
    "    \"Voters to vote on whether to vote\",    \n",
    "    \"Marijuana issue sent to a joint committee\",\n",
    "    \"Breathing oxygen linked to staying alive\",    \n",
    "]\n",
    "\n",
    "set(published) - set(views)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Anagram\n",
    "\n",
    "Natural pythonic way to track number of different \"things\" is to use dictionaries.\n",
    "\n",
    "Two phrases are called **anagram** when a phrase contains exactly the same count of particular letters as an another phrase. Spaces are ignored. Here we create two dictionaries like so:\n",
    "\n",
    "- **d1**:\n",
    " * `letter1` => `number of occuriences in phrase1`\n",
    " * `letter2` => `number of occuriences in phrase1`\n",
    " * ...\n",
    "- **d2**:\n",
    " * `letter1` => `number of occuriences in phrase2`\n",
    " * `letter2` => `number of occuriences in phrase2`\n",
    " * ...\n",
    "\n",
    "And assume that two phrases are mutual anagrams if **d1** == **d2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 3, 'g': 1, 'm': 1, 'n': 1, 'r': 1}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count_letters(phrase):\n",
    "    result = {}\n",
    "    for letter in phrase:\n",
    "        if letter in result:\n",
    "            result[letter] += 1\n",
    "        else:\n",
    "            result[letter] = 1\n",
    "            \n",
    "        # same if-else but using ternary if:\n",
    "        # result[letter] = result[letter] + 1 if letter in result else 1\n",
    "        \n",
    "    return result\n",
    "\n",
    "count_letters('anagram')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above we are preventing `KeyError` with if-else but there's more convinient method `dict.get()` (if there are no such key return second argument) to achieve the same effect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 3, 'g': 1, 'm': 1, 'n': 1, 'r': 1}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count_letters(phrase):\n",
    "    result = {}\n",
    "    for letter in phrase:\n",
    "        result[letter] = result.get(letter, 0) + 1\n",
    "        \n",
    "    return result\n",
    "\n",
    "count_letters('anagram')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It appears there's a type called [Counter](https://docs.python.org/2/library/collections.html#collections.Counter) from module `collections` which is very similar to `dict` and is perfect for this task:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'a': 3, 'g': 1, 'm': 1, 'n': 1, 'r': 1})"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "# you can coerce it to dict if you want like: dict(Counter('anagram'))\n",
    "# but you really need not to, Counter has really the same look-and-feel, e.g. same interface as dictionary\n",
    "Counter('anagram')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare two phrases now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def anagram(phrase1, phrase2):\n",
    "    # you can use count_letters() here as well\n",
    "    c1 = Counter(phrase1)\n",
    "    c2 = Counter(phrase2)\n",
    "    \n",
    "    # don't forget to remove spaces\n",
    "    del c1[' ']\n",
    "    del c2[' ']\n",
    "        \n",
    "    return c1 == c2\n",
    "\n",
    "assert anagram('anagram', 'nag a ram')\n",
    "assert anagram('binary', 'brainy')\n",
    "assert anagram('funeral', 'real fun')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Fibonacci numbers\n",
    "\n",
    "By definition:\n",
    "\n",
    "\\begin{equation*}\n",
    "F_n = \\begin{cases}\n",
    "  0, & \\mbox{if } n\\mbox{=0} \\\\\n",
    "  1, & \\mbox{if } n\\mbox{=1} \\\\\n",
    "  F_{n-1} + F_{n-2}, & \\mbox{if } n\\mbox{>1}  \n",
    " \\end{cases}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fibonacci(N):\n",
    "    result = [0, 1]\n",
    "\n",
    "    for i in range(2, N):\n",
    "        result += [result[-1] + result[-2]]\n",
    "\n",
    "    return result[:N]\n",
    "\n",
    "fibonacci(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It appears that Fibonacci uses a [Recursive definition](https://en.wikipedia.org/wiki/Recursive_definition), e.g. next value can be computed from a number of previous values. Thus we can create a recursive function that will be more close to definition and more clear:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fibonacci(N):\n",
    "    if N <= 2:\n",
    "        return [0, 1][:N]\n",
    "\n",
    "    f = fibonacci(N - 1)\n",
    "    \n",
    "    return f + [f[-1] + f[-2]]\n",
    "\n",
    "fibonacci(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Btw it's a good place to use memoize pattern and decorators to avoid unnecessary computations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compute: fibonacci(1) = 1\n",
      "Compute: fibonacci(0) = 0\n",
      "Compute: fibonacci(2) = 1\n",
      "Take cached: fibonacci(1) = 1\n",
      "Compute: fibonacci(3) = 2\n",
      "Take cached: fibonacci(2) = 1\n",
      "Compute: fibonacci(4) = 3\n",
      "Take cached: fibonacci(3) = 2\n",
      "Compute: fibonacci(5) = 5\n",
      "Take cached: fibonacci(4) = 3\n",
      "Compute: fibonacci(6) = 8\n",
      "Take cached: fibonacci(5) = 5\n",
      "Compute: fibonacci(7) = 13\n",
      "Take cached: fibonacci(6) = 8\n",
      "Compute: fibonacci(8) = 21\n",
      "Take cached: fibonacci(7) = 13\n",
      "Compute: fibonacci(9) = 34\n",
      "Take cached: fibonacci(8) = 21\n",
      "Compute: fibonacci(10) = 55\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cache = {}\n",
    "\n",
    "def memoize(f):\n",
    "    def wrapper(N):\n",
    "        if N in cache:\n",
    "            print \"Take cached: fibonacci({}) = {}\".format(N, cache[N])\n",
    "            return cache[N]\n",
    "\n",
    "        result = f(N)\n",
    "        cache[N] = result\n",
    "        print \"Compute: fibonacci({}) = {}\".format(N, result)\n",
    "        return result\n",
    "    \n",
    "    return wrapper\n",
    "\n",
    "@memoize\n",
    "def fibonacci_number(N):\n",
    "    if N <= 1:\n",
    "        return N\n",
    "\n",
    "    return fibonacci_number(N - 1) + fibonacci_number(N - 2)\n",
    "\n",
    "fibonacci_number(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fibonacci numbers using iterators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci_iter():\n",
    "    x_1, x_2 = 0, -1\n",
    "\n",
    "    while x_1 <= 0: \n",
    "        x_2, x_1 = 0, x_2 + 1\n",
    "        yield x_1\n",
    "\n",
    "    while True:\n",
    "        x = x_2 + x_1\n",
    "        x_2, x_1 = x_1, x\n",
    "        yield x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = fibonacci_iter()\n",
    "\n",
    "[next(f) for i in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Christmas tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!!!!!!!*!!!!!!!\n",
      "!!!!!!***!!!!!!\n",
      "!!!!!*****!!!!!\n",
      "!!!!*******!!!!\n",
      "!!!*********!!!\n",
      "!!***********!!\n",
      "!*************!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "s = ''\n",
    "for i in range(1, 14, 2):\n",
    "    s += '!' * ((15 - i) // 2) + (i * '*') + '!' * ((15 - i) // 2) + '\\n'\n",
    "\n",
    "print s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: darts\n",
    "\n",
    "Pythagorean theorem:\n",
    "\n",
    "$$a^2 + b^2 = r^2$$\n",
    "\n",
    "or\n",
    "\n",
    "$$r = \\sqrt{a^2 + b^2}$$\n",
    "\n",
    "`sqrt()` is available in module `math`\n",
    "\n",
    "Run this cell to see illustrating picture:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Circle\n",
    "%matplotlib inline\n",
    "\n",
    "fig, ax = plt.subplots(subplot_kw={'aspect': 'equal'}, figsize=(20, 10))\n",
    "ax.add_patch(Circle((0, 0), radius=10, fc=\"b\"))\n",
    "ax.add_patch(Circle((0, 0), radius=5, fc=\"w\"))\n",
    "ax.add_patch(Circle((0, 0), radius=1, fc=\"r\"))\n",
    "\n",
    "ax.annotate('10 points', xy=(0, 0), xytext=(10, 10), arrowprops=dict(facecolor='black', shrink=0.05), fontsize=20)\n",
    "ax.annotate('5 points', xy=(2.5, -2.5), xytext=(10, -10), arrowprops=dict(facecolor='black', shrink=0), fontsize=20)\n",
    "ax.annotate('1 point', xy=(-5, -5), xytext=(-15, -10), arrowprops=dict(facecolor='black', shrink=0), fontsize=20)\n",
    "\n",
    "ax.set_xlim(-20, 20)\n",
    "ax.set_ylim(-15, 15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def score(x, y):\n",
    "    r = sqrt(x ** 2 + y ** 2)\n",
    "    \n",
    "    if r <= 1:\n",
    "        return 10\n",
    "    \n",
    "    if r <= 5:\n",
    "        return 5\n",
    "    \n",
    "    if r <= 10:\n",
    "        return 1\n",
    "    \n",
    "    return 0\n",
    "\n",
    "assert score(-9, 9) == 0\n",
    "assert score(0, 10) == 1\n",
    "assert score(4, 4) == 1\n",
    "assert score(5, 0) == 5\n",
    "assert score(0.8, -0.8) == 5\n",
    "assert score(0, -1) == 10\n",
    "assert score(-0.1, -0.1) == 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Layman's Histogram II\n",
    "\n",
    "This solution uses `itertools.groupby`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "random.seed(1)\n",
    "data = [random.gauss(100, 10) for i in range(100)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9\n",
      "0 1 2 3 4 5 6 7    \n",
      "    2 3 4 5 6 7    \n",
      "    2 3 4 5 6 7    \n",
      "    2 3 4 5 6 7    \n",
      "    2 3 4 5 6 7    \n",
      "    2 3 4 5 6 7    \n",
      "    2 3 4 5 6 7    \n",
      "    2 3 4 5 6 7    \n",
      "      3 4 5 6      \n",
      "      3 4 5 6      \n",
      "      3 4 5 6      \n",
      "      3 4 5        \n",
      "      3 4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4 5        \n",
      "        4          \n",
      "        4          \n"
     ]
    }
   ],
   "source": [
    "data_min = min(data)\n",
    "data_max = max(data)\n",
    "spread = data_max - data_min\n",
    "bins = 9\n",
    "binw = spread / bins\n",
    "\n",
    "d = [int((d - data_min) / binw) for d in data]\n",
    "\n",
    "from itertools import groupby\n",
    "dd = []\n",
    "for b, g in groupby(sorted(d)):\n",
    "    dd += [(b, len(list(g)))]\n",
    "    \n",
    "dd\n",
    "\n",
    "maxh = max(j for i, j in dd) \n",
    "\n",
    "for y in range(1, maxh + 1):\n",
    "    for b, x in dd:\n",
    "        print (b if x >= y else ' '),\n",
    "    print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: hangman I\n",
    "\n",
    "Using string concatenation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'__A___A__'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def guessing_hangman(letter):\n",
    "    secret = \"EVAPORATE\"\n",
    "    \n",
    "    result = ''\n",
    "    for s in secret:\n",
    "        if s == letter:\n",
    "            result += letter\n",
    "        else:\n",
    "            result += '_'\n",
    "            \n",
    "        # ternary if-else version\n",
    "        # result += letter if s == letter else '_'\n",
    "\n",
    "    return result\n",
    "\n",
    "guessing_hangman('A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Altering list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'__A___A__'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def guessing_hangman(letter):\n",
    "    secret = \"EVAPORATE\"\n",
    "    \n",
    "    result = ['_'] * len(secret)\n",
    "    for i, s in enumerate(secret):\n",
    "        if s == letter:\n",
    "            result[i] = letter\n",
    "            \n",
    "    return ''.join(result)\n",
    "\n",
    "guessing_hangman('A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'__A___A__'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def guessing_hangman(letter):\n",
    "    secret = \"EVAPORATE\"\n",
    "    \n",
    "    return ''.join(letter if s == letter else '_' for s in secret)\n",
    "\n",
    "guessing_hangman('A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: hangman II"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'E_A___A_E'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hangman_joiner(string1, string2):\n",
    "    result = ''\n",
    "    \n",
    "    for i, s1 in enumerate(string1):\n",
    "        s2 = string2[i]\n",
    "        \n",
    "        if s1 != '_':\n",
    "            result += s1\n",
    "        elif s2 != '_':\n",
    "            result += s2\n",
    "        else:\n",
    "            result += '_'\n",
    "            \n",
    "    return result\n",
    "\n",
    "hangman_joiner('__A___A__', 'E_______E')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes universal solution is shorter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'EVAP_RA_E'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def universal_hangman_joiner(*args):\n",
    "    result = ['_'] * len(args[0])\n",
    "    \n",
    "    for s in args:\n",
    "        for i, c in enumerate(s):\n",
    "            if c != '_':\n",
    "                result[i] = c\n",
    "        \n",
    "    return ''.join(result)\n",
    "\n",
    "universal_hangman_joiner('__A______', 'E_______E', '_V_P_R___', '______A__')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: transpose matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transpose(matrix):\n",
    "    height = len(matrix)\n",
    "    width = len(matrix[0])\n",
    "\n",
    "    result = [[None for i in range(height)] for j in range(width)]\n",
    "    \n",
    "    for i, row in enumerate(matrix):\n",
    "        for j, cell in enumerate(row):\n",
    "            result[j][i] = cell\n",
    "            \n",
    "    return result\n",
    "\n",
    "assert transpose([[1, 2, 3],\n",
    "                  [0, 0, 3],\n",
    "                  [9, 0, 3]]) \\\n",
    "                     == \\\n",
    "                 [[1, 0, 9],\n",
    "                  [2, 0, 0],\n",
    "                  [3, 3, 3]]\n",
    "\n",
    "assert transpose([[1, 2, 3, 0],\n",
    "                  [0, 0, 3, 0],\n",
    "                  [9, 0, 3, 0]]) \\\n",
    "                     == \\\n",
    "                 [[1, 0, 9],\n",
    "                  [2, 0, 0],\n",
    "                  [3, 3, 3],\n",
    "                  [0, 0, 0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Cows and Bulls\n",
    "\n",
    "**Algorithm:**\n",
    "\n",
    "Firstly, convert both numbers to strings just because it's easier to access elements at arbitrary positions when it's a string or a list-alike."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('1224', '1400')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "guess = 1224\n",
    "guessed = 1400\n",
    "\n",
    "guess = str(guess)\n",
    "guessed = str(guessed)\n",
    "\n",
    "guess, guessed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first count all guessed numbers disregarding position.\n",
    "\n",
    "\"Cows\" are guessed numbers with respect of position. If so, correct number of \"bulls\" is the number of all guessed numbers minus number of \"cows\".\n",
    "\n",
    "We store number of occuriences of each number in a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'1': 1, '2': 2, '4': 1}, {'0': 2, '1': 1, '4': 1})"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "guess_counter = {}\n",
    "for number in guess:\n",
    "    guess_counter[number] = guess_counter.get(number, 0) + 1\n",
    "\n",
    "guessed_counter = {}\n",
    "for number in guessed:\n",
    "    guessed_counter[number] = guessed_counter.get(number, 0) + 1\n",
    "    \n",
    "guess_counter, guessed_counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or just use `collections.Counter()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Counter({'1': 1, '2': 2, '4': 1}), Counter({'0': 2, '1': 1, '4': 1}))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "guess_counter = Counter(guess)\n",
    "guessed_counter = Counter(guessed)\n",
    "\n",
    "guess_counter, guessed_counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the number of bulls is the sum of all numbers guessed correctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bulls = 0\n",
    "for number, count in guessed_counter.items():\n",
    "    bulls += min(guess_counter[number], count)\n",
    "\n",
    "bulls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use `min()` because:\n",
    " * If guessed number has N occuriences of a number and guess has less then N, then bulls = guess\n",
    " * If guessed number has N occuriences of a number and guess has more then N, then bulls = guessed\n",
    " \n",
    "For example:\n",
    "  * Guessed is 4444 and guess is 4400 then min(4, 2) = 2\n",
    "  * Guessed is 4400 and guess is 4444 then min(2, 4) = 2\n",
    "  \n",
    "Shorter version of the loop above using `sum()` and list comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bulls = sum(min(guessed_counter[number], guess_counter[number]) for number in guessed_counter)\n",
    "bulls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, some of these \"bulls\" are \"cows\" actually.\n",
    "\n",
    "Cows are elements with the same value AND position. Value-position make an unique pair and `tuple()` and `set()` are natural types to deal with them.\n",
    "\n",
    "Converting both numbers to value-position pairs can be easily achieved with `enumerate()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, '1'), (1, '2'), (2, '2'), (3, '4')]\n",
      "[(0, '1'), (1, '4'), (2, '0'), (3, '0')]\n"
     ]
    }
   ],
   "source": [
    "guess_pairs = list(enumerate(guess))\n",
    "guessed_pairs = list(enumerate(guessed))\n",
    "\n",
    "print guess_pairs\n",
    "print guessed_pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find \"cows\", e.g. elements with the same value-position pairs we use `set()` and it's convenient operation of intersection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set([(0, '1')])\n"
     ]
    }
   ],
   "source": [
    "guessed_pairs = set(guessed_pairs)\n",
    "guess_pairs = set(guess_pairs)\n",
    "\n",
    "cows_pairs = guessed_pairs & guess_pairs\n",
    "print cows_pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, \"bulls\" are determined as the number of \"bulls\" minus \"cows\", but \"cows\" is just the number of elements in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cows = len(cows_pairs)\n",
    "bulls = bulls - len(cows_pairs)\n",
    "\n",
    "cows, bulls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complete solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "def cows_and_bulls(guessed, guess):\n",
    "    cows = bulls = 0\n",
    "    \n",
    "    guess = str(guess)\n",
    "    guessed = str(guessed)\n",
    "\n",
    "    guess_counter = Counter(guess)\n",
    "    guessed_counter = Counter(guessed)\n",
    "    \n",
    "    bulls = sum(min(guessed_counter[number], guess_counter[number]) for number in guessed_counter)\n",
    "            \n",
    "    guessed_pairs, guess_pairs = set(enumerate(str(guessed))), set(enumerate(str(guess)))\n",
    "\n",
    "    cows_pairs = guessed_pairs & guess_pairs\n",
    "            \n",
    "    return len(cows_pairs), bulls - len(cows_pairs)\n",
    "\n",
    "assert cows_and_bulls(1111, 2222) == (0, 0)\n",
    "assert cows_and_bulls(1111, 1111) == (4, 0)\n",
    "assert cows_and_bulls(1234, 4321) == (0, 4)\n",
    "assert cows_and_bulls(1234, 1439) == (2, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: prime numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_prime(number):\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: random password"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "settings = {\n",
    "    'min_length': 10,\n",
    "    'must_have_uppercase': True,\n",
    "    'must_have_special': True,\n",
    "    'alpha_less_then_percent': 0.7\n",
    "}\n",
    "\n",
    "def generate_password(settings):\n",
    "    return ''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: check password security"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "settings = {\n",
    "    'min_length': 10,\n",
    "    'must_have_uppercase': True,\n",
    "    'must_have_special': True,\n",
    "    'alpha_less_then_percent': 0.7\n",
    "}\n",
    "\n",
    "def test_password_security(settings, password):\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: poker I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_poker_hand():\n",
    "    return []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: poker II"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def best_hand_ranking(hand):\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: spiral matrix\n",
    "\n",
    " * 0 -- left\n",
    " * 1 -- down\n",
    " * 2 -- right\n",
    " * 3 -- up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pretty_matrix_print(matrix):\n",
    "    print '\\n'.join([\n",
    "            ''.join([\n",
    "                '{:3}'.format(item) for item in row\n",
    "                ]) for row in matrix\n",
    "        ])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1  2  3  4\n",
      " 12 13 14  5\n",
      " 11 16 15  6\n",
      " 10  9  8  7\n"
     ]
    }
   ],
   "source": [
    "def spiral_matrix(size):\n",
    "    def can_move(x, y):\n",
    "        return x < size \\\n",
    "            and x >= 0 \\\n",
    "            and y < size \\\n",
    "            and y >= 0 \\\n",
    "            and result[y][x] == 0\n",
    "    \n",
    "    result = [[0 for i in range(size)] for j in range(size)]\n",
    "    direction_to_vector = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n",
    "    \n",
    "    x = y = 0\n",
    "    direction = 0\n",
    "    vector = direction_to_vector[0]    \n",
    "    for i in range(size ** 2):\n",
    "        if not can_move(x + vector[0], y + vector[1]):\n",
    "            direction += 1\n",
    "            \n",
    "        vector = direction_to_vector[direction % 4]            \n",
    "        \n",
    "        result[y][x] = i + 1\n",
    "        \n",
    "        x += vector[0]\n",
    "        y += vector[1]        \n",
    "    \n",
    "    return result\n",
    "    \n",
    "pretty_matrix_print(spiral_matrix(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get rid of `direction` variable by using `itertools.cycle()` function that will cycle thru values endlessly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "10\n",
      "0\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "from itertools import cycle\n",
    "\n",
    "it = cycle([0, 10])\n",
    "print next(it)\n",
    "print next(it)\n",
    "print next(it)\n",
    "print next(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1  2  3  4\n",
      " 12 13 14  5\n",
      " 11 16 15  6\n",
      " 10  9  8  7\n"
     ]
    }
   ],
   "source": [
    "from itertools import cycle\n",
    "\n",
    "def spiral_matrix(size):\n",
    "    def can_move(x, y):\n",
    "        return x < size \\\n",
    "            and x >= 0 \\\n",
    "            and y < size \\\n",
    "            and y >= 0 \\\n",
    "            and result[y][x] == 0\n",
    "    \n",
    "    result = [[0 for i in range(size)] for j in range(size)]\n",
    "    \n",
    "    x = y = 0\n",
    "\n",
    "    it = cycle([(1, 0), (0, 1), (-1, 0), (0, -1)])\n",
    "    vector = next(it)\n",
    "    \n",
    "    for i in range(1, size ** 2 + 1):\n",
    "        if not can_move(x + vector[0], y + vector[1]):\n",
    "            vector = next(it)\n",
    "        \n",
    "        result[y][x] = i\n",
    "        \n",
    "        x += vector[0]\n",
    "        y += vector[1]        \n",
    "    \n",
    "    return result\n",
    "    \n",
    "pretty_matrix_print(spiral_matrix(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: diamond\n",
    "\n",
    "Please notice `abs()` inside `print_diamond()`. It is used to have one for-loop not two."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 4 3 2 1 0\n"
     ]
    }
   ],
   "source": [
    "for i in range(11):\n",
    "    print 5 - abs(5 - i),"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution to problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "...A...\n",
      "..B.B..\n",
      ".C...C.\n",
      "D.....D\n",
      ".C...C.\n",
      "..B.B..\n",
      "...A...\n"
     ]
    }
   ],
   "source": [
    "from string import ascii_uppercase as alphabet\n",
    "\n",
    "def print_diamond(letter):\n",
    "    last = alphabet.index(letter) + 1\n",
    "    side = last * 2 - 1\n",
    "\n",
    "    for i in range(side):\n",
    "        line = ['.'] * side\n",
    "        position = side / 2 - abs(side / 2 - i)\n",
    "        letter = alphabet[position]\n",
    "        \n",
    "        line[side / 2 - position] = letter\n",
    "        line[side - side / 2 + position - 1] = letter\n",
    "        \n",
    "        print ''.join(line)\n",
    "\n",
    "print_diamond('D')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Tic Tac Toe draw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_O_|___|_X_\n",
      "___|_X_|_O_\n",
      " X |   |   \n"
     ]
    }
   ],
   "source": [
    "game = [[2, 0, 1],\n",
    "        [0, 1, 2],\n",
    "        [1, 0, 0]]\n",
    "\n",
    "def cell(cell, bottom_line):\n",
    "    return [bottom_line, 'X', 'O'][cell]\n",
    "\n",
    "def row(row, bottom_line):\n",
    "    cells = []\n",
    "    for i in range(3):\n",
    "        cells.append(bottom_line + cell(row[i], bottom_line) + bottom_line)\n",
    "    \n",
    "    return '|'.join(cells)\n",
    "\n",
    "def board(game):\n",
    "    rows = []\n",
    "    for i in range(3):\n",
    "        rows.append(row(game[i], '_' if i < 2 else ' '))\n",
    "    \n",
    "    return '\\n'.join(rows)\n",
    "\n",
    "print board(game)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Tic Tac Toe winner\n",
    "\n",
    "Here we are reusing solution to **#11: transpose** problem. `transpose()` is used to rotate game 90 degrees so we can keep looking for identical in rows only.\n",
    "\n",
    "We use `set()` feauture to keep only unique elements of a sequence. If resulting set contains only one element -- this row contains equal elements. Take a look [at other](https://thispointer.com/python-check-if-all-elements-in-a-list-are-same-or-matches-a-condition/) ways to find equal elements of a list.\n",
    "\n",
    "Take a look at `check_winner()` and notice how boolean operators threat truish values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "None or \"I love\" or \"Python\" or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * **or** will try to evaluate condition until it finds **first truish** value, then it will return it.\n",
    " * **and** will try to evaluate condition until it finds **first falsish** value, then it will return it. If all values are truish, the last one will be returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love Python'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and 1 and \"I love Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and 1 and \"I love Python\" and False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This trick is usually used to give a variable some default value if falsish value passed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default value\n",
      "Defined value\n"
     ]
    }
   ],
   "source": [
    "def myfun(param):\n",
    "    param = param or \"Default value\"\n",
    "    return param\n",
    "\n",
    "print myfun(None)\n",
    "print myfun(\"Defined value\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution to problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run solution for 11'th problem to define transpose() function\n",
    "\n",
    "def check_row(row):\n",
    "    variability = list(set(row))\n",
    "    \n",
    "    return variability[0] if len(variability) == 1 else None\n",
    "\n",
    "def check_horizonals(game):\n",
    "    # make list of sets containing only unique elements of each row\n",
    "    rows_result = [check_row(game[i]) for i in range(3)]\n",
    "    \n",
    "    # filter out winning rows, e.g. throw away None results\n",
    "    winners = [result for result in rows_result if not result is None]\n",
    "\n",
    "    if len(winners) == 0:\n",
    "        return None\n",
    "    \n",
    "    return winners[0]\n",
    "\n",
    "def check_verticals(game):\n",
    "    return check_horizonals(transpose(game))\n",
    "\n",
    "def get_diagonal(game, row_calculator):\n",
    "    return [game[i][row_calculator(i)] for i in range(3)]\n",
    "\n",
    "# lambda i: i        -> left-top to right-bottom\n",
    "# lambda i: 2 - i    -> left-bottom to right-top\n",
    "def check_winner(game):\n",
    "    return check_horizonals(game) \\\n",
    "        or check_verticals(game) \\\n",
    "        or check_row(get_diagonal(game, lambda i: i)) \\\n",
    "        or check_row(get_diagonal(game, lambda i: 2 - i))\n",
    "\n",
    "winner_is_2 = [[2, 2, 0],\n",
    "               [2, 1, 0],\n",
    "               [2, 1, 1]]\n",
    "\n",
    "winner_is_1 = [[1, 2, 0],\n",
    "               [2, 1, 0],\n",
    "               [2, 1, 1]]\n",
    "\n",
    "winner_is_also_1 = [[0, 1, 0],\n",
    "                    [2, 1, 0],\n",
    "                    [2, 1, 1]]\n",
    "\n",
    "no_winner = [[1, 2, 0],\n",
    "             [2, 1, 0],\n",
    "             [2, 1, 2]]\n",
    "\n",
    "also_no_winner = [[1, 2, 0],\n",
    "                  [2, 1, 0],\n",
    "                  [2, 1, 0]]\n",
    "\n",
    "assert check_winner(winner_is_2) == 2\n",
    "assert check_winner(winner_is_1) == 1\n",
    "assert check_winner(winner_is_also_1) == 1\n",
    "assert check_winner(no_winner) == None\n",
    "assert check_winner(also_no_winner) == None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: sum of its parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1, 1], [1, 2], [2, 1], [3]]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum_combinations(N):\n",
    "    if N == 0:\n",
    "        return [[]]\n",
    "\n",
    "    if N == 1:\n",
    "        return [[1]]\n",
    "    \n",
    "    results = []\n",
    "    for i in range(1, N + 1):\n",
    "        subcombinations = sum_combinations(N - i)\n",
    "        for s in subcombinations:\n",
    "            results.append([i] + s)\n",
    "\n",
    "    return results\n",
    "\n",
    "sum_combinations(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: change\n",
    "\n",
    "Since we don't know how much iterations it will take to calculate the result, this is the case where **while** is convinient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coin_combinations(total, coins):\n",
    "#     print total\n",
    "    \n",
    "    if total == 0:\n",
    "        return [[]]\n",
    "    \n",
    "    if total == 1:\n",
    "        return [[1]]\n",
    "    \n",
    "    results = []\n",
    "    for coin in coins:\n",
    "        if coin <= total:\n",
    "            x = coin_combinations(total - coin, coins)\n",
    "\n",
    "            for s in x:\n",
    "                results.append([coin] + s)\n",
    "            \n",
    "    return results\n",
    "\n",
    "def find_minimum_coins(total, coins):\n",
    "    d = ((len(s), s) for s in coin_combinations(total, coins))\n",
    "    \n",
    "    return sorted(d, key=lambda x: x[0])[0][1]\n",
    "\n",
    "assert find_minimum_coins(25, [1, 5, 10, 25, 100]) == [25]\n",
    "assert find_minimum_coins(15, [1, 5, 10, 25, 100]) == [5, 10]\n",
    "assert find_minimum_coins(23, [1, 4, 15, 20, 50]) == [4, 4, 15]\n",
    "assert find_minimum_coins(63, [1, 5, 10, 21, 25]) == [21, 21, 21]\n",
    "assert find_minimum_coins(999, [1, 2, 5, 10, 20, 50, 100]) == [2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100]\n",
    "assert find_minimum_coins(21, [2, 5, 10, 20, 50]) == [2, 2, 2, 5, 10]\n",
    "assert find_minimum_coins(27, [4, 5]) == [4, 4, 4, 5, 5, 5]\n",
    "assert find_minimum_coins(0, [1, 5, 10, 21, 25]) == []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.16"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}