├── .ipynb_checkpoints ├── 2 - Searching-checkpoint.ipynb ├── 5 - Recursion 1-checkpoint.ipynb ├── 6 - Recursion 2-checkpoint.ipynb ├── 7 - Problem Solving-checkpoint.ipynb ├── 3 - Time Complexity + Sorting 1-checkpoint.ipynb ├── 4 - Time Complexity + Sorting 2-checkpoint.ipynb └── 1 - Comprehension + Misc Questions-checkpoint.ipynb ├── 5 - Recursion 1.ipynb ├── 6 - Recursion 2.ipynb ├── 3 - Time Complexity + Sorting 1.ipynb ├── 2 - Searching.ipynb ├── 7 - Problem Solving.ipynb ├── 4 - Time Complexity + Sorting 2.ipynb └── 1 - Comprehension + Misc Questions.ipynb /.ipynb_checkpoints/2 - Searching-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /.ipynb_checkpoints/5 - Recursion 1-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /.ipynb_checkpoints/6 - Recursion 2-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /.ipynb_checkpoints/7 - Problem Solving-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /.ipynb_checkpoints/3 - Time Complexity + Sorting 1-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /.ipynb_checkpoints/4 - Time Complexity + Sorting 2-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /.ipynb_checkpoints/1 - Comprehension + Misc Questions-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 5 6 | } 7 | -------------------------------------------------------------------------------- /5 - Recursion 1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 10, 6 | "id": "14fdccab", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "def factorial(n):\n", 11 | " if n < 0 or type(n) != int:\n", 12 | " return \"Factorial not defined!\"\n", 13 | " \n", 14 | " if n == 0 or n == 1:\n", 15 | " return 1\n", 16 | " \n", 17 | " result = n * factorial(n - 1)\n", 18 | " return result" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 11, 24 | "id": "c7822667", 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "data": { 29 | "text/plain": [ 30 | "'Factorial not defined!'" 31 | ] 32 | }, 33 | "execution_count": 11, 34 | "metadata": {}, 35 | "output_type": "execute_result" 36 | } 37 | ], 38 | "source": [ 39 | "factorial(-4)" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 12, 45 | "id": "95014a9c", 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "data": { 50 | "text/plain": [ 51 | "120" 52 | ] 53 | }, 54 | "execution_count": 12, 55 | "metadata": {}, 56 | "output_type": "execute_result" 57 | } 58 | ], 59 | "source": [ 60 | "factorial(5)" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 3, 66 | "id": "a9614d4f", 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "def sum(a, b):\n", 71 | " return a + b" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 4, 77 | "id": "3ab8160b", 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "result = sum(4, 5)" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 5, 87 | "id": "4a8f0bcb", 88 | "metadata": {}, 89 | "outputs": [ 90 | { 91 | "data": { 92 | "text/plain": [ 93 | "9" 94 | ] 95 | }, 96 | "execution_count": 5, 97 | "metadata": {}, 98 | "output_type": "execute_result" 99 | } 100 | ], 101 | "source": [ 102 | "result" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 13, 108 | "id": "54c90506", 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [ 112 | "def fibonacci_number(n):\n", 113 | " if n < 0:\n", 114 | " return \"Not Defined!\"\n", 115 | " elif n == 0:\n", 116 | " return 0\n", 117 | " elif n == 1 or n == 2:\n", 118 | " return 1\n", 119 | " else:\n", 120 | " return fibonacci_number(n-1) + fibonacci_number(n-2)\n", 121 | " \n", 122 | "'''\n", 123 | "n = 6\n", 124 | "n = 5, n = 4\n", 125 | "\n", 126 | "n = 5\n", 127 | "n = 4, n = 3\n", 128 | "\n", 129 | "n = 4\n", 130 | "n = 3, n = 2\n", 131 | "'''" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 15, 137 | "id": "1aa85dcb", 138 | "metadata": {}, 139 | "outputs": [ 140 | { 141 | "data": { 142 | "text/plain": [ 143 | "13" 144 | ] 145 | }, 146 | "execution_count": 15, 147 | "metadata": {}, 148 | "output_type": "execute_result" 149 | } 150 | ], 151 | "source": [ 152 | "fibonacci_number(7)" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "id": "e265f78c", 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [] 162 | } 163 | ], 164 | "metadata": { 165 | "kernelspec": { 166 | "display_name": "Python 3 (ipykernel)", 167 | "language": "python", 168 | "name": "python3" 169 | }, 170 | "language_info": { 171 | "codemirror_mode": { 172 | "name": "ipython", 173 | "version": 3 174 | }, 175 | "file_extension": ".py", 176 | "mimetype": "text/x-python", 177 | "name": "python", 178 | "nbconvert_exporter": "python", 179 | "pygments_lexer": "ipython3", 180 | "version": "3.9.5" 181 | } 182 | }, 183 | "nbformat": 4, 184 | "nbformat_minor": 5 185 | } 186 | -------------------------------------------------------------------------------- /6 - Recursion 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "id": "bce2920c", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "data": { 11 | "text/plain": [ 12 | "'\\na = [1,2,3,4,5,6]\\n\\nRecursive call 1 - \\n\\nresult = [1,3,5]\\nreturn [1,3,5] + solve([2,4,6]) -> [1,3,5] + [2,6,4] -> [1,3,5,2,6,4]\\n\\n----------\\n\\na = [2,4,6]\\n\\nRecursive call 2 - \\n\\nresult = [2,6]\\nreturn [2,6] + solve([4]) -> [2,6] + [4] -> [2,6,4]\\n\\n----------\\n\\na = [4]\\n\\nRecursive call 3 - \\nreturn [4]\\n'" 13 | ] 14 | }, 15 | "execution_count": 2, 16 | "metadata": {}, 17 | "output_type": "execute_result" 18 | } 19 | ], 20 | "source": [ 21 | "def solve(a):\n", 22 | " # Base condition\n", 23 | " if len(a) == 1:\n", 24 | " return a\n", 25 | " \n", 26 | " result = a[::2] # Even Indexes\n", 27 | " \n", 28 | " return result + solve(a[1::2]) # Odd Indexes\n", 29 | "\n", 30 | "'''\n", 31 | "a = [1,2,3,4,5,6]\n", 32 | "\n", 33 | "Recursive call 1 - \n", 34 | "\n", 35 | "result = [1,3,5]\n", 36 | "return [1,3,5] + solve([2,4,6]) -> [1,3,5] + [2,6,4] -> [1,3,5,2,6,4]\n", 37 | "\n", 38 | "----------\n", 39 | "\n", 40 | "a = [2,4,6]\n", 41 | "\n", 42 | "Recursive call 2 - \n", 43 | "\n", 44 | "result = [2,6]\n", 45 | "return [2,6] + solve([4]) -> [2,6] + [4] -> [2,6,4]\n", 46 | "\n", 47 | "----------\n", 48 | "\n", 49 | "a = [4]\n", 50 | "\n", 51 | "Recursive call 3 - \n", 52 | "return [4]\n", 53 | "'''" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 3, 59 | "id": "5869e5b5", 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [ 63 | "a = 5\n", 64 | "b = 2" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 4, 70 | "id": "b2256bac", 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "if a < b:\n", 75 | " result = [a, b]\n", 76 | "else:\n", 77 | " result = [b, a]" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 5, 83 | "id": "53ecd169", 84 | "metadata": {}, 85 | "outputs": [ 86 | { 87 | "data": { 88 | "text/plain": [ 89 | "[2, 5]" 90 | ] 91 | }, 92 | "execution_count": 5, 93 | "metadata": {}, 94 | "output_type": "execute_result" 95 | } 96 | ], 97 | "source": [ 98 | "result" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 6, 104 | "id": "09a566ac", 105 | "metadata": {}, 106 | "outputs": [ 107 | { 108 | "data": { 109 | "text/plain": [ 110 | "'\\nQuestion 1 - \\n\\nGiven two sorted lists A and B, write a function which returns a result.\\nThis result should be a sorted concatenation of both A and B.\\n\\nExample ->\\nINPUT - \\nA = [1,4,5]\\nB = [2,3,6,7,8]\\nResult = [1,2,3,4,5,6,7,8]\\n'" 111 | ] 112 | }, 113 | "execution_count": 6, 114 | "metadata": {}, 115 | "output_type": "execute_result" 116 | } 117 | ], 118 | "source": [ 119 | "'''\n", 120 | "Question 1 - \n", 121 | "\n", 122 | "Given two sorted lists A and B, write a function which returns a result.\n", 123 | "This result should be a sorted concatenation of both A and B.\n", 124 | "\n", 125 | "Example ->\n", 126 | "INPUT - \n", 127 | "A = [1,4,5]\n", 128 | "B = [2,3,6,7,8]\n", 129 | "Result = [1,2,3,4,5,6,7,8]\n", 130 | "'''" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 7, 136 | "id": "d4a0f3e5", 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [ 140 | "def sorted_merge(a, b):\n", 141 | " i, j = 0, 0\n", 142 | " \n", 143 | " result = []\n", 144 | " \n", 145 | " while i < len(a) and j < len(b):\n", 146 | " if a[i] <= b[j]:\n", 147 | " result.append(a[i])\n", 148 | " i += 1\n", 149 | " else:\n", 150 | " result.append(b[j])\n", 151 | " j += 1\n", 152 | " \n", 153 | " if i < len(a):\n", 154 | " result += a[i:]\n", 155 | " elif j < len(b):\n", 156 | " result += b[j:]\n", 157 | " \n", 158 | " return result" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 8, 164 | "id": "0e8da06b", 165 | "metadata": {}, 166 | "outputs": [], 167 | "source": [ 168 | "def merge_sort(a):\n", 169 | " # BASE CONDITION\n", 170 | " if len(a) <= 1:\n", 171 | " return a\n", 172 | " \n", 173 | " # RECURSION PART\n", 174 | " n = len(a)\n", 175 | " \n", 176 | " left = merge_sort(a[:n//2])\n", 177 | " right = merge_sort(a[n//2:])\n", 178 | " \n", 179 | " # MERGING PART\n", 180 | " i, j = 0, 0\n", 181 | " \n", 182 | " result = []\n", 183 | " \n", 184 | " while i < len(left) and j < len(right):\n", 185 | " if left[i] <= right[j]:\n", 186 | " result.append(left[i])\n", 187 | " i += 1\n", 188 | " else:\n", 189 | " result.append(right[j])\n", 190 | " j += 1\n", 191 | " \n", 192 | " if i < len(left):\n", 193 | " result += left[i:]\n", 194 | " elif j < len(right):\n", 195 | " result += right[j:]\n", 196 | " \n", 197 | " return result" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 9, 203 | "id": "70faa155", 204 | "metadata": {}, 205 | "outputs": [ 206 | { 207 | "data": { 208 | "text/plain": [ 209 | "[0, 1, 2, 3, 4, 7, 8, 9, 10, 12]" 210 | ] 211 | }, 212 | "execution_count": 9, 213 | "metadata": {}, 214 | "output_type": "execute_result" 215 | } 216 | ], 217 | "source": [ 218 | "merge_sort([4,3,2,8,9,1,0,10,12,7])" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 1, 224 | "id": "a568b33a", 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [ 228 | "def solve(a, b):\n", 229 | " return a + b" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "id": "23cf98da", 236 | "metadata": {}, 237 | "outputs": [], 238 | "source": [ 239 | "result = solve(4, 5)" 240 | ] 241 | } 242 | ], 243 | "metadata": { 244 | "kernelspec": { 245 | "display_name": "Python 3 (ipykernel)", 246 | "language": "python", 247 | "name": "python3" 248 | }, 249 | "language_info": { 250 | "codemirror_mode": { 251 | "name": "ipython", 252 | "version": 3 253 | }, 254 | "file_extension": ".py", 255 | "mimetype": "text/x-python", 256 | "name": "python", 257 | "nbconvert_exporter": "python", 258 | "pygments_lexer": "ipython3", 259 | "version": "3.9.5" 260 | } 261 | }, 262 | "nbformat": 4, 263 | "nbformat_minor": 5 264 | } 265 | -------------------------------------------------------------------------------- /3 - Time Complexity + Sorting 1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 3, 6 | "id": "3effa175", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "data": { 11 | "text/plain": [ 12 | "'\\nCost Function -> A function to define number of operations.\\nCost(foo()) = 3 (Constant)\\n'" 13 | ] 14 | }, 15 | "execution_count": 3, 16 | "metadata": {}, 17 | "output_type": "execute_result" 18 | } 19 | ], 20 | "source": [ 21 | "# Example 1\n", 22 | "\n", 23 | "def foo():\n", 24 | " x = 1 # Operation 1\n", 25 | " y = 2 # Operation 2\n", 26 | " z = 3 # Operation 3\n", 27 | " \n", 28 | "'''\n", 29 | "Cost Function -> A function to define number of operations.\n", 30 | "Cost(foo()) = 3 (Constant)\n", 31 | "'''" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 4, 37 | "id": "88f2ea2f", 38 | "metadata": {}, 39 | "outputs": [ 40 | { 41 | "data": { 42 | "text/plain": [ 43 | "'\\nCost(foo()) = 3 (Constant)\\n'" 44 | ] 45 | }, 46 | "execution_count": 4, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "# Example 2\n", 53 | "\n", 54 | "def foo(n):\n", 55 | " x = 1 # Operation 1\n", 56 | " y = 2 # Operation 2\n", 57 | " z = 3 # Operation 3\n", 58 | " \n", 59 | "'''\n", 60 | "Cost(foo()) = 3 (Constant)\n", 61 | "'''" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 5, 67 | "id": "0f95d62b", 68 | "metadata": {}, 69 | "outputs": [ 70 | { 71 | "data": { 72 | "text/plain": [ 73 | "'\\nCost(foo()) = n (Linear)\\n\\nfoo(5) - 5 operations\\nfoo(100) - 100 operations\\n'" 74 | ] 75 | }, 76 | "execution_count": 5, 77 | "metadata": {}, 78 | "output_type": "execute_result" 79 | } 80 | ], 81 | "source": [ 82 | "# Example 3\n", 83 | "\n", 84 | "def foo(n):\n", 85 | " for i in range(n):\n", 86 | " print(i) # Operation n\n", 87 | " \n", 88 | "'''\n", 89 | "Cost(foo()) = n (Linear)\n", 90 | "\n", 91 | "foo(5) - 5 operations\n", 92 | "foo(100) - 100 operations\n", 93 | "'''" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 6, 99 | "id": "47ae984d", 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "data": { 104 | "text/plain": [ 105 | "'\\nCost(foo()) = n + 2 (Linear)\\n'" 106 | ] 107 | }, 108 | "execution_count": 6, 109 | "metadata": {}, 110 | "output_type": "execute_result" 111 | } 112 | ], 113 | "source": [ 114 | "# Example 4\n", 115 | "\n", 116 | "def foo(n):\n", 117 | " x = 2 # Operation 1\n", 118 | " y = 3 # Operation 2\n", 119 | " \n", 120 | " for i in range(n):\n", 121 | " print(i) # Operation n\n", 122 | "\n", 123 | "'''\n", 124 | "Cost(foo()) = n + 2 (Linear)\n", 125 | "'''" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 7, 131 | "id": "2a88842e", 132 | "metadata": {}, 133 | "outputs": [ 134 | { 135 | "data": { 136 | "text/plain": [ 137 | "'\\nCost(foo()) = n^2 (Exponential)\\n'" 138 | ] 139 | }, 140 | "execution_count": 7, 141 | "metadata": {}, 142 | "output_type": "execute_result" 143 | } 144 | ], 145 | "source": [ 146 | "# Example 5\n", 147 | "\n", 148 | "def foo(n):\n", 149 | " for i in range(n):\n", 150 | " for j in range(n):\n", 151 | " print(i) # Operation n^2\n", 152 | " \n", 153 | "'''\n", 154 | "Cost(foo()) = n^2 (Exponential)\n", 155 | "'''" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 8, 161 | "id": "75db0fdf", 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "data": { 166 | "text/plain": [ 167 | "'\\nCost(foo()) = n^2 + n\\n'" 168 | ] 169 | }, 170 | "execution_count": 8, 171 | "metadata": {}, 172 | "output_type": "execute_result" 173 | } 174 | ], 175 | "source": [ 176 | "# Example 6\n", 177 | "\n", 178 | "def foo(n):\n", 179 | " for i in range(n):\n", 180 | " for j in range(n):\n", 181 | " print(i) # Operation n^2\n", 182 | " \n", 183 | " for k in range(n):\n", 184 | " print(k) # Operation n\n", 185 | " \n", 186 | "'''\n", 187 | "Cost(foo()) = n^2 + n\n", 188 | "'''" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 11, 194 | "id": "cbc6491f", 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [ 198 | "def bubble_sort(a):\n", 199 | " for i in range(len(a)):\n", 200 | " for j in range(len(a) - i - 1):\n", 201 | " if a[j] > a[j+1]:\n", 202 | " a[j], a[j+1] = a[j+1], a[j]\n", 203 | " \n", 204 | " return a" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 12, 210 | "id": "cc28e9d7", 211 | "metadata": {}, 212 | "outputs": [], 213 | "source": [ 214 | "a = [1, 5, 2, 4, 7, 3]" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 13, 220 | "id": "340f9ce7", 221 | "metadata": {}, 222 | "outputs": [ 223 | { 224 | "data": { 225 | "text/plain": [ 226 | "[1, 2, 3, 4, 5, 7]" 227 | ] 228 | }, 229 | "execution_count": 13, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | } 233 | ], 234 | "source": [ 235 | "bubble_sort(a)" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 14, 241 | "id": "9f4cd502", 242 | "metadata": {}, 243 | "outputs": [], 244 | "source": [ 245 | "# Shortcoming -> Bubble sort will run n^2 times even if the list is already sorted!" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 17, 251 | "id": "898f227d", 252 | "metadata": {}, 253 | "outputs": [], 254 | "source": [ 255 | "def bubble_sort_visual(a):\n", 256 | " print(f\"{a}\")\n", 257 | " \n", 258 | " for i in range(len(a)):\n", 259 | " for j in range(len(a) - i - 1):\n", 260 | " if a[j] > a[j+1]:\n", 261 | " a[j], a[j+1] = a[j+1], a[j]\n", 262 | " \n", 263 | " print(f\"\\t{a}\")\n", 264 | " \n", 265 | " print(f\"{a}\")\n", 266 | " print(\"-\"*25)\n", 267 | " \n", 268 | " return a" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 18, 274 | "id": "f3375e37", 275 | "metadata": {}, 276 | "outputs": [ 277 | { 278 | "name": "stdout", 279 | "output_type": "stream", 280 | "text": [ 281 | "[1, 5, 2, 4, 7, 3]\n", 282 | "\t[1, 5, 2, 4, 7, 3]\n", 283 | "\t[1, 2, 5, 4, 7, 3]\n", 284 | "\t[1, 2, 4, 5, 7, 3]\n", 285 | "\t[1, 2, 4, 5, 7, 3]\n", 286 | "\t[1, 2, 4, 5, 3, 7]\n", 287 | "[1, 2, 4, 5, 3, 7]\n", 288 | "-------------------------\n", 289 | "\t[1, 2, 4, 5, 3, 7]\n", 290 | "\t[1, 2, 4, 5, 3, 7]\n", 291 | "\t[1, 2, 4, 5, 3, 7]\n", 292 | "\t[1, 2, 4, 3, 5, 7]\n", 293 | "[1, 2, 4, 3, 5, 7]\n", 294 | "-------------------------\n", 295 | "\t[1, 2, 4, 3, 5, 7]\n", 296 | "\t[1, 2, 4, 3, 5, 7]\n", 297 | "\t[1, 2, 3, 4, 5, 7]\n", 298 | "[1, 2, 3, 4, 5, 7]\n", 299 | "-------------------------\n", 300 | "\t[1, 2, 3, 4, 5, 7]\n", 301 | "\t[1, 2, 3, 4, 5, 7]\n", 302 | "[1, 2, 3, 4, 5, 7]\n", 303 | "-------------------------\n", 304 | "\t[1, 2, 3, 4, 5, 7]\n", 305 | "[1, 2, 3, 4, 5, 7]\n", 306 | "-------------------------\n", 307 | "[1, 2, 3, 4, 5, 7]\n", 308 | "-------------------------\n" 309 | ] 310 | }, 311 | { 312 | "data": { 313 | "text/plain": [ 314 | "[1, 2, 3, 4, 5, 7]" 315 | ] 316 | }, 317 | "execution_count": 18, 318 | "metadata": {}, 319 | "output_type": "execute_result" 320 | } 321 | ], 322 | "source": [ 323 | "bubble_sort_visual([1, 5, 2, 4, 7, 3])" 324 | ] 325 | }, 326 | { 327 | "cell_type": "code", 328 | "execution_count": 19, 329 | "id": "5155cfe8", 330 | "metadata": {}, 331 | "outputs": [ 332 | { 333 | "name": "stdout", 334 | "output_type": "stream", 335 | "text": [ 336 | "[1, 2, 3, 4, 5]\n", 337 | "\t[1, 2, 3, 4, 5]\n", 338 | "\t[1, 2, 3, 4, 5]\n", 339 | "\t[1, 2, 3, 4, 5]\n", 340 | "\t[1, 2, 3, 4, 5]\n", 341 | "[1, 2, 3, 4, 5]\n", 342 | "-------------------------\n", 343 | "\t[1, 2, 3, 4, 5]\n", 344 | "\t[1, 2, 3, 4, 5]\n", 345 | "\t[1, 2, 3, 4, 5]\n", 346 | "[1, 2, 3, 4, 5]\n", 347 | "-------------------------\n", 348 | "\t[1, 2, 3, 4, 5]\n", 349 | "\t[1, 2, 3, 4, 5]\n", 350 | "[1, 2, 3, 4, 5]\n", 351 | "-------------------------\n", 352 | "\t[1, 2, 3, 4, 5]\n", 353 | "[1, 2, 3, 4, 5]\n", 354 | "-------------------------\n", 355 | "[1, 2, 3, 4, 5]\n", 356 | "-------------------------\n" 357 | ] 358 | }, 359 | { 360 | "data": { 361 | "text/plain": [ 362 | "[1, 2, 3, 4, 5]" 363 | ] 364 | }, 365 | "execution_count": 19, 366 | "metadata": {}, 367 | "output_type": "execute_result" 368 | } 369 | ], 370 | "source": [ 371 | "bubble_sort_visual([1,2,3,4,5])" 372 | ] 373 | }, 374 | { 375 | "cell_type": "code", 376 | "execution_count": 20, 377 | "id": "c9e12882", 378 | "metadata": {}, 379 | "outputs": [ 380 | { 381 | "data": { 382 | "text/plain": [ 383 | "'\\nHOMEWORK - \\nFigure out a way to optimise bubble sort so that it only requires \"n operations\" if the list is already sorted!\\n'" 384 | ] 385 | }, 386 | "execution_count": 20, 387 | "metadata": {}, 388 | "output_type": "execute_result" 389 | } 390 | ], 391 | "source": [ 392 | "'''\n", 393 | "HOMEWORK - \n", 394 | "Figure out a way to optimise bubble sort so that it only requires \"n operations\" if the list is already sorted!\n", 395 | "'''" 396 | ] 397 | }, 398 | { 399 | "cell_type": "code", 400 | "execution_count": null, 401 | "id": "31cd3601", 402 | "metadata": {}, 403 | "outputs": [], 404 | "source": [] 405 | } 406 | ], 407 | "metadata": { 408 | "kernelspec": { 409 | "display_name": "Python 3 (ipykernel)", 410 | "language": "python", 411 | "name": "python3" 412 | }, 413 | "language_info": { 414 | "codemirror_mode": { 415 | "name": "ipython", 416 | "version": 3 417 | }, 418 | "file_extension": ".py", 419 | "mimetype": "text/x-python", 420 | "name": "python", 421 | "nbconvert_exporter": "python", 422 | "pygments_lexer": "ipython3", 423 | "version": "3.9.5" 424 | } 425 | }, 426 | "nbformat": 4, 427 | "nbformat_minor": 5 428 | } 429 | -------------------------------------------------------------------------------- /2 - Searching.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "411d999a", 6 | "metadata": {}, 7 | "source": [ 8 | "## LINEAR SEARCH" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 7, 14 | "id": "6e683e75", 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "data": { 19 | "text/plain": [ 20 | "'\\nQuestion 1 - \\n\\nGiven a list of values and a target element.\\n - Return the index of the target element if it is present in the list\\n - If not present, return -1\\n'" 21 | ] 22 | }, 23 | "execution_count": 7, 24 | "metadata": {}, 25 | "output_type": "execute_result" 26 | } 27 | ], 28 | "source": [ 29 | "'''\n", 30 | "Question 1 - \n", 31 | "\n", 32 | "Given a list of values and a target element.\n", 33 | " - Return the index of the target element if it is present in the list\n", 34 | " - If not present, return -1\n", 35 | "'''" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 15, 41 | "id": "fae61d15", 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "a = [10,20,30,40,50,60,70,80,90,100]\n", 46 | "target = 50" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 9, 52 | "id": "6f9eb753", 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [ 56 | "# Approach 1\n", 57 | "def linear_search(a, target):\n", 58 | " for i in range(len(a)):\n", 59 | " if a[i] == target:\n", 60 | " return i\n", 61 | " \n", 62 | " return -1" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 10, 68 | "id": "dfec7700", 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "text/plain": [ 74 | "4" 75 | ] 76 | }, 77 | "execution_count": 10, 78 | "metadata": {}, 79 | "output_type": "execute_result" 80 | } 81 | ], 82 | "source": [ 83 | "linear_search(a, target)" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 8, 89 | "id": "9c7238c4", 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "# Enumerate" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 46, 99 | "id": "4c181b2e", 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "a = [10,20,30,40,50]" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": 47, 109 | "id": "720a6970", 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "enumerated_a = list(enumerate(a))" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 48, 119 | "id": "fa3a3ce7", 120 | "metadata": {}, 121 | "outputs": [ 122 | { 123 | "data": { 124 | "text/plain": [ 125 | "[(0, 10), (1, 20), (2, 30), (3, 40), (4, 50)]" 126 | ] 127 | }, 128 | "execution_count": 48, 129 | "metadata": {}, 130 | "output_type": "execute_result" 131 | } 132 | ], 133 | "source": [ 134 | "enumerated_a" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 17, 140 | "id": "462de4aa", 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "# Approach 2\n", 145 | "def linear_search(a, target):\n", 146 | " for index, value in enumerate(a):\n", 147 | " if value == target:\n", 148 | " return index\n", 149 | " \n", 150 | " return -1" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 18, 156 | "id": "c0c84b7b", 157 | "metadata": {}, 158 | "outputs": [ 159 | { 160 | "data": { 161 | "text/plain": [ 162 | "4" 163 | ] 164 | }, 165 | "execution_count": 18, 166 | "metadata": {}, 167 | "output_type": "execute_result" 168 | } 169 | ], 170 | "source": [ 171 | "linear_search(a, target)" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": 20, 177 | "id": "dd1f179a", 178 | "metadata": {}, 179 | "outputs": [ 180 | { 181 | "data": { 182 | "text/plain": [ 183 | "'\\nlen(a) = n\\nTarget is present at the last index.\\n\\nHow many times will the loop run to reach the target?\\n\\n\"n operations\" in the worst case\\n'" 184 | ] 185 | }, 186 | "execution_count": 20, 187 | "metadata": {}, 188 | "output_type": "execute_result" 189 | } 190 | ], 191 | "source": [ 192 | "'''\n", 193 | "len(a) = n\n", 194 | "Target is present at the last index.\n", 195 | "\n", 196 | "How many times will the loop run to reach the target?\n", 197 | "\n", 198 | "\"n operations\" in the worst case\n", 199 | "'''" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "id": "2f2e51c9", 205 | "metadata": {}, 206 | "source": [ 207 | "## Binary Search" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": 21, 213 | "id": "b1bd4d9e", 214 | "metadata": {}, 215 | "outputs": [], 216 | "source": [ 217 | "def binary_search(a, target):\n", 218 | " start, end = 0, len(a) - 1\n", 219 | " \n", 220 | " while start <= end:\n", 221 | " mid = (start + end) // 2\n", 222 | " \n", 223 | " if a[mid] == target:\n", 224 | " return mid\n", 225 | " elif a[mid] < target:\n", 226 | " start = mid + 1\n", 227 | " else:\n", 228 | " end = mid - 1\n", 229 | " \n", 230 | " return -1" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 22, 236 | "id": "21427544", 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [ 240 | "a = [10,20,30,40,50,60,70,80,90,100]\n", 241 | "target = 50" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": 25, 247 | "id": "61e2e0c4", 248 | "metadata": {}, 249 | "outputs": [ 250 | { 251 | "data": { 252 | "text/plain": [ 253 | "0" 254 | ] 255 | }, 256 | "execution_count": 25, 257 | "metadata": {}, 258 | "output_type": "execute_result" 259 | } 260 | ], 261 | "source": [ 262 | "binary_search(a, 10)" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 31, 268 | "id": "22e7b676", 269 | "metadata": {}, 270 | "outputs": [], 271 | "source": [ 272 | "def linear_search_with_count(a, target):\n", 273 | " count = 0\n", 274 | " \n", 275 | " for index, value in enumerate(a):\n", 276 | " count += 1\n", 277 | " if value == target:\n", 278 | " print(f\"I ran {count} times!\")\n", 279 | " return index\n", 280 | " \n", 281 | " print(f\"I ran {count} times!\")\n", 282 | " \n", 283 | " return -1" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": 41, 289 | "id": "e779f83c", 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "data": { 294 | "text/plain": [ 295 | "'\\nnumber of operations = log2(n)\\n'" 296 | ] 297 | }, 298 | "execution_count": 41, 299 | "metadata": {}, 300 | "output_type": "execute_result" 301 | } 302 | ], 303 | "source": [ 304 | "def binary_search_with_count(a, target):\n", 305 | " start, end = 0, len(a) - 1\n", 306 | " count = 0\n", 307 | " \n", 308 | " while start <= end:\n", 309 | " mid = (start + end) // 2\n", 310 | " count += 1\n", 311 | " \n", 312 | " if a[mid] == target:\n", 313 | " print(f\"I ran {count} times!\")\n", 314 | " return mid\n", 315 | " elif a[mid] < target:\n", 316 | " start = mid + 1\n", 317 | " else:\n", 318 | " end = mid - 1\n", 319 | " \n", 320 | " print(f\"I ran {count} times!\")\n", 321 | " \n", 322 | " return -1\n", 323 | "\n", 324 | "'''\n", 325 | "number of operations = log2(n)\n", 326 | "'''" 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": 33, 332 | "id": "c57e7715", 333 | "metadata": {}, 334 | "outputs": [], 335 | "source": [ 336 | "a = [10,20,30,40,50,60,70,80,90,100]\n", 337 | "target = 70" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": 34, 343 | "id": "47c64804", 344 | "metadata": {}, 345 | "outputs": [ 346 | { 347 | "name": "stdout", 348 | "output_type": "stream", 349 | "text": [ 350 | "I ran 7 times!\n" 351 | ] 352 | }, 353 | { 354 | "data": { 355 | "text/plain": [ 356 | "6" 357 | ] 358 | }, 359 | "execution_count": 34, 360 | "metadata": {}, 361 | "output_type": "execute_result" 362 | } 363 | ], 364 | "source": [ 365 | "linear_search_with_count(a, target)" 366 | ] 367 | }, 368 | { 369 | "cell_type": "code", 370 | "execution_count": 35, 371 | "id": "20a49abc", 372 | "metadata": {}, 373 | "outputs": [ 374 | { 375 | "name": "stdout", 376 | "output_type": "stream", 377 | "text": [ 378 | "I ran 4 times!\n" 379 | ] 380 | }, 381 | { 382 | "data": { 383 | "text/plain": [ 384 | "6" 385 | ] 386 | }, 387 | "execution_count": 35, 388 | "metadata": {}, 389 | "output_type": "execute_result" 390 | } 391 | ], 392 | "source": [ 393 | "binary_search_with_count(a, target)" 394 | ] 395 | }, 396 | { 397 | "cell_type": "code", 398 | "execution_count": 36, 399 | "id": "05c7371f", 400 | "metadata": {}, 401 | "outputs": [], 402 | "source": [ 403 | "a = list(range(1,1001))" 404 | ] 405 | }, 406 | { 407 | "cell_type": "code", 408 | "execution_count": 38, 409 | "id": "2215647c", 410 | "metadata": {}, 411 | "outputs": [], 412 | "source": [ 413 | "# a" 414 | ] 415 | }, 416 | { 417 | "cell_type": "code", 418 | "execution_count": 39, 419 | "id": "6e41d627", 420 | "metadata": {}, 421 | "outputs": [ 422 | { 423 | "name": "stdout", 424 | "output_type": "stream", 425 | "text": [ 426 | "I ran 675 times!\n" 427 | ] 428 | }, 429 | { 430 | "data": { 431 | "text/plain": [ 432 | "674" 433 | ] 434 | }, 435 | "execution_count": 39, 436 | "metadata": {}, 437 | "output_type": "execute_result" 438 | } 439 | ], 440 | "source": [ 441 | "linear_search_with_count(a, 675)" 442 | ] 443 | }, 444 | { 445 | "cell_type": "code", 446 | "execution_count": 40, 447 | "id": "484f92e4", 448 | "metadata": {}, 449 | "outputs": [ 450 | { 451 | "name": "stdout", 452 | "output_type": "stream", 453 | "text": [ 454 | "I ran 8 times!\n" 455 | ] 456 | }, 457 | { 458 | "data": { 459 | "text/plain": [ 460 | "674" 461 | ] 462 | }, 463 | "execution_count": 40, 464 | "metadata": {}, 465 | "output_type": "execute_result" 466 | } 467 | ], 468 | "source": [ 469 | "binary_search_with_count(a, 675)" 470 | ] 471 | }, 472 | { 473 | "cell_type": "code", 474 | "execution_count": 42, 475 | "id": "99aa27c9", 476 | "metadata": {}, 477 | "outputs": [], 478 | "source": [ 479 | "# log2(8 * 10^9) -> 33" 480 | ] 481 | }, 482 | { 483 | "cell_type": "code", 484 | "execution_count": 44, 485 | "id": "7fb25180", 486 | "metadata": {}, 487 | "outputs": [ 488 | { 489 | "data": { 490 | "text/plain": [ 491 | "1" 492 | ] 493 | }, 494 | "execution_count": 44, 495 | "metadata": {}, 496 | "output_type": "execute_result" 497 | } 498 | ], 499 | "source": [ 500 | "binary_search([1,2,3,4,5], 2)" 501 | ] 502 | }, 503 | { 504 | "cell_type": "code", 505 | "execution_count": null, 506 | "id": "c134f0c4", 507 | "metadata": {}, 508 | "outputs": [], 509 | "source": [] 510 | } 511 | ], 512 | "metadata": { 513 | "kernelspec": { 514 | "display_name": "Python 3 (ipykernel)", 515 | "language": "python", 516 | "name": "python3" 517 | }, 518 | "language_info": { 519 | "codemirror_mode": { 520 | "name": "ipython", 521 | "version": 3 522 | }, 523 | "file_extension": ".py", 524 | "mimetype": "text/x-python", 525 | "name": "python", 526 | "nbconvert_exporter": "python", 527 | "pygments_lexer": "ipython3", 528 | "version": "3.9.5" 529 | } 530 | }, 531 | "nbformat": 4, 532 | "nbformat_minor": 5 533 | } 534 | -------------------------------------------------------------------------------- /7 - Problem Solving.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 37, 6 | "id": "60d66abd", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "def fibonacci_number(n):\n", 11 | " if n < 0:\n", 12 | " return \"Not Defined!\"\n", 13 | " elif n == 0:\n", 14 | " return 0\n", 15 | " elif n == 1:\n", 16 | " if 1 not in fibonacci_series:\n", 17 | " fibonacci_series.append(1)\n", 18 | " \n", 19 | " return 1\n", 20 | " elif n == 2:\n", 21 | " if 1 not in fibonacci_series:\n", 22 | " fibonacci_series.extend([1,1]) \n", 23 | " \n", 24 | " return 1\n", 25 | " else:\n", 26 | " number = fibonacci_number(n-1) + fibonacci_number(n-2)\n", 27 | " \n", 28 | " if number not in fibonacci_series:\n", 29 | " fibonacci_series.append(number)\n", 30 | " \n", 31 | " return number" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 47, 37 | "id": "76cc5c9f", 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "fibonacci_series = [0]" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 48, 47 | "id": "cd57e385", 48 | "metadata": {}, 49 | "outputs": [ 50 | { 51 | "data": { 52 | "text/plain": [ 53 | "55" 54 | ] 55 | }, 56 | "execution_count": 48, 57 | "metadata": {}, 58 | "output_type": "execute_result" 59 | } 60 | ], 61 | "source": [ 62 | "fibonacci_number(10)" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 49, 68 | "id": "eaaf388b", 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "text/plain": [ 74 | "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]" 75 | ] 76 | }, 77 | "execution_count": 49, 78 | "metadata": {}, 79 | "output_type": "execute_result" 80 | } 81 | ], 82 | "source": [ 83 | "fibonacci_series" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 50, 89 | "id": "a50fc67f", 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "text/plain": [ 95 | "True" 96 | ] 97 | }, 98 | "execution_count": 50, 99 | "metadata": {}, 100 | "output_type": "execute_result" 101 | } 102 | ], 103 | "source": [ 104 | "\"abc\" < \"zebra\"" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 61, 110 | "id": "78ec82e2", 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [ 114 | "def binary_search(a, target):\n", 115 | " start, end = 0, len(a) - 1\n", 116 | " \n", 117 | " while start <= end:\n", 118 | " mid = (start + end) // 2\n", 119 | " \n", 120 | " if a[mid] == target:\n", 121 | " return mid\n", 122 | " elif a[mid] < target:\n", 123 | " start = mid + 1\n", 124 | " else:\n", 125 | " end = mid - 1\n", 126 | " \n", 127 | " print(f\"start = {start}, end = {end}, mid = {mid}\")\n", 128 | " \n", 129 | " return start" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 62, 135 | "id": "ec2053aa", 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "a = [1,2,4,5,6,7,8,9,10]" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 63, 145 | "id": "bbf17f40", 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "name": "stdout", 150 | "output_type": "stream", 151 | "text": [ 152 | "start = 2, end = 1, mid = 2\n" 153 | ] 154 | }, 155 | { 156 | "data": { 157 | "text/plain": [ 158 | "2" 159 | ] 160 | }, 161 | "execution_count": 63, 162 | "metadata": {}, 163 | "output_type": "execute_result" 164 | } 165 | ], 166 | "source": [ 167 | "binary_search(a, 3)" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 64, 173 | "id": "a6e5e534", 174 | "metadata": {}, 175 | "outputs": [], 176 | "source": [ 177 | "a = [1,2,3,4,6,7,8,9,10]" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 65, 183 | "id": "cd706b97", 184 | "metadata": {}, 185 | "outputs": [ 186 | { 187 | "name": "stdout", 188 | "output_type": "stream", 189 | "text": [ 190 | "start = 4, end = 3, mid = 3\n" 191 | ] 192 | }, 193 | { 194 | "data": { 195 | "text/plain": [ 196 | "4" 197 | ] 198 | }, 199 | "execution_count": 65, 200 | "metadata": {}, 201 | "output_type": "execute_result" 202 | } 203 | ], 204 | "source": [ 205 | "binary_search(a, 5)" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 66, 211 | "id": "74f103f4", 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "a = [1,2,3,4,5,6,7,9,10]" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 67, 221 | "id": "0a0692f1", 222 | "metadata": {}, 223 | "outputs": [ 224 | { 225 | "name": "stdout", 226 | "output_type": "stream", 227 | "text": [ 228 | "start = 7, end = 6, mid = 7\n" 229 | ] 230 | }, 231 | { 232 | "data": { 233 | "text/plain": [ 234 | "7" 235 | ] 236 | }, 237 | "execution_count": 67, 238 | "metadata": {}, 239 | "output_type": "execute_result" 240 | } 241 | ], 242 | "source": [ 243 | "binary_search(a,8)" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": 68, 249 | "id": "174afa04", 250 | "metadata": {}, 251 | "outputs": [], 252 | "source": [ 253 | "import math" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": 69, 259 | "id": "1bc1fcd4", 260 | "metadata": {}, 261 | "outputs": [ 262 | { 263 | "data": { 264 | "text/plain": [ 265 | "3628800" 266 | ] 267 | }, 268 | "execution_count": 69, 269 | "metadata": {}, 270 | "output_type": "execute_result" 271 | } 272 | ], 273 | "source": [ 274 | "math.factorial(10)" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": 70, 280 | "id": "e69e24d3", 281 | "metadata": {}, 282 | "outputs": [], 283 | "source": [ 284 | "def selection_sort(a):\n", 285 | " for i in range(len(a) - 1):\n", 286 | " current_min = i\n", 287 | " \n", 288 | " for j in range(i + 1, len(a)):\n", 289 | " if a[j] < a[current_min]:\n", 290 | " current_min = j\n", 291 | " \n", 292 | " if i != current_min:\n", 293 | " a[i], a[current_min] = a[current_min], a[i]\n", 294 | " \n", 295 | " return a" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": 71, 301 | "id": "fe5c9c44", 302 | "metadata": {}, 303 | "outputs": [], 304 | "source": [ 305 | "a = [\"chaithra\", \"bipin\", \"bheeshma\", \"gauri\", \"ravi\", \"akshay\", \"surendra\"]" 306 | ] 307 | }, 308 | { 309 | "cell_type": "code", 310 | "execution_count": 72, 311 | "id": "2aa93d79", 312 | "metadata": {}, 313 | "outputs": [ 314 | { 315 | "data": { 316 | "text/plain": [ 317 | "['akshay', 'bheeshma', 'bipin', 'chaithra', 'gauri', 'ravi', 'surendra']" 318 | ] 319 | }, 320 | "execution_count": 72, 321 | "metadata": {}, 322 | "output_type": "execute_result" 323 | } 324 | ], 325 | "source": [ 326 | "selection_sort(a)" 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": 73, 332 | "id": "f39a6518", 333 | "metadata": {}, 334 | "outputs": [ 335 | { 336 | "data": { 337 | "text/plain": [ 338 | "True" 339 | ] 340 | }, 341 | "execution_count": 73, 342 | "metadata": {}, 343 | "output_type": "execute_result" 344 | } 345 | ], 346 | "source": [ 347 | "\"akshay\" < \"bipin\"" 348 | ] 349 | }, 350 | { 351 | "cell_type": "code", 352 | "execution_count": 74, 353 | "id": "61ade726", 354 | "metadata": {}, 355 | "outputs": [], 356 | "source": [ 357 | "a = [5,1,3,9,7,2,4]" 358 | ] 359 | }, 360 | { 361 | "cell_type": "code", 362 | "execution_count": 75, 363 | "id": "66935d19", 364 | "metadata": {}, 365 | "outputs": [], 366 | "source": [ 367 | "a.sort()" 368 | ] 369 | }, 370 | { 371 | "cell_type": "code", 372 | "execution_count": 76, 373 | "id": "48a9861f", 374 | "metadata": {}, 375 | "outputs": [ 376 | { 377 | "data": { 378 | "text/plain": [ 379 | "[1, 2, 3, 4, 5, 7, 9]" 380 | ] 381 | }, 382 | "execution_count": 76, 383 | "metadata": {}, 384 | "output_type": "execute_result" 385 | } 386 | ], 387 | "source": [ 388 | "a" 389 | ] 390 | }, 391 | { 392 | "cell_type": "code", 393 | "execution_count": 77, 394 | "id": "24cad977", 395 | "metadata": {}, 396 | "outputs": [ 397 | { 398 | "data": { 399 | "text/plain": [ 400 | "[1, 2, 3, 4, 5, 7, 9]" 401 | ] 402 | }, 403 | "execution_count": 77, 404 | "metadata": {}, 405 | "output_type": "execute_result" 406 | } 407 | ], 408 | "source": [ 409 | "a" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": 78, 415 | "id": "f8a76d24", 416 | "metadata": {}, 417 | "outputs": [], 418 | "source": [ 419 | "a = [5,1,3,9,7,2,4]" 420 | ] 421 | }, 422 | { 423 | "cell_type": "code", 424 | "execution_count": 79, 425 | "id": "9260f9f1", 426 | "metadata": {}, 427 | "outputs": [ 428 | { 429 | "data": { 430 | "text/plain": [ 431 | "[1, 2, 3, 4, 5, 7, 9]" 432 | ] 433 | }, 434 | "execution_count": 79, 435 | "metadata": {}, 436 | "output_type": "execute_result" 437 | } 438 | ], 439 | "source": [ 440 | "sorted(a)" 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": 80, 446 | "id": "fbbf0b65", 447 | "metadata": {}, 448 | "outputs": [ 449 | { 450 | "data": { 451 | "text/plain": [ 452 | "[5, 1, 3, 9, 7, 2, 4]" 453 | ] 454 | }, 455 | "execution_count": 80, 456 | "metadata": {}, 457 | "output_type": "execute_result" 458 | } 459 | ], 460 | "source": [ 461 | "a" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": 87, 467 | "id": "60cdc569", 468 | "metadata": {}, 469 | "outputs": [ 470 | { 471 | "data": { 472 | "text/plain": [ 473 | "'\\nn = 123, temp = \"\"\\n\\nInitial Call - \\n last_digit = 3\\n temp = \"3\"\\n reverse_number(12, \"3\")\\n \\nRecursive Call 1 - \\n last_digit = 2\\n temp = \"32\"\\n reverse_number(1, \"32\")\\n \\nRecursive Call 2 - \\n last_digit = 1\\n temp = \"321\"\\n \\n'" 474 | ] 475 | }, 476 | "execution_count": 87, 477 | "metadata": {}, 478 | "output_type": "execute_result" 479 | } 480 | ], 481 | "source": [ 482 | "def reverse_number(n, temp = \"\"): \n", 483 | " last_digit = n % 10\n", 484 | " temp += str(last_digit)\n", 485 | " \n", 486 | " if n // 10 == 0:\n", 487 | " return temp\n", 488 | " else:\n", 489 | " return reverse_number(n // 10, temp)\n", 490 | "\n", 491 | "\n", 492 | "'''\n", 493 | "n = 123, temp = \"\"\n", 494 | "\n", 495 | "Initial Call - \n", 496 | " last_digit = 3\n", 497 | " temp = \"3\"\n", 498 | " reverse_number(12, \"3\")\n", 499 | " \n", 500 | "Recursive Call 1 - \n", 501 | " last_digit = 2\n", 502 | " temp = \"32\"\n", 503 | " reverse_number(1, \"32\")\n", 504 | " \n", 505 | "Recursive Call 2 - \n", 506 | " last_digit = 1\n", 507 | " temp = \"321\"\n", 508 | " \n", 509 | "'''" 510 | ] 511 | }, 512 | { 513 | "cell_type": "code", 514 | "execution_count": 88, 515 | "id": "e9173a3c", 516 | "metadata": {}, 517 | "outputs": [ 518 | { 519 | "data": { 520 | "text/plain": [ 521 | "'54321'" 522 | ] 523 | }, 524 | "execution_count": 88, 525 | "metadata": {}, 526 | "output_type": "execute_result" 527 | } 528 | ], 529 | "source": [ 530 | "reverse_number(12345)" 531 | ] 532 | }, 533 | { 534 | "cell_type": "code", 535 | "execution_count": 89, 536 | "id": "707812e2", 537 | "metadata": {}, 538 | "outputs": [ 539 | { 540 | "data": { 541 | "text/plain": [ 542 | "'001'" 543 | ] 544 | }, 545 | "execution_count": 89, 546 | "metadata": {}, 547 | "output_type": "execute_result" 548 | } 549 | ], 550 | "source": [ 551 | "reverse_number(100)" 552 | ] 553 | }, 554 | { 555 | "cell_type": "code", 556 | "execution_count": null, 557 | "id": "175cdaec", 558 | "metadata": {}, 559 | "outputs": [], 560 | "source": [] 561 | } 562 | ], 563 | "metadata": { 564 | "kernelspec": { 565 | "display_name": "Python 3 (ipykernel)", 566 | "language": "python", 567 | "name": "python3" 568 | }, 569 | "language_info": { 570 | "codemirror_mode": { 571 | "name": "ipython", 572 | "version": 3 573 | }, 574 | "file_extension": ".py", 575 | "mimetype": "text/x-python", 576 | "name": "python", 577 | "nbconvert_exporter": "python", 578 | "pygments_lexer": "ipython3", 579 | "version": "3.9.5" 580 | } 581 | }, 582 | "nbformat": 4, 583 | "nbformat_minor": 5 584 | } 585 | -------------------------------------------------------------------------------- /4 - Time Complexity + Sorting 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "eade1adf", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "def random(n):\n", 11 | " x = n # 1 operation\n", 12 | " \n", 13 | " for i in range(x):\n", 14 | " for j in range(x):\n", 15 | " # n^2 operations\n", 16 | " if x == 10:\n", 17 | " break" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 2, 23 | "id": "ecf23ac6", 24 | "metadata": {}, 25 | "outputs": [ 26 | { 27 | "data": { 28 | "text/plain": [ 29 | "'\\nn = 5\\n\\nx = 5\\n\\ni = 0\\n j = 0\\n -> x == n (5 == 5) - TRUE\\n -> break\\n \\ni = 1\\n j = 0\\n -> x == n (5 == 5) - TRUE\\n -> break\\n \\ni == 2\\n.\\n.\\n.\\n'" 30 | ] 31 | }, 32 | "execution_count": 2, 33 | "metadata": {}, 34 | "output_type": "execute_result" 35 | } 36 | ], 37 | "source": [ 38 | "def random(n):\n", 39 | " x = n # 1 operation\n", 40 | " \n", 41 | " # n operations\n", 42 | " for i in range(x):\n", 43 | " for j in range(x): # This loop will break in only 1 iteration!\n", 44 | " if x == n: # TRUE\n", 45 | " break\n", 46 | " \n", 47 | " \n", 48 | "'''\n", 49 | "n = 5\n", 50 | "\n", 51 | "x = 5\n", 52 | "\n", 53 | "i = 0\n", 54 | " j = 0\n", 55 | " -> x == n (5 == 5) - TRUE\n", 56 | " -> break\n", 57 | " \n", 58 | "i = 1\n", 59 | " j = 0\n", 60 | " -> x == n (5 == 5) - TRUE\n", 61 | " -> break\n", 62 | " \n", 63 | "i == 2\n", 64 | ".\n", 65 | ".\n", 66 | ".\n", 67 | "'''" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 3, 73 | "id": "67df86b5", 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "name": "stdout", 78 | "output_type": "stream", 79 | "text": [ 80 | "random\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "if 5:\n", 86 | " print(\"random\")" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 4, 92 | "id": "c699eaf4", 93 | "metadata": {}, 94 | "outputs": [], 95 | "source": [ 96 | "if 0:\n", 97 | " print(\"random\")" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": 10, 103 | "id": "4be7ac0b", 104 | "metadata": {}, 105 | "outputs": [], 106 | "source": [ 107 | "def bubble_sort_unoptimized(a):\n", 108 | " count = 0\n", 109 | " \n", 110 | " for i in range(len(a)):\n", 111 | " for j in range(len(a) - i - 1):\n", 112 | " count += 1\n", 113 | " if a[j] > a[j+1]:\n", 114 | " a[j], a[j+1] = a[j+1], a[j]\n", 115 | " \n", 116 | " print(f\"I ran {count} times!\")\n", 117 | " \n", 118 | " return a" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 11, 124 | "id": "022942d9", 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "def bubble_sort_optimized(a):\n", 129 | " count = 0\n", 130 | " \n", 131 | " for i in range(len(a)):\n", 132 | " is_sorted = True\n", 133 | " \n", 134 | " for j in range(len(a) - i - 1):\n", 135 | " count += 1\n", 136 | " if a[j] > a[j+1]:\n", 137 | " is_sorted = False\n", 138 | " a[j], a[j+1] = a[j+1], a[j]\n", 139 | " \n", 140 | " if is_sorted:\n", 141 | " break\n", 142 | " \n", 143 | " print(f\"I ran {count} times!\")\n", 144 | " \n", 145 | " return a" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 12, 151 | "id": "304dc974", 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "name": "stdout", 156 | "output_type": "stream", 157 | "text": [ 158 | "I ran 45 times!\n" 159 | ] 160 | }, 161 | { 162 | "data": { 163 | "text/plain": [ 164 | "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" 165 | ] 166 | }, 167 | "execution_count": 12, 168 | "metadata": {}, 169 | "output_type": "execute_result" 170 | } 171 | ], 172 | "source": [ 173 | "bubble_sort_unoptimized([1,2,3,4,5,6,7,8,9,10])" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 13, 179 | "id": "157bcaf9", 180 | "metadata": {}, 181 | "outputs": [ 182 | { 183 | "name": "stdout", 184 | "output_type": "stream", 185 | "text": [ 186 | "I ran 9 times!\n" 187 | ] 188 | }, 189 | { 190 | "data": { 191 | "text/plain": [ 192 | "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" 193 | ] 194 | }, 195 | "execution_count": 13, 196 | "metadata": {}, 197 | "output_type": "execute_result" 198 | } 199 | ], 200 | "source": [ 201 | "bubble_sort_optimized([1,2,3,4,5,6,7,8,9,10])" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 14, 207 | "id": "ea2ade4f", 208 | "metadata": {}, 209 | "outputs": [ 210 | { 211 | "name": "stdout", 212 | "output_type": "stream", 213 | "text": [ 214 | "I ran 15 times!\n" 215 | ] 216 | }, 217 | { 218 | "data": { 219 | "text/plain": [ 220 | "[2, 4, 6, 8, 10, 12]" 221 | ] 222 | }, 223 | "execution_count": 14, 224 | "metadata": {}, 225 | "output_type": "execute_result" 226 | } 227 | ], 228 | "source": [ 229 | "bubble_sort_unoptimized([2,4,6,8,12,10])" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 15, 235 | "id": "e09fa054", 236 | "metadata": {}, 237 | "outputs": [ 238 | { 239 | "name": "stdout", 240 | "output_type": "stream", 241 | "text": [ 242 | "I ran 9 times!\n" 243 | ] 244 | }, 245 | { 246 | "data": { 247 | "text/plain": [ 248 | "[2, 4, 6, 8, 10, 12]" 249 | ] 250 | }, 251 | "execution_count": 15, 252 | "metadata": {}, 253 | "output_type": "execute_result" 254 | } 255 | ], 256 | "source": [ 257 | "bubble_sort_optimized([2,4,6,8,12,10])" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": 16, 263 | "id": "b09cd373", 264 | "metadata": {}, 265 | "outputs": [], 266 | "source": [ 267 | "def bubble_sort_visual_1(a):\n", 268 | " print(f\"{a}\")\n", 269 | " \n", 270 | " for i in range(len(a)):\n", 271 | " for j in range(len(a) - i - 1):\n", 272 | " if a[j] > a[j+1]:\n", 273 | " a[j], a[j+1] = a[j+1], a[j]\n", 274 | " \n", 275 | " print(f\"\\t{a}\")\n", 276 | " \n", 277 | " print(f\"{a}\")\n", 278 | " print(\"-\"*25)\n", 279 | " \n", 280 | " return a" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": 18, 286 | "id": "6a4c6622", 287 | "metadata": {}, 288 | "outputs": [], 289 | "source": [ 290 | "def bubble_sort_visual_2(a):\n", 291 | " print(f\"{a}\")\n", 292 | " \n", 293 | " for i in range(len(a)):\n", 294 | " is_sorted = True\n", 295 | " \n", 296 | " for j in range(len(a) - i - 1):\n", 297 | " if a[j] > a[j+1]:\n", 298 | " is_sorted = False\n", 299 | " a[j], a[j+1] = a[j+1], a[j]\n", 300 | " \n", 301 | " print(f\"\\t{a}\")\n", 302 | " \n", 303 | " print(f\"{a}\")\n", 304 | " print(\"-\"*25)\n", 305 | " \n", 306 | " if is_sorted:\n", 307 | " break\n", 308 | " \n", 309 | " return a" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": 19, 315 | "id": "afa91687", 316 | "metadata": {}, 317 | "outputs": [ 318 | { 319 | "name": "stdout", 320 | "output_type": "stream", 321 | "text": [ 322 | "[2, 4, 6, 8, 12, 10]\n", 323 | "\t[2, 4, 6, 8, 12, 10]\n", 324 | "\t[2, 4, 6, 8, 12, 10]\n", 325 | "\t[2, 4, 6, 8, 12, 10]\n", 326 | "\t[2, 4, 6, 8, 12, 10]\n", 327 | "\t[2, 4, 6, 8, 10, 12]\n", 328 | "[2, 4, 6, 8, 10, 12]\n", 329 | "-------------------------\n", 330 | "\t[2, 4, 6, 8, 10, 12]\n", 331 | "\t[2, 4, 6, 8, 10, 12]\n", 332 | "\t[2, 4, 6, 8, 10, 12]\n", 333 | "\t[2, 4, 6, 8, 10, 12]\n", 334 | "[2, 4, 6, 8, 10, 12]\n", 335 | "-------------------------\n", 336 | "\t[2, 4, 6, 8, 10, 12]\n", 337 | "\t[2, 4, 6, 8, 10, 12]\n", 338 | "\t[2, 4, 6, 8, 10, 12]\n", 339 | "[2, 4, 6, 8, 10, 12]\n", 340 | "-------------------------\n", 341 | "\t[2, 4, 6, 8, 10, 12]\n", 342 | "\t[2, 4, 6, 8, 10, 12]\n", 343 | "[2, 4, 6, 8, 10, 12]\n", 344 | "-------------------------\n", 345 | "\t[2, 4, 6, 8, 10, 12]\n", 346 | "[2, 4, 6, 8, 10, 12]\n", 347 | "-------------------------\n", 348 | "[2, 4, 6, 8, 10, 12]\n", 349 | "-------------------------\n" 350 | ] 351 | }, 352 | { 353 | "data": { 354 | "text/plain": [ 355 | "[2, 4, 6, 8, 10, 12]" 356 | ] 357 | }, 358 | "execution_count": 19, 359 | "metadata": {}, 360 | "output_type": "execute_result" 361 | } 362 | ], 363 | "source": [ 364 | "bubble_sort_visual_1([2,4,6,8,12,10])" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": 20, 370 | "id": "4b625fdb", 371 | "metadata": {}, 372 | "outputs": [ 373 | { 374 | "name": "stdout", 375 | "output_type": "stream", 376 | "text": [ 377 | "[2, 4, 6, 8, 12, 10]\n", 378 | "\t[2, 4, 6, 8, 12, 10]\n", 379 | "\t[2, 4, 6, 8, 12, 10]\n", 380 | "\t[2, 4, 6, 8, 12, 10]\n", 381 | "\t[2, 4, 6, 8, 12, 10]\n", 382 | "\t[2, 4, 6, 8, 10, 12]\n", 383 | "[2, 4, 6, 8, 10, 12]\n", 384 | "-------------------------\n", 385 | "\t[2, 4, 6, 8, 10, 12]\n", 386 | "\t[2, 4, 6, 8, 10, 12]\n", 387 | "\t[2, 4, 6, 8, 10, 12]\n", 388 | "\t[2, 4, 6, 8, 10, 12]\n", 389 | "[2, 4, 6, 8, 10, 12]\n", 390 | "-------------------------\n" 391 | ] 392 | }, 393 | { 394 | "data": { 395 | "text/plain": [ 396 | "[2, 4, 6, 8, 10, 12]" 397 | ] 398 | }, 399 | "execution_count": 20, 400 | "metadata": {}, 401 | "output_type": "execute_result" 402 | } 403 | ], 404 | "source": [ 405 | "bubble_sort_visual_2([2,4,6,8,12,10])" 406 | ] 407 | }, 408 | { 409 | "cell_type": "code", 410 | "execution_count": 21, 411 | "id": "85eac0f3", 412 | "metadata": {}, 413 | "outputs": [ 414 | { 415 | "data": { 416 | "text/plain": [ 417 | "'\\nOptimized Bubble Sort - \\nO(n^2) -> worst case time complexity\\nOmega(n) -> best case time complexity\\n\\nUnoptimized Bubble Sort - \\nO(n^2)\\nOmega(n^2)\\n'" 418 | ] 419 | }, 420 | "execution_count": 21, 421 | "metadata": {}, 422 | "output_type": "execute_result" 423 | } 424 | ], 425 | "source": [ 426 | "'''\n", 427 | "Optimized Bubble Sort - \n", 428 | "O(n^2) -> worst case time complexity\n", 429 | "Omega(n) -> best case time complexity\n", 430 | "\n", 431 | "Unoptimized Bubble Sort - \n", 432 | "O(n^2)\n", 433 | "Omega(n^2)\n", 434 | "'''" 435 | ] 436 | }, 437 | { 438 | "cell_type": "code", 439 | "execution_count": 22, 440 | "id": "450602ee", 441 | "metadata": {}, 442 | "outputs": [], 443 | "source": [ 444 | "def selection_sort(a):\n", 445 | " for i in range(len(a) - 1):\n", 446 | " current_min = i\n", 447 | " \n", 448 | " for j in range(i + 1, len(a)):\n", 449 | " if a[j] < a[current_min]:\n", 450 | " current_min = j\n", 451 | " \n", 452 | " if i != current_min:\n", 453 | " a[i], a[current_min] = a[current_min], a[i]\n", 454 | " \n", 455 | " return a" 456 | ] 457 | }, 458 | { 459 | "cell_type": "code", 460 | "execution_count": 23, 461 | "id": "d510cb54", 462 | "metadata": {}, 463 | "outputs": [ 464 | { 465 | "data": { 466 | "text/plain": [ 467 | "[1, 2, 3, 4, 5, 8, 9]" 468 | ] 469 | }, 470 | "execution_count": 23, 471 | "metadata": {}, 472 | "output_type": "execute_result" 473 | } 474 | ], 475 | "source": [ 476 | "selection_sort([2,8,5,3,9,4,1])" 477 | ] 478 | }, 479 | { 480 | "cell_type": "code", 481 | "execution_count": 24, 482 | "id": "bb9084a3", 483 | "metadata": {}, 484 | "outputs": [ 485 | { 486 | "data": { 487 | "text/plain": [ 488 | "[-3, -1, 3, 4, 5, 9]" 489 | ] 490 | }, 491 | "execution_count": 24, 492 | "metadata": {}, 493 | "output_type": "execute_result" 494 | } 495 | ], 496 | "source": [ 497 | "selection_sort([9,5,3,4,-3,-1])" 498 | ] 499 | }, 500 | { 501 | "cell_type": "code", 502 | "execution_count": 25, 503 | "id": "6b7b0481", 504 | "metadata": {}, 505 | "outputs": [ 506 | { 507 | "data": { 508 | "text/plain": [ 509 | "'\\nTime Complexity ->\\n\\nn-1 + n-2 + n-3 ...... + 1 -> n(n-1)/2\\n\\nO(n^2)\\nOmega(n^2)\\n'" 510 | ] 511 | }, 512 | "execution_count": 25, 513 | "metadata": {}, 514 | "output_type": "execute_result" 515 | } 516 | ], 517 | "source": [ 518 | "'''\n", 519 | "Time Complexity ->\n", 520 | "\n", 521 | "n-1 + n-2 + n-3 ...... + 1 -> n(n-1)/2\n", 522 | "\n", 523 | "O(n^2)\n", 524 | "Omega(n^2)\n", 525 | "'''" 526 | ] 527 | }, 528 | { 529 | "cell_type": "code", 530 | "execution_count": 26, 531 | "id": "e5afeae9", 532 | "metadata": {}, 533 | "outputs": [], 534 | "source": [ 535 | "def insertion_sort(a):\n", 536 | " for i in range(1, len(a)):\n", 537 | " index_to_insert = i\n", 538 | " j = i - 1\n", 539 | " \n", 540 | " while j >= 0:\n", 541 | " if a[j] < a[index_to_insert]:\n", 542 | " break\n", 543 | " \n", 544 | " a[j], a[index_to_insert] = a[index_to_insert], a[j]\n", 545 | " index_to_insert = j\n", 546 | " j -= 1\n", 547 | " \n", 548 | " return a" 549 | ] 550 | }, 551 | { 552 | "cell_type": "code", 553 | "execution_count": 27, 554 | "id": "b44b0338", 555 | "metadata": {}, 556 | "outputs": [ 557 | { 558 | "data": { 559 | "text/plain": [ 560 | "[1, 2, 3, 4, 5]" 561 | ] 562 | }, 563 | "execution_count": 27, 564 | "metadata": {}, 565 | "output_type": "execute_result" 566 | } 567 | ], 568 | "source": [ 569 | "insertion_sort([4,5,1,3,2])" 570 | ] 571 | }, 572 | { 573 | "cell_type": "code", 574 | "execution_count": null, 575 | "id": "5af69e4b", 576 | "metadata": {}, 577 | "outputs": [], 578 | "source": [] 579 | } 580 | ], 581 | "metadata": { 582 | "kernelspec": { 583 | "display_name": "Python 3 (ipykernel)", 584 | "language": "python", 585 | "name": "python3" 586 | }, 587 | "language_info": { 588 | "codemirror_mode": { 589 | "name": "ipython", 590 | "version": 3 591 | }, 592 | "file_extension": ".py", 593 | "mimetype": "text/x-python", 594 | "name": "python", 595 | "nbconvert_exporter": "python", 596 | "pygments_lexer": "ipython3", 597 | "version": "3.9.5" 598 | } 599 | }, 600 | "nbformat": 4, 601 | "nbformat_minor": 5 602 | } 603 | -------------------------------------------------------------------------------- /1 - Comprehension + Misc Questions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "id": "69426403", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "data": { 11 | "text/plain": [ 12 | "'\\nQuestion 1 - \\nCreate a list of squares of all numbers from 1 to 10.\\n\\nOutput - [1, 4, 9, 16, 25....100]\\n'" 13 | ] 14 | }, 15 | "execution_count": 2, 16 | "metadata": {}, 17 | "output_type": "execute_result" 18 | } 19 | ], 20 | "source": [ 21 | "'''\n", 22 | "Question 1 - \n", 23 | "Create a list of squares of all numbers from 1 to 10.\n", 24 | "\n", 25 | "Output - [1, 4, 9, 16, 25....100]\n", 26 | "'''" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 3, 32 | "id": "63e8c58e", 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "result = []\n", 37 | "\n", 38 | "for i in range(1,11):\n", 39 | " result.append(i**2)" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 4, 45 | "id": "0112264b", 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "data": { 50 | "text/plain": [ 51 | "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" 52 | ] 53 | }, 54 | "execution_count": 4, 55 | "metadata": {}, 56 | "output_type": "execute_result" 57 | } 58 | ], 59 | "source": [ 60 | "result" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 7, 66 | "id": "a9e6d8aa", 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "result1 = [ i**2 for i in range(1,11) ]" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 8, 76 | "id": "7b97516f", 77 | "metadata": {}, 78 | "outputs": [ 79 | { 80 | "data": { 81 | "text/plain": [ 82 | "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" 83 | ] 84 | }, 85 | "execution_count": 8, 86 | "metadata": {}, 87 | "output_type": "execute_result" 88 | } 89 | ], 90 | "source": [ 91 | "result1" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 10, 97 | "id": "a5140e66", 98 | "metadata": {}, 99 | "outputs": [ 100 | { 101 | "data": { 102 | "text/plain": [ 103 | "'\\nQuestion 2 - \\nGiven an input list of ages, create a new list telling whether that person is above 18 or under.\\n\\nINPUT - [24, 45, 15, 12, 10, 19, 17, 20]\\nOUTPUT - [True, True, False, False, False, True, False, True]\\n\\nNOTE - False for 18 as well.\\n'" 104 | ] 105 | }, 106 | "execution_count": 10, 107 | "metadata": {}, 108 | "output_type": "execute_result" 109 | } 110 | ], 111 | "source": [ 112 | "'''\n", 113 | "Question 2 - \n", 114 | "Given an input list of ages, create a new list telling whether that person is above 18 or under.\n", 115 | "\n", 116 | "INPUT - [24, 45, 15, 12, 10, 19, 17, 20]\n", 117 | "OUTPUT - [True, True, False, False, False, True, False, True]\n", 118 | "\n", 119 | "NOTE - False for 18 as well.\n", 120 | "'''" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 11, 126 | "id": "984fedc2", 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "A = [24, 45, 15, 12, 10, 19, 17, 20]" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 14, 136 | "id": "1b031c5e", 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [ 140 | "# Approach 1\n", 141 | "\n", 142 | "result1 = []\n", 143 | "\n", 144 | "for i in A:\n", 145 | " if i <= 18:\n", 146 | " result1.append(False)\n", 147 | " else:\n", 148 | " result1.append(True)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 15, 154 | "id": "e32ef495", 155 | "metadata": {}, 156 | "outputs": [ 157 | { 158 | "data": { 159 | "text/plain": [ 160 | "[True, True, False, False, False, True, False, True]" 161 | ] 162 | }, 163 | "execution_count": 15, 164 | "metadata": {}, 165 | "output_type": "execute_result" 166 | } 167 | ], 168 | "source": [ 169 | "result1" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 17, 175 | "id": "b5857532", 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [ 179 | "# Approach 1 Optimised\n", 180 | "\n", 181 | "result1 = []\n", 182 | "\n", 183 | "for i in A:\n", 184 | " result1.append(i > 18)" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 18, 190 | "id": "51a2cdde", 191 | "metadata": {}, 192 | "outputs": [ 193 | { 194 | "data": { 195 | "text/plain": [ 196 | "[True, True, False, False, False, True, False, True]" 197 | ] 198 | }, 199 | "execution_count": 18, 200 | "metadata": {}, 201 | "output_type": "execute_result" 202 | } 203 | ], 204 | "source": [ 205 | "result1" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 19, 211 | "id": "6a49e251", 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "# Approach 2\n", 216 | "\n", 217 | "result2 = [ i > 18 for i in A ]" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": 20, 223 | "id": "e283b8e9", 224 | "metadata": {}, 225 | "outputs": [ 226 | { 227 | "data": { 228 | "text/plain": [ 229 | "[True, True, False, False, False, True, False, True]" 230 | ] 231 | }, 232 | "execution_count": 20, 233 | "metadata": {}, 234 | "output_type": "execute_result" 235 | } 236 | ], 237 | "source": [ 238 | "result2" 239 | ] 240 | }, 241 | { 242 | "cell_type": "code", 243 | "execution_count": 21, 244 | "id": "7ec32571", 245 | "metadata": {}, 246 | "outputs": [ 247 | { 248 | "data": { 249 | "text/plain": [ 250 | "'\\nQuestion 3 - \\n\\nWrite a one line python code to print the multiplication table from 1 to 10.\\n\\n1 2 3 4 5 6 7 8 9 10\\n2 4 6 8 10 12 14 16 18 20\\n.\\n.\\n.\\n.\\n.\\n10 20 30 40 50 60 70 80 90 100\\n'" 251 | ] 252 | }, 253 | "execution_count": 21, 254 | "metadata": {}, 255 | "output_type": "execute_result" 256 | } 257 | ], 258 | "source": [ 259 | "'''\n", 260 | "Question 3 - \n", 261 | "\n", 262 | "Write a one line python code to print the multiplication table from 1 to 10.\n", 263 | "\n", 264 | "1 2 3 4 5 6 7 8 9 10\n", 265 | "2 4 6 8 10 12 14 16 18 20\n", 266 | ".\n", 267 | ".\n", 268 | ".\n", 269 | ".\n", 270 | ".\n", 271 | "10 20 30 40 50 60 70 80 90 100\n", 272 | "'''" 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": 22, 278 | "id": "a63a4cb3", 279 | "metadata": {}, 280 | "outputs": [], 281 | "source": [ 282 | "mul_table = [ [ i*j for j in range(1,11) ] for i in range(1,11) ]" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 23, 288 | "id": "562c5c65", 289 | "metadata": {}, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "text/plain": [ 294 | "[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n", 295 | " [2, 4, 6, 8, 10, 12, 14, 16, 18, 20],\n", 296 | " [3, 6, 9, 12, 15, 18, 21, 24, 27, 30],\n", 297 | " [4, 8, 12, 16, 20, 24, 28, 32, 36, 40],\n", 298 | " [5, 10, 15, 20, 25, 30, 35, 40, 45, 50],\n", 299 | " [6, 12, 18, 24, 30, 36, 42, 48, 54, 60],\n", 300 | " [7, 14, 21, 28, 35, 42, 49, 56, 63, 70],\n", 301 | " [8, 16, 24, 32, 40, 48, 56, 64, 72, 80],\n", 302 | " [9, 18, 27, 36, 45, 54, 63, 72, 81, 90],\n", 303 | " [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]]" 304 | ] 305 | }, 306 | "execution_count": 23, 307 | "metadata": {}, 308 | "output_type": "execute_result" 309 | } 310 | ], 311 | "source": [ 312 | "mul_table" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": 25, 318 | "id": "4f45a616", 319 | "metadata": {}, 320 | "outputs": [], 321 | "source": [ 322 | "mul_table = []\n", 323 | "\n", 324 | "for i in range(1,11):\n", 325 | " row = []\n", 326 | " \n", 327 | " for j in range(1,11):\n", 328 | " row.append(i*j)\n", 329 | " \n", 330 | " mul_table.append(row)" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 26, 336 | "id": "4a2bb0ee", 337 | "metadata": {}, 338 | "outputs": [ 339 | { 340 | "data": { 341 | "text/plain": [ 342 | "[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n", 343 | " [2, 4, 6, 8, 10, 12, 14, 16, 18, 20],\n", 344 | " [3, 6, 9, 12, 15, 18, 21, 24, 27, 30],\n", 345 | " [4, 8, 12, 16, 20, 24, 28, 32, 36, 40],\n", 346 | " [5, 10, 15, 20, 25, 30, 35, 40, 45, 50],\n", 347 | " [6, 12, 18, 24, 30, 36, 42, 48, 54, 60],\n", 348 | " [7, 14, 21, 28, 35, 42, 49, 56, 63, 70],\n", 349 | " [8, 16, 24, 32, 40, 48, 56, 64, 72, 80],\n", 350 | " [9, 18, 27, 36, 45, 54, 63, 72, 81, 90],\n", 351 | " [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]]" 352 | ] 353 | }, 354 | "execution_count": 26, 355 | "metadata": {}, 356 | "output_type": "execute_result" 357 | } 358 | ], 359 | "source": [ 360 | "mul_table" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 27, 366 | "id": "12495114", 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [ 370 | "result = [ i*j for j in range(1,11) for i in range(1,11) ]" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": 29, 376 | "id": "898625bc", 377 | "metadata": {}, 378 | "outputs": [], 379 | "source": [ 380 | "# result" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": 34, 386 | "id": "682e4128", 387 | "metadata": {}, 388 | "outputs": [], 389 | "source": [ 390 | "result = [ (i, j) for j in [1, 2] for i in [\"A\", \"B\"] ] \n", 391 | "# Outermost loop is at the left and we go to innermost towards the right\n", 392 | "\n", 393 | "# OUTPUT\n", 394 | "# [(\"A\", 1), (\"A\", 2), (\"B\", 1), (\"B\", 2)]" 395 | ] 396 | }, 397 | { 398 | "cell_type": "code", 399 | "execution_count": 35, 400 | "id": "30263015", 401 | "metadata": {}, 402 | "outputs": [ 403 | { 404 | "data": { 405 | "text/plain": [ 406 | "[('A', 1), ('B', 1), ('A', 2), ('B', 2)]" 407 | ] 408 | }, 409 | "execution_count": 35, 410 | "metadata": {}, 411 | "output_type": "execute_result" 412 | } 413 | ], 414 | "source": [ 415 | "result" 416 | ] 417 | }, 418 | { 419 | "cell_type": "code", 420 | "execution_count": 36, 421 | "id": "80fc9ae8", 422 | "metadata": {}, 423 | "outputs": [], 424 | "source": [ 425 | "s1 = { i for i in range(1,6) }" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": 37, 431 | "id": "a73976ee", 432 | "metadata": {}, 433 | "outputs": [ 434 | { 435 | "data": { 436 | "text/plain": [ 437 | "{1, 2, 3, 4, 5}" 438 | ] 439 | }, 440 | "execution_count": 37, 441 | "metadata": {}, 442 | "output_type": "execute_result" 443 | } 444 | ], 445 | "source": [ 446 | "s1" 447 | ] 448 | }, 449 | { 450 | "cell_type": "code", 451 | "execution_count": 46, 452 | "id": "f5e94b43", 453 | "metadata": {}, 454 | "outputs": [], 455 | "source": [ 456 | "d1 = { f\"value - {i}\" : i for i in range(1, 6) }" 457 | ] 458 | }, 459 | { 460 | "cell_type": "code", 461 | "execution_count": 39, 462 | "id": "9a9c9423", 463 | "metadata": {}, 464 | "outputs": [ 465 | { 466 | "data": { 467 | "text/plain": [ 468 | "{'value - 1': 1,\n", 469 | " 'value - 2': 2,\n", 470 | " 'value - 3': 3,\n", 471 | " 'value - 4': 4,\n", 472 | " 'value - 5': 5}" 473 | ] 474 | }, 475 | "execution_count": 39, 476 | "metadata": {}, 477 | "output_type": "execute_result" 478 | } 479 | ], 480 | "source": [ 481 | "d1" 482 | ] 483 | }, 484 | { 485 | "cell_type": "code", 486 | "execution_count": 47, 487 | "id": "d0a72596", 488 | "metadata": {}, 489 | "outputs": [], 490 | "source": [ 491 | "d2 = { i : i**2 for i in range(1, 6) }" 492 | ] 493 | }, 494 | { 495 | "cell_type": "code", 496 | "execution_count": 48, 497 | "id": "8cf6869f", 498 | "metadata": {}, 499 | "outputs": [ 500 | { 501 | "data": { 502 | "text/plain": [ 503 | "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}" 504 | ] 505 | }, 506 | "execution_count": 48, 507 | "metadata": {}, 508 | "output_type": "execute_result" 509 | } 510 | ], 511 | "source": [ 512 | "d2" 513 | ] 514 | }, 515 | { 516 | "cell_type": "code", 517 | "execution_count": 40, 518 | "id": "0e954335", 519 | "metadata": {}, 520 | "outputs": [], 521 | "source": [ 522 | "t1 = ( i for i in range(1,11) )" 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "execution_count": 42, 528 | "id": "1fbc649f", 529 | "metadata": {}, 530 | "outputs": [ 531 | { 532 | "data": { 533 | "text/plain": [ 534 | " at 0x7fcdb91c6350>" 535 | ] 536 | }, 537 | "execution_count": 42, 538 | "metadata": {}, 539 | "output_type": "execute_result" 540 | } 541 | ], 542 | "source": [ 543 | "t1 # we'll learn about generator objects later" 544 | ] 545 | }, 546 | { 547 | "cell_type": "code", 548 | "execution_count": 43, 549 | "id": "010d2c46", 550 | "metadata": {}, 551 | "outputs": [ 552 | { 553 | "data": { 554 | "text/plain": [ 555 | "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)" 556 | ] 557 | }, 558 | "execution_count": 43, 559 | "metadata": {}, 560 | "output_type": "execute_result" 561 | } 562 | ], 563 | "source": [ 564 | "tuple(t1)" 565 | ] 566 | }, 567 | { 568 | "cell_type": "code", 569 | "execution_count": 44, 570 | "id": "61f76eb0", 571 | "metadata": {}, 572 | "outputs": [], 573 | "source": [ 574 | "s1 = \"i for i in range(1, 11)\"" 575 | ] 576 | }, 577 | { 578 | "cell_type": "code", 579 | "execution_count": 45, 580 | "id": "d7578fb3", 581 | "metadata": {}, 582 | "outputs": [ 583 | { 584 | "data": { 585 | "text/plain": [ 586 | "'i for i in range(1, 11)'" 587 | ] 588 | }, 589 | "execution_count": 45, 590 | "metadata": {}, 591 | "output_type": "execute_result" 592 | } 593 | ], 594 | "source": [ 595 | "s1" 596 | ] 597 | }, 598 | { 599 | "cell_type": "code", 600 | "execution_count": 58, 601 | "id": "0339ec73", 602 | "metadata": {}, 603 | "outputs": [], 604 | "source": [ 605 | "def coolest_pattern_ever(n):\n", 606 | " for i in range(n):\n", 607 | " for j in range(n):\n", 608 | " print(max(i + 1, j + 1, n - i, n - j), end = \" \")\n", 609 | " \n", 610 | " print()" 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "execution_count": 57, 616 | "id": "6ee11923", 617 | "metadata": {}, 618 | "outputs": [ 619 | { 620 | "name": "stdout", 621 | "output_type": "stream", 622 | "text": [ 623 | "3 3 3 3 2 3 3 3 3 " 624 | ] 625 | } 626 | ], 627 | "source": [ 628 | "coolest_pattern_ever(3)" 629 | ] 630 | }, 631 | { 632 | "cell_type": "code", 633 | "execution_count": null, 634 | "id": "f3f36f6d", 635 | "metadata": {}, 636 | "outputs": [], 637 | "source": [] 638 | } 639 | ], 640 | "metadata": { 641 | "kernelspec": { 642 | "display_name": "Python 3 (ipykernel)", 643 | "language": "python", 644 | "name": "python3" 645 | }, 646 | "language_info": { 647 | "codemirror_mode": { 648 | "name": "ipython", 649 | "version": 3 650 | }, 651 | "file_extension": ".py", 652 | "mimetype": "text/x-python", 653 | "name": "python", 654 | "nbconvert_exporter": "python", 655 | "pygments_lexer": "ipython3", 656 | "version": "3.9.5" 657 | } 658 | }, 659 | "nbformat": 4, 660 | "nbformat_minor": 5 661 | } 662 | --------------------------------------------------------------------------------