A4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a88edfe2e70b6d87134bda645730086a",
     "grade": false,
     "grade_id": "cell-9c3dc90b172ad4c7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Assignment 4\n",
    "## Data Is Just My Type :D\n",
    "### Maximum grade: 29 / 26\n",
    "\n",
    "The purpose of this assignment is to:\n",
    "* Get familiar with the Set Data type\n",
    "* Function Definition\n",
    "* Learn to write recursive functions\n",
    "\n",
    "You are supposed to download this notebook, embed your answers to the questions in the cells below, and submit it through JupyterHub. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "50f3790aa6619a74f5b261d87e05d9ef",
     "grade": false,
     "grade_id": "cell-8c89169e14f0e9e7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def tester(student_answer, expected_answer = True):\n",
    "    return \"Congratulations, you have passed!\" if student_answer == expected_answer else f\"You have failed this test case. -- {student_answer} != {expected_answer}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a22b04c7f17fe53fdec399056caddf6e",
     "grade": false,
     "grade_id": "cell-05ad93a1c2846409",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Question 1a -  Increasing Numbers in List - First Occurence (3 points)\n",
    "\n",
    "Write a function `numIncreasing1(L)` that takes as input a list of numbers and returns a list of the __first__ sequence within that is increasing order, and has a length of at least 2.  If no increasing sequential numbers are found, (ie. the input list is in descending order) then naturally a list of just the first value is returned. \n",
    "\n",
    "Increasing sequence means for a number to be valid it has to be greater than the previous.\n",
    "\n",
    " + `[5, 2, 1, 3, 4]` returns `[1, 3, 4]`, because only the last 3 are in increasing order \n",
    " + `[-1, 1, 4, 2, 6]` returns `[-1, 1, 4]`\n",
    " + `[5, 1, 8, 9, 10, 100]` returns `[1, 8, 9, 10, 100]` \n",
    " + `[4, 1, 2, 3, 4, 2, 4, 6, 8]` returns `[1, 2, 3, 4]`\n",
    " \n",
    "Hint: _the `break` keyword may prove useful to exit a loop_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2832ced531242ad3afc80b496cbb983e",
     "grade": false,
     "grade_id": "cell-444a4ab27463ffd7",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def numIncreasing1(L):\n",
    "\n",
    "    increasing = [L[0]]\n",
    "    for i in range(1, len(L)):\n",
    "        \n",
    "        if( (L[i-1] >= L[i]) and (len(increasing) <= 2)):\n",
    "            increasing.clear()\n",
    "        \n",
    "        if((L[i-1] >= L[i]) and (len(increasing) > 2)):\n",
    "            return increasing\n",
    "        \n",
    "        increasing.append(L[i])\n",
    "            \n",
    "    return increasing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "133b2d8e8326ebb8761367f6678eefa6",
     "grade": false,
     "grade_id": "cell-740056f9709c9c8f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are my sample test cases correct?\n",
      "Question #1a Test Case #1: Congratulations, you have passed!\n",
      "Question #1a Test Case #2: Congratulations, you have passed!\n",
      "Question #1a Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Are my sample test cases correct?\")\n",
    "print(\"Question #1a Test Case #1:\", tester(numIncreasing1([5, 2, 1, 3, 4]), [1,3,4]))\n",
    "print(\"Question #1a Test Case #2:\", tester(numIncreasing1([2, 1, 4, 5, 6]), [1,4,5,6]))\n",
    "print(\"Question #1a Test Case #3:\", tester(numIncreasing1([1,2,3,4,4,3,4,5,6,7,7]), [1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e4daaef19c08e3eb6e1fe1ec2ec9f517",
     "grade": true,
     "grade_id": "cell-f3289e62bd137bda",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "280362a9d3659cd80e886fa4c69a85e0",
     "grade": true,
     "grade_id": "cell-65cdc4db9d70a421",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Hey, I am a hidden test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "23e9f7f0c1af292809b2381b3c1d73a8",
     "grade": false,
     "grade_id": "cell-493e7aa1c2fba922",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Question 1b: Increasing Numbers in List - Longest Streak (3 points)\n",
    "\n",
    "Now write a function `numIncreasing2(L)` which applies similar constraints from Question 1a except returns the __longest__ running sequence of increasing numbers `L`. If two sequences are the same length, return the first sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9b9ab7fb6b2bbefd598fa68f6d375dcd",
     "grade": false,
     "grade_id": "cell-7705867d2bca8d4f",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def numIncreasing2(s):\n",
    "    current = [s[0]]\n",
    "    highest = current.copy()\n",
    "    \n",
    "    for i in range(1, len(s)):\n",
    "        if( s[i-1] >= s[i] ):\n",
    "            current.clear()\n",
    "        \n",
    "        current.append(s[i])\n",
    "        \n",
    "        if(len(highest) < len(current)):\n",
    "            highest = current.copy()\n",
    "            \n",
    "    return highest\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "69143c094390ab6b5dfd076a68254ff3",
     "grade": false,
     "grade_id": "cell-4e89b13dfca3c670",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are my sample test cases correct?\n",
      "Question #1b Test Case #1: Congratulations, you have passed!\n",
      "Question #1b Test Case #2: Congratulations, you have passed!\n",
      "Question #1b Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Are my sample test cases correct?\")\n",
    "print(\"Question #1b Test Case #1:\", tester(numIncreasing2([5,4,3,2,1]), [5]))\n",
    "print(\"Question #1b Test Case #2:\", tester(numIncreasing2([1,2,3,4,5]), [1,2,3,4,5]))\n",
    "print(\"Question #1b Test Case #3:\", tester(numIncreasing2([1,2,3,4,4,3,4,5,6,7,7]), [3, 4, 5, 6, 7]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0169ba5ee51f74cf1fb72a6c52d01d76",
     "grade": true,
     "grade_id": "cell-27eedc6832cd070c",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Hey, I am a hidden test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d17b4d1c50af5df113b8af99e442d032",
     "grade": true,
     "grade_id": "cell-9752c47972a6e13e",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Hey, I am a hidden test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1c: Increasing Numbers in List - Default Arguments (2 points)\n",
    "\n",
    "Now that you have defined the behavior for both `numIncreasing1` and `numIncreasing2`, create a \"wrapper function\" `numIncreasing` which takes a list `L` of numbers and a boolean `longest` which by default is equal to `False`: \n",
    "\n",
    "- `numIncreasing1` is executed if `longest` is False \n",
    "- `numIncreasing2` is executed if `longest` is True\n",
    "\n",
    "The value of the function should be propogated, which means that you should return the output of the `numIncreasing1` or `numIncreasing2` function as if it were the output of `numIncreasing`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d17fde2fb95246332fff36c72d8e708c",
     "grade": false,
     "grade_id": "cell-4f1662bda2bb64cb",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def numIncreasing(L, longest):\n",
    "    if(longest):\n",
    "        return numIncreasing2(L)\n",
    "    else:\n",
    "        return numIncreasing1(L)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are my sample test cases correct?\n",
      "Question #1c Test Case #1: Congratulations, you have passed!\n",
      "Question #1c Test Case #2: Congratulations, you have passed!\n",
      "Question #1c Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Are my sample test cases correct?\")\n",
    "print(\"Question #1c Test Case #1:\", tester(numIncreasing([5,4,3,2,1], True), [5]))\n",
    "print(\"Question #1c Test Case #2:\", tester(numIncreasing([2, 1, 4, 5, 6], False), [1,4,5,6]))\n",
    "print(\"Question #1c Test Case #3:\", tester(numIncreasing([1,2,3,4,4,3,4,5,6,7,7], True), [3, 4, 5, 6, 7]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fcccab2551c0516e2285578a5dd36359",
     "grade": true,
     "grade_id": "cell-860f3a5db5d3d6dd",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Hey, I am a hidden test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8c3808e45ce8369dba93317ee0060615",
     "grade": true,
     "grade_id": "cell-3a32de1026482acd",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Hey, I am a hidden test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "315a9e21d55dadc2b5d703df1e72a66b",
     "grade": false,
     "grade_id": "cell-ce2a211e20ce67f7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "##  Question 2 : Playing with Sets (2 points)\n",
    "\n",
    "Write a function `uniqueSet(t)` which, when given a string seperated by spaces, will return a __set__ containing the words in the string. There should be no duplicates within the set, meaning all items in it are __unique__. Capitalizations should be ignored. \n",
    "\n",
    "For example: $$Hello \\equiv hello$$\n",
    "\n",
    "Now, you can assume that punctuation has been banished to the shadow realm for this question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b1a2724d7d1f0ec14e9a530c2a545d8a",
     "grade": false,
     "grade_id": "cell-7fe8c0405b18f890",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "import string \n",
    "\n",
    "def uniqueSet(t):\n",
    "    \n",
    "    for x in string.punctuation:\n",
    "        t = t.replace(x, '')\n",
    "    \n",
    "    word_list = t.split()\n",
    "    unique = []\n",
    "        \n",
    "    for i in word_list:\n",
    "        if (i not in unique):\n",
    "            unique.append(i)\n",
    "            \n",
    "    return set(unique)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b8e4fbf4824f1fa72797d3964dee4f61",
     "grade": false,
     "grade_id": "cell-43d94ccba610cb64",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are my sample test cases correct?\n",
      "Question #2 Test Case #1: Congratulations, you have passed!\n",
      "Question #2 Test Case #2: Congratulations, you have passed!\n",
      "Question #2 Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Are my sample test cases correct?\")\n",
    "print(\"Question #2 Test Case #1:\", tester(len(uniqueSet(\"Born too late to have invented the internet\")), 8))\n",
    "test2 = uniqueSet(\"Born too early to have entered the\")\n",
    "test2.add(\"matrix\")\n",
    "print(\"Question #2 Test Case #2:\", tester(len(test2), 8))\n",
    "test3 = uniqueSet(\"Born right on time\")\n",
    "test3.update([\"to\", \"browse\", \"Dank\", \"Memes\"])\n",
    "print(\"Question #2 Test Case #3:\", tester(len(test3), 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9a0d7e0186be1a74c5e86edf478eee97",
     "grade": true,
     "grade_id": "cell-0c9024dda3538da3",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fcbe53dd41313719c4550f255637f2df",
     "grade": true,
     "grade_id": "cell-0aa6c8c1f907d8f5",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8ae2b20f8824a4321e1219090d6d7897",
     "grade": false,
     "grade_id": "cell-356b09ecc63835c2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "##  Question 3: Partition the Values (3 points)\n",
    "\n",
    "The term **\"Partition\"** means to seperate 1 item into multiple sub-items. Commonly, you partition hard drives to make a dedicated space for a second Operating System.\n",
    "\n",
    "Given two lists of integers, `listA` and `listB`, write a function `partitionLists` that takes two list arguments and one optional boolean parameter `largerFirst` which defaults to `False`. \n",
    "\n",
    "Your function should return a tuple containing two sorted lists, where the first list is the same length as `listA`, and the second is the length of `listB`.  All the elements in `listA` must be __less than or equal__ to those in `listB`, and the lists should be by default __ascending__ order. **Basically, it is one big sorted list split in half so they are the same size as the original lists.**\n",
    "\n",
    "If `largerFirst` is `True`, then the elements in list A must be __greater than or equal to__ those in list B, and the lists should be in __descending__ order. Essentially, sort that big list in reverse order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c95e593a00505db5d0d4f58194b9479a",
     "grade": false,
     "grade_id": "cell-150c7a63ffd4c1db",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def partitionLists(listA, listB, largerFirst=False):\n",
    "    \n",
    "    megaList = listA + listB\n",
    "    \n",
    "    if largerFirst:\n",
    "        megaList.sort(reverse=True)\n",
    "    else:\n",
    "        megaList.sort()\n",
    "    \n",
    "    listA = megaList[:len(listA)]\n",
    "    listB = megaList[len(listA):]\n",
    "    \n",
    "    return (listA, listB)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "70c2fd88420e79e8d1cd2f6276bcb60d",
     "grade": false,
     "grade_id": "cell-1d4f3f1507c14fc8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are my sample test cases correct?\n",
      "Question #3 Test Case #1: Congratulations, you have passed!\n",
      "Question #3 Test Case #2: Congratulations, you have passed!\n",
      "Question #3 Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Are my sample test cases correct?\")\n",
    "print(\"Question #3 Test Case #1:\", \n",
    "      tester(\n",
    "          partitionLists([8,2,5,10], [4,5,6,3,7,5,3]), \n",
    "          ([2, 3, 3, 4], [5, 5, 5, 6, 7, 8, 10])\n",
    "      ))\n",
    "print(\"Question #3 Test Case #2:\", \n",
    "      tester(\n",
    "          partitionLists([1,4,56,723,5,7,34,1], [4,5,543,6,3,45,7,5,432,3,65]), \n",
    "          ([1, 1, 3, 3, 4, 4, 5, 5], [5, 6, 7, 7, 34, 45, 56, 65, 432, 543, 723])\n",
    "      ))\n",
    "print(\"Question #3 Test Case #3:\", \n",
    "      tester(\n",
    "          partitionLists([1,4,56,723,5,7,34,1], [4,5,543,6,3,45,7,5,432,3,65], True), \n",
    "          ([723, 543, 432, 65, 56, 45, 34, 7], [7, 6, 5, 5, 5, 4, 4, 3, 3, 1, 1])\n",
    "      ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "111d4199d113e2ce585a151d4da5a3d8",
     "grade": true,
     "grade_id": "cell-4c236c2200b391d8",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a9e05fe1997ce9d4750d4df7bf8c33c6",
     "grade": true,
     "grade_id": "cell-d1242aa57f1e409f",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST CELL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7b8801ba692167e44b8df3934e4ed4c2",
     "grade": false,
     "grade_id": "cell-3d7a9f2783b29953",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Question 4: Recursive Combinations (3 points)\n",
    "\n",
    "Given a set of `n` items, we can choose `k` of them in $_nC_k$ ways. That is, if we have `n=3` items (for instance, an apple, an orange, and a pear) and we want to select `k=2` of them, there are $_3C_2 = 3$  ways to do this (an apple and an orange, an orange and a pear, or an apple and a pear).\n",
    "\n",
    "We can compute $_nC_k$ recursively:\n",
    "\n",
    "$$ _nC_k = \\begin{cases} 1, & \\text{if } k = 0, \\\\ 0, & \\text{if } n < k, \\\\ _{n-1}C_{k-1} + _{n-1}C_{k}, & \\text{otherwise}. \\end{cases} $$\n",
    "\n",
    "Write a function choose(n,k) that recursively computes the number of ways you can choose `k` out of `n` items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e3a193948172b89fa1e4aee752701149",
     "grade": false,
     "grade_id": "cell-97ff437c45c12ddc",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def choose(n,k):\n",
    "    if (n < k):\n",
    "        return 0\n",
    "    \n",
    "    elif (k == 0):\n",
    "        return 1\n",
    "    \n",
    "    return (choose(n-1,k-1) + choose(n-1,k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cde08e127d4d4edfc73f8770770c9a10",
     "grade": false,
     "grade_id": "cell-ae1f915e12d402fe",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question #4 Test Case #1: Congratulations, you have passed!\n",
      "Question #4 Test Case #2: Congratulations, you have passed!\n",
      "Question #4 Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Question #4 Test Case #1:\", tester(choose(3, 2), 3))\n",
    "print(\"Question #4 Test Case #2:\", tester(choose(5, 3), 10))\n",
    "print(\"Question #4 Test Case #3:\", tester(choose(20, 10), 184756))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e89550a8dbf2047f23957bcf13af8026",
     "grade": true,
     "grade_id": "cell-e166d922f83ef13c",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "09803f6e042d30925c9069a5c8278f67",
     "grade": true,
     "grade_id": "cell-967520d88f1ddee1",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f9e1b8ae61f2c1fefee111ee58450183",
     "grade": false,
     "grade_id": "cell-364f74b3c9b6ce87",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Question 5a: Verifying Palindromes Recursively (3 points)\n",
    "\n",
    "A word is a palindrome if it reads the same forwards as it does backwards. For instance, `racecar` and `kayak` are both palindromes, whereas `computer` is not.\n",
    "\n",
    "Write a function that determines whether or not a given string is a palindrome. For this question, you must write your own function and test cases. Your function should be called `is_palindrome` and accept a single string as input, and return the boolean value `True` or `False` as output. Your function does not need to check anything with the input, you can assume that this function will only be passed entirely lowercase strings.\n",
    "\n",
    "Use the following recursive algorithm to check if a string is a palindrome: If the string is 0 or 1 items long, it is definitely a palindrome (by definition). If the string is 2 or more characters long, remove the first and last characters, check if they are equal. If they aren't, the string is not a palindrome, otherwise, check if the remainder of the string is a palindrome.\n",
    "\n",
    "If this question is not done recursively, you get no grades."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9f3ecd9f26565cc05b2ef6b1ba13f69e",
     "grade": false,
     "grade_id": "cell-7fbe4917a4099385",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Write your answer in this cell\n",
    "def is_palindrome(s):\n",
    "    if( len(s) <= 1 ):\n",
    "        return True\n",
    "    \n",
    "    if( (len(s) >= 2) and (s[0] != s[-1]) ):\n",
    "        return False\n",
    "    \n",
    "    return is_palindrome(s[1:-1])\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "eb31bb7a3163b9b95833883fa29764aa",
     "grade": false,
     "grade_id": "cell-3d07018c23b7a450",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question #5a Test Case #1: Congratulations, you have passed!\n",
      "Question #5a Test Case #2: Congratulations, you have passed!\n",
      "Question #5a Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Question #5a Test Case #1:\", tester(not is_palindrome(\"featherbed\")))\n",
    "print(\"Question #5a Test Case #2:\", tester(is_palindrome(\"boltonotlob\")))\n",
    "print(\"Question #5a Test Case #3:\", tester(is_palindrome(\"racecar\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "530eb9abe972bfac285a904fa1a449bb",
     "grade": true,
     "grade_id": "cell-a5becab389cd268f",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b8d16dea457cf751ed7e81a1d55ff0f6",
     "grade": true,
     "grade_id": "cell-a8b37e88effcb7df",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f0599fa514abd2d2c00de4b00ce0d50c",
     "grade": false,
     "grade_id": "cell-1817dc15e756cf03",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Question 5b: Improving our Palindrome Function (1 point)\n",
    "\n",
    "Let's improve the palindrome function so that it works with a sentence that has punctuation in it.\n",
    "First, write a function **only_letters(s)** that removes all punctuation (including spaces) from a given string and converts it to lowercase.\n",
    "\n",
    "For this question you may assume the string contains only letters, punctuation, numerical characters, and spaces. You may choose whether or not to use a recursive approach for this question.\n",
    "\n",
    "No need for recursion here; go crazy!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f442b664b1103199a290d0c47c087bda",
     "grade": false,
     "grade_id": "cell-a1b9f5ebbcf0d70d",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Write your answer in this cell\n",
    "from string import punctuation\n",
    "\n",
    "def only_letters(s):\n",
    "    s = s.lower()\n",
    "    s = s.replace(' ', '')\n",
    "    for x in string.punctuation:\n",
    "        s = s.replace(x, '')\n",
    "    \n",
    "    for i in s:\n",
    "        if i.isdigit():\n",
    "            s = s.replace(i, '')\n",
    "        \n",
    "    return s\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6146c4c2fb346bd219482288aa7edb16",
     "grade": false,
     "grade_id": "cell-478c0d25d634fa32",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question #5b Test Case: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Question #5b Test Case:\", tester(only_letters(\",.12 34A\"), \"a\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c7b6969249373aecca1f8ab524339c8e",
     "grade": true,
     "grade_id": "cell-a1caa4022bc7d9ca",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "d5946f1d093e573160c07d9c2d5fb379",
     "grade": false,
     "grade_id": "cell-c7387232f339182f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Question 5c: Combining the Two (2 points)\n",
    "\n",
    "Now, using the previous two functions, write a function **is_palindrome_plus(s)** that determines if a string is a palindrome or not, ignoring punctuation or letter case.\n",
    "\n",
    "**Note:** Because **Question 5a** was recursive, this function is also recursive. That is a property of combining the two functions after all. You don't need to go out of your way or anything, it will pass the recursion checker if you **USE Question 5a** here, which you should."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "539a1903484ff9b5a4a6ddc23baaf571",
     "grade": false,
     "grade_id": "cell-f65d34128c43a028",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Write your answer in this cell\n",
    "def is_palindrome_plus(s): \n",
    "    \n",
    "    return is_palindrome(only_letters(s))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4fedc2a2aebd1a21d8cc910e4dac32de",
     "grade": false,
     "grade_id": "cell-6abfc3f5497fc481",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question #5c Test Case #1: Congratulations, you have passed!\n",
      "Question #5c Test Case #2: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Question #5c Test Case #1:\", \n",
    "      tester(is_palindrome_plus(\"Do geese see God?\")))\n",
    "print(\"Question #5c Test Case #2:\", \n",
    "      tester(is_palindrome_plus(only_letters('go hang a salami, i\\'m a lasagna hog!'))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "848310bd06ab9c73d4caa8508abedb8f",
     "grade": true,
     "grade_id": "cell-587883d1c909c10b",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c8c1c67f0af9b117627783af9b29a78c",
     "grade": true,
     "grade_id": "cell-f3ee0ab48ffadaf8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9b80b98bd73aaca036cd2f76c1dc059b",
     "grade": false,
     "grade_id": "cell-3228258e3faf0f0d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Question 5d: Palindromic, but in Chunks (4 points)\n",
    "\n",
    "Given a string, I want you to tell me the smallest chunk size that makes a palindrome like effect. To understand this concept, let's look at some examples of various strings, and the smallest chunk size associated with it:\n",
    "\n",
    "- `racecar` - In this situaton, the chunk size is 1. `[\"r\", \"a\", \"c\", \"e\", \"c\", \"a\", \"r\"]` is the same forwards as it is backards.\n",
    "- `010801` - In this situaton, the chunk size is 2. `[\"01\", \"08\", \"01\"]` is the same forwards as it is backards.\n",
    "- `Nick Moore` - In this situaton, the chunk size is 10. `[\"Nick Moore\"]` is the same forwards as it is backwards, as it is only 1 item.\n",
    "\n",
    "This function doesn't have to be recursive. Also, every chunk need not be the same number of letters. For example, `car` with chunk size 2 is just `[\"ca\", \"r\"]`, as there aren't enough letters in the string anymore. Finally, we have removed the punctuation for you already, and the spaces are important (**space is a character!**), but you still need to account for uppercase letters, meaning you should make the entire string ONE case.\n",
    "\n",
    "Write a function called `chunk_palindrome` that takes a string and returns the integer number representing the \"chunk\" size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d31d226c3cfe8b13789def0ac4a6b98c",
     "grade": false,
     "grade_id": "cell-fb6f27715f17ebad",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def chunkList(s, n):\n",
    "    return [s[i:i+n] for i in range(0, len(s), n)]\n",
    "\n",
    "    \n",
    "def chunk_palindrome(s):\n",
    "    s = s.lower()\n",
    "    \n",
    "    if ( is_palindrome(s) ):\n",
    "        return 1\n",
    "    \n",
    "    for i in range(1, len(s)//2 ):\n",
    "        if ( is_palindrome(chunkList(s, i)) ):\n",
    "            return i\n",
    "    \n",
    "    return len(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "aa3b7f03f184489baac4df59e3630e71",
     "grade": false,
     "grade_id": "cell-ad323c3727393e81",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question #5d - Test Case #1: Congratulations, you have passed!\n",
      "Question #5d - Test Case #2: Congratulations, you have passed!\n",
      "Question #5d - Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Question #5d - Test Case #1:\", \n",
    "      tester(chunk_palindrome(\"Racecar\"), 1)\n",
    ")\n",
    "print(\"Question #5d - Test Case #2:\", \n",
    "      tester(chunk_palindrome(\"010801\"), 2)\n",
    ")\n",
    "print(\"Question #5d - Test Case #3:\", \n",
    "      tester(chunk_palindrome(\"Mark Hutchison\"), 14)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9cf16ee4277d50344ce2b07f7202e6d9",
     "grade": true,
     "grade_id": "cell-346c107bf241b680",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7f6ad28bf585c6920a2fda6bdff2ecd7",
     "grade": true,
     "grade_id": "cell-f9cf3b399a8fa53d",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dcfe634e319cfb7ca6750da3a782ed64",
     "grade": true,
     "grade_id": "cell-af05c46bbfd5a59e",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "75e6155eac4652b3da993fa1477e8ac7",
     "grade": true,
     "grade_id": "cell-fb07f5cdaad4bce1",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "338c0186abb295addb541657b2934129",
     "grade": true,
     "grade_id": "cell-1fa4955a86c5872e",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "75ad8e3480ada4cfeae402bc3aae1edb",
     "grade": false,
     "grade_id": "cell-7037dad8150ec470",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "##  Bonus: Recursive Encryption (3 points)\n",
    "\n",
    "Privacy has been a major talking point amongst many tech giants as of the past 2 years. Let's be creative and find a way to encrypt our messages to send to one another!\n",
    "\n",
    "Define a function `encrypt` which takes 3 arguments:\n",
    "* `msg` -  a non-empty string message\n",
    "* `shift` - a non-negative integer\n",
    "* `func` - a lambda function that takes one integer argument and returns an integer. For the math lovers (which means all of you) the type definition looks like this: $$Int \\rightarrow Int$$\n",
    "\n",
    "The secret sauce to this encryption method is that it will shift every character by some integer amount `shift`. For example 'h' shifted 5 characters is 'm'. When `shift` is positive value, the shifted char will move in the (right) direction based on nominal value. (Consult Ascii chart for more info: http://www.asciitable.com/). \n",
    "\n",
    "Therefore, we will go through every character `c` in the string and modify each by increasing the ordinal/nominal value by `shift` creating a new character `c'` (pronounced c-prime or /sē/yah/prīm/).\n",
    "\n",
    "Here's the catch, the shift for the **next** character will always change, as dictated by the lambda function `func`. The lambda function should receive as argument the **ordinal value of c' (`ord(c')`)** from that recursive call and return you a new `shift` integer value... (Oh yea, do this recursively; you'll thank me later.) But in the iterative sense, `func` supplies you with the **next** `shift` value for the **next proceeding** character.\n",
    "\n",
    "HINT: With a recursive solution, this can be as little as 2 lines of concise code; first defining a base case (string of length 1), and then computing the solution in terms of its own smaller subproblems (the remainder of string).\n",
    "\n",
    "WINK: Use `ord` and `chr` built ins. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5e3bc44ff8dbe3cad49f7686cab255ee",
     "grade": false,
     "grade_id": "cell-f250828c3b7fcde5",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def encrypt(msg, shift, func):\n",
    "    if (len(msg) == 0):\n",
    "        return \"\"\n",
    "    \n",
    "    new_ord = ord(msg[0])+shift\n",
    "    \n",
    "    return chr(new_ord) + encrypt(msg[1:], func(new_ord), func)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6bd644a58d91ea65decc36a755b52386",
     "grade": false,
     "grade_id": "cell-c975fec812ae733c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are my sample test cases correct?\n",
      "Bonus Test Case #1: Congratulations, you have passed!\n",
      "Bonus Test Case #2: Congratulations, you have passed!\n",
      "Bonus Test Case #3: Congratulations, you have passed!\n"
     ]
    }
   ],
   "source": [
    "print(\"Are my sample test cases correct?\")\n",
    "\n",
    "print(\"Bonus Test Case #1:\", \n",
    "      tester(encrypt(\"hello\",1, lambda x: (x + 1) % 10 ), \"iktsu\"))\n",
    "print(\"Bonus Test Case #2:\", \n",
    "      tester(encrypt(\"covfefe\",13, lambda x: x % 13 if x % 2 == 0 else x % 3), \"pwxiehe\"))\n",
    "print(\"Bonus Test Case #3:\", \n",
    "      tester(encrypt(\"precious\",12, lambda x: x + 1), \"|ïŕƹȣʓ̉ͽ\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a86f3f51c7cfcd4f4f5ec10fbddb9c98",
     "grade": true,
     "grade_id": "cell-f5569831a2b5ae4f",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9adb72f0cbb699278322346842e2e793",
     "grade": true,
     "grade_id": "cell-057993f6a5772739",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b05535e4c16b8526b1455fdc1423740d",
     "grade": true,
     "grade_id": "cell-f058097f9b6a8fb8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# HIDDEN TEST"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}