nov3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# n - 1 steps\n",
    "# O(n) - order of n.\n",
    "n = 10\n",
    "while n > 1:\n",
    "    print(n)\n",
    "    n = n - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-35c4fc76416b>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-35c4fc76416b>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    2n -> order of n\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "2n -> order of n\n",
    "2n - 10 -> order of n\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total 5050\n"
     ]
    }
   ],
   "source": [
    "# 1 + 2 + 3 + .... + n\n",
    "i = 1\n",
    "total = 0\n",
    "n = 100\n",
    "while i <= n:\n",
    "    total = total + i\n",
    "    i += 1\n",
    "print(f\"Total {total}\")\n",
    "#Complexity: Order of n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Complexity: Order of n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5050"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(1,n+1)) #Complexity: Order of n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for n numbers 1, 2, 3...n\n",
    "# Sum: n*(n+1)/2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050.0\n"
     ]
    }
   ],
   "source": [
    "n = 100\n",
    "print(n*(n+1)/2)\n",
    "#Complexity: Order of 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55.0\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "print(n*(n+1)/2) # It is a function number of digits in a number.\n",
    "#Complexity: Order of number of digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 -> 99 ~ 100\n",
    "3 -> 999 ~ 1000\n",
    "4 -> 9999 ~ 10000\n",
    "number of digits = log(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['5', '6', '0', '8', '8']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(str(123*456))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(10**0.5) # 10**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5440680443502757"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(35)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34.999351707968145"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**1.54406"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.006105525288209"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**.6995"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6989700043360189"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.99552105106688"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(989739837249899883749238)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(str(989739837249899883749238))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# order of complexity is k**2 where k is number of number of digit\n",
    "# order of complexity is [log(n)]**2, where n is the max of the two number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myint(d):\n",
    "    return ord(d) - ord('0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Picking 6\n",
      "Picking 5\n",
      "Picking 4\n"
     ]
    }
   ],
   "source": [
    "num1 = ['1','2','3'] #123\n",
    "num2 = ['4','5','6'] #456\n",
    "def multiplyBasic(num1, num2):\n",
    "    i = len(num2) - 1\n",
    "    while i >= 0:\n",
    "        n2 = num2[i]\n",
    "        print(f\"Picking {n2}\")\n",
    "        i -= 1 # i = i - 1\n",
    "multiplyBasic(num1, num2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = ['1','2','3'] #123\n",
    "num2 = ['4','5','6'] #456\n",
    "def multiply0(num1, num2):\n",
    "    i = len(num2) - 1\n",
    "    while i >= 0:\n",
    "        n2 = num2[i]\n",
    "        j = len(num1) - 1\n",
    "        print(f\"{n2}\")\n",
    "        while j >= 0:\n",
    "            n1 = num1[j]\n",
    "            print(f\"Multiplying {n2} <> {n1}\")\n",
    "            j -= 1\n",
    "        i -= 1 # i = i - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "Multiplying 6 <> 3\n",
      "Multiplying 6 <> 2\n",
      "Multiplying 6 <> 1\n",
      "5\n",
      "Multiplying 5 <> 3\n",
      "Multiplying 5 <> 2\n",
      "Multiplying 5 <> 1\n",
      "4\n",
      "Multiplying 4 <> 3\n",
      "Multiplying 4 <> 2\n",
      "Multiplying 4 <> 1\n"
     ]
    }
   ],
   "source": [
    "num1 = ['1','2','3'] #123\n",
    "num2 = ['4','5','6'] #456\n",
    "multiply0(num1, num2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5784"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "723*8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiplyby1digit(num1, n2): # ['7','2','3']*8 -> [5,7,8,4]\n",
    "    j = len(num1) - 1\n",
    "    carryover = 0\n",
    "    output = []\n",
    "    while j >= 0:\n",
    "        n1 = num1[j]\n",
    "        print(f\"Multiplying {n2} <> {n1}\")\n",
    "        result = myint(n1) * myint(n2) + carryover # 6 * 3 + 0\n",
    "        output.append(result%10) # 18 % 10 -> 8\n",
    "        carryover = result // 10\n",
    "        j -= 1\n",
    "    if carryover > 0:\n",
    "        output.append(carryover)\n",
    "    print('before: ', output)\n",
    "    output.reverse()\n",
    "    print(output)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplying 8 <> 3\n",
      "Multiplying 8 <> 2\n",
      "Multiplying 8 <> 7\n",
      "before:  [4, 8, 7, 5]\n",
      "[5, 7, 8, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[5, 7, 8, 4]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiplyby1digit(['7','2','3'], '8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = ['1','2','3'] #123\n",
    "num2 = ['4','5','6'] #456\n",
    "def multiply(num1, num2):\n",
    "    i = len(num2) - 1\n",
    "    result = []\n",
    "    while i >= 0:\n",
    "        n2 = num2[i]\n",
    "        res = multiplyby1digit(num1, n2)\n",
    "        result.append(res)\n",
    "        i -= 1 # i = i - 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplying 6 <> 3\n",
      "Multiplying 6 <> 2\n",
      "Multiplying 6 <> 1\n",
      "before:  [8, 3, 7]\n",
      "[7, 3, 8]\n",
      "Multiplying 5 <> 3\n",
      "Multiplying 5 <> 2\n",
      "Multiplying 5 <> 1\n",
      "before:  [5, 1, 6]\n",
      "[6, 1, 5]\n",
      "Multiplying 4 <> 3\n",
      "Multiplying 4 <> 2\n",
      "Multiplying 4 <> 1\n",
      "before:  [2, 9, 4]\n",
      "[4, 9, 2]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[7, 3, 8], [6, 1, 5], [4, 9, 2]]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1 = ['1','2','3'] #123\n",
    "num2 = ['4','5','6'] #456\n",
    "multiply(num1, num2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shiftandadd(num1, num2):# ([1, 7, 3, 8], [6, 1, 5]) -> [ 6, 8, 8, 8]\n",
    "    num2.append(0)\n",
    "    i = len(num1) - 1\n",
    "    j = len(num2) - 1\n",
    "    result = []\n",
    "    carryover = 0\n",
    "    while i > -1 or j > -1:\n",
    "        if i >= 0:\n",
    "            n1 = num1[i]\n",
    "        else:\n",
    "            n1 = 0\n",
    "        \n",
    "        if j >= 0:\n",
    "            n2 = num2[j]\n",
    "        else:\n",
    "            n2 = 0\n",
    "        r = n1 + n2 + carryover\n",
    "#         print(f\"{n1} + {n2} -> {r}\")\n",
    "        result.append(r%10)\n",
    "        carryover = r // 10\n",
    "        i -= 1\n",
    "        j -= 1\n",
    "    if carryover > 0:\n",
    "        result.append(carryover)\n",
    "    result.reverse()\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 + 0 -> 9\n",
      "9 + 1 -> 10\n",
      "0 + 9 -> 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 0, 0, 9]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shiftandadd([9,9], [9, 1]) #[1, 7, 3, 8], [6, 1, 5, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 0 -> 1\n",
      "2 + 1 -> 3\n",
      "1 + 3 -> 4\n",
      "0 + 1 -> 1\n"
     ]
    }
   ],
   "source": [
    "# [1, 1, 1] + [1,2,1] + [1, 3, 1]\n",
    "\n",
    "r = shiftandadd([1,2,1], [1, 3, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 0 -> 1\n",
      "1 + 1 -> 2\n",
      "1 + 3 -> 4\n",
      "0 + 4 -> 4\n",
      "0 + 1 -> 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 4, 4, 2, 1]"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shiftandadd([1,1,1], r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 8, 8, 8]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shiftandadd([7, 3, 8], [6, 1, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 1]\n",
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "nums = [[1, 1], [1,2], [2,1]]\n",
    "print(nums[-1])\n",
    "print(nums[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "remaining = nums[:-2]\n",
    "remaining.append([1,4,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1], [1, 4, 4]]"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "remaining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [[1, 1], [1,1], [1,1][] -> [1,2,2,1]\n",
    "def shift_and_add_arrays(nums):\n",
    "    if len(nums) == 0:\n",
    "        return None\n",
    "    if len(nums) == 1:\n",
    "        return nums[0]\n",
    "    n2 = nums[-1]\n",
    "    n1 = nums[-2]\n",
    "    r = shiftandadd(n1, n2)\n",
    "    remaining = nums[:-2]\n",
    "    remaining.append(r)\n",
    "    return shift_and_add_arrays(remaining)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 2, 1]"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shift_and_add_arrays([[1, 1, 1], [1,1, 1], [1,1,1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = ['9','2','3'] #123\n",
    "num2 = ['4','5','6'] #456\n",
    "def multiply(num1, num2):\n",
    "    i = len(num2) - 1\n",
    "    result = []\n",
    "    while i >= 0:\n",
    "        n2 = num2[i]\n",
    "        res = multiplyby1digit(num1, n2)\n",
    "        result.append(res)\n",
    "        i -= 1 # i = i - 1\n",
    "    return shift_and_add_arrays(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplying 6 <> 3\n",
      "Multiplying 6 <> 2\n",
      "Multiplying 6 <> 9\n",
      "before:  [8, 3, 5, 5]\n",
      "[5, 5, 3, 8]\n",
      "Multiplying 5 <> 3\n",
      "Multiplying 5 <> 2\n",
      "Multiplying 5 <> 9\n",
      "before:  [5, 1, 6, 4]\n",
      "[4, 6, 1, 5]\n",
      "Multiplying 4 <> 3\n",
      "Multiplying 4 <> 2\n",
      "Multiplying 4 <> 9\n",
      "before:  [2, 9, 6, 3]\n",
      "[3, 6, 9, 2]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[4, 2, 0, 8, 8, 8]"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(['9','2','3'], ['4','5','6'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "420888\n"
     ]
    }
   ],
   "source": [
    "def cal(n1, n2):\n",
    "    print(int(''.join(n1)) * int(''.join(n2)))\n",
    "    \n",
    "cal(['9','2','3'], ['4','5','6'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your own add digit arrays\n",
    "[1,1,2] + [1,2,1] -> [2, 3,3]\n",
    "[1,2] + [1,0] -> [2,2]\n",
    "\n",
    "\n",
    "# Write the matrix multiplication\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_digit_decimals(num_str1, num_str2): \"2.3\", \"4.56\" -> \"6.86\"\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an array of n size with 0zeros\n",
    "create_array(4) # [0, 0, 0, 0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_zeros_array(n):\n",
    "    arr = []\n",
    "    for i in range(n):\n",
    "        arr.append(0)\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "create_zeros_array(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_zeros_array1(n):\n",
    "    return [0 for i in range(n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "create_zeros_array1(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delete(combox_box, arr_indices):\n",
    "    # elements shift, 1,2, 3\n",
    "    #....\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [[1,2,3],[4,6,7]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[-1][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}