Day3Functions-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On this lab we will put to practice some of the concepts we have learned on this past few days.\n",
    "\n",
    "`NOTE: On this lab you should try to write all the functions yourself using only the most basic of python syntax and without functions such as len, count, sum, max, min, in, etc. Give it a try. 🧑🏻‍💻👩🏻‍💻`\n",
    "\n",
    "The cell after each exercise contains a few tests to check if your function works as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mod.testing import *\n",
    "import unittest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Write a function that returns the greater of two numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greater(a, b):\n",
    "    if a > b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.046s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_greater(greater)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_greater(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(fn(*self.input), self.output, f\"Should be {self.output}\")\n",
    "    suite = unittest.TestSuite()\n",
    "    for _ in range(100):\n",
    "        a, b = random.randint(-1000, 1000), random.randint(-1000, 1000)\n",
    "        suite.addTest(TestKnown([a, b], max([a, b])))\n",
    "    unittest.TextTestRunner().run(suite)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Now write a function that returns the largest element on a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.059s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "def greatest(lst):\n",
    "    # Initialize the maximum with the first element\n",
    "    largest = lst[0]\n",
    "    for num in lst:\n",
    "        if num > largest:\n",
    "            largest = num\n",
    "    return largest\n",
    "\n",
    "# Test the function\n",
    "test_greatest(greatest)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.050s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_greatest(greatest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Write a function that sums all the elements on a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "import random\n",
    "\n",
    "# Function to sum all elements in a list\n",
    "def sum_all(lst):\n",
    "    total = 0\n",
    "    for element in lst:\n",
    "        total += element\n",
    "    return total\n",
    "\n",
    "# Test function provided\n",
    "def test_sum(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(fn(self.input), self.output, f\"Should be {self.output}\")\n",
    "    \n",
    "    suite = unittest.TestSuite()\n",
    "    for _ in range(100):\n",
    "        arr = [random.randint(-1000, 1000) for _ in range(random.randint(10, 100))]\n",
    "        suite.addTest(TestKnown(arr, sum(arr)))\n",
    "    \n",
    "    unittest.TextTestRunner().run(suite)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.047s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_sum(sum_all)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Write another function that multiplies all the elements on a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "import random\n",
    "from functools import reduce\n",
    "\n",
    "def mult_all(lst):\n",
    "    if not lst:  # Handle empty list\n",
    "        return 1\n",
    "\n",
    "    product = 1\n",
    "    for element in lst:\n",
    "        product *= element\n",
    "    return product\n",
    "\n",
    "def test_mult(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(fn(self.input), self.output, f\"Should be {self.output}\")\n",
    "    \n",
    "    suite = unittest.TestSuite()\n",
    "    for _ in range(100):\n",
    "        arr = [random.randint(-10, 10) for _ in range(random.randint(10, 100))]\n",
    "        suite.addTest(TestKnown(arr, reduce(lambda a, b: a * b, arr, 1)))\n",
    "    \n",
    "    unittest.TextTestRunner().run(suite)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.049s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_mult(mult_all)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Now combine those two ideas and write a function that receives a list and either \"+\" or \"*\" and outputs acordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.062s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "import unittest\n",
    "import random\n",
    "\n",
    "def test_operations(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(fn(*self.input), self.output, f\"Should be {self.output}\")\n",
    "\n",
    "    suite = unittest.TestSuite()\n",
    "    for _ in range(100):\n",
    "        arr = ([random.randint(-10, 10) for _ in range(random.randint(10, 100))], random.choice([\"+\", \"*\"]))\n",
    "        def ans(arr, op):\n",
    "            if op == \"+\":\n",
    "                return sum(arr)\n",
    "            else:\n",
    "                return reduce(lambda a, b: a * b, arr, 1)\n",
    "        suite.addTest(TestKnown(arr, ans(*arr)))\n",
    "    unittest.TextTestRunner().run(suite)\n",
    "\n",
    "def oper_all(arr, oper=\"*\"):\n",
    "    if oper == \"+\":\n",
    "        result = 0\n",
    "        for num in arr:\n",
    "            result += num\n",
    "    elif oper == \"*\":\n",
    "        result = 1\n",
    "        for num in arr:\n",
    "            result *= num\n",
    "    else:\n",
    "        raise ValueError(\"Invalid operation. Use '+' or '*'.\")\n",
    "    return result\n",
    "\n",
    "# Test the function\n",
    "test_operations(oper_all)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.053s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_operations(oper_all)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Write a function that returns the factorial of a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "import random\n",
    "import math\n",
    "\n",
    "def factorial(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "\n",
    "    result = 1\n",
    "    for i in range(2, n + 1):\n",
    "        result *= i\n",
    "    return result\n",
    "\n",
    "def test_factorial(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(fn(self.input), self.output, f\"Should be {self.output}\")\n",
    "    \n",
    "    suite = unittest.TestSuite()\n",
    "    for _ in range(100):\n",
    "        n = random.randint(1, 100)\n",
    "        suite.addTest(TestKnown(n, math.factorial(n)))\n",
    "    \n",
    "    unittest.TextTestRunner().run(suite)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "#factorial formula\n",
    "#n! = n * ( n - 1 ) *...*1\n",
    "\n",
    "# This code defines a function called \"factorial\" which takes an input \"n\". The function uses a for loop to iterate through the range of numbers \n",
    "# from 1 to n+1. For each number in that range, it multiplies the current value of x by the number in the range. At the end of the loop, \n",
    "# the function returns the final value of x, which will be the factorial of the input number \"n\".\n",
    "\n",
    "# The Factorial of a positive integer n is the product of all positive integers less than or equal to n. \n",
    "# For example, the factorial of 6 (written \"6!\") is 6 * 5 * 4 * 3 * 2 * 1 = 720.\n",
    "\n",
    "# So this function takes an input of any positive integer, and returns the factorial of that number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.051s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_factorial(factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Write a function that takes a list and returns a list of the unique values.\n",
    "\n",
    "`NOTE: You cannot use set. 🤔`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "import random\n",
    "\n",
    "def unique(lst_un):\n",
    "    unique_list = []\n",
    "    for element in lst_un:\n",
    "        is_unique = True\n",
    "        for unique_element in unique_list:\n",
    "            if element == unique_element:\n",
    "                is_unique = False\n",
    "                break\n",
    "        if is_unique:\n",
    "            unique_list.append(element)\n",
    "    return unique_list\n",
    "\n",
    "def test_unique(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(set(fn(self.input)), self.output, f\"Should be {self.output}\")\n",
    "    \n",
    "    suite = unittest.TestSuite()\n",
    "    for _ in range(100):\n",
    "        arr = [random.randint(-100, 100) for _ in range(random.randint(10, 1000))]\n",
    "        suite.addTest(TestKnown(arr, set(arr)))\n",
    "    \n",
    "    unittest.TextTestRunner().run(suite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.299s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_unique(unique)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Write a function that returns the mode of a list, i.e.: the element that appears the most times.\n",
    "`NOTE: You should not use count... 🧐`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "import random\n",
    "from statistics import mode\n",
    "\n",
    "def mode_counter(arr):\n",
    "    mode = None\n",
    "    max_count = 0\n",
    "    for i in arr:\n",
    "        count = 0\n",
    "        for j in arr:\n",
    "            if i == j:\n",
    "                count += 1\n",
    "        if count > max_count:\n",
    "            max_count = count\n",
    "            mode = i\n",
    "    return mode\n",
    "\n",
    "def test_mode(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(fn(self.input), self.output, f\"Should be {self.output}\")\n",
    "    \n",
    "    suite = unittest.TestSuite()\n",
    "    for _ in range(100):\n",
    "        arr = [random.randint(1, 25) for _ in range(random.randint(100, 125))] + 50 * [random.randint(1, 25)]\n",
    "        suite.addTest(TestKnown(arr, mode(arr)))\n",
    "    \n",
    "    unittest.TextTestRunner().run(suite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.134s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_mode(mode_counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Write a function that calculates the standard deviation of a list.\n",
    "`NOTE: Do not use any libraries or already built functions. 😉`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def st_dev(list_sd):\n",
    "    # Step 1: Calculate the mean\n",
    "    total = 0\n",
    "    for num in list_sd:\n",
    "        total += num\n",
    "    mean = total / len(list_sd)\n",
    "    \n",
    "    # Step 2: Calculate squared differences\n",
    "    squared_diffs = []\n",
    "    for num in list_sd:\n",
    "        squared_diffs.append((num - mean) ** 2)\n",
    "    \n",
    "    # Step 3: Calculate the variance (divide by n-1 for sample standard deviation)\n",
    "    variance_sum = 0\n",
    "    for diff in squared_diffs:\n",
    "        variance_sum += diff\n",
    "    variance = variance_sum / (len(list_sd) - 1)\n",
    "    \n",
    "    # Step 4: Calculate the standard deviation\n",
    "    std_dev = variance ** 0.5\n",
    "    return std_dev\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.055s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_stdev(st_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Write a function to check if a string is a pangram, i.e.: if it contains all the letters of the alphabet at least once. Mind that the strings may contain characters that are not letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to check if a string is a pangram\n",
    "def pangram(string):\n",
    "    # Alphabet to check against\n",
    "    alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "    # Convert the input string to lowercase\n",
    "    string = string.lower()\n",
    "    \n",
    "    # Check if each letter in the alphabet is present in the string\n",
    "    for letter in alphabet:\n",
    "        found = False\n",
    "        for char in string:\n",
    "            if char == letter:\n",
    "                found = True\n",
    "                break\n",
    "        if not found:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "# List of pangrams\n",
    "pangrams = [\n",
    "    \"Waltz, nymph, for quick jigs vex Bud.\",\n",
    "    \"Sphinx of black quartz, judge my vow.\",\n",
    "    \"Pack my box with five dozen liquor jugs.\",\n",
    "    \"Glib jocks quiz nymph to vex dwarf.\",\n",
    "    \"Jackdaws love my big sphinx of quartz.\",\n",
    "    \"The five boxing wizards jump quickly.\",\n",
    "    \"How vexingly quick daft zebras jump!\",\n",
    "    \"Quick zephyrs blow, vexing daft Jim.\",\n",
    "    \"Two driven jocks help fax my big quiz.\",\n",
    "    \"The jay, pig, fox, zebra and my wolves quack!\",\n",
    "    \"Sympathizing would fix Quaker objectives.\",\n",
    "    \"A wizard's job is to vex chumps quickly in fog.\",\n",
    "    \"Watch 'Jeopardy!', Alex Trebek's fun TV quiz game.\",\n",
    "    \"By Jove, my quick study of lexicography won a prize!\",\n",
    "    \"Waxy and quivering, jocks fumble the pizza.\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "..............................\n",
      "----------------------------------------------------------------------\n",
      "Ran 30 tests in 0.015s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_pangram(pangram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Write a function that receives a string of comma separated words and returns a string of comma separated words sorted alphabetically.\n",
    "\n",
    "`NOTE: You may use sorted but not split and definitely no join! 🤪`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_alpha(string):\n",
    "   \n",
    "    words = []\n",
    "    word = \"\"\n",
    "    for char in string:\n",
    "        if char == \",\":\n",
    "            words.append(word)\n",
    "            word = \"\"\n",
    "        else:\n",
    "            word += char\n",
    "    if word:  # Append the last word if any\n",
    "        words.append(word)\n",
    "\n",
    "    sorted_words = sorted(words)\n",
    "\n",
    "    result = \"\"\n",
    "    for i, word in enumerate(sorted_words):\n",
    "        if i > 0:\n",
    "            result += \",\"\n",
    "        result += word\n",
    "    return result\n",
    "\n",
    "import unittest\n",
    "import random\n",
    "from string import ascii_lowercase\n",
    "\n",
    "def test_alpha(fn):\n",
    "    class TestKnown(unittest.TestCase):\n",
    "        def __init__(self, input, output):\n",
    "            super(TestKnown, self).__init__()\n",
    "            self.input = input\n",
    "            self.output = output\n",
    "\n",
    "        def runTest(self):\n",
    "            self.assertEqual(fn(self.input), self.output, f\"Should be {self.output}\")\n",
    "    \n",
    "    suite = unittest.TestSuite()\n",
    "    tests = [\",\".join([\"\".join([random.choice(ascii_lowercase) for _ in range(random.randint(4, 10))]) for _ in range(random.randint(4, 25))]) for _ in range(100)]\n",
    "    for test in tests:\n",
    "        suite.addTest(TestKnown(test, \",\".join(sorted(test.split(\",\")))))\n",
    "    unittest.TextTestRunner().run(suite)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.066s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_alpha(sort_alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. Write a function to check if a given password is strong (at least 8 characters, at least one lower case, at least one upper case, at least one number and at least one special character). It should output True if strong and False if not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_pass(password):\n",
    "    # Define the required sets\n",
    "    lower = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "    upper = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "    digits = \"0123456789\"\n",
    "    special = \"#@!$%&()^*[]{}\"\n",
    "    \n",
    "    # Check conditions\n",
    "    has_lower = any(char in lower for char in password)\n",
    "    has_upper = any(char in upper for char in password)\n",
    "    has_digit = any(char in digits for char in password)\n",
    "    has_special = any(char in special for char in password)\n",
    "    is_long_enough = len(password) >= 8\n",
    "    \n",
    "    # Return True if all conditions are met, otherwise False\n",
    "    return has_lower and has_upper and has_digit and has_special and is_long_enough\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.056s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_pass(check_pass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.12.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}