DebjitHore_Function_Practice_Exercises.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.6.6"
    },
    "colab": {
      "name": "DebjitHore-Function Practice Exercises.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/DebjitHore/Python-Codes/blob/master/DebjitHore_Function_Practice_Exercises.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "syWTdBx5q7Sv"
      },
      "source": [
        "___\n",
        "\n",
        "<a href='https://www.udemy.com/user/joseportilla/'><img src='https://github.com/Pierian-Data/Complete-Python-3-Bootcamp/blob/master/Pierian_Data_Logo.png?raw=1'/></a>\n",
        "___\n",
        "<center><em>Content Copyright by Pierian Data</em></center>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7QjqxuRIq7S3"
      },
      "source": [
        "# Function Practice Exercises\n",
        "\n",
        "Problems are arranged in increasing difficulty:\n",
        "* Warmup - these can be solved using basic comparisons and methods\n",
        "* Level 1 - these may involve if/then conditional statements and simple methods\n",
        "* Level 2 - these may require iterating over sequences, usually with some kind of loop\n",
        "* Challenging - these will take some creativity to solve"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oL5cRkhXq7S4"
      },
      "source": [
        "## WARMUP SECTION:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qmdjEFuTq7S4"
      },
      "source": [
        "#### LESSER OF TWO EVENS: Write a function that returns the lesser of two given numbers *if* both numbers are even, but returns the greater if one or both numbers are odd\n",
        "    lesser_of_two_evens(2,4) --> 2\n",
        "    lesser_of_two_evens(2,5) --> 5"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "fxn0cKM5q7S4"
      },
      "source": [
        "def lesser_of_two_evens(a,b):\n",
        "  if a%2==0 and b%2==0:\n",
        "    if a>b:\n",
        "      return b\n",
        "    else:\n",
        "      return a \n",
        "  else:\n",
        "    if a>b:\n",
        "      return a\n",
        "    else:\n",
        "      return b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "c4hQm4yVq7S5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a4d9e87-7344-4342-84e5-637b1e96fbb5"
      },
      "source": [
        "# Check\n",
        "lesser_of_two_evens(2,4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "ACaIf60Jq7S6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5cdc8f71-6a40-4c15-e33b-5e1266a832fb"
      },
      "source": [
        "# Check\n",
        "lesser_of_two_evens(2,5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPdzCe9-q7S6"
      },
      "source": [
        "#### ANIMAL CRACKERS: Write a function takes a two-word string and returns True if both words begin with same letter\n",
        "    animal_crackers('Levelheaded Llama') --> True\n",
        "    animal_crackers('Crazy Kangaroo') --> False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "OIJUlEOXq7S7"
      },
      "source": [
        "def animal_crackers(text):\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "TYvUbKkfq7S8"
      },
      "source": [
        "# Check\n",
        "animal_crackers('Levelheaded Llama')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "6pfJYXJXq7S8"
      },
      "source": [
        "# Check\n",
        "animal_crackers('Crazy Kangaroo')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zE-EWzFCq7S9"
      },
      "source": [
        "#### MAKES TWENTY: Given two integers, return True if the sum of the integers is 20 *or* if one of the integers is 20. If not, return False\n",
        "\n",
        "    makes_twenty(20,10) --> True\n",
        "    makes_twenty(12,8) --> True\n",
        "    makes_twenty(2,3) --> False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "1D_5qoReq7S9"
      },
      "source": [
        "def makes_twenty(n1,n2):\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "jIB5Jn1oq7S9"
      },
      "source": [
        "# Check\n",
        "makes_twenty(20,10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "Dew5LKxAq7S-"
      },
      "source": [
        "# Check\n",
        "makes_twenty(2,3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HoYGTnGLq7S-"
      },
      "source": [
        "# LEVEL 1 PROBLEMS"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GzmoeOv6q7S-"
      },
      "source": [
        "#### OLD MACDONALD: Write a function that capitalizes the first and fourth letters of a name\n",
        "     \n",
        "    old_macdonald('macdonald') --> MacDonald\n",
        "    \n",
        "Note: `'macdonald'.capitalize()` returns `'Macdonald'`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "c4xU-3ruq7S-"
      },
      "source": [
        "def old_macdonald(name):\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "3DSEh3_lq7S_"
      },
      "source": [
        "# Check\n",
        "old_macdonald('macdonald')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BK7wmLQ2q7S_"
      },
      "source": [
        "#### MASTER YODA: Given a sentence, return a sentence with the words reversed\n",
        "\n",
        "    master_yoda('I am home') --> 'home am I'\n",
        "    master_yoda('We are ready') --> 'ready are We'\n",
        "    \n",
        "Note: The .join() method may be useful here. The .join() method allows you to join together strings in a list with some connector string. For example, some uses of the .join() method:\n",
        "\n",
        "    >>> \"--\".join(['a','b','c'])\n",
        "    >>> 'a--b--c'\n",
        "\n",
        "This means if you had a list of words you wanted to turn back into a sentence, you could just join them with a single space string:\n",
        "\n",
        "    >>> \" \".join(['Hello','world'])\n",
        "    >>> \"Hello world\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "tRAII1Mxq7S_"
      },
      "source": [
        "def master_yoda(text):\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "ahEyMOt7q7S_"
      },
      "source": [
        "# Check\n",
        "master_yoda('I am home')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "doSsIyULq7TA"
      },
      "source": [
        "# Check\n",
        "master_yoda('We are ready')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qm2jb6ycq7TA"
      },
      "source": [
        "#### ALMOST THERE: Given an integer n, return True if n is within 10 of either 100 or 200\n",
        "\n",
        "    almost_there(90) --> True\n",
        "    almost_there(104) --> True\n",
        "    almost_there(150) --> False\n",
        "    almost_there(209) --> True\n",
        "    \n",
        "NOTE: `abs(num)` returns the absolute value of a number"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "ux2CkLGYq7TA"
      },
      "source": [
        "def almost_there(n):\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "eVdhBa33q7TA"
      },
      "source": [
        "# Check\n",
        "almost_there(104)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "_BWJ64s-q7TA"
      },
      "source": [
        "# Check\n",
        "almost_there(150)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "hsbQeNXtq7TB"
      },
      "source": [
        "# Check\n",
        "almost_there(209)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OxRnek4iq7TB"
      },
      "source": [
        "# LEVEL 2 PROBLEMS"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TvHYVdA2q7TB"
      },
      "source": [
        "#### FIND 33: \n",
        "\n",
        "Given a list of ints, return True if the array contains a 3 next to a 3 somewhere.\n",
        "\n",
        "    has_33([1, 3, 3]) → True\n",
        "    has_33([1, 3, 1, 3]) → False\n",
        "    has_33([3, 1, 3]) → False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "NYVS9ujQq7TB"
      },
      "source": [
        "def has_33(nums):\n",
        "    for i in range(0, len(nums)-1):\n",
        "      if nums[i] == 3 and nums[i+1] ==3:\n",
        "        return True\n",
        "    return False\n",
        "      "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "2TNluAhLq7TB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c99a3c7e-ca32-4d3a-c964-d8cabe3c36fe"
      },
      "source": [
        "# Check\n",
        "has_33([1, 3, 3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "Rcf0-0gBq7TC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfb23f42-d05a-4ada-d844-222560aa7986"
      },
      "source": [
        "# Check\n",
        "has_33([1, 3, 1, 3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "p9_ab-GKq7TC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f2d7e700-f358-4d3e-9280-e80709b29540"
      },
      "source": [
        "# Check\n",
        "has_33([3, 1, 3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4GfiLxWvq7TC"
      },
      "source": [
        "#### PAPER DOLL: Given a string, return a string where for every character in the original there are three characters\n",
        "    paper_doll('Hello') --> 'HHHeeellllllooo'\n",
        "    paper_doll('Mississippi') --> 'MMMiiissssssiiippppppiii'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "zyGBWvcXq7TC"
      },
      "source": [
        "def paper_doll(text):\n",
        "  newtext=''\n",
        "  for i in range(len(text)):\n",
        "      newtext+=3*text[i]\n",
        "  return newtext"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "4e9llnkJq7TD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "5d87845d-65dd-4089-c93b-47adbe3198cd"
      },
      "source": [
        "# Check\n",
        "paper_doll('Hello')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'HHHeeellllllooo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "2x8DUCtEq7TD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "0c157600-db50-41c2-d0d5-2a66edbcea2d"
      },
      "source": [
        "# Check\n",
        "paper_doll('Mississippi')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'MMMiiissssssiiissssssiiippppppiii'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EgdHdg6aq7TD"
      },
      "source": [
        "#### BLACKJACK: Given three integers between 1 and 11, if their sum is less than or equal to 21, return their sum. If their sum exceeds 21 *and* there's an eleven, reduce the total sum by 10. Finally, if the sum (even after adjustment) exceeds 21, return 'BUST'\n",
        "    blackjack(5,6,7) --> 18\n",
        "    blackjack(9,9,9) --> 'BUST'\n",
        "    blackjack(9,9,11) --> 19"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "dsmKTY-Mq7TD"
      },
      "source": [
        "def blackjack(a,b,c):\n",
        "    if (a+b+c)<=21:\n",
        "      return a+b+c\n",
        "    elif (a+b+c)>21:\n",
        "      if a==11 or b ==11 or c==11:\n",
        "        s=(a+b+c)-10\n",
        "        if s<21:\n",
        "          return s\n",
        "      else:\n",
        "          print ('BUST')\n",
        "\n",
        "      "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "LlPyABs3q7TE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "312bfb62-a274-4f7a-c165-e93c17aeb46f"
      },
      "source": [
        "# Check\n",
        "blackjack(5,6,7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "18"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "Nn0v2-JAq7TE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5a457057-dd0e-4d17-bedf-36f6f65c3ebb"
      },
      "source": [
        "# Check\n",
        "blackjack(9,9,9)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "BUST\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "h9Twj5R5q7TE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "23e25ddc-8033-440a-bf51-6b7addea1a5b"
      },
      "source": [
        "# Check\n",
        "blackjack(9,9,11)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "19"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Y83NKC1q7TE"
      },
      "source": [
        "#### SUMMER OF '69: Return the sum of the numbers in the array, except ignore sections of numbers starting with a 6 and extending to the next 9 (every 6 will be followed by at least one 9). Return 0 for no numbers.\n",
        " \n",
        "    summer_69([1, 3, 5]) --> 9\n",
        "    summer_69([4, 5, 6, 7, 8, 9]) --> 9\n",
        "    summer_69([2, 1, 6, 9, 11]) --> 14"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "_s-FxHOmq7TE"
      },
      "source": [
        "def summer_69(arr):\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "Dpdnk9NWq7TF"
      },
      "source": [
        "# Check\n",
        "summer_69([1, 3, 5])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "u4uf661dq7TF"
      },
      "source": [
        "# Check\n",
        "summer_69([4, 5, 6, 7, 8, 9])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "BC5vS762q7TF"
      },
      "source": [
        "# Check\n",
        "summer_69([2, 1, 6, 9, 11])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3zxEMA0aq7TG"
      },
      "source": [
        "# CHALLENGING PROBLEMS"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NuTqi18yq7TG"
      },
      "source": [
        "#### SPY GAME: Write a function that takes in a list of integers and returns True if it contains 007 in order\n",
        "\n",
        "     spy_game([1,2,4,0,0,7,5]) --> True\n",
        "     spy_game([1,0,2,4,0,5,7]) --> True\n",
        "     spy_game([1,7,2,0,4,5,0]) --> False\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "vmL3i5C-q7TG"
      },
      "source": [
        "def spy_game(nums):\n",
        "  for i in range(0, len(nums)-1):\n",
        "    if nums[i:i+3]==[0,0,7]:\n",
        "      return True\n",
        "  return False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "5k1KeEA8q7TH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36309d2f-56f1-47b8-f975-b1352f7e1cb7"
      },
      "source": [
        "# Check\n",
        "spy_game([1,2,4,0,0,7,5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "JzniVuAMq7TH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "feb6af05-bffb-454f-fefa-aeb2d0eb48b3"
      },
      "source": [
        "# Check\n",
        "spy_game([1,0,2,4,0,5,7])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "GCjUXVIZq7TH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "10075ef1-afbc-474e-c9b5-5bdb889a3b96"
      },
      "source": [
        "# Check\n",
        "spy_game([1,7,2,0,4,5,0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cB7PiQXlq7TH"
      },
      "source": [
        "#### COUNT PRIMES: Write a function that returns the *number* of prime numbers that exist up to and including a given number\n",
        "    count_primes(100) --> 25\n",
        "\n",
        "By convention, 0 and 1 are not prime."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "Lu5ghUQCq7TH"
      },
      "source": [
        "def count_primes(num): \n",
        "  primes=[2]\n",
        "  if num<2:\n",
        "    return 0\n",
        "  for i in range (3,num):\n",
        "    for j in range (2, i):\n",
        "      if i%j==0:\n",
        "        break\n",
        "    else:\n",
        "        primes.append(i)\n",
        "  return len(primes)\n",
        "                "
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "bnYGq4RZq7TH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a010d7df-b16a-44d9-8059-076ff4ecef5a"
      },
      "source": [
        "# Check\n",
        "count_primes(100)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "25"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s8UMHRyAq7TI"
      },
      "source": [
        "### Just for fun:\n",
        "#### PRINT BIG: Write a function that takes in a single letter, and returns a 5x5 representation of that letter\n",
        "    print_big('a')\n",
        "    \n",
        "    out:   *  \n",
        "          * *\n",
        "         *****\n",
        "         *   *\n",
        "         *   *\n",
        "HINT: Consider making a dictionary of possible patterns, and mapping the alphabet to specific 5-line combinations of patterns. <br>For purposes of this exercise, it's ok if your dictionary stops at \"E\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "YrZI6wGJq7TI"
      },
      "source": [
        "def print_big(letter):\n",
        "  pass\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "dyyygJ1sq7TI"
      },
      "source": [
        "print_big('a')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_luc_pRKq7TI"
      },
      "source": [
        "## Great Job!"
      ]
    }
  ]
}