From 8d57c637ace7c09cb73665223c024f49eb8b61a4 Mon Sep 17 00:00:00 2001 From: Mitesh Parab Date: Wed, 8 Oct 2025 18:16:41 +0200 Subject: [PATCH] initial commit --- main.ipynb | 466 +++++++++++++++++++----- mod/__pycache__/testing.cpython-313.pyc | Bin 0 -> 20229 bytes 2 files changed, 373 insertions(+), 93 deletions(-) create mode 100644 mod/__pycache__/testing.cpython-313.pyc diff --git a/main.ipynb b/main.ipynb index b05630a..26ccd07 100644 --- a/main.ipynb +++ b/main.ipynb @@ -20,12 +20,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from mod.testing import *\n", - "import unittest" + "import unittest\n" ] }, { @@ -41,18 +41,23 @@ "metadata": {}, "outputs": [], "source": [ - "def greater(a,b):\n", - "#your code here" + "def greater(a, b):\n", + " test_greater(greater)\n", + "#your code here " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ - "# This will test your function \n", - "test_greater(greater)" + "def find_greater(a: 5, b: 10) -> int:\n", + " if a > b:\n", + " return a\n", + " else:\n", + " return b\n", + " print(find_greater(5, 10))" ] }, { @@ -76,18 +81,38 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "#your code here" - ] + "source": [] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# This will test your function \n", - "test_greatest(greatest)" + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "x = [3, 10, 5, 7, 4]\n", + "\n", + "def find_largest(numbers: list) -> int:\n", + " if numbers == []:\n", + " return None\n", + "\n", + " \n", + " largest = numbers[0]\n", + "\n", + " \n", + " for num in numbers:\n", + " if num > largest:\n", + " largest = num\n", + "\n", + " return largest\n", + "print( find_largest(x))\n" ] }, { @@ -99,12 +124,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ - "def sum_all(lst):\n", - "#your code here" + "def sum_all(lst):[5,2,3,4]\n" ] }, { @@ -113,10 +137,30 @@ "metadata": { "scrolled": true }, - "outputs": [], - "source": [ - "# This will test your function \n", - "test_sum(sum_all)" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14\n" + ] + } + ], + "source": [ + "def sum_all_while(lst):\n", + " total = 0\n", + " i = 0\n", + " while i < len(lst): \n", + " total = total + lst[i]\n", + " i = i + 1\n", + " return total\n", + "\n", + "# Test\n", + "print(sum_all_while([5, 2, 3, 4]))\n", + "\n", + "\n", + "\n", + "\n" ] }, { @@ -128,24 +172,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ - "def mult_all(lst):\n", - "#your code here" + "def mult_all(lst):[5,2,3,4]\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120\n" + ] + } + ], "source": [ - "# This will test your function \n", - "test_mult(mult_all)" + "\n", + "def multiply_all_while(lst):\n", + " product = 1\n", + " i = 0\n", + " while i < len(lst):\n", + " product = product * lst[i]\n", + " i += 1\n", + " return product\n", + "\n", + "print(multiply_all_while([5,2,3,4]))\n" ] }, { @@ -157,12 +216,46 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def oper_all(arr, oper = \"*\"):\n", - "#your code here" + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120\n" + ] + } + ], + "source": [ + "def oper_all(arr, oper = \"*\"):[5, 2, 3, 4]\n", + "def oper_all(arr, oper=\"*\"):\n", + " \"\"\"\n", + " Receives a list of numbers and an operator ('+' or '*').\n", + " Returns the result of applying the operation on all elements.\n", + " \"\"\"\n", + " \n", + " if arr == []:\n", + " # Return 0 for sum, 1 for multiplication if list is empty\n", + " return 0 if oper == \"+\" else 1\n", + " \n", + " if oper == \"+\":\n", + " result = 0\n", + " for num in arr:\n", + " result += num\n", + " return result\n", + " elif oper == \"*\":\n", + " result = 1\n", + " for num in arr:\n", + " result *= num\n", + " return result\n", + " else:\n", + " return None # Invalid operator\n", + "\n", + "\n", + "# 🧪 Example tests\n", + "print(oper_all([5, 2, 3, 4]))\n", + "\n" ] }, { @@ -171,8 +264,8 @@ "metadata": {}, "outputs": [], "source": [ - "# This will test your function \n", - "test_operations(oper_all)" + "\n", + "test_operations(oper_all)\n" ] }, { @@ -184,12 +277,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 69, "metadata": {}, "outputs": [], "source": [ - "def factorial(n):\n", - "#your code here" + "def factorial(n):5\n" ] }, { @@ -213,12 +305,34 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# This will test your function \n", - "test_factorial(factorial)" + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120\n" + ] + } + ], + "source": [ + " \n", + "def factorial(n):\n", + " if n < 0:\n", + " return None \n", + "\n", + " result = 1\n", + " for i in range(1, n + 1):\n", + " result = result * i \n", + "\n", + " return result \n", + "\n", + "\n", + "\n", + "print(factorial(5)) \n", + "\n", + "\n" ] }, { @@ -232,22 +346,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "metadata": {}, "outputs": [], "source": [ - "def unique(lst_un):\n", - "#your code here" + "def unique(lst_un):[10, 20, 30, 20, 10 , 40, 50 , 30]\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10, 20, 30, 40, 50]\n" + ] + } + ], "source": [ - "# This will test your function \n", - "test_unique(unique)" + "\n", + "def unique(lst_un):\n", + " \n", + " unique_lst = [] \n", + " \n", + " for item in lst_un:\n", + " if item not in unique_lst: \n", + " unique_lst.append(item)\n", + " \n", + " return unique_lst\n", + "\n", + "numbers = [10, 20, 30, 20, 10, 40, 50, 30]\n", + "print(unique(numbers)) \n" ] }, { @@ -260,12 +392,51 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], "source": [ "def mode_counter(arr):\n", - "#your code here" + " \"\"\"Return the mode (most frequent element) of a list.\"\"\"\n", + " if arr == []:\n", + " return None # empty list has no mode\n", + " \n", + " frequency = [] # list to store [element, count]\n", + " \n", + " # Count occurrences manually\n", + " for item in arr:\n", + " found = False\n", + " for pair in frequency:\n", + " if pair[0] == item:\n", + " pair[1] += 1 # increment count\n", + " found = True\n", + " break\n", + " if not found:\n", + " frequency.append([item, 1]) # add new element with count 1\n", + " \n", + " # Find the element with the highest count\n", + " max_count = 0\n", + " mode_value = None\n", + " for pair in frequency:\n", + " if pair[1] > max_count:\n", + " max_count = pair[1]\n", + " mode_value = pair[0]\n", + " \n", + " return mode_value\n", + "\n", + "\n", + "# Example usage\n", + "numbers = [1, 2, 3, 4, 2, 2, 1, 1, 4, 5, 1]\n", + "print(mode_counter(numbers)) # Output: 1\n", + "\n" ] }, { @@ -273,10 +444,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "# This will test your function \n", - "test_mode(mode_counter)" - ] + "source": [] }, { "cell_type": "markdown", @@ -292,18 +460,43 @@ "metadata": {}, "outputs": [], "source": [ - "def st_dev(list_sd):\n", - "#your code here" + "def st_dev(list_sd):\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ - "# This will test your function \n", - "test_stdev(st_dev)" + "\n", + "def st_dev(list_sd):\n", + " n = 0\n", + " for _ in list_sd:\n", + " n = n + 1\n", + " total = 0\n", + " for x in list_sd:\n", + " total = total + x\n", + " mean = total / n\n", + " variance_sum = 0\n", + " for x in list_sd:\n", + " diff = x - mean\n", + " variance_sum = variance_sum + diff * diff\n", + " if n > 1:\n", + " variance = variance_sum / (n - 1)\n", + " else:\n", + " variance = 0 \n", + " std_dev = variance ** 0.5\n", + " return std_dev \n", + "print()" ] }, { @@ -317,10 +510,37 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n" + ] + } + ], "source": [ "def pangram(string):\n", - "#your code here" + " def pangram(string):\n", + " \"\"\"Return True if string is a pangram, False otherwise.\"\"\"\n", + " \n", + " alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n", + " string = string.lower() \n", + " \n", + " for letter in alphabet:\n", + " if letter not in string:\n", + " return False \n", + " \n", + " return True \n", + "\n", + "\n", + "# 🧪 Example tests\n", + "print(pangram(\"The quick brown fox jumps over the lazy dog\")) # True\n", + "print(pangram(\"Hello World\")) # False\n", + "print(pangram(\"Pack my box with five dozen liquor jugs.\")) # True\n", + "\n" ] }, { @@ -344,12 +564,46 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apple,banana,cherry\n", + "ant,bird,cat,dog\n", + "ant,elephant,Lion,Zebra\n", + "\n" + ] + } + ], "source": [ + "\n", "def sort_alpha(string):\n", - "#your code here" + " \"\"\"Return comma-separated words sorted alphabetically (bubble sort).\"\"\"\n", + " \n", + " if string == \"\":\n", + " return \"\"\n", + " \n", + " # Split and strip spaces\n", + " words = [word.strip() for word in string.split(\",\")]\n", + " \n", + " # Bubble sort\n", + " n = len(words)\n", + " for i in range(n):\n", + " for j in range(0, n-i-1):\n", + " if words[j].lower() > words[j+1].lower():\n", + " words[j], words[j+1] = words[j+1], words[j]\n", + " \n", + " return \",\".join(words)\n", + "\n", + "\n", + "# 🧪 Example tests\n", + "print(sort_alpha(\"banana, apple, cherry\")) \n", + "print(sort_alpha(\"dog,cat,ant,bird\")) \n", + "print(sort_alpha(\"Zebra, elephant, Lion, ant\"))\n", + "print(sort_alpha(\"\")) \n" ] }, { @@ -357,10 +611,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "# This will test your function \n", - "test_alpha(sort_alpha)" - ] + "source": [] }, { "cell_type": "markdown", @@ -373,10 +624,47 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], "source": [ "def check_pass(password):\n", - "#your code here" + " \"\"\"Return True if password is strong, False otherwise.\"\"\"\n", + " \n", + " if len(password) < 8:\n", + " return False # too short\n", + " \n", + " has_lower = False\n", + " has_upper = False\n", + " has_digit = False\n", + " has_special = False\n", + " \n", + " special_chars = \"!@#$%^&*()-_+=<>?/.,\"\n", + " \n", + " for char in password:\n", + " if char.islower():\n", + " has_lower = True\n", + " elif char.isupper():\n", + " has_upper = True\n", + " elif char.isdigit():\n", + " has_digit = True\n", + " elif char in special_chars:\n", + " has_special = True\n", + " \n", + " return has_lower and has_upper and has_digit and has_special\n", + "\n", + "\n", + "# Test the function\n", + "print(check_pass(\"Abc123!@\")) \n", + "print(check_pass(\"abc123\")) \n", + "\n" ] }, { @@ -384,15 +672,12 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "# This will test your function \n", - "test_pass(check_pass)" - ] + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "base", "language": "python", "name": "python3" }, @@ -406,12 +691,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" - }, - "vscode": { - "interpreter": { - "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" - } + "version": "3.13.5" } }, "nbformat": 4, diff --git a/mod/__pycache__/testing.cpython-313.pyc b/mod/__pycache__/testing.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfaa10a732d81a4f78122d0a628894b2cff03e5e GIT binary patch literal 20229 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