17May-ML.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function per_str at 0x7fbc004edb70> abc\n"
     ]
    }
   ],
   "source": [
    "s='abc'\n",
    "\n",
    "def per_str (str,index=0):\n",
    "    if index==len(str)-1:\n",
    "        print(''.join(str))\n",
    "        for i in range(index,len(str)):\n",
    "            wlist=(i for i in str)\n",
    "            wlist [index],wlist[i] = wlist[1], wlist[index]\n",
    "            per_str(wlist,index+1)\n",
    "print (per_str,s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "per_str(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left\n",
      "left\n"
     ]
    }
   ],
   "source": [
    "# You have a robot:\n",
    "#     - turnleft()\n",
    "#     - turnright()\n",
    "#     - Moveforward()\n",
    "#     - MoveReverse()\n",
    "\n",
    "# Turn 180\n",
    "def turnaround():\n",
    "    print(\"left\")\n",
    "    print(\"left\")\n",
    "\n",
    "turnaround()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readtxt():\n",
    "    txt = input(\"    2. Enter you name: \")\n",
    "    print(\"    2. Welcome\", txt.upper())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readtxt_1():\n",
    "    txt = input(\"1. Enter you name: \")\n",
    "    if txt != \".\":\n",
    "        readtxt()\n",
    "    print(\"1. Welcome\", txt.upper())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Enter you name: sandeep\n",
      "    2. Enter you name: giri\n",
      "    2. Welcome GIRI\n",
      "1. Welcome SANDEEP\n"
     ]
    }
   ],
   "source": [
    "readtxt_1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readrecur():\n",
    "    txt = input(\"Enter a word: \")\n",
    "    if txt != \".\":\n",
    "        readrecur()\n",
    "    print(txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: a\n",
      "Enter a word: b\n",
      "Enter a word: c\n",
      "Enter a word: d\n",
      "Enter a word: e\n",
      "Enter a word: .\n",
      ".\n",
      "e\n",
      "d\n",
      "c\n",
      "b\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "readrecur()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_num = max(1,2,3,5,6,66,6,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max('abAB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' > 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = '9'\n",
    "num = 0\n",
    "ord(x) - ord('0') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('0') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('9')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('A') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "95"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('_') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('\\t') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('\\n') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a1b') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ord('') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'string' 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-70-8da130f19041>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprintable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'string' is not defined"
     ]
    }
   ],
   "source": [
    "string.printable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\t'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 -> 2\n",
    "2 -> 4\n",
    "3 -> 8\n",
    "4 -> 16\n",
    "8 -> 256 # only represent 255 printable character\n",
    "16 -> 256*256 64k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'इ'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(0x907)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('123')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123.4"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('123.4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg(x, y):\n",
    "    a = (x + y)/2\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.0\n"
     ]
    }
   ],
   "source": [
    "avg(10, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.0\n"
     ]
    }
   ],
   "source": [
    "final = avg(10, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg(x, y):\n",
    "    a = (x + y)/2\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.0\n"
     ]
    }
   ],
   "source": [
    "final = avg(10, 12)\n",
    "print(final)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final == 11.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interest(p, r, t):\n",
    "    i = p*r*t/100\n",
    "    return i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200.0"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interest(1000, 4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compound_interest(p, r, t):\n",
    "    total = p + interest(p,r,t)\n",
    "    print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1200.0\n"
     ]
    }
   ],
   "source": [
    "compound_interest(1000, 4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAY_PREFS = ['Sun','Mon', \"Tues\", 'Wednes', 'Thurs', 'Fri', 'Satur']\n",
    "def get_weekday(day):\n",
    "    if type(day) == str:\n",
    "        return day\n",
    "    elif type(day) == int:\n",
    "        idx = day - 1\n",
    "        pref = DAY_PREFS[idx]\n",
    "        return  pref + 'day'\n",
    "    else:\n",
    "        print(\"SORRY\")\n",
    "        return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sun', 'Mon', 'Wednes', 'Thurs', 'Fri', 'Satur']"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DAY_PREFS = ['Sun','Mon', \"Tues\", 'Wednes', 'Thurs', 'Fri', 'Satur']\n",
    "# without x = SUN\n",
    "\n",
    "x = 2\n",
    "\n",
    "DAY_PREFS[:x] + DAY_PREFS[x+1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Fri', 'Satur', 'Sun', 'Thurs', 'Tues', 'Wednes'}"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DAY_PREFS = set(['Sun','Mon', \"Tues\", 'Wednes', 'Thurs', 'Fri', 'Satur'])\n",
    "DAY_PREFS - set(['Mon'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Wednesday'"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_weekday(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MONDAY'"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_weekday('MONDAY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyse(arr):\n",
    "    return (max(arr), min(arr), sum(arr), len(arr), sum(arr)/len(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 1, 15, 5, 3.0)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "analyse([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, start=0, /)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg(*arr):\n",
    "    return sum(arr)/len(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg(1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg(1, 2, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n"
     ]
    }
   ],
   "source": [
    "# Veena\n",
    "\n",
    "a=10\n",
    "b=5\n",
    "def multiply(x,y):\n",
    "    if y < 0:\n",
    "        return -multiply(x, -y)\n",
    "    elif (y==0):\n",
    "        return 0\n",
    "    else:\n",
    "        return x + multiply(x,y-1)\n",
    "\n",
    "product = multiply(a,b)\n",
    "print (product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "#samip\n",
    "\n",
    "def multiply(x, n):\n",
    "    if n == 0:\n",
    "        return 0 \n",
    "    else:\n",
    "        return x + multiply(x, n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "= multiply(10, 4)\n",
    "= 10 + multiply(10, 3)\n",
    "= 10 + 10 + multiply(10, 2)\n",
    "= 10 + 10 + 10 + multiply(10, 1)\n",
    "= 10 + 10 + 10 + 10 + multiply(10, 0)\n",
    "= 10 + 10 + 10 + 10 + 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-170-7ab151595f10>, line 7)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-170-7ab151595f10>\"\u001b[0;36m, line \u001b[0;32m7\u001b[0m\n\u001b[0;31m    or using anonymous function\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "#*****Which is better ******\n",
    "\n",
    "def func(x,y):\n",
    "    return (x+y)\n",
    "print(func(2,3))\n",
    "\n",
    "or using anonymous function\n",
    "\n",
    "func_a = lambda x,y : x+y\n",
    "print(func_a(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Factorial\n",
    "fact(0) = 1\n",
    "fact(1) = 1 * fact(0)\n",
    "fact(2) = 2 * fact(1)\n",
    "fact(3) = 3 * fact(2)\n",
    "fact(4) = 4*3*2*1 = 4 * fact(3)\n",
    "fact(5) = 5*4*3*2*1  = 5 * fact(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fact(n):\n",
    "    print(\"n = \", n)\n",
    "    \n",
    "    if n == 0:\n",
    "        print(\"returning 1\")\n",
    "        return 1\n",
    "    else:\n",
    "        x = n*fact(n-1)\n",
    "        print(\"returning \", x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n =  20\n",
      "n =  19\n",
      "n =  18\n",
      "n =  17\n",
      "n =  16\n",
      "n =  15\n",
      "n =  14\n",
      "n =  13\n",
      "n =  12\n",
      "n =  11\n",
      "n =  10\n",
      "n =  9\n",
      "n =  8\n",
      "n =  7\n",
      "n =  6\n",
      "n =  5\n",
      "n =  4\n",
      "n =  3\n",
      "n =  2\n",
      "n =  1\n",
      "n =  0\n",
      "returning 1\n",
      "returning  1\n",
      "returning  2\n",
      "returning  6\n",
      "returning  24\n",
      "returning  120\n",
      "returning  720\n",
      "returning  5040\n",
      "returning  40320\n",
      "returning  362880\n",
      "returning  3628800\n",
      "returning  39916800\n",
      "returning  479001600\n",
      "returning  6227020800\n",
      "returning  87178291200\n",
      "returning  1307674368000\n",
      "returning  20922789888000\n",
      "returning  355687428096000\n",
      "returning  6402373705728000\n",
      "returning  121645100408832000\n",
      "returning  2432902008176640000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2432902008176640000"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fact(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "def move2(src, target, aux):\n",
    "    print(\"Move 1 from \", src , 'to', aux)\n",
    "    print(\"Move 2 from \", src , 'to', target)\n",
    "    print(\"Move 1 from \", aux , 'to', target)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "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"
     ]
    }
   ],
   "source": [
    "move2('A', 'B', 'C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "def move3(src, target, aux):\n",
    "    move2(src, aux, target)\n",
    "    print('Move 3 from ', src, target)\n",
    "    move2(aux, target, src)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "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",
      "Move 3 from  A B\n",
      "Move 1 from  C to A\n",
      "Move 2 from  C to B\n",
      "Move 1 from  A to B\n"
     ]
    }
   ],
   "source": [
    "move3('A', 'B', 'C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def move(n, source, target, auxiliary):\n",
    "    if n == 1:\n",
    "        print(\"Move disk 1 from\", source, \"to\", target)\n",
    "        return\n",
    "    move(n - 1, source, auxiliary, target)\n",
    "    print(\"Move disk\", n, \"from\", source, \"to\", target)\n",
    "    move(n - 1, auxiliary, target, source)\n",
    "\n",
    "# Example usage\n",
    "n_disk = 4\n",
    "\n",
    "move(n_disk, 'A', 'C', 'B')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move disk 1 from A to B\n",
      "Move disk 2 from A to C\n",
      "Move disk 1 from B to C\n",
      "Move disk 3 from A to B\n",
      "Move disk 1 from C to A\n",
      "Move disk 2 from C to B\n",
      "Move disk 1 from A to B\n"
     ]
    }
   ],
   "source": [
    "def tower_of_hanoi(n,src,target,aux):\n",
    "    if n==1:\n",
    "        print(f\"Move disk {n} from {src} to {target}\")\n",
    "    else:\n",
    "        tower_of_hanoi(n-1,src, aux, target)\n",
    "        print(\"Move disk \"+str(n)+\" from \"+src+\" to \"+target)\n",
    "        tower_of_hanoi(n-1,aux, target, src)\n",
    "tower_of_hanoi(3,'A','B','C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tower_of_hanoi(n,src,target,aux):\n",
    "    if n > 0:\n",
    "        tower_of_hanoi(n-1,src, aux, target)\n",
    "        print(f\"Move disk {n} from {src} to {target}\")\n",
    "        tower_of_hanoi(n-1,aux, target, src)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move disk 1 from A to C\n",
      "Move disk 2 from A to B\n",
      "Move disk 1 from C to B\n"
     ]
    }
   ],
   "source": [
    "tower_of_hanoi(2,'A','B','C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tower_of_hanoi(src, target, aux):\n",
    "#     print ('move 2 from src', src, 'tar', target, 'aux', aux)\n",
    "    if(len(src)==0):\n",
    "        return\n",
    "    tower_of_hanoi(src[1:], target, aux)\n",
    "    t = src.pop(0)\n",
    "    target.insert(0, t)\n",
    "    tower_of_hanoi(aux[1:], src, target )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2] [1, 2] []\n"
     ]
    }
   ],
   "source": [
    "src = [1, 2]\n",
    "target =[]\n",
    "aux = []\n",
    "\n",
    "tower_of_hanoi(src, target, aux)\n",
    "print(src, target, aux)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "print(aux)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tower_of_hanoi(src, target, aux):\n",
    "    if(len(src[1])==0):\n",
    "        return\n",
    "    print(\"Start: \", src, target, aux)\n",
    "    tower_of_hanoi((src[0], src[1][1:]), aux, target)\n",
    "    print(f\"Moving {src[1][-1]} from {src[0]} to {target[0]} \")\n",
    "    target[1].append(src[1].pop())\n",
    "    tower_of_hanoi(aux, target, src )\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start:  ('A', [1, 2]) ('B', []) ('C', [])\n",
      "Start:  ('A', [2]) ('C', []) ('B', [])\n",
      "Moving 2 from A to C \n",
      "Moving 2 from A to B \n",
      "Start:  ('C', [2]) ('B', [2]) ('A', [1])\n",
      "Moving 2 from C to B \n",
      "Start:  ('A', [1]) ('B', [2, 2]) ('C', [])\n",
      "Moving 1 from A to B \n"
     ]
    }
   ],
   "source": [
    "src, target, aux = ('A',[1, 2]), ('B', []),('C', [])\n",
    "tower_of_hanoi(src, target, aux)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def move1(n, src, target, aux):\n",
    "    print(f\"Move {n} from {src} to {target}\")\n",
    "\n",
    "def moveN(n, src, target, aux):\n",
    "    if n <= 0:\n",
    "        return\n",
    "    moveN(n-1, src, aux, target)\n",
    "    move1(n, src, target, aux)\n",
    "    moveN(n-1, aux, target, src)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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"
     ]
    }
   ],
   "source": [
    "moveN(2, 'A', 'B', 'C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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",
      "Move 3 from A to B\n",
      "Move 1 from C to A\n",
      "Move 2 from C to B\n",
      "Move 1 from A to B\n"
     ]
    }
   ],
   "source": [
    "moveN(3, 'A', 'B', 'C')"
   ]
  },
  {
   "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
}