OPPE/Week-3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2024/08/08"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "  def __init__(self, data):\n",
    "    self.data = data\n",
    "    self.next = None\n",
    "    self.prev = None\n",
    "\n",
    "  def __str__(self):\n",
    "    return f'Node: {self.data}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "rahul = Node('rahul')\n",
    "vidu = Node('vidu')\n",
    "cmd = Node('cmd')\n",
    "harikesh = Node('harikesh')\n",
    "\n",
    "rahul.next = vidu\n",
    "vidu.prev = rahul\n",
    "\n",
    "vidu.next = cmd\n",
    "cmd.prev = vidu\n",
    "\n",
    "cmd.next = harikesh\n",
    "harikesh.prev = cmd\n",
    "\n",
    "head = rahul\n",
    "tail = harikesh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# muskan = Node('muskan')\n",
    "\n",
    "# # insert at start\n",
    "# muskan.next = head\n",
    "# head.prev = muskan\n",
    "# head = muskan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# muskan = Node('muskan')\n",
    "\n",
    "# # insert at end\n",
    "# tail.next = muskan\n",
    "# muskan.prev = tail\n",
    "# tail = muskan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # delete at start\n",
    "# head = head.next\n",
    "# head.prev = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # delete at end\n",
    "# tail = tail.prev\n",
    "# tail.next = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node: rahul\n",
      "Node: vidu\n",
      "Node: cmd\n",
      "Node: harikesh\n"
     ]
    }
   ],
   "source": [
    "curr = head\n",
    "while curr:\n",
    "  print(curr)\n",
    "  curr = curr.next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node: harikesh\n",
      "Node: cmd\n",
      "Node: vidu\n",
      "Node: rahul\n"
     ]
    }
   ],
   "source": [
    "curr = tail\n",
    "while curr:\n",
    "  print(curr)\n",
    "  curr = curr.prev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rahul', 'vidu', 'cmd', 'harikesh']\n"
     ]
    }
   ],
   "source": [
    "class LL:\n",
    "  def __init__(self):\n",
    "    self.head = None\n",
    "    self.tail = None\n",
    "\n",
    "  def is_empty(self):\n",
    "    return self.head == None\n",
    "\n",
    "  def insert_start(self, data):\n",
    "    node = Node(data)\n",
    "    if self.is_empty():\n",
    "      self.head = node\n",
    "      self.tail = node\n",
    "    else:\n",
    "      node.next = self.head\n",
    "      self.head.prev = node\n",
    "      self.head = node\n",
    "\n",
    "  def insert_end(self, data):\n",
    "    node = Node(data)\n",
    "    if self.is_empty():\n",
    "      self.head = node\n",
    "      self.tail = node\n",
    "    else:\n",
    "      node.prev = self.tail\n",
    "      self.tail.next = node\n",
    "      self.tail = node\n",
    "\n",
    "  def delete_start(self):\n",
    "    # empty\n",
    "    if self.is_empty():\n",
    "      return\n",
    "    # 1 elem\n",
    "    if self.head == self.tail:\n",
    "      self.head = None\n",
    "      self.tail = None\n",
    "    else:  # at least 2 elems\n",
    "      self.head = self.head.next\n",
    "      self.head.prev = None\n",
    "\n",
    "  def delete_end(self):\n",
    "    # empty\n",
    "    if self.is_empty():\n",
    "      return\n",
    "    # 1 elem\n",
    "    if self.head == self.tail:\n",
    "      self.head = None\n",
    "      self.tail = None\n",
    "    else:  # at least 2 elems\n",
    "      self.tail = self.tail.prev\n",
    "      self.tail.next = None\n",
    "\n",
    "  def __str__(self):\n",
    "    output = []\n",
    "    curr = self.head\n",
    "    while curr:\n",
    "      output.append(curr.data)\n",
    "      curr = curr.next\n",
    "    return str(output)\n",
    "\n",
    "\n",
    "chain = LL()\n",
    "chain.insert_start('rahul')\n",
    "chain.insert_end('vidu')\n",
    "chain.insert_end('cmd')\n",
    "chain.insert_end('harikesh')\n",
    "print(chain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39]\n",
      "[39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "  def __init__(self, data):\n",
    "    self.data = data\n",
    "    self.next = None\n",
    "    self.prev = None\n",
    "\n",
    "  def __str__(self):\n",
    "    return f'Node: {self.data}'\n",
    "\n",
    "\n",
    "class doubly_linked_list:\n",
    "  def __init__(self):\n",
    "    self.head = None\n",
    "    self.last = None\n",
    "\n",
    "  def is_empty(self):\n",
    "    return self.head == None\n",
    "\n",
    "  def insert_end(self, data):\n",
    "    node = Node(data)\n",
    "    if self.is_empty():\n",
    "      self.head = node\n",
    "      self.last = node\n",
    "    else:\n",
    "      self.last.next = node\n",
    "      node.prev = self.last\n",
    "      self.last = node\n",
    "\n",
    "  def delete_end(self):\n",
    "    # empty\n",
    "    if self.is_empty():\n",
    "      return\n",
    "    # 1 elem\n",
    "    if self.head == self.last:\n",
    "      self.head = None\n",
    "      self.last = None\n",
    "    else:  # at least 2 elems\n",
    "      self.last = self.last.prev\n",
    "      self.last.next = None\n",
    "\n",
    "  def traverse_lr(self):\n",
    "    output = []\n",
    "    curr = self.head\n",
    "    while curr:\n",
    "      output.append(curr.data)\n",
    "      curr = curr.next\n",
    "    return str(output)\n",
    "\n",
    "  def traverse_rl(self):\n",
    "    output = []\n",
    "    curr = self.last\n",
    "    while curr:\n",
    "      output.append(curr.data)\n",
    "      curr = curr.prev\n",
    "    return str(output)\n",
    "\n",
    "\n",
    "chain = doubly_linked_list()\n",
    "# chain.insert_end('rahul')\n",
    "# chain.insert_end('vidu')\n",
    "# chain.insert_end('cmd')\n",
    "# chain.insert_end('vaish')\n",
    "for x in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]:\n",
    "  chain.insert_end(x)\n",
    "for i in range(60):\n",
    "  chain.delete_end()\n",
    "print(chain.traverse_lr())\n",
    "print(chain.traverse_rl())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "{1872615521: 10, 8177261622: 7}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "marks = {\n",
    "    'rahul': 100,\n",
    "    'vidu': 90,\n",
    "    'cmd': 50\n",
    "}\n",
    "\n",
    "freq = {\n",
    "    1872615521: 4,\n",
    "    8177261622: 7,\n",
    "}\n",
    "\n",
    "freq[1872615521]  # get\n",
    "freq[1872615521] = 10  # set\n",
    "freq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "16266 % 7\n",
    "16267 % 7\n",
    "16268 % 7\n",
    "16269 % 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[42, 48, None, None, None, 90, 35]\n"
     ]
    }
   ],
   "source": [
    "m = 7  # capacity\n",
    "storage = [None]*m\n",
    "\n",
    "# index=0 to index=6\n",
    "storage[5] = 90\n",
    "storage[6] = 35\n",
    "storage[0] = 42\n",
    "storage[1] = 48\n",
    "\n",
    "print(storage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set: index=2, key=9, value=95\n",
      "set: index=0, key=16, value=45\n",
      "set: index=1, key=23, value=50\n",
      "set: index=3, key=30, value=26\n",
      "set: index=4, key=37, value=26\n",
      "set: index=5, key=44, value=26\n",
      "set: index=6, key=51, value=26\n",
      "[45, 50, 95, 26, 26, 26, 26]\n"
     ]
    }
   ],
   "source": [
    "class HashTable:\n",
    "  def __init__(self, capacity):\n",
    "    self.m = capacity\n",
    "    self.c1 = 1\n",
    "    self.c2 = 1\n",
    "    self.storage = [None]*capacity\n",
    "\n",
    "  def h(self, k):\n",
    "    return k % self.m\n",
    "\n",
    "  def linear_probing(self, key):\n",
    "    index = self.h(key)\n",
    "    # found empty slot\n",
    "    if self.storage[index] == None:\n",
    "      return index\n",
    "    # search for next empty slot\n",
    "    for i in range(self.m):\n",
    "      if self.storage[i] == None:\n",
    "        return i\n",
    "    raise Exception('storage is full')\n",
    "\n",
    "  def h_quad(self, k, i):\n",
    "    return (self.h(k) + self.c1*i + self.c2*i*i) % m\n",
    "\n",
    "  def quadratic_probing(self, key):\n",
    "    index = self.h(key)\n",
    "    # found empty slot\n",
    "    if self.storage[index] == None:\n",
    "      return index\n",
    "    # search for next empty slot\n",
    "    for i in range(self.m):\n",
    "      index = self.h_quad(key, i)\n",
    "      if self.storage[index] == None:\n",
    "        return index\n",
    "    raise Exception('storage is full')\n",
    "\n",
    "  def set(self, key, value):\n",
    "    index = self.linear_probing(key)\n",
    "    print(f'set: {index=}, {key=}, {value=}')\n",
    "    self.storage[index] = value\n",
    "\n",
    "\n",
    "ht = HashTable(7)\n",
    "ht.set(9, 95)\n",
    "ht.set(16, 45)\n",
    "ht.set(23, 50)\n",
    "ht.set(30, 26)\n",
    "ht.set(37, 26)\n",
    "ht.set(44, 26)\n",
    "ht.set(51, 26)\n",
    "# ht.set(58, 26)\n",
    "\n",
    "print(ht.storage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hash table is full\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 10]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Hashing:\n",
    "  def __init__(self, c1, c2, m):\n",
    "    self.hashtable = []\n",
    "    for i in range(m):\n",
    "      self.hashtable.append(None)\n",
    "    self.c1 = c1\n",
    "    self.c2 = c2\n",
    "    self.m = m\n",
    "\n",
    "  def h(self, k):\n",
    "    return k % self.m\n",
    "\n",
    "  def h_quad(self, k, i):\n",
    "    return (self.h(k) + self.c1*i + self.c2*i*i) % self.m\n",
    "\n",
    "  def quad_probing(self, key):\n",
    "    index = self.h(key)\n",
    "    # empty slot found, probing not required\n",
    "    if self.hashtable[index] == None:\n",
    "      return index\n",
    "    # do probing, check next empty slot\n",
    "    for i in range(self.m):\n",
    "      index = self.h_quad(key, i)\n",
    "      if self.hashtable[index] == None:\n",
    "        return index\n",
    "    # no slots avail\n",
    "    return False\n",
    "\n",
    "  def store_data(self, key):\n",
    "    index = self.quad_probing(key)\n",
    "    if index is False:\n",
    "      print('Hash table is full')\n",
    "      return\n",
    "    self.hashtable[index] = key\n",
    "\n",
    "  def display_hashtable(self):\n",
    "    return self.hashtable\n",
    "\n",
    "\n",
    "ht = Hashing(1, 2, 11)\n",
    "for x in [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]:\n",
    "  ht.store_data(x)\n",
    "ht.display_hashtable()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "class Node:\n",
    "  def __init__(self, data):\n",
    "    self.data = data\n",
    "    self.next = None\n",
    "    self.prev = None\n",
    "\n",
    "\n",
    "class doubly_linked_list:\n",
    "  def __init__(self):\n",
    "    self.head = None\n",
    "    self.last = None\n",
    "\n",
    "  def is_empty(self):\n",
    "    return self.head == None\n",
    "\n",
    "  def insert_end(self, data):\n",
    "    node = Node(data)\n",
    "    if self.is_empty():\n",
    "      self.head = node\n",
    "      self.last = node\n",
    "    else:\n",
    "      self.last.next = node\n",
    "      node.prev = self.last\n",
    "      self.last = node\n",
    "\n",
    "  def delete_end(self):\n",
    "    if self.is_empty():\n",
    "      return\n",
    "    if self.head == self.last:\n",
    "      self.head = None\n",
    "      self.last = None\n",
    "    else:\n",
    "      self.last = self.last.prev\n",
    "      self.last.next = None\n",
    "\n",
    "  def traverse_lr(self):\n",
    "    output = []\n",
    "    curr = self.head\n",
    "    while curr:\n",
    "      output.append(curr.data)\n",
    "      curr = curr.next\n",
    "    return output\n",
    "\n",
    "  def traverse_rl(self):\n",
    "    output = []\n",
    "    curr = self.last\n",
    "    while curr:\n",
    "      output.append(curr.data)\n",
    "      curr = curr.prev\n",
    "    return output\n",
    "\n",
    "\n",
    "chain = doubly_linked_list()\n",
    "# chain.insert_end('rahul')\n",
    "# chain.insert_end('vidu')\n",
    "# chain.insert_end('cmd')\n",
    "# chain.insert_end('harikesh')\n",
    "# chain.delete_end()\n",
    "# chain.traverse_lr()\n",
    "# chain.traverse_rl()\n",
    "\n",
    "for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\n",
    "  chain.insert_end(x)\n",
    "for i in range(5):\n",
    "  chain.delete_end()\n",
    "\n",
    "print(chain.traverse_lr())\n",
    "print(chain.traverse_rl())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "4\n",
      "12\n",
      "7\n",
      "0\n",
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def h(k):\n",
    "  m = 15\n",
    "  return k % m\n",
    "\n",
    "# m addresses are available\n",
    "# m = 15\n",
    "# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14\n",
    "\n",
    "\n",
    "print(h(456262))  # address 7 ✅\n",
    "print(h(456214))  # address 4 ✅\n",
    "print(h(456132))  # address 12 ✅\n",
    "print(h(456277))  # address 0 ✅\n",
    "print(h(1500))  # address 1 ✅\n",
    "print(h(1501))  # address 2 ✅\n",
    "print(h(1503))  # address 3 ✅\n",
    "print(h(1504))  # address 5 ✅"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "14\n",
      "21\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "def h(k):\n",
    "  m = 50\n",
    "  return k % m\n",
    "\n",
    "\n",
    "# 0, 1, 2, 3, 4, 5, 6\n",
    "\n",
    "print(h(7))  # ✅\n",
    "print(h(14))  # ✅\n",
    "print(h(21))  # ✅\n",
    "print(h(28))  # ✅"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7000\n",
      "7007\n",
      "7014\n",
      "7021\n"
     ]
    }
   ],
   "source": [
    "def h(k):\n",
    "  m = 7050\n",
    "  return k % m\n",
    "\n",
    "\n",
    "# 0, 1, 2, 3, 4, 5, 6\n",
    "\n",
    "print(h(7000))  # ✅\n",
    "print(h(7007))  # ✅\n",
    "print(h(7014))  # ✅\n",
    "print(h(7021))  # ✅"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def h(k):\n",
    "  m = 15\n",
    "  return k % m\n",
    "\n",
    "# m addresses are available\n",
    "# m = 15\n",
    "# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14\n",
    "\n",
    "\n",
    "print(h(15))  # ✅\n",
    "print(h(30))  # 💥\n",
    "print(h(45))  # 💥\n",
    "print(h(60))  # 💥\n",
    "print(h(75))  # 💥\n",
    "print(h(90))  # 💥\n",
    "print(h(105))  # 💥"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14\n",
    "# LP attempt #0:   at index  0\n",
    "# LP attempt #1:   at index  1\n",
    "# LP attempt #2:   at index  2\n",
    "# LP attempt #3:   at index  3\n",
    "# LP attempt #4:   at index  4\n",
    "# LP attempt #5:   at index  5\n",
    "# LP attempt #6:   at index  6\n",
    "# LP attempt #7:   at index  7\n",
    "# LP attempt #8:   at index  8\n",
    "# LP attempt #9:   at index  9\n",
    "# LP attempt #10:  at index 10\n",
    "# LP attempt #11:  at index 11\n",
    "# LP attempt #12:  at index 12\n",
    "# LP attempt #13:  at index 13\n",
    "# LP attempt #14:  at index 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# c1, c2 = 1, 1\n",
    "# [h(k) + i + i^2] % m\n",
    "\n",
    "# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14\n",
    "# QP attempt #0:   at index  0 + 0 + 0 = 0\n",
    "# QP attempt #1:   at index  0 + 1 + 1 = 2\n",
    "# QP attempt #2:   at index  0 + 2 + 4 = 6\n",
    "# QP attempt #3:   at index  0 + 3 + 9 = 12\n",
    "# QP attempt #4:   at index  0 + 4 + 16 = 5\n",
    "# QP attempt #5:   at index  0 + 5 + 5^2 = 0\n",
    "# QP attempt #6:   at index  0 + 6 + 6^2 = 12\n",
    "# QP attempt #7:   at index  0 + 7 + 7^2 = 11\n",
    "# QP attempt #8:   at index  0 + 8 + 8^2 = 12\n",
    "# QP attempt #9:   at index  0 + 9 + 9^2 = 0\n",
    "# QP attempt #10:  at index  0 + 10 + 10^2 = 5\n",
    "# QP attempt #11:  at index  0 + 11 + 11^2 = 12\n",
    "# QP attempt #12:  at index  0 + 12 + 12^2 = 6\n",
    "# QP attempt #13:  at index  0 + 13 + 13^2 = 2\n",
    "# QP attempt #14:  at index  0 + 14 + 14^2 = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "6\n",
      "12\n",
      "5\n",
      "0\n",
      "12\n",
      "11\n",
      "12\n",
      "0\n",
      "5\n",
      "12\n",
      "6\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print((0 + 0) % 15)\n",
    "print((1 + 1) % 15)\n",
    "print((2 + 4) % 15)\n",
    "print((3 + 9) % 15)\n",
    "print((4 + 16) % 15)\n",
    "print((5 + 5**2) % 15)\n",
    "print((6 + 6**2) % 15)\n",
    "print((7 + 7**2) % 15)\n",
    "print((8 + 8**2) % 15)\n",
    "print((9 + 9**2) % 15)\n",
    "print((10 + 10**2) % 15)\n",
    "print((11 + 11**2) % 15)\n",
    "print((12 + 12**2) % 15)\n",
    "print((13 + 13**2) % 15)\n",
    "print((14 + 14**2) % 15)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hash table is full\n",
      "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 10]\n"
     ]
    }
   ],
   "source": [
    "class Hashing:\n",
    "  def __init__(self, c1, c2, m):\n",
    "    self.hashtable = []\n",
    "    for i in range(m):\n",
    "      self.hashtable.append(None)\n",
    "    self.c1 = c1\n",
    "    self.c2 = c2\n",
    "    self.m = m\n",
    "\n",
    "  def h(self, k):\n",
    "    return k % self.m\n",
    "\n",
    "  def h_quad(self, k, i):\n",
    "    return (self.h(k) + self.c1*i + self.c2*i*i) % m\n",
    "\n",
    "  def qp(self, data):\n",
    "    # do we even need probing?\n",
    "    index = self.h(data)\n",
    "    if self.hashtable[index] == None:\n",
    "      return index\n",
    "\n",
    "    # yes, now we do probing\n",
    "    for i in range(self.m):\n",
    "      index = self.h_quad(data, i)  # QP for ith attempt\n",
    "      if self.hashtable[index] == None:\n",
    "        return index\n",
    "    return None  # no empty slots found\n",
    "\n",
    "  def store_data(self, data):\n",
    "    index = self.qp(data)\n",
    "    if index == None:\n",
    "      print('Hash table is full')\n",
    "      return\n",
    "    self.hashtable[index] = data\n",
    "\n",
    "  def display_hashtable(self):\n",
    "    return self.hashtable\n",
    "\n",
    "\n",
    "# ht = Hashing(1, 1, 11)\n",
    "# ht.store_data(22)\n",
    "# ht.store_data(33)\n",
    "# ht.store_data(44)\n",
    "# ht.store_data(55)\n",
    "# ht.store_data(66)\n",
    "# print(ht.display_hashtable())\n",
    "\n",
    "ht = Hashing(1, 2, 11)\n",
    "for x in [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]:\n",
    "  ht.store_data(x)\n",
    "print(ht.display_hashtable())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hash table is full\n",
      "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 10]\n"
     ]
    }
   ],
   "source": [
    "class Hashing:\n",
    "  def __init__(self, c1, c2, m):\n",
    "    self.hashtable = []\n",
    "    for i in range(m):\n",
    "      self.hashtable.append(None)\n",
    "    self.c1 = c1\n",
    "    self.c2 = c2\n",
    "    self.m = m\n",
    "\n",
    "  def h(self, k):\n",
    "    return k % self.m\n",
    "\n",
    "  def h_quad(self, k, i):\n",
    "    return (self.h(k) + self.c1*i + self.c2*i*i) % m\n",
    "\n",
    "  def qp(self, data):\n",
    "    # do we even need probing?\n",
    "    index = self.h(data)\n",
    "    if self.hashtable[index] == None:\n",
    "      return index\n",
    "\n",
    "    # yes, we do probing.\n",
    "    for i in range(self.m):\n",
    "      index = self.h_quad(data, i)\n",
    "      if self.hashtable[index] == None:\n",
    "        return index\n",
    "    return None\n",
    "\n",
    "  def lp(self, data):\n",
    "    # do we even need probing?\n",
    "    index = self.h(data)\n",
    "    if self.hashtable[index] == None:\n",
    "      return index\n",
    "\n",
    "    # yes, we do probing.\n",
    "    for i in range(self.m):\n",
    "      if self.hashtable[i] == None:\n",
    "        return i\n",
    "    return None\n",
    "\n",
    "  def store_data(self, data):\n",
    "    index = self.lp(data)\n",
    "    if index == None:\n",
    "      print('Hash table is full')\n",
    "      return\n",
    "    self.hashtable[index] = data\n",
    "\n",
    "  def display_hashtable(self):\n",
    "    return self.hashtable\n",
    "\n",
    "\n",
    "ht = Hashing(1, 2, 11)\n",
    "for x in [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]:\n",
    "  ht.store_data(x)\n",
    "print(ht.display_hashtable())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# result = sorted(result) # not in place, returns a new list, original list remains untouched\n",
    "# result.sort() # in place sort, modifies original list, returns None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1002, 1004, 1007, 1008, 1001, 1003, 1005, 1006, 1009]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def DishPrepareOrder(orders):\n",
    "  freq = {}\n",
    "  for order in orders:\n",
    "    if order not in freq:\n",
    "      freq[order] = 0\n",
    "    freq[order] += 1\n",
    "\n",
    "  result = list(freq.items())\n",
    "  result.sort(key=lambda item: item[0])\n",
    "  result.sort(key=lambda item: item[1], reverse=True)\n",
    "  return [item[0] for item in result]\n",
    "\n",
    "\n",
    "DishPrepareOrder([1006, 1008, 1009, 1008, 1007, 1005, 1008, 1001, 1003, 1009, 1006, 1003, 1004, 1002,\n",
    "                 1008, 1005, 1004, 1007, 1006, 1002, 1002, 1001, 1004, 1001, 1003, 1007, 1007, 1005, 1004, 1002])\n",
    "# == [1002, 1004, 1007, 1008, 1001, 1003, 1005, 1006, 1009]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def DishPrepareOrder(orders):\n",
    "  freq = {}\n",
    "  for order in orders:\n",
    "    if order not in freq:\n",
    "      freq[order] = 0\n",
    "    freq[order] += 1\n",
    "\n",
    "  result = list(freq.items())\n",
    "  result.sort(key=lambda item: item[0])\n",
    "  result.sort(key=lambda item: item[1], reverse=True)\n",
    "  return [item[0] for item in result]\n",
    "\n",
    "\n",
    "DishPrepareOrder([1006, 1007, 1005, 1006, 1003, 1009, 1001, 1005, 1007, 1007, 1004, 1008, 1002, 1002, 1006, 1001, 1006, 1003, 1001, 1006, 1007, 1002, 1005, 1003, 1007, 1007, 1001, 1008, 1007, 1005, 1003, 1005, 1001, 1005, 1003, 1003, 1004, 1001, 1007, 1006, 1006, 1007, 1006, 1008, 1009, 1004, 1005, 1002, 1006, 1002, 1002, 1003, 1007, 1007, 1004, 1006, 1006, 1001, 1004, 1004, 1006, 1007, 1008, 1006, 1004, 1002, 1008, 1002, 1008, 1006, 1007, 1007, 1006, 1008, 1002, 1004, 1004, 1008, 1005, 1001, 1007, 1003, 1005, 1007, 1006, 1001, 1002, 1004, 1001, 1008, 1001, 1007, 1007, 1001, 1005, 1003, 1009, 1007, 1004,\n",
    "                 1006, 1001, 1002, 1005, 1006, 1003, 1003, 1006, 1001, 1005, 1003, 1005, 1005, 1004, 1006, 1005, 1002, 1005, 1006, 1005, 1003, 1006, 1006, 1001, 1003, 1009, 1009, 1005, 1003, 1008, 1005, 1006, 1008, 1004, 1002, 1008, 1001, 1009, 1008, 1009, 1009, 1003, 1007, 1009, 1005, 1003, 1006, 1008, 1007, 1001, 1008, 1009, 1006, 1004, 1002, 1004, 1006, 1001, 1002, 1007, 1008, 1003, 1002, 1004, 1008, 1009, 1006, 1002, 1004, 1004, 1006, 1001, 1001, 1006, 1002, 1009, 1005, 1004, 1005, 1009, 1006, 1008, 1001, 1009, 1001, 1002, 1004, 1003, 1003, 1007, 1001, 1006, 1006, 1006, 1001, 1001, 1005, 1003, 1001, 1001, 1007]) == [1006, 1001, 1007, 1005, 1003, 1004, 1002, 1008, 1009]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "5\n",
      "/\n",
      "5\n",
      "3\n",
      "-\n",
      "5\n",
      "4\n",
      "^\n",
      "^\n",
      "*\n",
      "+\n",
      "1.1138771039116688e+188\n"
     ]
    }
   ],
   "source": [
    "def is_number(token):\n",
    "  try:\n",
    "    float(token)\n",
    "    return True\n",
    "  except:\n",
    "    return False\n",
    "\n",
    "\n",
    "def EvaluateExpression(expression):\n",
    "  stack = []\n",
    "  tokens = expression.split()\n",
    "  for token in tokens:\n",
    "    print(token)\n",
    "\n",
    "    # token is numeric\n",
    "    if is_number(token):\n",
    "      stack.append(float(token))\n",
    "      continue  # skip to next token\n",
    "\n",
    "    # token is op\n",
    "    b = stack.pop()\n",
    "    a = stack.pop()\n",
    "    if token == '+':\n",
    "      result = a + b\n",
    "    if token == '-':\n",
    "      result = a - b\n",
    "    if token == '*':\n",
    "      result = a * b\n",
    "    if token == '/':\n",
    "      result = a / b\n",
    "    if token == '^':\n",
    "      result = a ** b\n",
    "    stack.append(result)\n",
    "\n",
    "  return stack[0]\n",
    "\n",
    "\n",
    "print(float(EvaluateExpression('2 4 5 / 5 3 - 5 4 ^ ^ * +')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.1138771039116688e+188"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**625 * 0.8 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "20\n",
      "40\n",
      "[10]\n"
     ]
    }
   ],
   "source": [
    "class Stack:\n",
    "  def __init__(self):\n",
    "    self.data = []\n",
    "\n",
    "  def is_empty(self):\n",
    "    return len(self.data) == 0\n",
    "\n",
    "  def push(self, value):\n",
    "    self.data.append(value)\n",
    "\n",
    "  def pop(self):\n",
    "    return self.data.pop()\n",
    "\n",
    "  def __str__(self):\n",
    "    return str(self.data)\n",
    "\n",
    "\n",
    "stack = Stack()\n",
    "stack.push(10)\n",
    "stack.push(20)\n",
    "stack.push(30)\n",
    "print(stack.pop())\n",
    "print(stack.pop())\n",
    "stack.push(40)\n",
    "print(stack.pop())\n",
    "print(stack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "20\n",
      "40\n",
      "[10]\n"
     ]
    }
   ],
   "source": [
    "stack = []\n",
    "stack.append(10)\n",
    "stack.append(20)\n",
    "stack.append(30)\n",
    "print(stack.pop())\n",
    "print(stack.pop())\n",
    "stack.append(40)\n",
    "print(stack.pop())\n",
    "print(stack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "[40]\n"
     ]
    }
   ],
   "source": [
    "stack = []\n",
    "stack.append(10)\n",
    "stack.append(20)\n",
    "stack.append(30)\n",
    "print(stack.pop(0))\n",
    "print(stack.pop(0))\n",
    "stack.append(40)\n",
    "print(stack.pop(0))\n",
    "print(stack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "757.0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "13111.0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def EvaluateExpression(expression):\n",
    "  stack = []\n",
    "  for token in expression.split():\n",
    "    if token not in ['+', '-', '*', '/', '**']:\n",
    "      stack.append(int(token))\n",
    "      continue  # go to next token\n",
    "\n",
    "    B = stack.pop()\n",
    "    A = stack.pop()\n",
    "    # A op B\n",
    "    if token == '+':\n",
    "      stack.append(A + B)\n",
    "    if token == '-':\n",
    "      stack.append(A - B)\n",
    "    if token == '*':\n",
    "      stack.append(A * B)\n",
    "    if token == '/':\n",
    "      stack.append(A / B)\n",
    "    if token == '**':\n",
    "      stack.append(A ** B)\n",
    "  return stack[0]\n",
    "\n",
    "\n",
    "EvaluateExpression('100 200 + 2 / 5 * 7 +')\n",
    "EvaluateExpression('1 2 3 2 3 ** ** * + 6 2 / 4 * -')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "  def __init__(self, data):\n",
    "    self.data = data\n",
    "    self.next = None\n",
    "\n",
    "  def __str__(self):\n",
    "    return f'Node: {self.data}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rahul', 'vidu', 'cmd', 'harikesh', 'muskan']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def list_to_ll(elems):\n",
    "  root = Node(elems[0])\n",
    "  prev = root\n",
    "  for elem in elems[1:]:\n",
    "    node = Node(elem)\n",
    "    prev.next = node\n",
    "    prev = node\n",
    "  return root\n",
    "\n",
    "\n",
    "def ll_to_list(root):\n",
    "  output = []\n",
    "  curr = root\n",
    "  while curr:\n",
    "    output.append(curr.data)\n",
    "    curr = curr.next\n",
    "  return output\n",
    "\n",
    "\n",
    "root = list_to_ll(['rahul', 'vidu', 'cmd', 'harikesh', 'muskan'])\n",
    "ll_to_list(root)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['muskan', 'harikesh', 'cmd', 'vidu', 'rahul']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def reverse(root):\n",
    "  prev = root  # P\n",
    "  curr = root.next  # C\n",
    "  root.next = None\n",
    "  while curr:\n",
    "    temp = curr.next  # T\n",
    "    curr.next = prev  # links adjust\n",
    "    prev = curr  # loop forward\n",
    "    curr = temp  # loop forward\n",
    "  return prev  # last P is root\n",
    "\n",
    "\n",
    "root = list_to_ll(['rahul', 'vidu', 'cmd', 'harikesh', 'muskan'])\n",
    "new_root = reverse(root)\n",
    "ll_to_list(new_root)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 14, 1, 13, 12, 12, 12, 3, 1]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root = list_to_ll([1, 3, 12, 12, 12, 13, 1, 14, 5])\n",
    "new_root = reverse(root)\n",
    "ll_to_list(new_root)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1007,\n",
       " 1001,\n",
       " 1001,\n",
       " 1001,\n",
       " 1003,\n",
       " 1005,\n",
       " 1009,\n",
       " 1006,\n",
       " 1006,\n",
       " 1002,\n",
       " 1001,\n",
       " 1009,\n",
       " 1006,\n",
       " 1007,\n",
       " 1008]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root = list_to_ll([1008, 1007, 1006, 1009, 1001, 1002, 1006, 1006, 1009, 1005, 1003, 1001, 1001, 1001, 1007])\n",
    "new_root = reverse(root)\n",
    "ll_to_list(new_root)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def removeDuplicate(head):\n",
    "  last = head\n",
    "  curr = head\n",
    "  while curr:\n",
    "    if last.data != curr.data:\n",
    "      last.next = curr\n",
    "      last = curr\n",
    "    curr = curr.next\n",
    "  last.next = None\n",
    "\n",
    "\n",
    "head = list_to_ll([1, 1, 2, 2, 2, 2, 3, 3, 3, 3])\n",
    "removeDuplicate(head)\n",
    "ll_to_list(head)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 3 - Live Coding Problem 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 👉 ll is empty 🌿 insert_end()\n",
    "# case 1: []\n",
    "# sanika (10)\n",
    "\n",
    "# 👉 pos at head (pos=1) 🌿 node <- -> head, head = node\n",
    "# case 2: [rahul, vidu]\n",
    "# sanika (1)\n",
    "\n",
    "# 👉 pos > count 🌿 insert_end()\n",
    "# case 3: [rahul, vidu]\n",
    "# sanika (10)\n",
    "\n",
    "# 👉 prev <-->  node  <--> curr 🌿 set 4 links <><>\n",
    "# case 4: [rahul, vidu, cmd, harikesh]\n",
    "# sanika (3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "  def __init__(self, data):\n",
    "    self.data = data\n",
    "    self.next = None\n",
    "    self.prev = None\n",
    "\n",
    "  def __str__(self):\n",
    "    return f'Node: {self.data}'\n",
    "\n",
    "\n",
    "class doubly_linked_list:\n",
    "  def __init__(self):\n",
    "    self.head = None\n",
    "    self.last = None\n",
    "\n",
    "  def insert_end(self, data):\n",
    "    node = Node(data)\n",
    "    if self.head == None:\n",
    "      self.head = node\n",
    "      self.last = node\n",
    "    else:\n",
    "      self.last.next = node\n",
    "      node.prev = self.last\n",
    "      self.last = node\n",
    "\n",
    "  def insert_at_pos(self, data, pos):\n",
    "    # ll is empty\n",
    "    if self.head == None:\n",
    "      self.insert_end(data)\n",
    "      return\n",
    "\n",
    "    # pos=1\n",
    "    if pos == 1:\n",
    "      node = Node(data)\n",
    "      self.head.prev = node\n",
    "      node.next = self.head\n",
    "      self.head = node\n",
    "      return\n",
    "\n",
    "    # find curr, count\n",
    "    count = 0\n",
    "    curr = self.head\n",
    "    while curr:\n",
    "      count += 1\n",
    "      if count == pos:\n",
    "        break\n",
    "      curr = curr.next\n",
    "\n",
    "    # pos > count\n",
    "    if pos > count:\n",
    "      self.insert_end(data)\n",
    "      return\n",
    "\n",
    "    # prev <--> node <--> curr\n",
    "    node = Node(data)\n",
    "    prev = curr.prev\n",
    "\n",
    "    # vidu <--> sanika <--> cmd\n",
    "    node.next = curr  # node -> curr\n",
    "    curr.prev = node  # node <- curr\n",
    "    prev.next = node  # prev -> node\n",
    "    node.prev = prev  # prev <- node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['sanika']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain = doubly_linked_list()\n",
    "# ll is empty\n",
    "chain.insert_at_pos('sanika', 10)\n",
    "ll_to_list(chain.head)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['sanika', 'rahul', 'vidu']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain = doubly_linked_list()\n",
    "# pos at head (pos=1)\n",
    "chain.insert_end('rahul')\n",
    "chain.insert_end('vidu')\n",
    "chain.insert_at_pos('sanika', 1)\n",
    "ll_to_list(chain.head)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rahul', 'vidu', 'sanika']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain = doubly_linked_list()\n",
    "# pos > count\n",
    "chain.insert_end('rahul')\n",
    "chain.insert_end('vidu')\n",
    "chain.insert_at_pos('sanika', 10)\n",
    "ll_to_list(chain.head)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rahul', 'vidu', 'sanika', 'cmd', 'harikesh']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain = doubly_linked_list()\n",
    "# prev <-->  node  <--> curr\n",
    "chain.insert_end('rahul')\n",
    "chain.insert_end('vidu')\n",
    "chain.insert_end('cmd')\n",
    "chain.insert_end('harikesh')\n",
    "chain.insert_at_pos('sanika', 3)\n",
    "ll_to_list(chain.head)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 3 - Live Coding Problem 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5, 6, 7, 9, 10, 11]\n"
     ]
    }
   ],
   "source": [
    "def mergeSortedList(head1, head2):\n",
    "  curr1 = head1\n",
    "  curr2 = head2\n",
    "  last = None\n",
    "  while curr1 and curr2:\n",
    "    if curr1.data < curr2.data:\n",
    "      if last == None:\n",
    "        last = curr1\n",
    "        new_head = last\n",
    "      else:\n",
    "        last.next = curr1\n",
    "        last = curr1\n",
    "      curr1 = curr1.next\n",
    "    else:\n",
    "      if last == None:\n",
    "        last = curr2\n",
    "        new_head = last\n",
    "      else:\n",
    "        last.next = curr2\n",
    "        last = curr2\n",
    "      curr2 = curr2.next\n",
    "\n",
    "  if curr1 != None:\n",
    "    last.next = curr1\n",
    "  if curr2 != None:\n",
    "    last.next = curr2\n",
    "\n",
    "  return new_head\n",
    "\n",
    "\n",
    "head1 = list_to_ll([3, 4, 6])\n",
    "head2 = list_to_ll([5, 7, 9, 10, 11])\n",
    "new_head = mergeSortedList(head1, head2)\n",
    "print(ll_to_list(new_head))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5, 6, 7, 9, 10, 11]\n"
     ]
    }
   ],
   "source": [
    "def mergeSortedList(head1, head2):\n",
    "  curr1 = head1\n",
    "  curr2 = head2\n",
    "  last = None\n",
    "  # do pair-wise comparisons\n",
    "  while curr1 and curr2:\n",
    "    if curr1.data < curr2.data:\n",
    "      # curr1 is smaller\n",
    "      if last == None:\n",
    "        last = curr1\n",
    "        new_head = last\n",
    "      else:\n",
    "        last.next = curr1\n",
    "        last = curr1\n",
    "      curr1 = curr1.next\n",
    "    else:\n",
    "      # curr2 is smaller\n",
    "      if last == None:\n",
    "        last = curr2\n",
    "        new_head = curr2\n",
    "      else:\n",
    "        last.next = curr2\n",
    "        last = curr2\n",
    "      curr2 = curr2.next\n",
    "\n",
    "  # add remaining elems\n",
    "  if curr1 != None:\n",
    "    last.next = curr1\n",
    "  if curr2 != None:\n",
    "    last.next = curr2\n",
    "\n",
    "  return new_head\n",
    "\n",
    "\n",
    "head1 = list_to_ll([3, 4, 6])\n",
    "head2 = list_to_ll([5, 7, 9, 10, 11])\n",
    "new_head = mergeSortedList(head1, head2)\n",
    "print(ll_to_list(new_head))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 3 - Live Coding Problem 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# queue: entry-exit opposite (f-b, b-f)\n",
    "# stack: entry-exit same (f-f, b-b)\n",
    "# q1: exit [50, 40, 30, 20, 10] entry\n",
    "# q2: exit [] entry\n",
    "\n",
    "# Job: handle these as stack elems: 10, 20, 30, 40, 50\n",
    "# top(): look at 1st of q1\n",
    "# pop(): dequeue 1st of q1\n",
    "# push(value):\n",
    "#             (step1) transfer q1>q2,\n",
    "#             (step2) enqueue value to q1,\n",
    "#             (step3) transfer q2>q1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Queue:\n",
    "  def __init__(self):\n",
    "    self.items = []\n",
    "\n",
    "  def enqueue(self, key):\n",
    "    self.items.insert(0, key)\n",
    "\n",
    "  def dequeue(self):\n",
    "    return self.items.pop()\n",
    "\n",
    "\n",
    "class stack:\n",
    "  def __init__(self):\n",
    "    self.q1 = Queue()\n",
    "    self.q2 = Queue()\n",
    "    self.size = 0\n",
    "\n",
    "  def isempty(self):\n",
    "    return self.size == 0\n",
    "\n",
    "  def pop(self):\n",
    "    if self.isempty():\n",
    "      return 'Stack is empty'\n",
    "    self.size -= 1\n",
    "    return self.q1.dequeue()\n",
    "\n",
    "  def push(self, value):\n",
    "    # (step1) transfer q1>q2,\n",
    "    for i in range(self.size):\n",
    "      self.q2.enqueue(self.q1.dequeue())\n",
    "\n",
    "    # (step2) enqueue value to q1,\n",
    "    self.q1.enqueue(value)\n",
    "\n",
    "    # (step3) transfer q2>q1\n",
    "    for i in range(self.size):\n",
    "      self.q1.enqueue(self.q2.dequeue())\n",
    "\n",
    "    self.size += 1\n",
    "\n",
    "  def top(self):\n",
    "    if self.isempty():\n",
    "      return 'Stack is empty'\n",
    "    value = self.pop()  # remove\n",
    "    self.push(value)  # put it back\n",
    "    return value\n",
    "\n",
    "\n",
    "stack = stack()\n",
    "stack.push(10)\n",
    "stack.push(20)\n",
    "stack.push(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "class Queue:\n",
    "  def __init__(self):\n",
    "    self.items = []\n",
    "\n",
    "  def enqueue(self, key):\n",
    "    self.items.insert(0, key)\n",
    "\n",
    "  def dequeue(self):\n",
    "    return self.items.pop()\n",
    "\n",
    "\n",
    "class stack:\n",
    "  def __init__(self):\n",
    "    self.q1 = Queue()\n",
    "    self.q2 = Queue()\n",
    "    self.size = 0\n",
    "\n",
    "  def isempty(self):\n",
    "    return self.size == 0\n",
    "\n",
    "  def push(self, value):\n",
    "    # (step1) transfer q1>q2,\n",
    "    for i in range(self.size):\n",
    "      self.q2.enqueue(self.q1.dequeue())\n",
    "\n",
    "    # (step2) enqueue value to q1,\n",
    "    self.q1.enqueue(value)\n",
    "\n",
    "    # (step3) transfer q2>q1\n",
    "    for i in range(self.size):\n",
    "      self.q1.enqueue(self.q2.dequeue())\n",
    "\n",
    "    self.size += 1\n",
    "\n",
    "  def pop(self):\n",
    "    if self.isempty():\n",
    "      return 'Stack is empty'\n",
    "\n",
    "    self.size -= 1\n",
    "    return self.q1.dequeue()\n",
    "\n",
    "  def top(self):\n",
    "    if self.isempty():\n",
    "      return 'Stack is empty'\n",
    "    value = self.pop()  # remove\n",
    "    self.push(value)  # put it back\n",
    "    return value\n",
    "\n",
    "\n",
    "stack = stack()\n",
    "stack.push(10)\n",
    "stack.push(20)\n",
    "stack.push(30)\n",
    "print(stack.top())"
   ]
  }
 ],
 "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}