From 5ed4e19d7f511ceaf08031f0156790e4e2750f9c Mon Sep 17 00:00:00 2001 From: Shyam-Gupta-Chiliveri Date: Wed, 8 Oct 2025 18:32:24 +0200 Subject: [PATCH 1/2] initial commit --- main.ipynb | 472 ++++++++++++++++++++---- mod/__pycache__/testing.cpython-313.pyc | Bin 0 -> 20233 bytes 2 files changed, 392 insertions(+), 80 deletions(-) create mode 100644 mod/__pycache__/testing.cpython-313.pyc diff --git a/main.ipynb b/main.ipynb index b05630a..a75187c 100644 --- a/main.ipynb +++ b/main.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -41,27 +41,42 @@ "metadata": {}, "outputs": [], "source": [ - "def greater(a,b):\n", - "#your code here" + "def greater_number(a, b):\n", + " \"\"\"Return the greater of two numbers.\"\"\"\n", + " if a > b:\n", + " return a\n", + " else:\n", + " return b" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "# This will test your function \n", - "test_greater(greater)" + "def test_greater(func):\n", + " print(greater_number(10, 5)) # Output: 10\n", + " print(greater_number(3, 8)) # Output: 8" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "8\n" + ] + } + ], "source": [ - "#your code here" + "# This will test your function \n", + "test_greater(greater)" ] }, { @@ -73,21 +88,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ - "#your code here" + "def largest_element(lst):\n", + " \"\"\"Return the largest element in a list.\"\"\"\n", + " if not lst:\n", + " return None\n", + " largest = lst[0]\n", + " for num in lst:\n", + " if num > largest:\n", + " largest = num\n", + " return largest\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], + "source": [ + "def test_largest(func):\n", + " print(largest_element([3, 1, 4, 1, 5, 9, 2, 6, 5])) # Output: 9\n", + " print(largest_element([])) # Output: None" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n", + "None\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_greatest(greatest)" + "test_largest(largest_element)" ] }, { @@ -99,21 +142,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of numbers: 36\n" + ] + } + ], "source": [ - "def sum_all(lst):\n", - "#your code here" + "numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]\n", + "sum_result = 0\n", + "for number in numbers:\n", + " sum_result += number\n", + "print(\"Sum of numbers:\", sum_result)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "....................................................................................................\n", + "----------------------------------------------------------------------\n", + "Ran 100 tests in 0.104s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# This will test your function \n", "test_sum(sum_all)" @@ -128,21 +194,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "def mult_all(lst):\n", - "#your code here" + " \"\"\"Return the product of all elements in a list.\"\"\"\n", + " if not lst:\n", + " return None\n", + " product = 1\n", + " for num in lst:\n", + " product *= num\n", + " return product\n", + "def test_mult(func):\n", + " print(mult_all([1, 2, 3, 4])) # Output: 24\n", + " print(mult_all([])) # Output: None" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24\n", + "None\n" + ] + } + ], "source": [ "# This will test your function \n", "test_mult(mult_all)" @@ -157,22 +241,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ - "def oper_all(arr, oper = \"*\"):\n", - "#your code here" + "def calculate(numbers, operation):\n", + " \"\"\"perform the specified operation sum or product on the list of numbers\"\"\"\n", + " if operation == 'sum':\n", + " return sum(numbers)\n", + " elif operation == 'product':\n", + " return mult_all(numbers)\n", + " else:\n", + " return None\n", + "def test_calculate(func):\n", + " print(calculate([1, 2, 3, 4], 'sum')) # Output: 10\n", + " print(calculate([1, 2, 3, 4], 'product')) # Output: 24\n", + " print(calculate([1, 2, 3, 4], 'average')) # Output: None" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "24\n", + "None\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_operations(oper_all)" + "test_calculate(calculate)" ] }, { @@ -184,17 +288,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ "def factorial(n):\n", - "#your code here" + " \"\"\"Return the factorial of a number.\"\"\"\n", + " print(n, '!')\n", + " # Corner case: 0! and negative numbers both return 1\n", + " if n <= 0:\n", + " return 1\n", + " else:\n", + " # Recursive case: n! = n * (n-1)!\n", + " result = n * factorial(n - 1)\n", + " return result\n", + "\n", + "\n", + "def test_factorial(func):\n", + " print(func(5)) # Expected output: 120\n", + " print(func(0)) # Expected output: 1\n", + " print(func(-3)) # Expected output: 1" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -213,9 +331,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 !\n", + "4 !\n", + "3 !\n", + "2 !\n", + "1 !\n", + "0 !\n", + "120\n", + "0 !\n", + "1\n", + "-3 !\n", + "1\n" + ] + } + ], "source": [ "# This will test your function \n", "test_factorial(factorial)" @@ -232,19 +368,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ "def unique(lst_un):\n", - "#your code here" + " \"\"\"Return a list of unique elements from the input list.\"\"\"\n", + " unique_list = []\n", + " for item in lst_un:\n", + " if item not in unique_list:\n", + " unique_list.append(item)\n", + " return unique_list\n", + "def test_unique(func):\n", + " print(unique([1, 2, 2, 3, 4, 4, 5])) # Output: [1, 2, 3, 4, 5]\n", + " print(unique([])) # Output: []" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5]\n", + "[]\n" + ] + } + ], "source": [ "# This will test your function \n", "test_unique(unique)" @@ -260,19 +413,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "metadata": {}, "outputs": [], "source": [ - "def mode_counter(arr):\n", - "#your code here" + "def find_mode(numbers):\n", + " \"\"\"Return the mode of a list (the element that appears most often).\"\"\"\n", + " \n", + " if not numbers:\n", + " return None # Handle empty list\n", + " \n", + " # Step 1: Count occurrences using a dictionary\n", + " frequency = {} # empty dictionary\n", + " for num in numbers:\n", + " if num in frequency:\n", + " frequency[num] += 1 # increment count\n", + " else:\n", + " frequency[num] = 1 # first occurrence\n", + " \n", + " # Step 2: Find the number with the maximum count\n", + " mode = None\n", + " max_count = 0\n", + " for num, count in frequency.items():\n", + " if count > max_count:\n", + " max_count = count\n", + " mode = num\n", + " return mode\n", + "def test_mode(func):\n", + " print(mode([1, 2, 3, 4, 5, 5, 5])) # Output: 2\n", + " print(mode([1, 1, 2, 2, 3])) # Output: 1 or 2 (any one of the modes)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "1\n" + ] + } + ], "source": [ "# This will test your function \n", "test_mode(mode_counter)" @@ -288,19 +473,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 106, "metadata": {}, "outputs": [], "source": [ "def st_dev(list_sd):\n", - "#your code here" + " \"\"\"Return the standard deviation of a list of numbers.\"\"\"\n", + " if not list_sd:\n", + " return None # Handle empty list\n", + " \n", + " n = len(list_sd)\n", + " mean = sum(list_sd) / n\n", + " squared_diffs = [(x - mean) ** 2 for x in list_sd]\n", + " variance = sum((x - mean) ** 2 for x in list_sd) / n\n", + " std_deviation = variance ** 0.5\n", + " return std_deviation\n", + "def test_stdev(func):\n", + " print(st_dev([1, 2, 3, 4, 5])) # Output: 1.4142135623730951\n", + " print(st_dev([])) # Output: None" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4142135623730951\n", + "None\n" + ] + } + ], "source": [ "# This will test your function \n", "test_stdev(st_dev)" @@ -317,20 +523,61 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [ - "def pangram(string):\n", - "#your code here" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "def is_pangram(s):\n", + " # Step 1: convert the string to lowercase\n", + " s = s.lower()\n", + " \n", + " # Step 2: create a set to store letters we encounter\n", + " letters_seen = set()\n", + " \n", + " # Step 3: iterate through each character in the string\n", + " for char in s:\n", + " # Step 4: check if the character is a letter\n", + " if char.isalpha(): # True if char is a-z or A-Z\n", + " letters_seen.add(char)\n", + " \n", + " # Step 5: check if we have all 26 letters\n", + " return len(letters_seen) == 26\n", + "\n", + "# Example usage:\n", + "sentence = \"The quick brown fox jumps over the lazy dog\"\n", + "print(is_pangram(sentence)) # Output: True\n", + "\n", + "sentence2 = \"Hello World\"\n", + "print(is_pangram(sentence2)) # Output: False" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "..............................\n", + "----------------------------------------------------------------------\n", + "Ran 30 tests in 0.056s\n", + "\n", + "OK\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_pangram(pangram)" + "test_pangram(is_pangram)" ] }, { @@ -344,22 +591,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 129, "metadata": {}, "outputs": [], "source": [ - "def sort_alpha(string):\n", - "#your code here" + "def sort_words(text):\n", + " words = [] # to store words we extract\n", + " current_word = \"\" # to build each word letter by letter\n", + " \n", + " # Step 1: manually split the string by commas\n", + " for ch in text:\n", + " if ch == ',':\n", + " words.append(current_word)\n", + " current_word = \"\" # reset for next word\n", + " else:\n", + " current_word += ch # build the word\n", + " \n", + " # Don't forget to add the last word after the loop\n", + " words.append(current_word)\n", + "\n", + " # Step 2: sort the list of words\n", + " sorted_words = sorted(words)\n", + " \n", + " # Step 3: manually build the result string (no join!)\n", + " result = \"\"\n", + " for i in range(len(sorted_words)):\n", + " result += sorted_words[i]\n", + " if i < len(sorted_words) - 1: # add comma except after last word\n", + " result += ','\n", + " \n", + " # Step 4: return the final string\n", + " return result\n", + "\n", + "def test_sort(func):\n", + " print(sort_words(\"banana,apple,cherry\")) # Output: \"apple,banana,cherry\"\n", + " print(sort_words(\"dog,cat,bird\")) # Output: \"bird,cat,dog\"" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apple,banana,cherry\n", + "bird,cat,dog\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_alpha(sort_alpha)" + "test_sort(sort_alpha)" ] }, { @@ -376,23 +661,55 @@ "outputs": [], "source": [ "def check_pass(password):\n", - "#your code here" + " \"\"\"Check if the password meets the criteria.\"\"\"\n", + " if len(password) < 8:\n", + " return False\n", + " \n", + " has_upper = False\n", + " has_lower = False\n", + " has_digit = False\n", + " has_special = False\n", + " special_characters = \"!@#$%^&*()-+\"\n", + " \n", + " for char in password:\n", + " if char.isupper():\n", + " has_upper = True\n", + " elif char.islower():\n", + " has_lower = True\n", + " elif char.isdigit():\n", + " has_digit = True\n", + " elif char in special_characters:\n", + " has_special = True\n", + " \n", + " return has_upper and has_lower and has_digit and has_special \n", + "def test_password(func):\n", + " print(check_pass(\"Ammulu@9989\")) # Output: True\n", + " print(check_pass(\"pass\")) # Output: False" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], "source": [ "# This will test your function \n", - "test_pass(check_pass)" + "test_password(check_pass)" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -406,12 +723,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" - }, - "vscode": { - "interpreter": { - "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" - } + "version": "3.13.7" } }, "nbformat": 4, diff --git a/mod/__pycache__/testing.cpython-313.pyc b/mod/__pycache__/testing.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2220b4cbc661809b3d66304b9d41bff9e5cad55d GIT binary patch literal 20233 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 Date: Wed, 8 Oct 2025 18:39:43 +0200 Subject: [PATCH 2/2] initial commit --- main.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/main.ipynb b/main.ipynb index a75187c..9750d23 100644 --- a/main.ipynb +++ b/main.ipynb @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 138, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 139, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 140, "metadata": {}, "outputs": [ { @@ -76,7 +76,7 @@ ], "source": [ "# This will test your function \n", - "test_greater(greater)" + "test_greater(greater_number)" ] }, {