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": 1,
   "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greater(a,b):\n",
    "#your code here\n",
    "    if a > b:\n",
    "        return a\n",
    "    elif a < b:\n",
    "        return b\n",
    "    else:\n",
    "        return \"a = b\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.085s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_greater(greater)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Now write a function that returns the largest element on a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#your code here\n",
    "def greatest(lst):\n",
    "    \n",
    "    largest = lst[0]\n",
    "    for i in lst:\n",
    "        if i > largest:\n",
    "            largest = i\n",
    "\n",
    "    return largest\n",
    "\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.091s\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": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_all(lst):\n",
    "#your code here\n",
    "    total = 0\n",
    "    for i in lst:\n",
    "        total = total + i\n",
    "    \n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.093s\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": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mult_all(lst):\n",
    "#your code here\n",
    "    total = 1\n",
    "    for i in lst:\n",
    "        total = total * i\n",
    "    \n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.089s\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": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def oper_all(arr, oper = \"*\"):\n",
    "#your code here\n",
    "    if oper == \"*\":\n",
    "        total = 1\n",
    "        for i in arr:\n",
    "            total = total * i\n",
    "        return total\n",
    "    \n",
    "    elif oper == \"+\":\n",
    "        total = 0\n",
    "        for i in arr:\n",
    "            total = total + i\n",
    "        return total\n",
    "\n",
    "    else:\n",
    "          return \"Operator issue\"\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.090s\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": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "#your code here\n",
    "    x = 1\n",
    "    for i in range(1,n + 1):\n",
    "        x *= i\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.058s\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": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unique(lst_un):\n",
    "#your code here\n",
    "    lst = []\n",
    "\n",
    "    for i in lst_un:\n",
    "        if i not in lst:\n",
    "            lst.append(i)\n",
    "\n",
    "    return lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.113s\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": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mode_counter(arr):\n",
    "#your code here\n",
    "    counter = {}\n",
    "\n",
    "    for i in arr:\n",
    "        if i not in counter:\n",
    "            counter[i] = 1\n",
    "        else:\n",
    "            counter[i] += 1\n",
    "\n",
    "    max_key = max(counter, key=counter.get)\n",
    "\n",
    "    return max_key\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".............."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "......................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.072s\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": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def st_dev(list_sd):\n",
    "#your code here\n",
    "    if not list_sd:\n",
    "        return None\n",
    "\n",
    "\n",
    "    sum_i = 0\n",
    "    for i in list_sd:\n",
    "        sum_i += i\n",
    "\n",
    "    total_i = len(list_sd)\n",
    "    average = sum_i / total_i\n",
    "\n",
    "    variance = sum((i - average) ** 2 for i in list_sd)  \n",
    "    sd = (variance / (total_i-1)) ** 0.5  \n",
    "\n",
    "    return sd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "............"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "........................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.098s\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": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pangram(string):\n",
    "#your code here\n",
    "\n",
    "    string = string.lower()\n",
    "\n",
    "    alphabet = {chr(i): 0 for i in range(ord('a'), ord('z') + 1)}\n",
    "\n",
    "    for i in string:\n",
    "        if i.isalpha():\n",
    "            alphabet[i] += 1\n",
    "            \n",
    "\n",
    "    if 0 in alphabet.values():\n",
    "        return False\n",
    "    else:\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "..............................\n",
      "----------------------------------------------------------------------\n",
      "Ran 30 tests in 0.017s\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": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_alpha(string):\n",
    "#your code here\n",
    "    lst = []  # Initialize an empty list\n",
    "    word_count = 0\n",
    "\n",
    "    for i in string:\n",
    "        if i.isalpha():  # Check if the character is alphabetic\n",
    "            if word_count >= len(lst):  # Add a new entry if needed\n",
    "                lst.append(\"\")\n",
    "            lst[word_count] += i  # Append the character to the current word\n",
    "        else:\n",
    "            if word_count < len(lst):  # Increment word count for a new word\n",
    "                word_count += 1\n",
    "\n",
    "    lst=sorted(lst)\n",
    "\n",
    "    # Manually concatenate the words with spaces\n",
    "    result = \"\"\n",
    "    for i in range(len(lst)):\n",
    "        result += lst[i]  # Add the word\n",
    "        if i < len(lst) - 1:  # Add a space if it's not the last word\n",
    "            result += \",\"\n",
    "\n",
    "    return result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "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_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": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_pass(password):\n",
    "#your code here\n",
    "\n",
    "    if len(password)<8:\n",
    "            return False\n",
    "    \n",
    "    has_lowercase = any(char.islower() for char in password)\n",
    "    has_uppercase = any(char.isupper() for char in password)\n",
    "    has_digit = any(char.isdigit() for char in password)\n",
    "    has_special = any(not char.isalnum() and not char.isspace() for char in password)\n",
    "\n",
    "    if has_lowercase and has_uppercase and has_digit and has_special:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....................................................................................................\n",
      "----------------------------------------------------------------------\n",
      "Ran 100 tests in 0.071s\n",
      "\n",
      "OK\n"
     ]
    }
   ],
   "source": [
    "# This will test your function \n",
    "test_pass(check_pass)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}