oct 6.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200.0\n"
     ]
    }
   ],
   "source": [
    "p = 1000\n",
    "r = 10\n",
    "t = 2\n",
    "print(p*r*t/100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hypotenuse:  5.0\n"
     ]
    }
   ],
   "source": [
    "base = 3\n",
    "perp = 4\n",
    "hyp = math.sqrt(base*base +perp*perp)\n",
    "print(\"Hypotenuse: \", hyp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.280109889280518\n"
     ]
    }
   ],
   "source": [
    "# Problem: \n",
    "x1, y1 = 10, 20\n",
    "x2, y2 = 12, 13\n",
    "\n",
    "'''\n",
    "The way to think about \n",
    "it is using the triangle visuals\n",
    "and we basicall\n",
    "'''\n",
    "d = math.sqrt((x2-x1)**2+(y2-y1)**2)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.280109889280518\n"
     ]
    }
   ],
   "source": [
    "# Problem: \n",
    "x1, y1 = 10, 20\n",
    "x2, y2 = 12, 13\n",
    "\n",
    "'''\n",
    "The way to think about \n",
    "it is using the triangle visuals\n",
    "and we basicall\n",
    "'''\n",
    "base = x2 - x1\n",
    "perp = y2 - y1\n",
    "\n",
    "d = math.sqrt(base*base +perp*perp)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is the comment\n",
    "\n",
    "x = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "fname = \"Sandeep\"\n",
    "lname = 'Giri'\n",
    "descrption = '''He is someone who lives in India and Canda.\n",
    "He has a family.\n",
    "He run cloudxlab.\n",
    "He is passionate about coding\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sandeep Giri He is someone who lives in India and Canda.\n",
      "He has a family.\n",
      "He run cloudxlab.\n",
      "He is passionate about coding\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(fname, lname, descrption)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FInd the distance between the two points\n",
    "\n",
    "x1, y1, z1 = 10, 20, 30\n",
    "x2, y2, z2 = 2, 3, 4\n",
    "print(\"Distance: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThe way to think about \\nit is using the triangle visuals\\nand we basicall\\n'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "The way to think about \n",
    "it is using the triangle visuals\n",
    "and we basicall\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThe way to think about \\nit is using the triangle visuals\\nand we basicall\\n'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "The way to think about \n",
    "it is using the triangle visuals\n",
    "and we basicall\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"D'silva\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "msg = \"\\\" is a double quote.\\' is a single quote\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\" is a double quote.' is a single quote\n"
     ]
    }
   ],
   "source": [
    "print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "msg = \"\\\" is a double quote.\\' is a single quote. \\\\ is a slash\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\" is a double quote.' is a single quote. \\ is a slash\n"
     ]
    }
   ],
   "source": [
    "print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\\\ are double slash\n"
     ]
    }
   ],
   "source": [
    "print(\"\\\\\\\\ are double slash\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute L1 distance between two points\n",
    "\n",
    "x1, y1 = 5, 6\n",
    "\n",
    "x2, y2 = 7, 8\n",
    "\n",
    "distance: 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "96"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 << "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b10, 0b100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "492"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "123 << 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 >> 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b101101'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b101110'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(46)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b11111'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(31)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b100'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(0b100 & 0b110)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 & 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b110'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(0b100 | 0b110)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b1110'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(0b1010 | 0b1100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 12)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b1010, 0b1100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 | 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 63)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0x15, 0o77"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b1100'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 & 1 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 & 1 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "123 & 1 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2816278168 & 1 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "14 % 3 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'-0b1000000000001'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(~0b1000000000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'-0b1'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "~4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-35"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "~34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 ^ 0 # XOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 ^ 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 ^ 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 ^ 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "XOR:\n",
    "1. If you flip any input, out will flip.\n",
    "2. You can recover one of the values given other two."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n"
     ]
    }
   ],
   "source": [
    "a = 12\n",
    "b = 45\n",
    "c = a ^ b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('0b1100', '0b101101', '0b100001')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(12), bin(45), bin(33)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 ^ 45"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "33 ^ 45"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 ^ 33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RAID5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10, 20, 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok\n"
     ]
    }
   ],
   "source": [
    "amount = 30\n",
    "if amount > 50:\n",
    "    print(\"Higher than 50\")\n",
    "print(\"ok\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "amount = 30\n",
    "if amount > 50:\n",
    "    print(\"Higher than 50\")\n",
    "    print(\"ok\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Higher than 50\n",
      "ok\n"
     ]
    }
   ],
   "source": [
    "amount = 300\n",
    "if amount > 50:\n",
    "    print(\"Higher than 50\")\n",
    "    print(\"ok\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even\n"
     ]
    }
   ],
   "source": [
    "amount = 8\n",
    "if amount > 50:\n",
    "    print(\"Higher than 50\")\n",
    "if amount % 2 == 0:\n",
    "    print(\"even\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Sandeep\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Name: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sandeep'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age: 30\n",
      "Hello Mr/Ms\n"
     ]
    }
   ],
   "source": [
    "num = input(\"Age: \")\n",
    "age = int(num)\n",
    "if age > 16:\n",
    "    print(\"Hello Mr/Ms\")\n",
    "else:\n",
    "    print(\"Hello Master\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance0(a, b):\n",
    "    if type(a) == str:\n",
    "        a = int(a)\n",
    "    if type(b) == str:\n",
    "        b = int(b)\n",
    "    diff = b - a\n",
    "    if diff < 0:\n",
    "        return -diff\n",
    "    else:\n",
    "        return diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "result = distance0(4, 5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [10,20]\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance0(\"5\", 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance0(\"5\", \"4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    print(\"Computing....\")\n",
    "    result = a + b\n",
    "    print(\"Done. Returning!\")\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interest(p, r, t):\n",
    "    intrst = p*r*t/100\n",
    "    print(\"INterest: \", intrst)\n",
    "    return intrst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INterest:  12.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interest(100, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compound_interest(p, r, t):\n",
    "    interest_cal = interest(p, r, t)\n",
    "    print(\"interest_cal: \", interest_cal)\n",
    "    return p + interest_cal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INterest:  12.0\n",
      "interest_cal:  12.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "112.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compound_interest(100, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance0(a, b):\n",
    "    if type(a) == str:\n",
    "        print(\"Needs to be number\")\n",
    "        return -1\n",
    "    if type(b) == str:\n",
    "        print(\"Needs to be number\")\n",
    "        return -1\n",
    "\n",
    "    diff = b - a\n",
    "    if diff < 0:\n",
    "        return -diff\n",
    "    else:\n",
    "        return diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Needs to be number\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance0(\"4\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiply two integers without using multiplication or loops\n",
    "def multiply(a, b):\n",
    "    if a == 0 or b == 0:\n",
    "        return 0\n",
    "    return multiply(a, b - 1) + a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "450"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(10, 45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute highest common factor without using loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def hcf_recursive_asmi(a, b):\n",
    "#     if b == 0:\n",
    "#         return a\n",
    "#     else:\n",
    "#         return hcf_recursive(b, a % b)\n",
    "# num1 = 48\n",
    "# num2 = 18\n",
    "# print(f\"The HCF of {num1} and {num2} is: {hcf_recursive(num1, num2)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hcf(a, b):\n",
    "    if a > b:\n",
    "        a, b = b, a\n",
    "    # a is smaller, b is bigger\n",
    "    if a == 0:\n",
    "        return 0\n",
    "    remainder = b % a\n",
    "    if remainder == 0:\n",
    "        return a\n",
    "    return hcf(remainder, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hcf(0, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "35 % 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60 45\n"
     ]
    }
   ],
   "source": [
    "x = 45\n",
    "y = 60\n",
    "z = x\n",
    "x = y\n",
    "y = z\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60 45\n"
     ]
    }
   ],
   "source": [
    "x = 45\n",
    "y = 60\n",
    "x = x+y\n",
    "y = x - y\n",
    "x = x - y\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q: Swap two values without using third using XOR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Previously covered:\n",
    "\n",
    "    * Binary Operations: \n",
    "        * AND\n",
    "        * OR\n",
    "        * XOR\n",
    "        * NOT\n",
    "    * if-else conditions\n",
    "    * Functions: recursion\n",
    "    * input, int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a = False\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(2 < 3 and 4 < 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print( (2 < 3 or 6 < 5) and (10 < 34))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 30\n",
    "is_male = True\n",
    "name = 'Sandeep'\n",
    "if age > 30 and is_male and name == 'Sandeep':\n",
    "    print(\"Hello Mr Sandeep\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Question: Given a single dimension, a point \n",
    "# tell whether the point is on the line.\n",
    "def is_online(st, end, p):\n",
    "    return True or False\n",
    "# Example\n",
    "print(is_online(1, 4, 3)) # True\n",
    "print(is_online(-3, -2, -1)) # False\n",
    "print(is_online(1, 4, 1)) # True\n",
    "print(is_online(1, 4, 4)) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remainder(n, m):\n",
    "    if n < m: # Comparator operators: <, >, ==, <=, >=, !=\n",
    "        return n\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Tripti.Pandey (Oct 13, 2024, 10:58 AM)\n",
    "def is_online(x1,x2,x):\n",
    "    if(x>=x1 and x<=x2):\n",
    "        return True\n",
    "    if(x>=x2 and x<=x1):\n",
    "        return False\n",
    "    return False\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test cases\n",
    "# Code coverage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code should pass all tests\n",
    "# Code should run in expected time and memory - Big O notation.\n",
    "# Code has to be human readable. it's for human consumption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Japneet Singh (Oct 13, 2024, 10:58 AM)\n",
    "def is_online(st,end,p):\n",
    "    if(p>=st and p<=end):\n",
    "        return True\n",
    "    else : return False\n",
    "    \n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Arpit Mishra to You (direct message) (Oct 13, 2024, 10:58 AM)\n",
    "def is_online(s,e,p):\n",
    "    if p>=s and p<=e:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "print(is_online(5,10,5))\n",
    "\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Arpit Mishra to You (direct message) (Oct 13, 2024, 10:59 AM)\n",
    "def f(a,b):\n",
    "    if b==0:\n",
    "        print(\"enter valid value!!\")\n",
    "        exit()\n",
    "    if a<b:\n",
    "        return a\n",
    "    return f(a-b,b)\n",
    "        \n",
    "print(f(5,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Sarika Padakanti (Oct 13, 2024, 10:58 AM)\n",
    "def is_online(st, end, p):\n",
    "    if p >= st and p<= end:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Amit Gupta (Oct 13, 2024, 10:59 AM)\n",
    "def is_online(st, end, p):\n",
    "    if(p >=st and p<=end):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Anuj Km (Oct 13, 2024, 10:59 AM)\n",
    "def is_online(st, end, p):\n",
    "    if p >= st and p <= end :\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Nikita Thapliyal (Oct 13, 2024, 11:00 AM)\n",
    "def is_online(st, end,p):\n",
    "    if st<= p and p<=end:\n",
    "        return True\n",
    "    if st >p or p>end :\n",
    "        return False\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Kavithadevi Gunasekaran (Oct 13, 2024, 11:00 AM)\n",
    "def is_online(st,end,p):\n",
    "    if(p>=st and p<=end):\n",
    "        return True \n",
    "    return False\n",
    "print(is_online(1,3,2))\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Ashutosh Sanjay (Oct 13, 2024, 11:15 AM)\n",
    "def iore(st,end,p):\n",
    "    if(p>=st and p<=end):\n",
    "        return True\n",
    "    else: \n",
    "        return False\n",
    "print(iore(2,5,6)==True)\n",
    "print(iore(1,2,3)==False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write code such that you don't need to explain \n",
    "# hence don't need to write comments\n",
    "# If the code is wrong the compiler or test cases will catch it, \n",
    "# But comments will continue to be wrong."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_online(st,end,p):\n",
    "    return p>=st and p<=end\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_online(st,end,p):\n",
    "    return (p-st)*(p-end) <= 0\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.15811388300841897"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "1/math.sqrt(40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Pradeepa (Oct 13, 2024, 11:28 AM)\n",
    "def is_online(st,end,p):\n",
    "    if((end-p) >= 0 and (p-st)>=0):\n",
    "        return True\n",
    "    else: \n",
    "        return False\n",
    "    \n",
    "    \n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prince Raj (Oct 13, 2024, 11:28 AM)\n",
    "def on_line(s, e, p):\n",
    "    if p >= s and p <=e:\n",
    "       return True\n",
    "    return False\n",
    "\n",
    "print(on_line(1, 4, 3))\n",
    "print(on_line(-3, -2, -1))\n",
    "print(on_line(1, 4, 1))\n",
    "print(on_line(1, 4, 4))\n",
    " \n",
    "# Tom George (Oct 13, 2024, 11:28 AM)\n",
    "def is_online(st, end, p):\n",
    "    if(p>=st and p<=end):\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "print(is_online(1, 4, 1))\n",
    "print(is_online(1, 4, 3))\n",
    "print(is_online(1, 4, 4))\n",
    "print(is_online(-1, 4, -2))\n",
    "print(is_online(-4,-1, -3))\n",
    "print(is_online(-1, 4, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Question: Given a single dimension, a point \n",
    "# tell whether the point is on the line.\n",
    "def is_online(x1, x2, p):\n",
    "    pass\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True\n",
    "print(is_online(4, 1, 3) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def is_online(x1,x2,p):\n",
    "    return p>=x1 and p<=x2\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True\n",
    "print(is_online(4, 1, 3) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_online(st, end, p):\n",
    "    return (p>=st and p<=end) or (p>=end and p<=st)\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True\n",
    "print(is_online(4, 1, 3) == True) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def is_online(x1,x2,p):\n",
    "    # p should be differnt sides of x1 and x2\n",
    "    return (p-x1)*(p-x2) <= 0\n",
    "\n",
    "print(is_online(1, 4, 3) == True) # True\n",
    "print(is_online(-3, -2, -1) == False) # False\n",
    "print(is_online(1, 4, 1) == True) # True\n",
    "print(is_online(1, 4, 4) == True) # True\n",
    "print(is_online(4, 1, 3) == True) # True\n",
    "print(is_online(1, 4, 10) == False) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Question: Given a rectangle (x1, y1),  (x2,y2), point (x, y.)\n",
    "# Return True if the point is on or inside the rectangle.\n",
    "\n",
    "def is_inside_rectangle(x1, y1, x2, y2, x, y):\n",
    "    return True or False\n",
    "\n",
    "print(is_inside_rectangle(1, 2, 3, 4, 2, 3) == True)\n",
    "print(is_inside_rectangle(-1, -2, -3, -4, -2, -3) == True)\n",
    "print(is_inside_rectangle(3, 4, 1, 2, 2, 3) == True)\n",
    "print(is_inside_rectangle(-3, -4, -1, -2, -2, -3) == True)\n",
    "\n",
    "\n",
    "print(is_inside_rectangle(1, 2, 3, 4, 5, 6) == False)\n",
    "print(is_inside_rectangle(-1, -2, -3, -4, -5, -6) == False)\n",
    "print(is_inside_rectangle(3, 4, 1, 2, 5, 6) == False)\n",
    "print(is_inside_rectangle(-3, -4, -1, -2, -5, -6) == False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Arpit Mishra to You (direct message)\n",
    "def is_inside_rectangle(x1,y1,x2,y2,x,y):\n",
    "    return (x<=x1 and x>=x2 and y<=y1 and y>=y2) or (x>=x1 and x<=x2 and y>=y1 and y<=y2) \n",
    "\n",
    "\n",
    "print(is_inside_rectangle(1, 2, 3, 4, 2, 3) == True)\n",
    "print(is_inside_rectangle(-1, -2, -3, -4, -2, -3) == True)\n",
    "print(is_inside_rectangle(3, 4, 1, 2, 2, 3) == True)\n",
    "print(is_inside_rectangle(-3, -4, -1, -2, -2, -3) == True)\n",
    "print(is_inside_rectangle(1, 2, 3, 4, 5, 6) == False)\n",
    "print(is_inside_rectangle(-1, -2, -3, -4, -5, -6) == False)\n",
    "print(is_inside_rectangle(3, 4, 1, 2, 5, 6) == False)\n",
    "print(is_inside_rectangle(-3, -4, -1, -2, -5, -6) == False)\n",
    "\n",
    "print(is_inside_rectangle(-1, -2, 3, 4, 2, 3) == True)\n",
    "print(is_inside_rectangle(1, 2, -3, -4, -2, -3) == True)\n",
    "print(is_inside_rectangle(3, 4, -1, -2, 2, 3) == True)\n",
    "print(is_inside_rectangle(-3, -4, 1, 2, -2, -3) == True)\n",
    "\n",
    "print(is_inside_rectangle(-1, -2, 3, 4, 5, 6) == False)\n",
    "print(is_inside_rectangle(1, 2, -3, -4, -5, -6) == False)\n",
    "print(is_inside_rectangle(3, 4, -1, -2, 5, 6) == False)\n",
    "print(is_inside_rectangle(-3, -4, 1, 2, -5, -6) == False)\n",
    "\n",
    "print(is_inside_rectangle(-1, -2, 3, 4, 1, 3) == True)\n",
    "print(is_inside_rectangle(1, 2, -3, -4, -1, -3) == True)\n",
    "print(is_inside_rectangle(3, 4, -1, -2, 1, 3) == True)\n",
    "print(is_inside_rectangle(-3, -4, 1, 2, -1, -3) == True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Nupur Mohanty (Oct 13, 2024, 11:49 AM)\n",
    "def is_inside_rectangle_nupur(x1, y1, x2, y2, x, y):\n",
    "    return (x-x1)*(x-x2) <=0 & (y-y1)*(y-y2)<=0\n",
    "\n",
    "test_my_function_rect_problem(is_inside_rectangle_nupur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_my_function_rect_problem(is_inside_rectangle):\n",
    "    print(is_inside_rectangle(1, 2, 3, 4, 2, 3) == True)\n",
    "    print(is_inside_rectangle(-1, -2, -3, -4, -2, -3) == True)\n",
    "    print(is_inside_rectangle(3, 4, 1, 2, 2, 3) == True)\n",
    "    print(is_inside_rectangle(-3, -4, -1, -2, -2, -3) == True)\n",
    "    print(is_inside_rectangle(1, 2, 3, 4, 5, 6) == False)\n",
    "    print(is_inside_rectangle(-1, -2, -3, -4, -5, -6) == False)\n",
    "    print(is_inside_rectangle(3, 4, 1, 2, 5, 6) == False)\n",
    "    print(is_inside_rectangle(-3, -4, -1, -2, -5, -6) == False)\n",
    "\n",
    "    print(is_inside_rectangle(-1, -2, 3, 4, 2, 3) == True)\n",
    "    print(is_inside_rectangle(1, 2, -3, -4, -2, -3) == True)\n",
    "    print(is_inside_rectangle(3, 4, -1, -2, 2, 3) == True)\n",
    "    print(is_inside_rectangle(-3, -4, 1, 2, -2, -3) == True)\n",
    "\n",
    "    print(is_inside_rectangle(-1, -2, 3, 4, 5, 6) == False)\n",
    "    print(is_inside_rectangle(1, 2, -3, -4, -5, -6) == False)\n",
    "    print(is_inside_rectangle(3, 4, -1, -2, 5, 6) == False)\n",
    "    print(is_inside_rectangle(-3, -4, 1, 2, -5, -6) == False)\n",
    "\n",
    "    print(is_inside_rectangle(-1, -2, 3, 4, 1, 3) == True)\n",
    "    print(is_inside_rectangle(1, 2, -3, -4, -1, -3) == True)\n",
    "    print(is_inside_rectangle(3, 4, -1, -2, 1, 3) == True)\n",
    "    print(is_inside_rectangle(-3, -4, 1, 2, -1, -3) == True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_my_function_rect_problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def HCF(n, m):\n",
    "    print(f\"Calling {n}, {m}\")\n",
    "    if n > m:\n",
    "        print(\"Swapping\")\n",
    "        n, m = m, n\n",
    "    rem = m % n\n",
    "    print(f\"Remainder: {rem}\")\n",
    "    if rem == 0:\n",
    "        return n\n",
    "    else:\n",
    "        return HCF(rem, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling 13, 12\n",
      "Swapping\n",
      "Remainder: 1\n",
      "Calling 1, 12\n",
      "Remainder: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HCF(13, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling 1303, 1202\n",
      "Swapping\n",
      "Remainder: 101\n",
      "Calling 101, 1202\n",
      "Remainder: 91\n",
      "Calling 91, 101\n",
      "Remainder: 10\n",
      "Calling 10, 91\n",
      "Remainder: 1\n",
      "Calling 1, 10\n",
      "Remainder: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HCF(1303, 1202)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_remainder(sol):\n",
    "    print(sol(5, 5) == 0)\n",
    "    print(sol(0, 5) == 0)\n",
    "    print(sol(1, 5) == 1)\n",
    "    print(sol(12, 5) == 2)\n",
    "    print(sol(12, 0) == None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(function, list, str, int, float)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(test_remainder), type([]), type(\"ccc\"), type(123), type(3.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "enter valid value!!\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Arpit Mishra to You (direct message) (Oct 13, 2024, 10:59 AM)\n",
    "def f(a,b):\n",
    "    if b==0:\n",
    "        print(\"enter valid value!!\")\n",
    "        return None\n",
    "    if a<b:\n",
    "        return a\n",
    "    return f(a-b,b)\n",
    "test_remainder(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tower of Hanoi:\n",
    "\n",
    "+ https://www.mathsisfun.com/games/towerofhanoi.html\n",
    "+ https://www.youtube.com/watch?v=rf6uf3jNjbo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tower_of_hanoi_1(n, source, target, aux):\n",
    "    print(f\"Move {n} from {source} to {target}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move 1 from A to C\n"
     ]
    }
   ],
   "source": [
    "tower_of_hanoi_1(1, \"A\", \"C\", \"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tower_of_hanoi_2(n, source, target, aux):\n",
    "   tower_of_hanoi_1(n, source, aux, target)\n",
    "   tower_of_hanoi_1(n-1, source, target, aux)\n",
    "   tower_of_hanoi_1(n, aux, target, source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move 4 from A to B\n",
      "Move 3 from A to C\n",
      "Move 4 from B to C\n"
     ]
    }
   ],
   "source": [
    "tower_of_hanoi_2(4, \"A\", \"C\", \"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tower_of_hanoi_1(n, source, target, aux):\n",
    "    print(f\"Move {n} from {source} to {target}\")\n",
    "def tower_of_hanoi(n, src, target, aux):\n",
    "    if n == 1:\n",
    "        tower_of_hanoi_1(n, src, target, aux)\n",
    "    else:\n",
    "        tower_of_hanoi(n-1, src, aux, target)\n",
    "        tower_of_hanoi_1(n, src, target, aux)\n",
    "        tower_of_hanoi(n-1, aux, target, src)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move 1 from A to C\n"
     ]
    }
   ],
   "source": [
    "tower_of_hanoi(1, \"A\", \"C\", \"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move 1 from A to B\n",
      "Move 2 from A to C\n",
      "Move 1 from B to C\n"
     ]
    }
   ],
   "source": [
    "tower_of_hanoi(2, \"A\", \"C\", \"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move 1 from A to C\n",
      "Move 2 from A to B\n",
      "Move 1 from C to B\n",
      "Move 3 from A to C\n",
      "Move 1 from B to A\n",
      "Move 2 from B to C\n",
      "Move 1 from A to C\n"
     ]
    }
   ],
   "source": [
    "tower_of_hanoi(3, \"A\", \"C\", \"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# factorial: \n",
    "# fact(3) = 3*2*1\n",
    "# fact(2) = 2*1\n",
    "# fact(0) = 1\n",
    "# Fact(1) = 1\n",
    "# fact(n) = n * fact(n-1)\n",
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    return n * factorial(n-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "_____123 = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(_____123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# power(4, 3) = 1*4*4*4\n",
    "# power(4, 2) = 1*4*4\n",
    "# power(4, 1) = 1*4\n",
    "# power(4, 0) = 1\n",
    "# power(4, 3) = power(4, 2) * 4\n",
    "# power(4, n) = power(n-1) * 4\n",
    "def pow(num, p, tab=\"\"): # **\n",
    "    print(f\"{tab}pow(num: {num}, p: {p})\")\n",
    "    if p == 0:\n",
    "        result = 1\n",
    "        print(f\"{tab}returning: {result}\")\n",
    "        return result\n",
    "    p_1_pow = pow(num, p - 1, tab + \"\\t\")\n",
    "    result = num * p_1_pow\n",
    "    print(f\"{tab}returning: {result}\")\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://github.com/girisandeep/calcuchat/blob/master/lib/calc.dart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pow(num: 4, p: 3)\n",
      "\tpow(num: 4, p: 2)\n",
      "\t\tpow(num: 4, p: 1)\n",
      "\t\t\tpow(num: 4, p: 0)\n",
      "\t\t\treturning: 1\n",
      "\t\treturning: 4\n",
      "\treturning: 16\n",
      "returning: 64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(4, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "level = 1\n",
    "\n",
    "def pow(num, p, tab=\"\", level=1): # **\n",
    "    print(f\"{tab}{level}.pow(num: {num}, p: {p})\")\n",
    "    if p == 0:\n",
    "        result = 1\n",
    "        print(f\"{tab}{level}returning: {result}\")\n",
    "        return result\n",
    "    p_1_pow = pow(num, p - 1, tab + \" \", level + 1)\n",
    "    result = num * p_1_pow\n",
    "    print(f\"{tab}{level}.returning: {result}\")\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.pow(num: 4, p: 10)\n",
      " 2.pow(num: 4, p: 9)\n",
      "  3.pow(num: 4, p: 8)\n",
      "   4.pow(num: 4, p: 7)\n",
      "    5.pow(num: 4, p: 6)\n",
      "     6.pow(num: 4, p: 5)\n",
      "      7.pow(num: 4, p: 4)\n",
      "       8.pow(num: 4, p: 3)\n",
      "        9.pow(num: 4, p: 2)\n",
      "         10.pow(num: 4, p: 1)\n",
      "          11.pow(num: 4, p: 0)\n",
      "          11returning: 1\n",
      "         10.returning: 4\n",
      "        9.returning: 16\n",
      "       8.returning: 64\n",
      "      7.returning: 256\n",
      "     6.returning: 1024\n",
      "    5.returning: 4096\n",
      "   4.returning: 16384\n",
      "  3.returning: 65536\n",
      " 2.returning: 262144\n",
      "1.returning: 1048576\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1048576"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(4, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ENter the two numbers separated by space: 6\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 2, got 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-61-af86dba2fc92>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mtxt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\".\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0ma_str\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb_str\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtxt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma_str\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb_str\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 2, got 1)"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    txt = input(\"ENter the two numbers separated by space: \")\n",
    "    if txt == \".\":\n",
    "        break\n",
    "    a_str, b_str = txt.split()\n",
    "    print(pow(int(a_str), int(b_str)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "defn1: \n",
    "    repeated multiplication of the same number with \n",
    "    itself p times. num*num*...p\n",
    "    \n",
    "defn2: Multiply 1 with the number num, p times.\n",
    "    1 * num * num... p times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _factorial(n):\n",
    "    \n",
    "    if n < 0:\n",
    "        print(\"Error!\")\n",
    "    elif n == 0:\n",
    "        return 1\n",
    "    elif k == n:\n",
    "        return k\n",
    "    return k * _factorial(n, k+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    def _factorial(n1, k):\n",
    "        if k == n1:\n",
    "            return k\n",
    "        return k * _factorial(n1, k+1)\n",
    "    if n < 0:\n",
    "        print(\"Error!\")\n",
    "    elif n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return _factorial(n, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error!\n"
     ]
    }
   ],
   "source": [
    "factorial(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def order(x, y):\n",
    "    if x > y:\n",
    "        return y, x\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = order(9, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 9)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def learn(x1, y1, x2, y2):\n",
    "    return slope, intercept # compute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(x, something):\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'something' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-64-4bd53016544a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mslope_intercept\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlearn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m9\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslope_intercept\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslope_intercept\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslope_intercept\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-59-4c1ff97757b0>\u001b[0m in \u001b[0;36mlearn\u001b[0;34m(x1, y1, x2, y2)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlearn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0msomething\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'something' is not defined"
     ]
    }
   ],
   "source": [
    "slope_intercept = learn(1, 5, 2, 9) \n",
    "predict(10, slope_intercept)\n",
    "predict(1.5, slope_intercept)\n",
    "predict(15, slope_intercept)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit(x1, y1, x2, y2):\n",
    "    m = (y2-y1)/(x2-x1)\n",
    "    c = y2 - m*x2 # y1 - m*x1\n",
    "    model = (m, c)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(m, c, x):\n",
    "    return m*x + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "m, c = fit(1, 1000, 2, 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(m, c, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predict(m, c, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# INside the lab\n",
    "model = fit(1,3, 5, 1)\n",
    "\n",
    "# save the model to file\n",
    "\n",
    "# Upload the file to a server\n",
    "\n",
    "# load file into model\n",
    "predict(model, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(model, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(model, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Sandeep\", \"Rohan\", \"Nikita\", \"Jyoti\", \"Akash\", \"Arpit\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sandeep'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Rohan'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sandeep', 'Rohan', 'Nikita']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Arpit'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skipping...\n",
      "Rohan\n",
      "Nikita\n",
      "Jyoti\n",
      "Akash\n",
      "Arpit\n"
     ]
    }
   ],
   "source": [
    "for _name in names:\n",
    "    if _name == \"Sandeep\":\n",
    "        print(\"Skipping...\")\n",
    "    else:\n",
    "        print(_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sandeep Rohan\n",
      "Sandeep Nikita\n",
      "Sandeep Jyoti\n",
      "Sandeep Akash\n",
      "Sandeep Arpit\n",
      "Rohan Sandeep\n",
      "Rohan Nikita\n",
      "Rohan Jyoti\n",
      "Rohan Akash\n",
      "Rohan Arpit\n",
      "Nikita Sandeep\n",
      "Nikita Rohan\n",
      "Nikita Jyoti\n",
      "Nikita Akash\n",
      "Nikita Arpit\n",
      "Jyoti Sandeep\n",
      "Jyoti Rohan\n",
      "Jyoti Nikita\n",
      "Jyoti Akash\n",
      "Jyoti Arpit\n",
      "Akash Sandeep\n",
      "Akash Rohan\n",
      "Akash Nikita\n",
      "Akash Jyoti\n",
      "Akash Arpit\n",
      "Arpit Sandeep\n",
      "Arpit Rohan\n",
      "Arpit Nikita\n",
      "Arpit Jyoti\n",
      "Arpit Akash\n"
     ]
    }
   ],
   "source": [
    "for name1 in names:\n",
    "    for name2 in names:\n",
    "        if name1 != name2:\n",
    "            print(name1, name2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def total(numbers):\n",
    "    sm = 0\n",
    "    for num in numbers:\n",
    "        sm = sm + num\n",
    "    return sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.399999999999999"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1.0, 2.3, 4.0, 5.1]\n",
    "total(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the sum of number which aren't less than 1\n",
    "def total1(numbers):\n",
    "    sm = 0\n",
    "    for num in numbers:\n",
    "        if not (num < 1): # num >= 1\n",
    "            sm = sm + num\n",
    "    return sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.399999999999999"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total1([0.5, 1.0, 2.3, 4.0, 5.1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sandeep\n",
      "Rohan\n",
      "Nikita\n",
      "Jyoti\n",
      "Akash\n",
      "Arpit\n"
     ]
    }
   ],
   "source": [
    "l = len(names)\n",
    "for i in range(l):\n",
    "    print(names[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the sum of number which aren't less than 1\n",
    "def total1(numbers):\n",
    "    sm = 0\n",
    "    for num in numbers:\n",
    "        if not (num < 1): # num >= 1\n",
    "            sm = sm + num\n",
    "    return sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(3, 10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "15\n",
      "20\n",
      "25\n",
      "30\n",
      "35\n",
      "40\n",
      "45\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "t = 5\n",
    "for i in range(t, t*11, t):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 10, 15, 20, 25, 30, 35, 40, 45, 50]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(t, t*11, t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem 1:\n",
    "\n",
    "articles = ['a', 'the', 'that', 'this']\n",
    "\n",
    "adjectives = [\"good\", \"bad\", \"nice\", \"blue\", \"light\"]\n",
    "\n",
    "words = [\"city\", \"sky\", \"water\", \"person\"]\n",
    "\n",
    "print all possible combinations:\n",
    "    a good city\n",
    "    a good sky\n",
    "    ...\n",
    "    the bad water\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "15\n",
      "20\n",
      "25\n",
      "30\n",
      "35\n",
      "40\n",
      "45\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "num = 5\n",
    "multiplier = 1\n",
    "while multiplier < 11:\n",
    "    print(num*multiplier)\n",
    "    multiplier += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [0.5, 1.1, 1.0, 4, 6, .1]\n",
    "# Find the sum of number\n",
    "i = 0\n",
    "sm = 0\n",
    "while i < len(numbers):\n",
    "    num = numbers[i]\n",
    "    sm += num\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.7"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [0.5, 1.1, 1.0, 4, 6, .1]\n",
    "# Find the sum of number which are >= 1\n",
    "i = 0\n",
    "sm = 0\n",
    "while i < len(numbers):\n",
    "    num = numbers[i]\n",
    "    if num >= 1:\n",
    "        sm += num\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.1"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Problem 2: Find average of list of numbers\n",
    "def avg(mylist):\n",
    "    return avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3, 4, 5]\n",
    "avg = sum(a)/len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Standard Deviation\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.0\n"
     ]
    }
   ],
   "source": [
    "a = [10, 20, 30]\n",
    "N = len(a)\n",
    "mu = sum(a)/N\n",
    "print(mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff = [-10, 0, 10]\n",
    "diff_sq = [100, 0, 100]\n",
    "sum(diff_sq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.16496580927726"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(sum(diff_sq)/N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-14.25, -12.25, 5.75, 20.75]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[2 3] -> 2*a = 3\n",
    "\n",
    "a = 3/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unsolvable\n",
    "a + b = 10\n",
    "5a + 5b = 100\n",
    "2a + 2b = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Two varible equations. y = mx + c (linear interpolation) or linear reg\n",
    "\n",
    "# Three variable equations, y = ax^2 + bx + c (cubic interpolation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1: Take 3 & 4 variable equations and solve them manually.\n",
    "\n",
    "Q2: Code the guassian elimination method recursive outline below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a + b + c = 10 -> [1, 1, 1, 10]\n",
    "# 2a + 3b + 4c = 50 [2, 3, 4, 50]\n",
    "# 3a + 5b - 8c = 100 [3, 5, -8, 100]\n",
    "\n",
    "def solve(eqns):\n",
    "    if len(eqns) != len(eqns[0]) - 1:\n",
    "        return None\n",
    "    if len(eqns) == 1:\n",
    "        #[0 10]\n",
    "        eqn = eqns[0]\n",
    "        return [eqn[1]/eqn[0]] # check if eqn[0] is 0\n",
    "    # eliminiate one variable and call solve(new_eqns)\n",
    "    new_equans = eliminate_n(eqns)\n",
    "    soln_1 = solve(new_equans)\n",
    "    \n",
    "    # put the soln in first equation i.e. eqn[0]\n",
    "    return [result, result1]\n",
    "\n",
    "eq1 = [1, 1, 1, 10]\n",
    "eq2 = [2, 3, 4, 50]\n",
    "eq3 = [3, 5, -8, 100]\n",
    "eqns = [eq1, eq2, eq3]\n",
    "result = solve(eqns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = [[2,3, 1],[4,5,6]]\n",
    "# [A] 2a + 3b = 1\n",
    "# [B] 4a + 5b = 6\n",
    "# [B] - A*2\n",
    "\n",
    "def eliminate(arr1, arr2):\n",
    "    mult = arr2[0]/arr1[0]\n",
    "    # arr2 - arr1*mult\n",
    "    L = len(arr2)\n",
    "    result = []\n",
    "    for i in range(1, L):\n",
    "        res = arr2[i] - arr1[i]*mult\n",
    "        result.append(res)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "mult = find_multiplier([2,3, 1], [4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1.0, 4.0]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eliminate([2,3, 1], [4,5,6], mult)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq1 = [1, 1, 1, 10]\n",
    "eq2 = [2, 3, 4, 50]\n",
    "eq3 = [3, 5, -8, 100]\n",
    "eqns = [eq1, eq2, eq3]\n",
    "\n",
    "# n equations to n - 1\n",
    "def elimitae_n(eqns):\n",
    "    first_eq = eqns[0]\n",
    "    new_eqns = []\n",
    "    for i in range(1, eqns):\n",
    "        new_eqn = eliminate(eqns[i], eqns[0])\n",
    "        new_eqns.append(new_eqn)\n",
    "    return new_eqns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in [1,2,3]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n",
      "22\n",
      "24\n",
      "26\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "for i in range(10, 30, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[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
}