├── Cormen, Thomas H._ Leiserson, Charles E._ Rivest, Ronald L._ Ste - Introduction to Algorithms (2022) - libgen.li.pdf ├── Lecture 1 └── Live Session Notes.pdf ├── Lecture 2 ├── Array Data Structure.ipynb └── Live Session Notes.pdf ├── Lecture 3 ├── Code Reference.txt └── Live Session Notes.pdf ├── Lecture 4 ├── Live Session Notes.pdf └── Recursion_Practice_Problems.ipynb ├── README.md └── Recursion_Practice_Problems.ipynb /Cormen, Thomas H._ Leiserson, Charles E._ Rivest, Ronald L._ Ste - Introduction to Algorithms (2022) - libgen.li.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/priya6971/Full-Stack-Data-Science-Pro-Batch/4c4943c23a5f712228e9faf1c74a4b9aa7a23883/Cormen, Thomas H._ Leiserson, Charles E._ Rivest, Ronald L._ Ste - Introduction to Algorithms (2022) - libgen.li.pdf -------------------------------------------------------------------------------- /Lecture 1/Live Session Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/priya6971/Full-Stack-Data-Science-Pro-Batch/4c4943c23a5f712228e9faf1c74a4b9aa7a23883/Lecture 1/Live Session Notes.pdf -------------------------------------------------------------------------------- /Lecture 2/Array Data Structure.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 9, 6 | "id": "d4246146-abf4-4566-ac0f-f7f58ff8b4b3", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "282\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "## Method definition of the sum function\n", 19 | "## Time complexity: O(n)\n", 20 | "## Space complexity: O(1)\n", 21 | "\n", 22 | "def summation(arr):\n", 23 | " n = len(arr)\n", 24 | " sumVal = 0\n", 25 | " for i in range(n):\n", 26 | " sumVal += arr[i]\n", 27 | " return sumVal\n", 28 | "\n", 29 | "## Driver code\n", 30 | "arr = [23, 34, 64, 12, 25, 56, 68]\n", 31 | "result = summation(arr)\n", 32 | "print(result)" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 4, 38 | "id": "fb0fab29-fbc5-4309-bf95-e09287476065", 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "## built in functions you discussed in the list session are available here as well\n", 43 | "arr = [23, 34, 56, 78, 89]\n", 44 | "arr.insert(1, 24)" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 5, 50 | "id": "a516f171-ceed-4954-9614-75bdc032678c", 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "data": { 55 | "text/plain": [ 56 | "[23, 24, 34, 56, 78, 89]" 57 | ] 58 | }, 59 | "execution_count": 5, 60 | "metadata": {}, 61 | "output_type": "execute_result" 62 | } 63 | ], 64 | "source": [ 65 | "arr" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 7, 71 | "id": "d54ca7c4-0e80-429f-8669-58f53a1f9c5d", 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "arr.remove(24)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 8, 81 | "id": "46480f4a-dfe0-4940-9a19-5b347c69dae1", 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "text/plain": [ 87 | "[23, 34, 56, 78, 89]" 88 | ] 89 | }, 90 | "execution_count": 8, 91 | "metadata": {}, 92 | "output_type": "execute_result" 93 | } 94 | ], 95 | "source": [ 96 | "arr" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 12, 102 | "id": "caf9623b-9165-4c95-8470-8ea3320a2985", 103 | "metadata": {}, 104 | "outputs": [ 105 | { 106 | "name": "stdout", 107 | "output_type": "stream", 108 | "text": [ 109 | "7\n" 110 | ] 111 | } 112 | ], 113 | "source": [ 114 | "## Searching Algorithms\n", 115 | "## time complexity: O(n)\n", 116 | "## space complexity: O(1)\n", 117 | "def linearSearch(arr, target):\n", 118 | " for i in range(len(arr)):\n", 119 | " if(arr[i] == target):\n", 120 | " return i\n", 121 | " ## in case element is not available in the array\n", 122 | " return -1\n", 123 | "\n", 124 | "## print -1 [it indicates that the target values is not available in the array]\n", 125 | "## Driver code\n", 126 | "arr = [12, 14, 16, 18, 11, 22, 26, 29]\n", 127 | "target = 29\n", 128 | "result = linearSearch(arr, target)\n", 129 | "print(result)" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 15, 135 | "id": "48683d2e-739a-418b-864a-de774bea2fc9", 136 | "metadata": {}, 137 | "outputs": [ 138 | { 139 | "name": "stdout", 140 | "output_type": "stream", 141 | "text": [ 142 | "([2, 18, 22], [5, 11, 13, 15])\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "## arr = [2, 5, 11, 13, 15, 18, 22]\n", 148 | "## even and odd array contaning even num and odd num\n", 149 | "## time complexity: O(n)\n", 150 | "## space complexity: O(n)\n", 151 | "\n", 152 | "## creating an external data structure[list[ to store the even and odd values\n", 153 | "even = []\n", 154 | "odd = []\n", 155 | "\n", 156 | "def evenAndodd(arr):\n", 157 | " ## write your own logic\n", 158 | " for i in arr:\n", 159 | " if i % 2 == 0:\n", 160 | " even.append(i)\n", 161 | " else:\n", 162 | " odd.append(i)\n", 163 | " return even, odd\n", 164 | "\n", 165 | "## Driver code\n", 166 | "arr = [2, 5, 11, 13, 15, 18, 22]\n", 167 | "print(evenAndodd(arr))\n" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 17, 173 | "id": "0b6388fb-472a-4d58-a4a3-2db1098e34bd", 174 | "metadata": {}, 175 | "outputs": [ 176 | { 177 | "name": "stdout", 178 | "output_type": "stream", 179 | "text": [ 180 | "Primary Diagonal Sum: 32\n", 181 | "Secondary Diagonal Sum: 31\n" 182 | ] 183 | } 184 | ], 185 | "source": [ 186 | "## function defintion\n", 187 | "## priya.bhatia@pw.live\n", 188 | "## time complexity: O(n^2)\n", 189 | "## space complexity: O(1)\n", 190 | "\n", 191 | "def printDiagonalSum(arr):\n", 192 | " n = len(arr)\n", 193 | " primaryDiagonalSum = 0\n", 194 | " secondaryDiagonalSum = 0\n", 195 | " for i in range(n):\n", 196 | " for j in range(n):\n", 197 | " ## condition to get the elements of primary diagonal\n", 198 | " if i == j:\n", 199 | " primaryDiagonalSum += arr[i][j]\n", 200 | " \n", 201 | " ## condition to get the elements of secondary diagonal \n", 202 | " if((i+j) == (n-1)):\n", 203 | " secondaryDiagonalSum += arr[i][j]\n", 204 | " print(\"Primary Diagonal Sum: \", primaryDiagonalSum)\n", 205 | " print(\"Secondary Diagonal Sum: \", secondaryDiagonalSum)\n", 206 | "\n", 207 | "## Driver code\n", 208 | "arr = [[2, 4, 6], [8, 11, 13], [14, 17, 19]]\n", 209 | "## function calling\n", 210 | "printDiagonalSum(arr)" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": null, 216 | "id": "872524cd-4a0a-47ff-8ae0-bca393a3f9ac", 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [ 220 | "## Properties of Logarithmic\n", 221 | "## Asymptotic Notations - Mathematical Idea/Intution\n", 222 | "## Arrays - 1D/2D Array\n", 223 | "## Random access - Searching and Sorting\n", 224 | "## Numerous coding problems[Linear Search, EvenOdd, Summation, DiagonalSum]\n", 225 | "## Time and Space Complexity\n", 226 | "## Next Session - Binary Search, Sorting Algorithms\n", 227 | "## Next Session - Recursion (Can't miss this session)" 228 | ] 229 | } 230 | ], 231 | "metadata": { 232 | "kernelspec": { 233 | "display_name": "Python 3 (ipykernel)", 234 | "language": "python", 235 | "name": "python3" 236 | }, 237 | "language_info": { 238 | "codemirror_mode": { 239 | "name": "ipython", 240 | "version": 3 241 | }, 242 | "file_extension": ".py", 243 | "mimetype": "text/x-python", 244 | "name": "python", 245 | "nbconvert_exporter": "python", 246 | "pygments_lexer": "ipython3", 247 | "version": "3.10.8" 248 | } 249 | }, 250 | "nbformat": 4, 251 | "nbformat_minor": 5 252 | } 253 | -------------------------------------------------------------------------------- /Lecture 2/Live Session Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/priya6971/Full-Stack-Data-Science-Pro-Batch/4c4943c23a5f712228e9faf1c74a4b9aa7a23883/Lecture 2/Live Session Notes.pdf -------------------------------------------------------------------------------- /Lecture 3/Code Reference.txt: -------------------------------------------------------------------------------- 1 | 1. Factorial of a given number 2 | // time complexity: O(n) 3 | // space complexity: O(n) 4 | ## Factorial of a given number 5 | ## Method definition via the recursion 6 | def factorial(n): 7 | ## 1. Base case condition 8 | if n <= 1: 9 | return 1 10 | 11 | ## 2. Recursive function call 12 | return n * factorial(n-1) 13 | 14 | ## Driver code 15 | n = 50 16 | result = factorial(n) 17 | print(result) 18 | 19 | 2. Fibonnaci Series 20 | // time complexity: O(2^n) 21 | // space complexity: O(n) 22 | 23 | class Solution: 24 | def fib(self, n: int) -> int: 25 | ## base case condition 26 | if n <= 1: 27 | return n 28 | 29 | ## recursive function call 30 | return self.fib(n-1) + self.fib(n-2) 31 | 32 | 33 | 3. Climbing Stairs 34 | // time complexity: O(2^n) 35 | // space complexity: O(n) 36 | 37 | TLE - Time Limit Exceeded because test cases taking bigger values of n 38 | class Solution: 39 | def climbStairs(self, n: int) -> int: 40 | if n <= 3: 41 | return n 42 | 43 | return self.climbStairs(n-1) + self.climbStairs(n-2) 44 | 45 | 46 | Optimized Approach - Iterative Approach 47 | // time complexity: O(n) 48 | // space complexity: O(1) 49 | class Solution: 50 | def climbStairs(self, n: int) -> int: 51 | ## base case condition 52 | if n == 1: 53 | return 1 54 | ## bigger value of n 55 | first = 1 56 | second = 2 57 | for i in range(3,n+1): 58 | third = first + second 59 | first = second 60 | second = third 61 | return second 62 | 63 | 64 | -------------------------------------------------------------------------------- /Lecture 3/Live Session Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/priya6971/Full-Stack-Data-Science-Pro-Batch/4c4943c23a5f712228e9faf1c74a4b9aa7a23883/Lecture 3/Live Session Notes.pdf -------------------------------------------------------------------------------- /Lecture 4/Live Session Notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/priya6971/Full-Stack-Data-Science-Pro-Batch/4c4943c23a5f712228e9faf1c74a4b9aa7a23883/Lecture 4/Live Session Notes.pdf -------------------------------------------------------------------------------- /Lecture 4/Recursion_Practice_Problems.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [] 7 | }, 8 | "kernelspec": { 9 | "name": "python3", 10 | "display_name": "Python 3" 11 | }, 12 | "language_info": { 13 | "name": "python" 14 | } 15 | }, 16 | "cells": [ 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": { 21 | "colab": { 22 | "base_uri": "https://localhost:8080/" 23 | }, 24 | "id": "h38Anq06MFCf", 25 | "outputId": "bb873fd9-0d34-4331-fa33-570fa2662c59" 26 | }, 27 | "outputs": [ 28 | { 29 | "output_type": "stream", 30 | "name": "stdout", 31 | "text": [ 32 | "10\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "## Method definition\n", 38 | "## Time complexity: O(n)\n", 39 | "## Space complexity: O(n) [n indicates the number of digits]\n", 40 | "def sum_of_digits(n):\n", 41 | " ## base case condition\n", 42 | " if n < 10:\n", 43 | " return n\n", 44 | " else:\n", 45 | " ## recursive function call\n", 46 | " return n % 10 + sum_of_digits(n // 10)\n", 47 | "\n", 48 | "\n", 49 | "## Driver code\n", 50 | "n = 1234\n", 51 | "result = sum_of_digits(n)\n", 52 | "print(result)" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "source": [ 58 | "## Method definition\n", 59 | "## Time complexity: O(n)\n", 60 | "## Space complexity: O(n)\n", 61 | "\n", 62 | "def powerOf(a,n):\n", 63 | " ## base case condition\n", 64 | " if n==0:\n", 65 | " return 1\n", 66 | " else:\n", 67 | " ## recursive function call\n", 68 | " return a*powerOf(a,n-1)\n", 69 | "\n", 70 | "\n", 71 | "## Driver code\n", 72 | "a = 2\n", 73 | "n = 16\n", 74 | "result = powerOf(a, n)\n", 75 | "print(result)\n" 76 | ], 77 | "metadata": { 78 | "colab": { 79 | "base_uri": "https://localhost:8080/" 80 | }, 81 | "id": "aDUCWXBrM-x3", 82 | "outputId": "2a121b0c-964d-41ec-d2cd-971c92ebcdd6" 83 | }, 84 | "execution_count": 2, 85 | "outputs": [ 86 | { 87 | "output_type": "stream", 88 | "name": "stdout", 89 | "text": [ 90 | "65536\n" 91 | ] 92 | } 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "source": [ 98 | "## Method definition\n", 99 | "def powerFind(a, n):\n", 100 | " ## base case condition\n", 101 | " if n == 1:\n", 102 | " return a\n", 103 | "\n", 104 | " ## recursive function calls\n", 105 | " else:\n", 106 | " mid = n // 2\n", 107 | " result = powerFind(a, mid)\n", 108 | " finalResult = result * result\n", 109 | "\n", 110 | " ## checking whether the value of n is even or odd\n", 111 | " if n % 2 == 0:\n", 112 | " return finalResult\n", 113 | " else:\n", 114 | " return a * finalResult\n", 115 | "\n", 116 | "## Driver code\n", 117 | "a = 2\n", 118 | "n = 19\n", 119 | "result = powerFind(a, n)\n", 120 | "print(result)" 121 | ], 122 | "metadata": { 123 | "colab": { 124 | "base_uri": "https://localhost:8080/" 125 | }, 126 | "id": "_4BSHPzhTyex", 127 | "outputId": "145566a7-2d49-497c-9dac-04cc7b98f9a1" 128 | }, 129 | "execution_count": 5, 130 | "outputs": [ 131 | { 132 | "output_type": "stream", 133 | "name": "stdout", 134 | "text": [ 135 | "524288\n" 136 | ] 137 | } 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "source": [ 143 | "Task: https://leetcode.com/problems/powx-n/description/" 144 | ], 145 | "metadata": { 146 | "id": "8BwOF_YTZ0Ss" 147 | } 148 | }, 149 | { 150 | "cell_type": "code", 151 | "source": [ 152 | "5//2" 153 | ], 154 | "metadata": { 155 | "colab": { 156 | "base_uri": "https://localhost:8080/" 157 | }, 158 | "id": "lJiDyry6YZEx", 159 | "outputId": "9d44e338-f959-441e-8e8e-9503dbc08370" 160 | }, 161 | "execution_count": 6, 162 | "outputs": [ 163 | { 164 | "output_type": "execute_result", 165 | "data": { 166 | "text/plain": [ 167 | "2" 168 | ] 169 | }, 170 | "metadata": {}, 171 | "execution_count": 6 172 | } 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "source": [ 178 | "5/2" 179 | ], 180 | "metadata": { 181 | "colab": { 182 | "base_uri": "https://localhost:8080/" 183 | }, 184 | "id": "1DbJnAS2ajxb", 185 | "outputId": "079c9647-6c6c-489a-9f33-8803a7131033" 186 | }, 187 | "execution_count": 7, 188 | "outputs": [ 189 | { 190 | "output_type": "execute_result", 191 | "data": { 192 | "text/plain": [ 193 | "2.5" 194 | ] 195 | }, 196 | "metadata": {}, 197 | "execution_count": 7 198 | } 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "source": [], 204 | "metadata": { 205 | "id": "AuldAcE_alBt" 206 | }, 207 | "execution_count": null, 208 | "outputs": [] 209 | } 210 | ] 211 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Full-Stack-Data-Science-Pro-Batch 2 | DSA with Python 3 | -------------------------------------------------------------------------------- /Recursion_Practice_Problems.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [] 7 | }, 8 | "kernelspec": { 9 | "name": "python3", 10 | "display_name": "Python 3" 11 | }, 12 | "language_info": { 13 | "name": "python" 14 | } 15 | }, 16 | "cells": [ 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": { 21 | "colab": { 22 | "base_uri": "https://localhost:8080/" 23 | }, 24 | "id": "h38Anq06MFCf", 25 | "outputId": "bb873fd9-0d34-4331-fa33-570fa2662c59" 26 | }, 27 | "outputs": [ 28 | { 29 | "output_type": "stream", 30 | "name": "stdout", 31 | "text": [ 32 | "10\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "## Method definition\n", 38 | "## Time complexity: O(n)\n", 39 | "## Space complexity: O(n) [n indicates the number of digits]\n", 40 | "def sum_of_digits(n):\n", 41 | " ## base case condition\n", 42 | " if n < 10:\n", 43 | " return n\n", 44 | " else:\n", 45 | " ## recursive function call\n", 46 | " return n % 10 + sum_of_digits(n // 10)\n", 47 | "\n", 48 | "\n", 49 | "## Driver code\n", 50 | "n = 1234\n", 51 | "result = sum_of_digits(n)\n", 52 | "print(result)" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "source": [ 58 | "## Method definition\n", 59 | "## Time complexity: O(n)\n", 60 | "## Space complexity: O(n)\n", 61 | "\n", 62 | "def powerOf(a,n):\n", 63 | " ## base case condition\n", 64 | " if n==0:\n", 65 | " return 1\n", 66 | " else:\n", 67 | " ## recursive function call\n", 68 | " return a*powerOf(a,n-1)\n", 69 | "\n", 70 | "\n", 71 | "## Driver code\n", 72 | "a = 2\n", 73 | "n = 16\n", 74 | "result = powerOf(a, n)\n", 75 | "print(result)\n" 76 | ], 77 | "metadata": { 78 | "colab": { 79 | "base_uri": "https://localhost:8080/" 80 | }, 81 | "id": "aDUCWXBrM-x3", 82 | "outputId": "2a121b0c-964d-41ec-d2cd-971c92ebcdd6" 83 | }, 84 | "execution_count": 2, 85 | "outputs": [ 86 | { 87 | "output_type": "stream", 88 | "name": "stdout", 89 | "text": [ 90 | "65536\n" 91 | ] 92 | } 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "source": [ 98 | "## Method definition\n", 99 | "def powerFind(a, n):\n", 100 | " ## base case condition\n", 101 | " if n == 1:\n", 102 | " return a\n", 103 | "\n", 104 | " ## recursive function calls\n", 105 | " else:\n", 106 | " mid = n // 2\n", 107 | " result = powerFind(a, mid)\n", 108 | " finalResult = result * result\n", 109 | "\n", 110 | " ## checking whether the value of n is even or odd\n", 111 | " if n % 2 == 0:\n", 112 | " return finalResult\n", 113 | " else:\n", 114 | " return a * finalResult\n", 115 | "\n", 116 | "## Driver code\n", 117 | "a = 2\n", 118 | "n = 19\n", 119 | "result = powerFind(a, n)\n", 120 | "print(result)" 121 | ], 122 | "metadata": { 123 | "colab": { 124 | "base_uri": "https://localhost:8080/" 125 | }, 126 | "id": "_4BSHPzhTyex", 127 | "outputId": "145566a7-2d49-497c-9dac-04cc7b98f9a1" 128 | }, 129 | "execution_count": 5, 130 | "outputs": [ 131 | { 132 | "output_type": "stream", 133 | "name": "stdout", 134 | "text": [ 135 | "524288\n" 136 | ] 137 | } 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "source": [ 143 | "Task: https://leetcode.com/problems/powx-n/description/" 144 | ], 145 | "metadata": { 146 | "id": "8BwOF_YTZ0Ss" 147 | } 148 | }, 149 | { 150 | "cell_type": "code", 151 | "source": [ 152 | "5//2" 153 | ], 154 | "metadata": { 155 | "colab": { 156 | "base_uri": "https://localhost:8080/" 157 | }, 158 | "id": "lJiDyry6YZEx", 159 | "outputId": "9d44e338-f959-441e-8e8e-9503dbc08370" 160 | }, 161 | "execution_count": 6, 162 | "outputs": [ 163 | { 164 | "output_type": "execute_result", 165 | "data": { 166 | "text/plain": [ 167 | "2" 168 | ] 169 | }, 170 | "metadata": {}, 171 | "execution_count": 6 172 | } 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "source": [ 178 | "5/2" 179 | ], 180 | "metadata": { 181 | "colab": { 182 | "base_uri": "https://localhost:8080/" 183 | }, 184 | "id": "1DbJnAS2ajxb", 185 | "outputId": "079c9647-6c6c-489a-9f33-8803a7131033" 186 | }, 187 | "execution_count": 7, 188 | "outputs": [ 189 | { 190 | "output_type": "execute_result", 191 | "data": { 192 | "text/plain": [ 193 | "2.5" 194 | ] 195 | }, 196 | "metadata": {}, 197 | "execution_count": 7 198 | } 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "source": [], 204 | "metadata": { 205 | "id": "AuldAcE_alBt" 206 | }, 207 | "execution_count": null, 208 | "outputs": [] 209 | } 210 | ] 211 | } --------------------------------------------------------------------------------