main.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": 3,
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.226s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "def greater(a,b):\n",
    "    if a > b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.155s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_greater(greater)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The greater number is: 20\n"
     ]
    }
   ],
   "source": [
    "#your code here\n",
    "# The greater of two numbers\n",
    "def greater(a,b):\n",
    "    if a > b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "    \n",
    "\n",
    "result = greater(10, 20)\n",
    "print(f\"The greater number is: {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Now write a function that returns the largest element on a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest element is: 1245\n"
     ]
    }
   ],
   "source": [
    "# Function for the largest number in a list\n",
    "\n",
    "def greatest(lst):\n",
    "    return max(lst)\n",
    "\n",
    "\n",
    "list = [5, 7, 23, 1245, 1]\n",
    "largest = greatest(list)\n",
    "print(f\"The largest element is: {largest}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.175s\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": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the elements is: 1281\n"
     ]
    }
   ],
   "source": [
    "# Function to sum all elements on a list\n",
    "def sum_all(lst):\n",
    "    return sum(lst)\n",
    "\n",
    "# Example usage:\n",
    "list = [5, 7, 23, 1245, 1]\n",
    "total = sum_all(list)\n",
    "print(f\"The sum of the elements is: {total}\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.277s\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": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The product of the elements is: 1002225\n"
     ]
    }
   ],
   "source": [
    "# Function that multiplies all elements in a list\n",
    "def mult_all(lst):\n",
    "    product = 1  # Initialize product to 1 (multiplicative identity)\n",
    "    for number in lst:\n",
    "        product *= number  # Multiply each element to product\n",
    "    return product\n",
    "\n",
    "# Example usage:\n",
    "list = [5, 7, 23, 1245, 1]\n",
    "result = mult_all(list)\n",
    "print(f\"The product of the elements is: {result}\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.159s\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": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "def process_list(lst, operation):\n",
    "    if operation == \"+\":\n",
    "        return sum(lst)  # Sum the elements if \"+\" is passed\n",
    "    elif operation == \"*\":\n",
    "        product = 1\n",
    "        for number in lst:\n",
    "            product *= number  # Multiply the elements if \"*\" is passed\n",
    "        return product\n",
    "    else:\n",
    "        return \"Invalid operation. Please use '+' for sum or '*' for multiplication.\"\n",
    "\n",
    "# Example usage:\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "print(process_list(numbers, \"+\"))  # Output: 15 (sum)\n",
    "print(process_list(numbers, \"*\"))  # Output: 120 (product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 3 is: 6\n"
     ]
    }
   ],
   "source": [
    "# Function that returns the factorial of a number\n",
    "\n",
    "def factorial(n):\n",
    "    if n < 0:\n",
    "        return \"Factorial is not defined for negative numbers\"\n",
    "    result = 1\n",
    "    for i in range(1, n + 1):\n",
    "        result *= i\n",
    "    return result\n",
    "\n",
    "# Example usage:\n",
    "number = 3\n",
    "print(f\"The factorial of {number} is: {factorial(number)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "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": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.124s\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": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The unique values are: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def unique_values(lst):\n",
    "    unique_lst = []  # Initialize an empty list to store unique values\n",
    "    for item in lst:\n",
    "        if item not in unique_lst:  # Check if the item is already in the unique list\n",
    "            unique_lst.append(item)  # Add the item if it's not already present\n",
    "    return unique_lst\n",
    "\n",
    "# Example usage:\n",
    "numbers = [1, 2, 2, 3, 4, 4, 5, 5, 5, 6]\n",
    "unique_numbers = unique_values(numbers)\n",
    "print(f\"The unique values are: {unique_numbers}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.531s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_unique(unique_values)"
   ]
  },
  {
   "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": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mode of the list is: 4\n"
     ]
    }
   ],
   "source": [
    "def mode_counter(arr):\n",
    "    frequency_dict = {}  # Dictionary to store frequency of each element\n",
    "    \n",
    "    # Iterate through the list and update frequencies\n",
    "    for item in arr:\n",
    "        if item in frequency_dict:\n",
    "            frequency_dict[item] += 1  # Increment count if item is already in the dictionary\n",
    "        else:\n",
    "            frequency_dict[item] = 1  # Add the item to the dictionary if not present\n",
    "\n",
    "    # Find the element with the highest frequency\n",
    "    mode = None\n",
    "    max_frequency = 0\n",
    "    for item, frequency in frequency_dict.items():\n",
    "        if frequency > max_frequency:\n",
    "            max_frequency = frequency\n",
    "            mode = item\n",
    "\n",
    "    return mode\n",
    "\n",
    "# Example usage:\n",
    "numbers = [1, 3, 3, 4, 2, 4, 4, 5, 4]\n",
    "mode_value = mode_counter(numbers)\n",
    "print(f\"The mode of the list is: {mode_value}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.325s\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": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The standard deviation is: 2.0\n"
     ]
    }
   ],
   "source": [
    "def st_dev(list_sd):\n",
    "    # Step 1: Calculate the mean\n",
    "    n = len(list_sd)\n",
    "    mean = sum(list_sd) / n\n",
    "    \n",
    "    # Step 2: Calculate the variance\n",
    "    variance = 0\n",
    "    for num in list_sd:\n",
    "        variance += (num - mean) ** 2  # Sum of squared differences from the mean\n",
    "    variance /= n  # Variance is the average of these squared differences\n",
    "    \n",
    "    # Step 3: Calculate the standard deviation (square root of variance)\n",
    "    std_dev = variance ** 0.5  # Using exponentiation to calculate square root\n",
    "    \n",
    "    return std_dev\n",
    "\n",
    "# Example usage:\n",
    "numbers = [2, 4, 4, 4, 5, 5, 7, 9]\n",
    "std_dev_value = st_dev(numbers)\n",
    "print(f\"The standard deviation is: {std_dev_value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "FF.FFF.F..FF.FF.FFF.FF..F...FFFF.FF.F.F..F..FF.FFFF..F.FFF.FF...FFF....F....FFF.F..FFFF..F.FF..F.FFF\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 510.24192838766646 != 517.0911197976059 within 5 delta (6.849191409939408 difference) : Should be 517.0911197976059\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 595.724061143071 != 609.7430159128888 within 5 delta (14.01895476981781 difference) : Should be 609.7430159128888\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 464.4900988214003 != 478.7854348735546 within 5 delta (14.295336052154312 difference) : Should be 478.7854348735546\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 640.9199937589715 != 654.1362294405246 within 5 delta (13.216235681553144 difference) : Should be 654.1362294405246\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 598.67754005596 != 604.5184348590741 within 5 delta (5.840894803114111 difference) : Should be 604.5184348590741\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 566.1791712828108 != 574.9576664258145 within 5 delta (8.778495143003738 difference) : Should be 574.9576664258145\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 580.5535472499413 != 589.0292298464019 within 5 delta (8.475682596460615 difference) : Should be 589.0292298464019\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 637.2110621903686 != 644.4114157332043 within 5 delta (7.200353542835728 difference) : Should be 644.4114157332043\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 471.1072331730102 != 480.43699498877703 within 5 delta (9.329761815766858 difference) : Should be 480.43699498877703\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 585.5162897988704 != 590.9128673797998 within 5 delta (5.396577580929375 difference) : Should be 590.9128673797998\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 533.962368734436 != 543.7606606629944 within 5 delta (9.798291928558342 difference) : Should be 543.7606606629944\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 567.9189426010214 != 574.640110783587 within 5 delta (6.721168182565634 difference) : Should be 574.640110783587\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 644.443804968594 != 650.8563390777161 within 5 delta (6.412534109122134 difference) : Should be 650.8563390777161\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 582.9747962989778 != 589.7146132264777 within 5 delta (6.739816927499874 difference) : Should be 589.7146132264777\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 369.9301360467346 != 386.37942570232775 within 5 delta (16.449289655593134 difference) : Should be 386.37942570232775\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 626.7680814332996 != 635.413566821563 within 5 delta (8.64548538826341 difference) : Should be 635.413566821563\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 537.5999348958294 != 566.6800880763521 within 5 delta (29.080153180522757 difference) : Should be 566.6800880763521\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 516.2439640325106 != 526.889289446401 within 5 delta (10.645325413890419 difference) : Should be 526.889289446401\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 545.1194875922107 != 552.2455349789471 within 5 delta (7.126047386736445 difference) : Should be 552.2455349789471\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 585.8915340303506 != 595.2663938415277 within 5 delta (9.374859811177089 difference) : Should be 595.2663938415277\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 537.6058418884963 != 543.2949510275765 within 5 delta (5.689109139080188 difference) : Should be 543.2949510275765\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 593.9821321731774 != 599.0807847648424 within 5 delta (5.0986525916649725 difference) : Should be 599.0807847648424\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 486.9959801792452 != 498.4562770927458 within 5 delta (11.4602969135006 difference) : Should be 498.4562770927458\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 615.6802208939313 != 628.3759941309025 within 5 delta (12.695773236971263 difference) : Should be 628.3759941309025\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 537.8173108313525 != 543.7602239585204 within 5 delta (5.9429131271679125 difference) : Should be 543.7602239585204\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 572.9862208660219 != 579.767358926139 within 5 delta (6.781138060117087 difference) : Should be 579.767358926139\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 574.0451888212847 != 581.7508381563282 within 5 delta (7.705649335043518 difference) : Should be 581.7508381563282\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 539.5354390584553 != 553.5516806567339 within 5 delta (14.016241598278611 difference) : Should be 553.5516806567339\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 548.4835197777269 != 553.6337127655361 within 5 delta (5.150192987809191 difference) : Should be 553.6337127655361\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 629.289467872298 != 649.9273677368367 within 5 delta (20.637899864538667 difference) : Should be 649.9273677368367\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 398.0312327220343 != 412.00146786608605 within 5 delta (13.970235144051742 difference) : Should be 412.00146786608605\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 578.5339232036804 != 585.7209555794278 within 5 delta (7.187032375747435 difference) : Should be 585.7209555794278\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 555.001490377267 != 571.0918221101102 within 5 delta (16.090331732843197 difference) : Should be 571.0918221101102\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 586.9740265159699 != 596.6767338611276 within 5 delta (9.702707345157705 difference) : Should be 596.6767338611276\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 545.325731876054 != 567.593017340183 within 5 delta (22.26728546412903 difference) : Should be 567.593017340183\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 703.5508757088885 != 737.8903835813408 within 5 delta (34.33950787245226 difference) : Should be 737.8903835813408\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 522.9044916980696 != 531.0120215639704 within 5 delta (8.107529865900801 difference) : Should be 531.0120215639704\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 578.0023159952893 != 588.6087477573774 within 5 delta (10.60643176208805 difference) : Should be 588.6087477573774\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 562.1213747937362 != 592.5279552711229 within 5 delta (30.406580477386683 difference) : Should be 592.5279552711229\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 588.1574624344096 != 605.2090358910573 within 5 delta (17.051573456647702 difference) : Should be 605.2090358910573\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 405.70791183094053 != 423.74809376526633 within 5 delta (18.0401819343258 difference) : Should be 423.74809376526633\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 604.2284392535005 != 611.5526877509986 within 5 delta (7.324248497498161 difference) : Should be 611.5526877509986\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 584.8646025412934 != 598.628005674216 within 5 delta (13.763403132922576 difference) : Should be 598.628005674216\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 528.6177876614622 != 543.9432159906236 within 5 delta (15.325428329161355 difference) : Should be 543.9432159906236\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 605.118374782984 != 612.8271998884163 within 5 delta (7.708825105432311 difference) : Should be 612.8271998884163\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 565.0187316592287 != 573.7792344172842 within 5 delta (8.760502758055509 difference) : Should be 573.7792344172842\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 600.2597850820734 != 605.7922502847412 within 5 delta (5.532465202667709 difference) : Should be 605.7922502847412\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 657.0956487452951 != 663.7668415942453 within 5 delta (6.671192848950227 difference) : Should be 663.7668415942453\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 574.6641965317747 != 580.6194249822053 within 5 delta (5.955228450430582 difference) : Should be 580.6194249822053\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 465.65834041709167 != 490.8469890573504 within 5 delta (25.188648640258748 difference) : Should be 490.8469890573504\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 506.5986461889796 != 512.0755474805203 within 5 delta (5.476901291540685 difference) : Should be 512.0755474805203\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 487.196890384165 != 513.5506141884491 within 5 delta (26.35372380428413 difference) : Should be 513.5506141884491\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 621.0596759629999 != 640.1736609518316 within 5 delta (19.113984988831703 difference) : Should be 640.1736609518316\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 542.0017242109282 != 548.5716819558794 within 5 delta (6.569957744951239 difference) : Should be 548.5716819558794\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 603.3741788143275 != 610.6880722617624 within 5 delta (7.313893447434907 difference) : Should be 610.6880722617624\n",
      "\n",
      "======================================================================\n",
      "FAIL: runTest (mod.testing.test_stdev.<locals>.TestKnown.runTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"c:\\Users\\s83me\\Desktop\\lab-functions-en\\mod\\testing.py\", line 142, in runTest\n",
      "    self.assertAlmostEqual(fn(self.input), self.output, delta=5, msg=f\"Should be {self.output}\")\n",
      "AssertionError: 604.6443528128165 != 634.1563472261969 within 5 delta (29.51199441338042 difference) : Should be 634.1563472261969\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.290s\n",
      "\n",
      "FAILED (failures=56)\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": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_pangram(s):\n",
    "    # Create a set of all 26 lowercase letters of the alphabet\n",
    "    alphabet = set(\"abcdefghijklmnopqrstuvwxyz\")\n",
    "    \n",
    "    # Convert the input string to lowercase and create a set of characters in the string\n",
    "    s = s.lower()\n",
    "    letters_in_string = set(char for char in s if char.isalpha())  # Only letters\n",
    "    \n",
    "    # Check if the set of letters in the string contains all letters in the alphabet\n",
    "    return letters_in_string >= alphabet  # True if all alphabet letters are present\n",
    "\n",
    "# Example usage:\n",
    "text = \"The quick brown fox jumps over a lazy dog.\"\n",
    "print(is_pangram(text))  # Output: True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "..............................\n",
      "----------------------------------------------------------------------\n",
      "Ran 30 tests in 0.083s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_pangram(is_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": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted string: apple,banana,grape,orange\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "def sort_comma_separated(words):\n",
    "    # Step 1: Manually split the string into a list of words\n",
    "    word_list = []\n",
    "    current_word = ''\n",
    "    \n",
    "    for char in words:\n",
    "        if char == ',':\n",
    "            word_list.append(current_word)  # Add the word to the list when a comma is found\n",
    "            current_word = ''  # Reset the current word\n",
    "        else:\n",
    "            current_word += char  # Build the word by adding characters\n",
    "    \n",
    "    # Append the last word (after the final comma)\n",
    "    word_list.append(current_word)\n",
    "\n",
    "    # Step 2: Sort the list of words alphabetically\n",
    "    sorted_words = sorted(word_list)\n",
    "\n",
    "    # Step 3: Rebuild the string of sorted words with commas\n",
    "    sorted_string = ''\n",
    "    \n",
    "    for i, word in enumerate(sorted_words):\n",
    "        if i == 0:\n",
    "            sorted_string = word  # Initialize with the first word\n",
    "        else:\n",
    "            sorted_string += ',' + word  # Append each word with a comma\n",
    "\n",
    "    return sorted_string\n",
    "\n",
    "# Example usage:\n",
    "input_string = \"banana,apple,orange,grape\"\n",
    "sorted_string = sort_comma_separated(input_string)\n",
    "print(f\"Sorted string: {sorted_string}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.210s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_alpha(sort_comma_separated)"
   ]
  },
  {
   "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": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Function to check password\n",
    "\n",
    "import re\n",
    "\n",
    "def check_pass(password):\n",
    "    # Check length\n",
    "    if len(password) < 8:\n",
    "        return False\n",
    "    \n",
    "    # Check for at least one lowercase letter\n",
    "    if not re.search(r'[a-z]', password):\n",
    "        return False\n",
    "    \n",
    "    # Check for at least one uppercase letter\n",
    "    if not re.search(r'[A-Z]', password):\n",
    "        return False\n",
    "    \n",
    "    # Check for at least one digit\n",
    "    if not re.search(r'[0-9]', password):\n",
    "        return False\n",
    "    \n",
    "    # Check for at least one special character\n",
    "    if not re.search(r'[!@#$%^&*(),.?\":{}|<>]', password):\n",
    "        return False\n",
    "    \n",
    "    return True\n",
    "\n",
    "# Example usage:\n",
    "passwords = [\"Password123!\", \"weakpassword\", \"Strong1@\", \"P@ssw0rd123\"]\n",
    "for pwd in passwords:\n",
    "    print(f\"'{pwd}' is strong: {check_pass(pwd)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'list' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[88], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# This will test your function \u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mpasswords\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcheck_pass\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'list' object is not callable"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "passwords(check_pass)"
   ]
  }
 ],
 "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.5"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}