24 May 2024 - PG AI.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1: Given two vectors (arrays or list of numbers)\n",
    "     \n",
    "     return the difference of the two vectors\n",
    "     diff([1,2,3], [2,3,4]) => [-1, -1, -1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diff_vectors(a, b):\n",
    "    if len(a) != len(b):\n",
    "        print('Unequal lengths!')\n",
    "        # You would use throws exception\n",
    "        return None\n",
    "    index = 0\n",
    "    result = []\n",
    "    while index < len(a):\n",
    "        print(index, result)\n",
    "        d = a[index] - b[index]\n",
    "        result.append(d)\n",
    "        index += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 []\n",
      "1 [-13]\n",
      "2 [-13, -49]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[-13, -49, -59]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff_vectors([1,2,3], [14,51,62])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sandeep\n",
      "Samip\n",
      "neil\n",
      "Rahul\n"
     ]
    }
   ],
   "source": [
    "a = [\"Sandeep\", \"Samip\", \"neil\", \"Rahul\"]\n",
    "for v in a:\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Sandeep\n",
      "------\n",
      "1\n",
      "Samip\n",
      "------\n",
      "2\n",
      "neil\n",
      "------\n",
      "3\n",
      "Rahul\n",
      "------\n"
     ]
    }
   ],
   "source": [
    "a = [\"Sandeep\", \"Samip\", \"neil\", \"Rahul\"]\n",
    "for i, v in enumerate(a):\n",
    "    print(i)\n",
    "    print(v)\n",
    "    print(\"------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Sandeep\n"
     ]
    }
   ],
   "source": [
    "i, v  = (0, \"Sandeep\")\n",
    "print(i)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Sandeep\n",
      "------\n",
      "1\n",
      "Samip\n",
      "------\n",
      "2\n",
      "neil\n",
      "------\n",
      "3\n",
      "Rahul\n",
      "------\n"
     ]
    }
   ],
   "source": [
    "a = [(0, \"Sandeep\"), (1, \"Samip\"), (2, \"neil\"), (3, \"Rahul\")]\n",
    "for i, v in a:\n",
    "    print(i)\n",
    "    print(v)\n",
    "    print(\"------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diff_vectors(a, b):\n",
    "    result = []\n",
    "    idx = 0\n",
    "    for va in a:\n",
    "        print(f\"idx: {idx}, va: {va}\")\n",
    "        d = va - b[idx]\n",
    "        result.append(d)\n",
    "        idx += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "idx: 0, va: 1\n",
      "idx: 1, va: 2\n",
      "idx: 2, va: 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[-3, -2, -1]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff_vectors([1,2,3], [4, 4, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'sandeep'), (1, 'veena'), (2, 'subodh')]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate([\"sandeep\", \"veena\", \"subodh\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diff_vectors(a, b):\n",
    "    result = []\n",
    "    for idx, va in enumerate(a):\n",
    "        print(f\"idx: {idx}, va: {va}\")\n",
    "        d = va - b[idx]\n",
    "        result.append(d)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "idx: 0, va: 1\n",
      "idx: 1, va: 2\n",
      "idx: 2, va: 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[-13, -49, -59]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff_vectors([1,2,3], [14,51,62])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-13, -49, -59])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.array([1,2,3]) - np.array([14, 51, 62])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 14), (2, 51), (3, 62)]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip([1,2,3, 4], [14, 51, 62]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -1, 3]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def vector_difference(L1,L2):\n",
    "    result = []\n",
    "    for a, b in zip(L1, L2):\n",
    "        result.append(a - b)\n",
    "    return result\n",
    "\n",
    "L1=[1,2,7]\n",
    "L2=[2,3,4]\n",
    "vector_difference(L1,L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "result = []\n",
    "for v in a:\n",
    "    result.append(2*v)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "result = [v*v for v in a]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Given two vectors(array or list of numbers). Return thr difference of the two vector\n",
    "def vector_difference(L1,L2):\n",
    "    return [a - b for a, b in zip(L1, L2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -1, 3]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1=[1,2,7]\n",
    "L2=[2,3,4]\n",
    "vector_difference(L1,L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# while, for, for-enumerate, for-zip, list-for, numpy diff, recursion, map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def diff_vector1(a, b):\n",
    "    if len(a) == 0 or len(b) == 0:\n",
    "        return []\n",
    "    else:\n",
    "        result = [a[0] - b[0]]\n",
    "        result1 = diff_vector(a[1:], b[1:])\n",
    "        result.extend(result1)\n",
    "    return result\n",
    "diff_vector1([1, 5], [1, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_txt():\n",
    "    x = input(\"ENter: \")\n",
    "    if x != \".\":\n",
    "        read_txt()\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ENter: 1\n",
      "ENter: sandeep\n",
      "ENter: 34.23\n",
      "ENter: .\n",
      ".\n",
      "34.23\n",
      "sandeep\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "read_txt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3]\n",
    "a.append(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 10]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 10, [3, 4, 5]]\n"
     ]
    }
   ],
   "source": [
    "a.append([3,4,5])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 10, [3, 4, 5], 10, 20, 30]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.extend([10, 20, 30])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, [...]]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1]\n",
    "a.append(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[1][1][1][1][0] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, [...]]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff_vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vector\n",
    "1. When we feed the data a model, the input data is converted to bunch of numbers. a vector.\n",
    "2. When training a model, model is an array of numbers. a vector\n",
    "3. Image -> [[1,2,3], a vector of vector - tensor\n",
    "4. Audio -> [Sequence of numbers] , a vector\n",
    "5. NLP: text -> embedding, a vector\n",
    "6. Computer Vision, Face -> face embedding, a vector\n",
    "7. Recommendation Engine: Amazon. representation of a product\n",
    "8. Vector Database/Datastore\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = np.array([[1,2,3], [2,3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fb0319c4198>"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD8CAYAAAB6paOMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAATOklEQVR4nO3df5Bd5X3f8fen+gExhFhYKWhAwTDRpMZ1ImyNbIaMQ2LAsv9AzNhNxKSxyMCo+UHdJk0ncpmBjFzP4HSm7mRKYjRYBTspkJI43rRyKQYz7gwR0SaV+SEXEHJbpGALI4fUwRZZ/O0fe3Cvl13t3b1Hu1o979fMnXvO8zzn3u8zR3M/OufcezZVhSSpXX9vsQuQJC0ug0CSGmcQSFLjDAJJapxBIEmNMwgkqXEjBUGSs5M8kOSZ7nnVDONeTbKve4wNtF+Y5NEkB5Lcm2TlKPVIkuZu1COC7cCDVbUOeLBbn863q2p997h6oP3jwCeq6keBbwLXj1iPJGmOMsoPypI8BVxeVc8nWQM8XFU/Ns24b1XVmVPaArwAnFtVE0kuBX6rqt4774IkSXO2fMTtz6mq57vlrwHnzDDu9CTjwARwa1X9CfAm4K+raqIbcwg4b6Y3SrIN2AawjGXveANnjVi6FtLE6jMWuwTNUVZNzD5IJ41jX3+JiZdezny2nTUIknwBOHearpsGV6qqksx0eHFBVR1OchHwUJLHgZfmUmhV7QR2ApyVs+udec9cNtci+8YHLl3sEjRHK655YbFL0Bw8+eE7573trEFQVVfM1Jfk60nWDJwaOjLDaxzung8meRi4BPgj4I1JlndHBecDh+cxB0nSCEa9WDwGbO2WtwKfmzogyaokp3XLq4HLgP01eXHii8AHj7e9JOnEGjUIbgWuTPIMcEW3TpINSe7oxrwFGE/yZSY/+G+tqv1d328Cv57kAJPXDD41Yj2SpDka6WJxVb0IvO5kfVWNAzd0y48Ab5th+4PAxlFqkCSNxl8WS1LjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklq3EhBkOTsJA8keaZ7XjXNmPVJ/izJk0keS/JzA313Jvlqkn3dY/0o9UiS5m7UI4LtwINVtQ54sFuf6mXgQ1X1VmAT8O+SvHGg/19W1frusW/EeiRJczRqEGwG7uqW7wKumTqgqp6uqme65b8CjgA/POL7SpJ6MmoQnFNVz3fLXwPOOd7gJBuBlcCzA80f604ZfSLJaSPWI0mao+WzDUjyBeDcabpuGlypqkpSx3mdNcBngK1V9d2u+SNMBshKYCfwm8COGbbfBmwDOJ03zFa2JGlIswZBVV0xU1+SrydZU1XPdx/0R2YYdxbwX4CbqmrPwGu/djRxLMl/AH7jOHXsZDIsOCtnzxg4kqS5GfXU0BiwtVveCnxu6oAkK4HPAp+uqvum9K3pnsPk9YUnRqxHkjRHowbBrcCVSZ4BrujWSbIhyR3dmJ8F3g1cN83XRP8gyePA48Bq4F+PWI8kaY5mPTV0PFX1IvCeadrHgRu65d8Hfn+G7X9mlPeXJI3OXxZLUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjeslCJJsSvJUkgNJtk/Tf1qSe7v+R5O8eaDvI137U0ne20c9kqThjRwESZYBtwHvAy4Grk1y8ZRh1wPfrKofBT4BfLzb9mJgC/BWYBPwu93rSZIWSB9HBBuBA1V1sKpeAe4BNk8Zsxm4q1u+D3hPknTt91TVsar6KnCgez1J0gLpIwjOA54bWD/UtU07pqomgJeANw25LQBJtiUZTzL+dxzroWxJEiyhi8VVtbOqNlTVhhWcttjlSNIpo48gOAysHVg/v2ubdkyS5cAPAS8Oua0k6QTqIwj2AuuSXJhkJZMXf8emjBkDtnbLHwQeqqrq2rd03yq6EFgH/HkPNUmShrR81BeoqokkNwL3A8uAXVX1ZJIdwHhVjQGfAj6T5ABwlMmwoBv3h8B+YAL41ap6ddSaJEnDGzkIAKpqN7B7StvNA8vfAf7RDNt+DPhYH3VIkuZuyVwsliSdGAaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNa6XIEiyKclTSQ4k2T5N/68n2Z/ksSQPJrlgoO/VJPu6x9Q/ei9JOsFG/pvFSZYBtwFXAoeAvUnGqmr/wLD/AWyoqpeT/DLw28DPdX3frqr1o9YhSZqfPo4INgIHqupgVb0C3ANsHhxQVV+sqpe71T3A+T28rySpB30EwXnAcwPrh7q2mVwPfH5g/fQk40n2JLlmpo2SbOvGjf8dx0YqWJL0/418amgukvxjYAPwUwPNF1TV4SQXAQ8lebyqnp26bVXtBHYCnJWza0EKlqQG9HFEcBhYO7B+ftf2fZJcAdwEXF1V3/svfVUd7p4PAg8Dl/RQkyRpSH0EwV5gXZILk6wEtgDf9+2fJJcAtzMZAkcG2lclOa1bXg1cBgxeZJYknWAjnxqqqokkNwL3A8uAXVX1ZJIdwHhVjQH/BjgT+E9JAP5PVV0NvAW4Pcl3mQylW6d820iSdIL1co2gqnYDu6e03TywfMUM2z0CvK2PGiRJ8+MviyWpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNa6XIEiyKclTSQ4k2T5N/3VJXkiyr3vcMNC3Nckz3WNrH/VIkoY38t8sTrIMuA24EjgE7E0yNs0fob+3qm6csu3ZwC3ABqCAv+i2/eaodUmShtPHEcFG4EBVHayqV4B7gM1Dbvte4IGqOtp9+D8AbOqhJknSkEY+IgDOA54bWD8EvHOacR9I8m7gaeDXquq5GbY9b7o3SbIN2Aaw4sxVfOPnL+2hdC2UFde8sNglaI72rL9vsUvQHGz8gfmfSFmoi8V/Cry5qn6cyf/13zXXF6iqnVW1oao2LD/9jN4LlKRW9REEh4G1A+vnd23fU1UvVtWxbvUO4B3DbitJOrH6CIK9wLokFyZZCWwBxgYHJFkzsHo18JVu+X7gqiSrkqwCruraJEkLZORrBFU1keRGJj/AlwG7qurJJDuA8aoaAz6c5GpgAjgKXNdtezTJR5kME4AdVXV01JokScPr42IxVbUb2D2l7eaB5Y8AH5lh213Arj7qkCTNnb8slqTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUuF6CIMmmJE8lOZBk+zT9n0iyr3s8neSvB/peHegbm7qtJOnEGvlvFidZBtwGXAkcAvYmGauq/a+NqapfGxj/T4FLBl7i21W1ftQ6JEnz08cRwUbgQFUdrKpXgHuAzccZfy1wdw/vK0nqQR9BcB7w3MD6oa7tdZJcAFwIPDTQfHqS8SR7klwz05sk2daNG5/4zt/2ULYkCXo4NTRHW4D7qurVgbYLqupwkouAh5I8XlXPTt2wqnYCOwHe8MNra2HKlaRTXx9HBIeBtQPr53dt09nClNNCVXW4ez4IPMz3Xz+QJJ1gfQTBXmBdkguTrGTyw/513/5J8g+AVcCfDbStSnJat7wauAzYP3VbSdKJM/KpoaqaSHIjcD+wDNhVVU8m2QGMV9VrobAFuKeqBk/rvAW4Pcl3mQylWwe/bSRJOvF6uUZQVbuB3VPabp6y/lvTbPcI8LY+apAkzY+/LJakxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1LhegiDJriRHkjwxQ3+S/E6SA0keS/L2gb6tSZ7pHlv7qEeSNLy+jgjuBDYdp/99wLrusQ34PYAkZwO3AO8ENgK3JFnVU02SpCH0EgRV9SXg6HGGbAY+XZP2AG9MsgZ4L/BAVR2tqm8CD3D8QJEk9WyhrhGcBzw3sH6oa5up/XWSbEsynmR84jt/e8IKlaTWLJmLxVW1s6o2VNWG5aefsdjlSNIpY6GC4DCwdmD9/K5tpnZJ0gJZqCAYAz7UfXvoXcBLVfU8cD9wVZJV3UXiq7o2SdICWd7HiyS5G7gcWJ3kEJPfBFoBUFWfBHYD7wcOAC8Dv9j1HU3yUWBv91I7qup4F50lST3rJQiq6tpZ+gv41Rn6dgG7+qhDkjR3S+ZisSTpxDAIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXG9BEGSXUmOJHlihv6fT/JYkseTPJLkJwb6/lfXvi/JeB/1SJKG19cRwZ3ApuP0fxX4qap6G/BRYOeU/p+uqvVVtaGneiRJQ+rrj9d/Kcmbj9P/yMDqHuD8Pt5XkjS6xbhGcD3w+YH1Av5bkr9Ism0R6pGkpvVyRDCsJD/NZBD85EDzT1bV4SR/H3ggyf+sqi9Ns+02YBvAijNXLUi9ktSCBTsiSPLjwB3A5qp68bX2qjrcPR8BPgtsnG77qtpZVRuqasPy089YiJIlqQkLEgRJfgT4Y+AXqurpgfYzkvzga8vAVcC03zySJJ0YvZwaSnI3cDmwOskh4BZgBUBVfRK4GXgT8LtJACa6bwidA3y2a1sO/Meq+q991CRJGk5f3xq6dpb+G4Abpmk/CPzE67eQJC0Uf1ksSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNa6XIEiyK8mRJE/M0H95kpeS7OseNw/0bUryVJIDSbb3UY8kaXh9HRHcCWyaZcx/r6r13WMHQJJlwG3A+4CLgWuTXNxTTZKkIfQSBFX1JeDoPDbdCByoqoNV9QpwD7C5j5okScNZvoDvdWmSLwN/BfxGVT0JnAc8NzDmEPDO6TZOsg3Y1q0e23f7v5j2NNQStxr4xmIXcULcfsrO7ZSd17JTc15w6u6zH5vvhgsVBH8JXFBV30ryfuBPgHVzeYGq2gnsBEgyXlUbeq9ykZ2q84JTd27Oa+k5VeeWZHy+2y7It4aq6m+q6lvd8m5gRZLVwGFg7cDQ87s2SdICWZAgSHJuknTLG7v3fRHYC6xLcmGSlcAWYGwhapIkTerl1FCSu4HLgdVJDgG3ACsAquqTwAeBX04yAXwb2FJVBUwkuRG4H1gG7OquHcxmZx91n4RO1XnBqTs357X0nKpzm/e8Mvl5LElqlb8slqTGGQSS1LglEQRJzk7yQJJnuudVM4x7deA2FiftRefZbquR5LQk93b9jyZ58yKUOWdDzOu6JC8M7KMbFqPOuRriFipJ8jvdvB9L8vaFrnE+Rrk1zMksydokX0yyP8mTSf7ZNGOW6j4bZm5z329VddI/gN8GtnfL24GPzzDuW4td6xBzWQY8C1wErAS+DFw8ZcyvAJ/slrcA9y523T3N6zrg3y92rfOY27uBtwNPzND/fuDzQIB3AY8uds09zety4D8vdp3zmNca4O3d8g8CT0/zb3Gp7rNh5jbn/bYkjgiYvO3EXd3yXcA1i1fKyIa5rcbgfO8D3vPa129PYqfs7UJq9luobAY+XZP2AG9MsmZhqpu/Iea1JFXV81X1l93y/wW+wuRdDAYt1X02zNzmbKkEwTlV9Xy3/DXgnBnGnZ5kPMmeJNcsTGlzNt1tNabuyO+NqaoJ4CXgTQtS3fwNMy+AD3SH4vclWTtN/1I07NyXokuTfDnJ55O8dbGLmavutOolwKNTupb8PjvO3GCO+20h7zV0XEm+AJw7TddNgytVVUlm+s7rBVV1OMlFwENJHq+qZ/uuVfP2p8DdVXUsyT9h8qjnZxa5Js1s5FvDLKYkZwJ/BPzzqvqbxa6nT7PMbc777aQ5IqiqK6rqH07z+Bzw9dcO27rnIzO8xuHu+SDwMJNpebIZ5rYa3xuTZDnwQ0z+EvtkNuu8qurFqjrWrd4BvGOBajvRTslbpdTMt4Y56SVZweQH5R9U1R9PM2TJ7rPZ5jaf/XbSBMEsxoCt3fJW4HNTByRZleS0bnk1cBmwf8EqHN4wt9UYnO8HgYequwp0Ept1XlPOwV7N5PnNU8EY8KHumyjvAl4aOJW5ZGXmW8Oc1LqaPwV8par+7QzDluQ+G2Zu89lvJ82poVncCvxhkuuB/w38LECSDcAvVdUNwFuA25N8l8mJ31pVJ10QVNW0t9VIsgMYr6oxJnf0Z5IcYPJi3pbFq3g4Q87rw0muBiaYnNd1i1bwHGT2W6jsZvJbKAeAl4FfXJxK52aIec10a5iT3WXALwCPJ9nXtf0r4Edgae8zhpvbnPebt5iQpMYtlVNDkqQTxCCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjft/CiIVMQrBYI0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "def sq(x):\n",
    "    return x*x\n",
    "res = map(sq, [1,2,3])\n",
    "print(list(res))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x7fb02989c160>\n",
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "def sq(x):\n",
    "    return x*x\n",
    "res = map(sq, [1,2,3])\n",
    "print(res)\n",
    "print(list(res))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -1, -35]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def diff(tup):\n",
    "    a, b = tup\n",
    "    return a - b\n",
    "\n",
    "list(map(diff, [(2,3), (5,6), (10, 45)]))\n",
    "    -> [diff((2,3)), diff((5, 6)), diff((10, 45))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diff_vector(a, b):\n",
    "    def diff(tup):\n",
    "        a, b = tup\n",
    "        return a - b\n",
    "    return list(map(diff, zip(a, b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-4, -7, -3]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff_vector([2,3,4], [6,10,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Serendipity\n",
    "# JSON, Reading array\n",
    "# Pas texercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mmap(f, l):\n",
    "    result = []\n",
    "    for e in l:\n",
    "        r = f(e)\n",
    "        result.append(r)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[64, 125, 216]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def cube(x):\n",
    "    return x*x*x\n",
    "mmap(cube, [4,5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-10"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# def neg(x):\n",
    "#     return -x\n",
    "neg = lambda x: -x\n",
    "neg(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[64, 125, 216]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mmap(lambda x: x*x*x, [4,5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vector_diff(a, b):\n",
    "    return list(map(lambda x: x[0]-x[1], zip(a, b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-5, 1, -7]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_diff([2,3,4], [7,2, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lambda Function: INline function, single statement\n",
    "#  - more memory for defining the function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Which one is more efficient?\n",
    "    - Memory\n",
    "        - approximate the order, recustion was proporation to number of elements\n",
    "    - Computation\n",
    "        - approximate the order\n",
    "    \n",
    "# What libraries like numpy do?\n",
    "    - it uses the C's array\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use timeit to time the execution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2: Given two vectors (arrays or list of numbers). Find absolute distance between them. L1 Distance.\n",
    "\n",
    "    abs_distance([1,2,3], [2, 3, 4]) -> 3\n",
    "    abs_distance([5,4,1], [2, 3, 4]) -> 3+1+3 = 7\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def distance2d(point1,point2):\n",
    "    x_distance = point1[0]-point2[0]\n",
    "    y_distance = point1[1]-point2[1]\n",
    "    dist = math.sqrt(x_distance**2 +y_distance**2)\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def abs_dist(a, b):\n",
    "    index = 0\n",
    "    dist = 0\n",
    "    while index < len(a):\n",
    "        diff = a[index] - b[index]\n",
    "        if diff < 0:\n",
    "            diff = -diff\n",
    "        dist += diff\n",
    "        index += 1\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, -1, -1]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Shweta\n",
    "#Given two vectors(array or list of number ). find absolute distance between them.\n",
    "def absolute_distance(L1,L2):\n",
    "    distance=0\n",
    "    result = [a - b for a, b in zip(L1, L2)]\n",
    "    print(result)\n",
    "    for r in result:\n",
    "        distance += abs(r) \n",
    "    print(distance)\n",
    "    \n",
    "\n",
    "L1=[1,2,3]\n",
    "L2=[2,3,4]\n",
    "absolute_distance(L1,L2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 3,\n",
       " 6,\n",
       " 9,\n",
       " 12,\n",
       " 15,\n",
       " 18,\n",
       " 21,\n",
       " 24,\n",
       " 27,\n",
       " 30,\n",
       " 33,\n",
       " 36,\n",
       " 39,\n",
       " 42,\n",
       " 45,\n",
       " 48,\n",
       " 51,\n",
       " 54,\n",
       " 57,\n",
       " 60,\n",
       " 63,\n",
       " 66,\n",
       " 69,\n",
       " 72,\n",
       " 75,\n",
       " 78,\n",
       " 81,\n",
       " 84,\n",
       " 87,\n",
       " 90,\n",
       " 93,\n",
       " 96,\n",
       " 99]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, 100, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "a = [10, 20, 30]\n",
    "for i in range(len(a)):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Shweta Jain to Everyone (25 May 2024, 12:35 AM)\n",
    "#Given two vectors(array or list of number ). find absolute distance between them.\n",
    "def absolute_distance(L1,L2):\n",
    "    distance=0\n",
    "    result = [a - b for a, b in zip(L1, L2)]\n",
    "    print(result)\n",
    "    for r in result:\n",
    "        distance += r \n",
    "    print(abs(distance))\n",
    "    \n",
    "\n",
    "L1=[1,2,3]\n",
    "L2=[2,3,4]\n",
    "absolute_distance(L1,L2)\n",
    "\n",
    "list1 = [7, 10, 14, 18]\n",
    "list2 = [3, 8, 9, 15]\n",
    "absolute_distance(list1,L2)\n",
    " \n",
    "Veena Gindo to Everyone (25 May 2024, 12:35 AM)\n",
    "import math\n",
    "\n",
    "def distance3d(point1,point2):\n",
    "    x_distance = point1[0]-point2[0]\n",
    "    y_distance = point1[1]-point2[1]\n",
    "    z_distance = point1[2]-point2[2]\n",
    "    dist = math.sqrt(x_distance**2 +y_distance**2+z_distance**2)\n",
    "    return dist\n",
    "import math\n",
    "\n",
    "def distanceNd(point1,point2):\n",
    "    sq_distance =0\n",
    "    for i in range(len(point1)):\n",
    "        sq_distance += (point1[i] - point2[i])**2\n",
    "    dist =math.sqrt(sq_distance)\n",
    "    return dist\n",
    "def abs_distance(arr1,arr2):\n",
    "    index=0; distance =0\n",
    "   \n",
    "    while(index < len(arr1)):\n",
    "        value = arr1[index]-arr2[index]\n",
    "        if value<0 :\n",
    "            value = -value\n",
    "        distance += value \n",
    "        index += 1\n",
    "    return distance\n",
    " \n",
    "Abhijeet to Everyone (25 May 2024, 12:42 AM)\n",
    "#Given two 2D, 3D, 4D vectors representing two points, find the distance between two points.\n",
    "import math\n",
    "def distance(a, b):\n",
    "    sum=0\n",
    "    for i in range(len(a)):\n",
    "        sum+=(a[i] -b[i])**2\n",
    "    return math.sqrt(sum)\n",
    "    \n",
    "a=[1,2,6]\n",
    "b= [3,5,8]\n",
    "print(distance(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coin_toss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1: Coin Toss: Create a function that return 0 or 1 with equal probability.\n",
    "Hint: random.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.38685374951515705\n",
      "0.7246327457354373\n",
      "0.23702408195016433\n",
      "0.24437723106848686\n",
      "0.1879029852964066\n",
      "0.228058179613282\n",
      "0.6971512044773999\n",
      "0.16771722873538286\n",
      "0.2426700501463851\n",
      "0.24825576875533384\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(random())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coin_toss():\n",
    "    r = random()\n",
    "    if r < 0.5:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def eval_coin_toss(f, num=10000):    \n",
    "#     return sum([f() for _ in range(num)])/num\n",
    "\n",
    "def eval_coin_toss(f, num=10000):    \n",
    "    result = []\n",
    "    for _ in range(num):\n",
    "        result.append(f())\n",
    "    return sum(result)/num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4993"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_coin_toss(coin_toss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Abhijit\n",
    "\n",
    "import random\n",
    "def coin_toss_n_abhijit(partition=2):\n",
    "    num =random.random()\n",
    "    for i in range(partition):\n",
    "        if num > i/partition and num <= (i+1)/partition :\n",
    "            #print(i/partition ,'<', num, '<', (i+1)/partition)\n",
    "            return i\n",
    "    \n",
    "# d = [0]*10\n",
    "# for i in range(100000): \n",
    "#     d[coin_toss(10)]+= 1\n",
    "# d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def n_coin_toss_gaurav(n_occrance):\n",
    "    r = random.random()\n",
    "    n_mean_equal_probability = 1/n_occrance\n",
    "    return int(r/n_mean_equal_probability)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def n_coin_toss_sg(n):\n",
    "    r = n*random.random()\n",
    "    return int(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_coin_toss(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_n_coin_toss(f,n, itr=10000):\n",
    "    result = [0]*n\n",
    "    for _ in range(itr):\n",
    "        r = f(n)\n",
    "        result[r] += 1\n",
    "    result = list(map(lambda x:x/itr, result))\n",
    "    return result\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.2031, 0.2003, 0.1992, 0.1972, 0.2002]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_n_coin_toss(n_coin_toss, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.1931, 0.2041, 0.2055, 0.197, 0.2003]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_n_coin_toss(n_coin_toss_sg, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a n faced die which generates number from 0 to n - 1 with equal probability.\n",
    "n_occrance = int(input('Enter Dice Face Size'))\n",
    "total_occrance =  int(input('Enter occrance Number'))\n",
    "\n",
    "     # or 1, 2, 3, ... n-1\n",
    "result = [n_coin_toss() for i in range(total_occrance)]\n",
    "for i  in range(n_occrance):\n",
    "    print(\"Probability of {0} is :- {1}\".format(i,result.count(i)/total_occrance))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10]*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 10, 10, 10]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0] = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 10, 10, 10]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.2395, 0.267, 0.244, 0.2495]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [0]*4\n",
    "itr = 10000\n",
    "for _ in range(itr):\n",
    "    r = coin_toss_n_abhijit(4)\n",
    "    result[r] += 1\n",
    "result = list(map(lambda x:x/itr, result))\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4955"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_coin_toss(coin_toss_n_abhijit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5650163094917281\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Saneesh\n",
    "import random \n",
    "def coin_toss_saneesh():\n",
    "    r = random.random()\n",
    "    if r < 0.5:\n",
    "        print (r)\n",
    "        return 0\n",
    "    else:\n",
    "        print (r)\n",
    "        return 1\n",
    "coin_toss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Neil\n",
    "\n",
    "def coin_toss_neil():\n",
    "    p = random()\n",
    "    if p <= 0.5:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'function'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-3568b94999a7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0meval_coin_toss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcoint_toss_neil\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-11-5dce8fd636ee>\u001b[0m in \u001b[0;36meval_coin_toss\u001b[0;34m(f, num)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0meval_coin_toss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1000\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[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mf\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum\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[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'function'"
     ]
    }
   ],
   "source": [
    "eval_coin_toss(coint_toss_neil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#coin toss 0 head 1 tail\n",
    "#Shweta\n",
    "\n",
    "import random \n",
    "def toss_equal_prob():\n",
    "    count_0=0\n",
    "    count_1=0\n",
    "    stack_l=[] ##stack to maintain fetched number\n",
    "    for i in range(0,99):\n",
    "        n=int(random.random())\n",
    "        #print(n)\n",
    "        if(len(stack_l)==2): #empty stack if we have both numbers in the stack\n",
    "            stack_l=[]\n",
    "        elif(len(stack_l)==0): #add the number if stack is empty \n",
    "            stack_l.append(n)\n",
    "        elif(stack_l.pop()==0): #toggle the number\n",
    "            n=1\n",
    "        elif(stack_l.pop()==1):\n",
    "            n=0  \n",
    "      ########      \n",
    "        \n",
    "        if(n==0):\n",
    "            count_0 += 1\n",
    "        if(n==1):\n",
    "            count_1 += 1\n",
    "    print(\"Probability of 0 \",count_0/99*100,'%',\"and count:\",count_0)\n",
    "    print(\"Probability of 1 is \",count_1/99*100,'%',\"and count:\",count_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter occrance Number10000\n",
      "Probability of O is :- 0.3397 \n",
      "Probability of 1 is :- 0.3315 \n",
      "Probability of 2 is :- 0.3288\n"
     ]
    }
   ],
   "source": [
    "# Gaurav\n",
    "#Q2: Coin Toss: Create a function that return 0, 1, 2 with equal probability.\n",
    "from random import random\n",
    "mean_equal_probability = 0.33333333333\n",
    "def coint_toss():\n",
    "    r = random()\n",
    "    if r <= mean_equal_probability:\n",
    "        return 0\n",
    "    elif r <=(mean_equal_probability*2):\n",
    "        return 1\n",
    "    else:\n",
    "        return 2\n",
    "total_occurance = int(input('Enter occrance Number'))\n",
    "result = [coint_toss() for i in range(total_occurance)]\n",
    "result\n",
    "print(\"Probability of O is :- {0} \\nProbability of 1 is :- {1} \\nProbability of 2 is :- {2}\"\n",
    "      .format(result.count(0)/total_occurance,result.count(1)/total_occurance,result.count(2)/total_occurance))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'coint_toss' 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-3-283df62023a9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mcoint_toss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10000\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      2\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m# ~ 0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-3-283df62023a9>\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mcoint_toss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10000\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      2\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m# ~ 0.5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'coint_toss' is not defined"
     ]
    }
   ],
   "source": [
    "result = [coint_toss() for i in range(10000)]\n",
    "sum(result)# ~ 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q2: Coin Toss: Create a function that return 0, 1, 2 with equal probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q3: Create a n faced die which generates number from 0 to n - 1 with equal probability.\n",
    "def coin_toss(n):\n",
    "    return 0 # or 1, 2, 3, ... n-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q4: Unfair Coin: \n",
    "def coin_toss(p1, p2):\n",
    "    # p1 /(p1 + p2), p2/(p1+p2)\n",
    "    # return 0 p1 probability\n",
    "    # return 1 with p2 probability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coin_toss(0.8, 0.2) #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Abhijit\n",
    "import random\n",
    "def coin_toss_bias(part):\n",
    "    if (sum(part)!= 1):\n",
    "        return \"Sum is not 1\"\n",
    "    num =random.random()\n",
    "    min_range =0\n",
    "    for i in range(len(part)):\n",
    "        val = part[i]\n",
    "        major_range = min_range + val\n",
    "        if min_range > val and val < major_range :\n",
    "            print(min_range ,'<', num, '<', major_range)\n",
    "            return i\n",
    "        min_range = major_range\n",
    "    \n",
    "coin_toss_bias([.7, .2, .1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#Manav\n",
    "from random import random\n",
    "def coin_toss_manav(iter):\n",
    "    for x in range(iter):\n",
    "        r = random()\n",
    "        if r >= 0.5:\n",
    "            print(\"1\")\n",
    "        else:\n",
    "            print(\"0\")\n",
    "coin_toss(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5039"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_coin_toss(coint_toss_neil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random\n",
    "\n",
    "def coin_toss_disha():\n",
    "    r = random()\n",
    "    if r <= 0.5:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5052"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval_coin_toss(coin_toss_disha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "#coin toss 0 head 1 tail\n",
    "def coin_toss_mm() :\n",
    "  if random.random() < 0.5 :\n",
    "    return 0;\n",
    "  else :\n",
    "    return 1;\n",
    "\n",
    "def coin_toss_wrap_mm(n) :\n",
    "    i = 0;\n",
    "    cnt_0 = 0;\n",
    "    cnt_1 = 0;\n",
    "    while i < n :\n",
    "        val = coin_toss();\n",
    "        if val==0 :\n",
    "            cnt_0 = cnt_0 + 1;\n",
    "        else :\n",
    "            cnt_1 = cnt_1 + 1;\n",
    "        i = i + 1;\n",
    "    print(f\"cnt_1 : {cnt_1/n}, cnt_0: {cnt_0/n}\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4068296914919348\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr = random.random()\n",
    "ii = int(rr*(10**(len(str(rr))-2)))\n",
    "print(ii)\n",
    "ii % 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random\n",
    "def coint_toss_fair_subodh(n):\n",
    "    rr = random()\n",
    "    ii = int(rr*(10**(len(str(rr))-3)))\n",
    "    return (ii % n)\n",
    "\n",
    "num = 100\n",
    "result = [coint_toss_fair(num) for i in range(10000)]\n",
    "print(\"Example for fair {num} sided coin toss\")\n",
    "\n",
    "total=0\n",
    "for i in range(num):\n",
    "    print(f\"Number of {i}'s occured : {100 * (result.count(i) / len(result)) :.2f}\")\n",
    "    total+=result.count(i) / len(result)\n",
    "    i+=1\n",
    "\n",
    "print(f\"Total : {total :.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#rohan\n",
    "\n",
    "import random\n",
    "choice=input(\"enter your choice Heads or Tails:\")\n",
    "num=random.randint(1,2)\n",
    "if num==1:\n",
    "    result=\"heads\"\n",
    "elif num==2:\n",
    "    result=\"tails\"\n",
    "    \n",
    "if choice==result:\n",
    "    print(\"you won the coin flipped\",result)\n",
    "else:\n",
    "    print(\"you lost the coin flipped\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coin_toss(0.8, 0.2) # return 0, 80% of times. 1, 20% of time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5: coin_toss, takes three probability p1, p2, p3 as arguments.\n",
    "\n",
    "    Return 0 with p1 probability. 1 with p2 probability\n",
    "    2 with p3 probability.\n",
    "\n",
    "coin_toss_3(0.7, 0.2, 0.1) # 0 - 70% of times, 1 - 20% of time, 2 - 10% of time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NOTE: use only random.random() from random module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q6: Generalize Q5 to n number of faces. Take an array of probabilities and return 0 to len of array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Problem BLEU score. Code it \n",
    "n =  4\n",
    "wgm=0\n",
    "weights = (0.25, 0.25, 1, 1) # Weights for uni-gram, bi-gram, tri-gram, and 4-gram\n",
    "p=(0.66,0.4,1,1)\n",
    "reference = [[\"the\",\"cat\",\"is\",\"on\",\"the\",\"mat\"],\n",
    "             [\"there\",\"is\",\"a\",\"cat\",\"on\",\"the\",\"mat\"]]\n",
    "predictions = [\"the\",\"the\",\"the\",\"the\",\"the\",\"the\",\"cat\"]\n",
    "\n",
    "r=max(len(reference[0]),len(reference[1]))\n",
    "c=len(predictions)\n",
    "print(r,c)\n",
    "exp=0\n",
    "BLEU_Score=0\n",
    "\n",
    "#Brevity penalty \n",
    "if(r<=c):\n",
    "    BP=1\n",
    "else:\n",
    "    BP=math.exp(1-r/c)\n",
    "    \n",
    "#BLEU Score\n",
    "#multiply the Brevity Penalty with the Geometric Average of the Precision Scores.\n",
    "#Bleu Score can be computed for different values of n. Typically, we use n = 4\n",
    "\n",
    "for i in range(0,n):\n",
    "    w=(weights[i])\n",
    "    l= ma.log(p[i])\n",
    "    wgm += (w*l)\n",
    "    #print(expression)\n",
    "print(wgm)\n",
    "exp_part = math.exp(wgm)\n",
    "print(exp_part)\n",
    "BLEU_Score=(BP*exp_part)\n",
    "print(BLEU_Score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How to create a fair coin with 2 faces, 3 faces and n-faces?\n",
    "\n",
    "from random import random\n",
    "def twofacecoin():\n",
    "    r = random()\n",
    "    if r < 0.5:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "twofacecoin()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O(1)\n",
    "def n_face_coin(n):\n",
    "    return int(random()*n) # time will be proportanal to number of digits in n. O(log n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_face_coin(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100168, 99945, 99632, 100228, 100136, 100044, 99880, 99900, 100187, 99880]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 10\n",
    "d = [0]*n\n",
    "for i in range(1000000):\n",
    "    d[n_face_coin(n)] += 1\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hemant\n",
    "\n",
    "import random\n",
    "from collections import Counter\n",
    "\n",
    "def prob_toss(n_bucket,n_flip):\n",
    "    bucket_idx=1\n",
    "    count_flip_idx=1\n",
    "    bucket_list=list()\n",
    "    while(count_flip_idx<=n_flip):\n",
    "        random_num = round(random.random(),4)\n",
    "        ##print(\"Random Number\",random_num)\n",
    "        for bucket_idx in range(1,n_bucket+1):\n",
    "            if(random_num<=(bucket_idx/n_bucket)):\n",
    "                bucket_list.append((round(bucket_idx/n_bucket,4)))\n",
    "                break\n",
    "        count_flip_idx+=1\n",
    "    return bucket_list\n",
    "    \n",
    "def final_result(n_bucket,n_flip=1):\n",
    "    if(n_bucket <=0):\n",
    "        print(\"Please Provide Valid Probability Bucket Count\")\n",
    "        return False\n",
    " \n",
    "    f_list = prob_toss(n_bucket,n_flip)\n",
    "    ob = Counter(f_list)\n",
    "    for i in ob.keys():\n",
    "        per_f=str(round(float((ob[i]/n_flip)*100),2))\n",
    "        per_k=str(i)\n",
    "        print(\"Percentage Weightage of Probability Bucket \"+per_k, \"is \" +per_f,\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# time taken by it and memory consumed\n",
    "# Time Varies based on Processor. HDD, RAM, how much data are we processing\n",
    "# Memory consumed is a function of how much data are we processing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# time -> how it varies with data\n",
    "#    - O(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def search(nums, to_search):\n",
    "    for num in nums:\n",
    "        if num == to_search:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "search([1,2,3,4], 1)\n",
    "\n",
    "# list has 10000 elements. what's worst case?\n",
    "# list has n element, worst case n times. \n",
    "O(n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#time taken by search is a function of nums.\n",
    "\n",
    "# if nums was 10000, it was taking 1ms\n",
    "# if nums becomes 100,000, how much time will it take: 10ms\n",
    "\n",
    "# O(n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O(n*n)\n",
    "def handshake(n):\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            print(i, j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "0 1\n",
      "0 2\n",
      "1 0\n",
      "1 1\n",
      "1 2\n",
      "2 0\n",
      "2 1\n",
      "2 2\n"
     ]
    }
   ],
   "source": [
    "handshake(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O(n*n) or above -- you have to reevaluate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_even(n):\n",
    "    i = 0\n",
    "    while i < n:\n",
    "        print(i)\n",
    "        i += 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print_even(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n/2 steps. \n",
    "# O(n/2) -> O(n)\n",
    "# O(n + 5) -> O(n)\n",
    "# O(3*n) --> O(n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(n):\n",
    "    i = 0\n",
    "    while i < n:\n",
    "        print(i)\n",
    "        i += 3\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Order of complexity: O(n/3) -> O(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O(r)\n",
    "def power(n, r): # computer N to the power r \n",
    "    product = 1\n",
    "    for i in range(r):\n",
    "        product = product * n\n",
    "    return product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 10, 100)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power(10, 0), power(10, 1),power(10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power(10, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1 multiplied by n, r times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0**0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(n):\n",
    "    i = 1\n",
    "    while i < n:\n",
    "        print(i)\n",
    "        i = i * 2\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "f(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "f(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2, loop runs for: 1\n",
    "n = 4, loop runs for: 2\n",
    "n = 8, loop runs for 3\n",
    "n = 16, loop runs for 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# n=1000, 2 seconds\n",
    "# n=1000,000, time=???"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1(n):\n",
    "    count = 0\n",
    "    while n > 1:\n",
    "        print(\"n: \", n)\n",
    "        n = n/2\n",
    "        count += 1\n",
    "    print(count)\n",
    "\n",
    "# If the number is 2^100, the loop will run 100 times.\n",
    "# If the number is 2^1000, the loop will run 1000 times.\n",
    "# If the number is 2^45, the loop will run 45 times.\n",
    "\n",
    "# Complexity: log2(n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n:  5\n",
      "n:  2.5\n",
      "n:  1.25\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "f1(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n:  10\n",
      "n:  5.0\n",
      "n:  2.5\n",
      "n:  1.25\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "f1(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n:  20\n",
      "n:  10.0\n",
      "n:  5.0\n",
      "n:  2.5\n",
      "n:  1.25\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "f1(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1(n):\n",
    "    count = 0\n",
    "    while n > 1:\n",
    "        print(\"n: \", n)\n",
    "        n = n/10\n",
    "        count += 1\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n:  10\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "f1(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n:  100\n",
      "n:  10.0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "f1(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n:  1000\n",
      "n:  100.0\n",
      "n:  10.0\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "f1(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Complexity: O(log10(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.log(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6309297535714573"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(1000, 3)/math.log(1000, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "left, right = 0, 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left:  51  right:  52\n",
      "51\n"
     ]
    }
   ],
   "source": [
    "# interger between 0 and 100. \n",
    "print(\"left: \", left, \" right: \", right)\n",
    "guess = (left+right)//2\n",
    "print(guess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "left = guess + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "right = guess - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SQRT(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "left, right = 0, 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left:  3.16162109375  right:  3.1640625\n",
      "Guess:  3.162841796875\n",
      "Square:  10.003568232059479\n"
     ]
    }
   ],
   "source": [
    "print(\"left: \", left, \" right: \", right)\n",
    "guess = (left+right)/2\n",
    "print(\"Guess: \", guess)\n",
    "print(\"Square: \", guess*guess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "right = guess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "left = guess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q1: Code the SQRT\n",
    "# Q2: Code the 1/4 power?\n",
    "# Q3: Code the 1/5 power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "316.2277699179979\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "n = 100000\n",
    "while i < n:\n",
    "#     print(\"Tring...\")\n",
    "    if i*i > n:\n",
    "        print(i)\n",
    "        break\n",
    "    else:\n",
    "        i += 0.00001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.04889999999985"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i*i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3169.9999999999764"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.1699999999999764/0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Biased Coin\n",
    "def coin(x, y):\n",
    "    r = random()\n",
    "    if r < x:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coin(0.8, 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coin(x1, x2, x3):\n",
    "    r = random()\n",
    "    if r < x1:\n",
    "        return 0\n",
    "    elif r < x1+x2:\n",
    "        return 1\n",
    "    else:\n",
    "        return 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coin(0.9, 0.05, 0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coin(arr):\n",
    "    r = random()\n",
    "    i = 1\n",
    "    # 0.1, 0.2, 0.3, 0.4 -> \n",
    "    # 0.1, 0.3, 0.6, 1.0\n",
    "    while i < len(arr):\n",
    "        arr[i] += arr[i - 1]\n",
    "        i += 1\n",
    "#     print(arr)\n",
    "    for i, v in enumerate(arr):\n",
    "        if r < v:\n",
    "            return i\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n-1 times + n => 2*n \n",
    "# O(2n) -> O(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1, 0.30000000000000004, 0.6000000000000001]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coin([0.1, 0.2, 0.3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q1: Code the SQRT\n",
    "# Q2: Code the 1/4 power?\n",
    "# Q3: Code the 1/5 power\n",
    "# Q4: Convert to probability\n",
    "# 10, 20, 30 -> 10/(10+20+30), 20/(10+20+30), 30/(10+20+30)\n",
    "def convert_to_prob(arr):\n",
    "    pass\n",
    "\n",
    "# Q5: Softmax\n",
    "# [1,2,3] -> 10^1, 10^2, 10^3 -> convert_to_prob \n",
    "def softmax(arr):\n",
    "    pass\n",
    "\n",
    "# Q6: Try calculating the complexity of all of above code"
   ]
  },
  {
   "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
}