Chapter 3 Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 3 Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reinforcement\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-----------R3-1-----------------\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "x = [10**i for i in range(10)]\n",
    "\n",
    "funcs = [lambda x: 8*x,\n",
    "        lambda x: 4*x*math.log(x),\n",
    "        lambda x: 2*x**2,\n",
    "        lambda x: x**3,\n",
    "        #lambda x: 2**x    #Note, this is too time consuming to compute\n",
    "        ]\n",
    "\n",
    "ys = []\n",
    "\n",
    "for func in funcs:\n",
    "    ys.append(list(map(func, x)))\n",
    "\n",
    "for y in ys:\n",
    "    plt.plot(x, y)\n",
    "plt.yscale('log')\n",
    "plt.xscale('log')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The answer is approximately 1.5 from the intersection between the graphs'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#-------------R3-2-------------------\n",
    "\"\"\"\n",
    "A is better than B for n greater than n when 8nlogn = 2n^2, or 4logn = n\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "x = [x/100 for x in range(1, 500)]\n",
    "y1 = list(map(lambda x: 4*math.log(x),x))\n",
    "y2 = x\n",
    "\n",
    "plt.plot(x, y1)\n",
    "plt.plot(x, y2)\n",
    "\n",
    "\"\"\"The answer is approximately 1.5 from the intersection between the graphs\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n40n^2 = 2n^3 when n = 20, which means n0 = 20\\n\\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------R3-3--------------\n",
    "\"\"\"\n",
    "40n^2 = 2n^3 when n = 20, which means n0 = 20\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nA constant function is plotted the same on each scale\\n\\n'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#----------R3-4--------------------\n",
    "\"\"\"\n",
    "A constant function is plotted the same on each scale\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nif y = n^c, then log(y) = log(n^c) = c log(n).\\n\\nThis is of the form y=mx for a log scale\\n\\n\\n'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#---------------R3-5-------------\n",
    "\"\"\"\n",
    "if y = n^c, then log(y) = log(n^c) = c log(n).\n",
    "\n",
    "This is of the form y=mx for a log scale\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThe sum is twice the sum of all the numbers from 0 to n, which is 2*(n+1)(n)/2 = (n+1)(n)\\n'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------R3-6------------------\n",
    "\"\"\"\n",
    "The sum is twice the sum of all the numbers from 0 to n, which is 2*(n+1)(n)/2 = (n+1)(n)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nIf the worst case runtime is O(f(n)), then there is a constant c such that cf(n)>worst_case for n>n0\\n\\nSince the worst case is always >= to all other cases, (worst case runtime >= g(n)), then cf(n)>=worst_case>= all other cases A\\n\\nSince a>=b and b>=c, then a>=c, which means that c (the algorithm A) is O(f(n))\\n\\n'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------R3-7----------------\n",
    "\"\"\"\n",
    "If the worst case runtime is O(f(n)), then there is a constant c such that cf(n)>worst_case for n>n0\n",
    "\n",
    "Since the worst case is always >= to all other cases, (worst case runtime >= g(n)), then cf(n)>=worst_case>= all other cases A\n",
    "\n",
    "Since a>=b and b>=c, then a>=c, which means that c (the algorithm A) is O(f(n))\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nIn increasing order or asymptotic growth rate...\\n\\nconstant (2^10)\\n\\nn (2^log(n) = n)\\nn (3n + 100logn) (<- this grows at a faster rate than the one before because 3>1)\\nn (4n) <- 4>3 and the 100logn term will eventually become relatively trivial at high n\\nnlogn (nlogn)\\nnlogn (4nlogn + 2n) <- Grows quicker because of the constant\\nn^2 (n^2 + 10)\\nn^3 (n^3)\\n2^n (2^n)\\n\\n'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------R3-8----------------------\n",
    "\"\"\"\n",
    "In increasing order or asymptotic growth rate...\n",
    "\n",
    "constant (2^10)\n",
    "\n",
    "n (2^log(n) = n)\n",
    "n (3n + 100logn) (<- this grows at a faster rate than the one before because 3>1)\n",
    "n (4n) <- 4>3 and the 100logn term will eventually become relatively trivial at high n\n",
    "nlogn (nlogn)\n",
    "nlogn (4nlogn + 2n) <- Grows quicker because of the constant\n",
    "n^2 (n^2 + 10)\n",
    "n^3 (n^3)\n",
    "2^n (2^n)\n",
    "\n",
    "\"\"\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nif d(n) is O(f(n)), there is a constant such that d(n) <= cf(n) for every n>n0.\\n\\nif we multiply d(n) by a, we get (ad(n)) <= acf(n) = c'f(n)\\n\\nEssentially, the new constant will be c_old * a, which still maintains the original condition of O notation, which \\nwill be true when n>a*n0\\n\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-9------------------\n",
    "\"\"\"\n",
    "if d(n) is O(f(n)), there is a constant such that d(n) <= cf(n) for every n>n0.\n",
    "\n",
    "if we multiply d(n) by a, we get (ad(n)) <= acf(n) = c'f(n)\n",
    "\n",
    "Essentially, the new constant will be c_old * a, which still maintains the original condition of O notation, which \n",
    "will be true when n>a*n0\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nIf d(n) is O(f(n)) and e(n) is O(g(n)), then d(n)<= cf(n) for n_f>n_f0 and e(n)<= dg(n) for n_e>n_e0\\n\\nas a result, d(n)e(n) <= (cf(n))*(dg(n)) and n_f*n_e > n_f0*n_e0\\n\\nwhich means that there is a new n' = n_f*n_e and and n0' = n_f0*n_e0, and a c' = c*d such that \\nd(n)e(n) <= c'(f(n)g(n)) for n'>n0', which means that d(n)e(n) is O(f(n)g(n))\\n\\n\\n\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------R-3-10-----------------------\n",
    "\"\"\"\n",
    "If d(n) is O(f(n)) and e(n) is O(g(n)), then d(n)<= cf(n) for n_f>n_f0 and e(n)<= dg(n) for n_e>n_e0\n",
    "\n",
    "as a result, d(n)e(n) <= (cf(n))*(dg(n)) and n_f*n_e > n_f0*n_e0\n",
    "\n",
    "which means that there is a new n' = n_f*n_e and and n0' = n_f0*n_e0, and a c' = c*d such that \n",
    "d(n)e(n) <= c'(f(n)g(n)) for n'>n0', which means that d(n)e(n) is O(f(n)g(n))\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nLike before, if d(n) is O(f(n)) and e(n) is O(g(n)), then d(n)<= cf(n) for n_f>n_f0 and e(n)<= dg(n) for n_e>n_e0\\n\\nThat means that d(n) + e(n) <= (cf(n)) + (dg(n)) and n > n_f0+n_e0\\n\\nwhich means that there is a new n' = n_f+n_e and and n0' = n_f0+n_e0, such that:\\n\\nd(n) + e(n) <= cf(n) + dg(n) for n>n0'; however, this still does not satisfy O notation.  \\n\\nWe can absorb c and d into their functions such that  d(n) + e(n) <= f(cn) + g(dn) \\n\\nTo absorb c, we note that n'' = cn', so n' = n''/c, which means that n''/c >= n0''/c\\n\\nsimilarly for d, n''/cd >= n0''/cd\\n\\nTherefore there are new values of n0 such that \\n\\nd(n) + e(n) <= (f(n)+d(n)) for n>= n0'', which satisfies O(f(n) + d(n)) conditions\\n\\n\\n\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------R3-11--------------\n",
    "\"\"\"\n",
    "Like before, if d(n) is O(f(n)) and e(n) is O(g(n)), then d(n)<= cf(n) for n_f>n_f0 and e(n)<= dg(n) for n_e>n_e0\n",
    "\n",
    "That means that d(n) + e(n) <= (cf(n)) + (dg(n)) and n > n_f0+n_e0\n",
    "\n",
    "which means that there is a new n' = n_f+n_e and and n0' = n_f0+n_e0, such that:\n",
    "\n",
    "d(n) + e(n) <= cf(n) + dg(n) for n>n0'; however, this still does not satisfy O notation.  \n",
    "\n",
    "We can absorb c and d into their functions such that  d(n) + e(n) <= f(cn) + g(dn) \n",
    "\n",
    "To absorb c, we note that n'' = cn', so n' = n''/c, which means that n''/c >= n0''/c\n",
    "\n",
    "similarly for d, n''/cd >= n0''/cd\n",
    "\n",
    "Therefore there are new values of n0 such that \n",
    "\n",
    "d(n) + e(n) <= (f(n)+d(n)) for n>= n0'', which satisfies O(f(n) + d(n)) conditions\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nThe key point here is that just because something is O(n) doesn't mean that is has to be that function\\nFor example, f(n) = 5 is O(n) is mathematically true, although it is poor form to say so\\n\\nTherefore, if we have d(n) = n and e(n) = n with f(n) = n and g(n) = n, then we satisfy\\nd(n) <= C(f(n)) for n>=0, and e(n) <= C2(g(n)) for n>=0\\n\\nf(n)-g(n) = 0 and d(n) -e(n) = n\\n\\nThere is no value for n>0 such that 0>=n, which means that d(n) -e(n) is not O(f(n)-g(n))\\n\\nSide Note: The wikipedia definition of Big-O is |f(n)| <= Mg(x) for all x>x0,\\nwhich provides more opportunities to disprove this property\\n\\n\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------R3-12--------------\n",
    "\"\"\"\n",
    "The key point here is that just because something is O(n) doesn't mean that is has to be that function\n",
    "For example, f(n) = 5 is O(n) is mathematically true, although it is poor form to say so\n",
    "\n",
    "Therefore, if we have d(n) = n and e(n) = n with f(n) = n and g(n) = n, then we satisfy\n",
    "d(n) <= C(f(n)) for n>=0, and e(n) <= C2(g(n)) for n>=0\n",
    "\n",
    "f(n)-g(n) = 0 and d(n) -e(n) = n\n",
    "\n",
    "There is no value for n>0 such that 0>=n, which means that d(n) -e(n) is not O(f(n)-g(n))\n",
    "\n",
    "Side Note: The wikipedia definition of Big-O is |f(n)| <= Mg(x) for all x>x0,\n",
    "which provides more opportunities to disprove this property\n",
    "\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nIf d(n) is O(f(n)) and f(n) is O(g(n)), then d(n)<= cf(n) for n_f>n_f0 and f(n)<= dg(n) for n_g>n_g0\\n\\n\\nIf that is true, then d(n)<=cf(n)<=c(d(g(n))) = cd*g(n) = c'g(n) by substitution, which is true for\\nn_f*n_g>n_f0*n_g0, or n>n0'\\n\\nTogether, these satisfy the conditions of d(n) is O(g(n))\\n\\n\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------R3-13-----------------\n",
    "\"\"\"\n",
    "If d(n) is O(f(n)) and f(n) is O(g(n)), then d(n)<= cf(n) for n_f>n_f0 and f(n)<= dg(n) for n_g>n_g0\n",
    "\n",
    "\n",
    "If that is true, then d(n)<=cf(n)<=c(d(g(n))) = cd*g(n) = c'g(n) by substitution, which is true for\n",
    "n_f*n_g>n_f0*n_g0, or n>n0'\n",
    "\n",
    "Together, these satisfy the conditions of d(n) is O(g(n))\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nBy definition, if y is the output of max{f(n), g(n)}, then by definition\\ny>=f(n) and y>=g(n), which means that 2y>=f(n) + g(n)\\nThat means that f(n) + g(n) <= 2(max{f(n), g(n)}) for every n>n0=0,\\nwhich satisfies our requirements for O\\n\\n'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-14---------------------\n",
    "\"\"\"\n",
    "By definition, if y is the output of max{f(n), g(n)}, then by definition\n",
    "y>=f(n) and y>=g(n), which means that 2y>=f(n) + g(n)\n",
    "That means that f(n) + g(n) <= 2(max{f(n), g(n)}) for every n>n0=0,\n",
    "which satisfies our requirements for O\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nfor f(n) to be O(g(n)), f(n)<=Cg(n) for all n>n0\\n\\nfor g(n) to be T(f(n)), g(n)>= Cf(b) for all n>n0\\n\\n\\nif g(n) is not T(f(n)), then there is a value where g(n)<=cf(b) for n>n0\\n\\nif that is true, then g(n)<=cf(n) at the critical n, then f(n)<=(1/c)f(n) for some n>n0\\n(note this is true because c>0)\\nwhich violates the rules for f(n) is O(g(n)).\\n\\nTherefore, the orginal statement holds by contraposition\\n\\n\\n\\n\\n'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#----------R3-15-------------------\n",
    "\"\"\"\n",
    "for f(n) to be O(g(n)), f(n)<=Cg(n) for all n>n0\n",
    "\n",
    "for g(n) to be T(f(n)), g(n)>= Cf(b) for all n>n0\n",
    "\n",
    "\n",
    "if g(n) is not T(f(n)), then there is a value where g(n)<=cf(b) for n>n0\n",
    "\n",
    "if that is true, then g(n)<=cf(n) at the critical n, then f(n)<=(1/c)f(n) for some n>n0\n",
    "(note this is true because c>0)\n",
    "which violates the rules for f(n) is O(g(n)).\n",
    "\n",
    "Therefore, the orginal statement holds by contraposition\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nIt has been shown earlier that a polynomial is O(n^d), where d is its highest order\\n\\nTherefore, f(n) <= f'(n), where f'(n) = Cn^d\\n\\nif we take the logarithm of this function, we get log(cn^d) = log(c) + dlog(n)\\n\\nWe can ignore the constant term, which means that log(f(n)) <= dlog(n), which means that\\nlog(f(n)) is O(log(n)) for a polynomial\\n\\n\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "#--------------R3-16---------------------------\n",
    "\"\"\"\n",
    "It has been shown earlier that a polynomial is O(n^d), where d is its highest order\n",
    "\n",
    "Therefore, f(n) <= f'(n), where f'(n) = Cn^d\n",
    "\n",
    "if we take the logarithm of this function, we get log(cn^d) = log(c) + dlog(n)\n",
    "\n",
    "We can ignore the constant term, which means that log(f(n)) <= dlog(n), which means that\n",
    "log(f(n)) is O(log(n)) for a polynomial\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nIf you expand out the function, you get n^5 + ax^4 + .... + 1,\\nwhich is < (1+a+a2...+1)n^5 for all n>n0.\\n\\nTherefore, it is O(n^5)\\n\\n'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------R3-17----------------------------\n",
    "\"\"\"\n",
    "If you expand out the function, you get n^5 + ax^4 + .... + 1,\n",
    "which is < (1+a+a2...+1)n^5 for all n>n0.\n",
    "\n",
    "Therefore, it is O(n^5)\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nFrom the power rules, 2^(n+1) = (2)(2^n), which means there is a constant C=2 such that\\n2^(n+1) <= Cf(n) for n>n0, where f(n) = 2^n\\n\\nTherefor 2^(n+1) is O(2^n)\\n\\n'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-18-------------------------\n",
    "\"\"\"\n",
    "From the power rules, 2^(n+1) = (2)(2^n), which means there is a constant C=2 such that\n",
    "2^(n+1) <= Cf(n) for n>n0, where f(n) = 2^n\n",
    "\n",
    "Therefor 2^(n+1) is O(2^n)\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nWe have shown previously that if d(n) is O(f(n)) and e(n) is O(g(n)), then \\nd(n)e(n) is O(f(n)g(n)).\\n\\nIf we set d(n) = n and e(n) = 1, with f(n) = n and g(n) = log(n), then \\n(n)(1) is O(nlog(n)), satisfying our requirements.\\n\\n\\n\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------R3-19-----------------------\n",
    "\"\"\"\n",
    "We have shown previously that if d(n) is O(f(n)) and e(n) is O(g(n)), then \n",
    "d(n)e(n) is O(f(n)g(n)).\n",
    "\n",
    "If we set d(n) = n and e(n) = 1, with f(n) = n and g(n) = log(n), then \n",
    "(n)(1) is O(nlog(n)), satisfying our requirements.\n",
    "\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nWe have shown that f(n) is O(g(n)) iff g(n) is T(f(n))\\n\\nTherefore, if nlogn is O(n^2), we have proved the above.\\n\\nLike in the previous exercise, log(n) is O(n) and n is O(n), so\\nnlogn is O(n^2) and therefore (n^2) is T(nlogn) for n>n0\\n\\n\\n'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-20---------------------\n",
    "\"\"\"\n",
    "We have shown that f(n) is O(g(n)) iff g(n) is T(f(n))\n",
    "\n",
    "Therefore, if nlogn is O(n^2), we have proved the above.\n",
    "\n",
    "Like in the previous exercise, log(n) is O(n) and n is O(n), so\n",
    "nlogn is O(n^2) and therefore (n^2) is T(nlogn) for n>n0\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nAs before, 1 is O(log(n)) for n>n0 (where n0>2 since log(1)=0)\\n\\nTherefore (n)*(1) is O(log(n)*n) and n is O(nlogn)\\n\\n'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#---------R3-21-------------------\n",
    "\"\"\"\n",
    "As before, 1 is O(log(n)) for n>n0 (where n0>2 since log(1)=0)\n",
    "\n",
    "Therefore (n)*(1) is O(log(n)*n) and n is O(nlogn)\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nf(n) <= ceil(f(n)) for all n>0, but ceil(f(n)) <= f(n) + 1.\\n\\nWe have shown that O(f(n) + g(n)) = O(max(f(n), g(n)),\\nif f(n) is f(n) and g(n) is 1, then O(f(n) + g(n)) is O(max(f(n), 1)), which will be \\n\\nf(n) for a specific range n>n0\\n\\nTherefore, cuil(f(n)) is O(f(n))\\n\\n\\n'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-22-----------------------\n",
    "\"\"\"\n",
    "f(n) <= ceil(f(n)) for all n>0, but ceil(f(n)) <= f(n) + 1.\n",
    "\n",
    "We have shown that O(f(n) + g(n)) = O(max(f(n), g(n)),\n",
    "if f(n) is f(n) and g(n) is 1, then O(f(n) + g(n)) is O(max(f(n), 1)), which will be \n",
    "\n",
    "f(n) for a specific range n>n0\n",
    "\n",
    "Therefore, cuil(f(n)) is O(f(n))\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nAccessing the len requires O(1)\\n\\nthe loop is called n times -> O(n)\\n    each loop requires O(1) times\\nOverall, the loop is O(n)\\n\\nThe return takes O(1)\\n\\nTherefore, O(1+n+1) is O(n)\\n\\n\\n'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-23--------------------------\n",
    "\"\"\"\n",
    "Accessing the len requires O(1)\n",
    "\n",
    "the loop is called n times -> O(n)\n",
    "    each loop requires O(1) times\n",
    "Overall, the loop is O(n)\n",
    "\n",
    "The return takes O(1)\n",
    "\n",
    "Therefore, O(1+n+1) is O(n)\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nAccessing the len requires O(1)\\n\\nthe loop is called n/2 times -> still O(n)\\n    each loop requires O(1) times\\nOverall, the loop is O(n)\\n\\nThe return takes O(1)\\n\\nTherefore, O(1+n+1) is O(n)\\n\\n'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------R3-24-------------------------\n",
    "\"\"\"\n",
    "Accessing the len requires O(1)\n",
    "\n",
    "the loop is called n/2 times -> still O(n)\n",
    "    each loop requires O(1) times\n",
    "Overall, the loop is O(n)\n",
    "\n",
    "The return takes O(1)\n",
    "\n",
    "Therefore, O(1+n+1) is O(n)\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThe initial steps are O(1)\\n\\nThe outer loop is called (n) times\\n    The inner loop is called between 1-n times\\n        Each inner loop action is O(1)\\nThe overall number of calls is 2, 3, 4, 5, ....n = (n)(n+1)/2 - 1, which is O(n^2)\\n\\nTherefor the overall is O(1+n^2), which is O(n^2)\\n\\n'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------R3-25-------------------------\n",
    "\"\"\"\n",
    "The initial steps are O(1)\n",
    "\n",
    "The outer loop is called (n) times\n",
    "    The inner loop is called between 1-n times\n",
    "        Each inner loop action is O(1)\n",
    "The overall number of calls is 2, 3, 4, 5, ....n = (n)(n+1)/2 - 1, which is O(n^2)\n",
    "\n",
    "Therefor the overall is O(1+n^2), which is O(n^2)\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nInitial is O(1)\\n\\nThe loop is called n times:\\n    each call uses O(1)\\nTherefore total is O(n)\\n\\nreturn is O(1)\\n\\nTotal is O(1+n+1) = O(n)\\n\\n\\n'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------R3-26-------------------------\n",
    "\"\"\"\n",
    "Initial is O(1)\n",
    "\n",
    "The loop is called n times:\n",
    "    each call uses O(1)\n",
    "Therefore total is O(n)\n",
    "\n",
    "return is O(1)\n",
    "\n",
    "Total is O(1+n+1) = O(n)\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nInitial is O(1)\\n\\nOuter Loop has n calls\\n    Inner two loops have O(n^2 calls) (see R3-25)\\n    \\nFinal is O(1)\\n\\nTherefore O(1+ n*n^2 + 1) = O(n^3)\\n\\n'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------R3-27------------------\n",
    "\"\"\"\n",
    "Initial is O(1)\n",
    "\n",
    "Outer Loop has n calls\n",
    "    Inner two loops have O(n^2 calls) (see R3-25)\n",
    "    \n",
    "Final is O(1)\n",
    "\n",
    "Therefore O(1+ n*n^2 + 1) = O(n^3)\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>seconds</th>\n",
       "      <th>hours</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>logn</th>\n",
       "      <td>inf</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n</th>\n",
       "      <td>1e+07</td>\n",
       "      <td>3.6e+10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>nlogn</th>\n",
       "      <td>87847</td>\n",
       "      <td>316249200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n2</th>\n",
       "      <td>3162.28</td>\n",
       "      <td>189737</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2n</th>\n",
       "      <td>23.2535</td>\n",
       "      <td>35.0673</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       seconds      hours\n",
       "logn       inf        NaN\n",
       "n        1e+07    3.6e+10\n",
       "nlogn    87847  316249200\n",
       "n2     3162.28     189737\n",
       "2n     23.2535    35.0673"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-28--------------\n",
    "import pandas as pd\n",
    "import math\n",
    "\n",
    "#Note, some of these calculations are too large for the computer to handle so I limited it to \n",
    "\n",
    "\n",
    "\n",
    "second = 10e6\n",
    "rel_lengths = [1, 60*60]\n",
    "\n",
    "x = [second*x for x in rel_lengths]\n",
    "functions = [lambda x: 0, #lambda x: 2**x,\n",
    "             lambda x: x,\n",
    "             lambda x: 0,  #This one can't be solved easily...\n",
    "             lambda x: x**(0.5),\n",
    "             lambda x: math.log(x, 2)\n",
    "            ]\n",
    "\n",
    "\n",
    "\n",
    "names = ['logn', 'n', 'nlogn', 'n2', '2n']\n",
    "\n",
    "df = pd.DataFrame(columns = ['seconds','hours'])\n",
    "\n",
    "\n",
    "for i in range(len(functions)):\n",
    "    inp = list(map(functions[i], x))\n",
    "    #print(inp)\n",
    "    df.loc[names[i]] = inp \n",
    "\n",
    "df.loc[names[0]] = [10e3000, np.nan]\n",
    "\n",
    "df.loc[names[2]] = [87847*x for x in rel_lengths]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThey multiply, so it is O(nlogn)\\n\\n'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------R3-29------------------------\n",
    "\"\"\"\n",
    "They multiply, so it is O(nlogn)\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nYou are choosing log(n) elements, which each require O(n)\\n\\nOverall, it is also O(nlogn)\\n\\n\\n'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------R3-30-----------------\n",
    "\"\"\"\n",
    "You are choosing log(n) elements, which each require O(n)\n",
    "\n",
    "Overall, it is also O(nlogn)\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nYou are doing O(n) and O(logn), which is overall O(n)\\n\\nIf all entries are odd, your best case is O(logn)\\n\\nWorst case in O(n) if they are all odd\\n\\n'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------R3-31----------------\n",
    "\"\"\"\n",
    "You are doing O(n) and O(logn), which is overall O(n)\n",
    "\n",
    "If all entries are odd, your best case is O(logn)\n",
    "\n",
    "Worst case in O(n) if they are all odd\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nAlgorithm D is calls Algorithm E n times\\n\\nTherefore, the worst case runtime is O(D(n))*(O(i)), which seems to be O(n*1) = O(n) from the description\\n\\n'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------R3-32---------------\n",
    "\"\"\"\n",
    "Algorithm D is calls Algorithm E n times\n",
    "\n",
    "Therefore, the worst case runtime is O(D(n))*(O(i)), which seems to be O(n*1) = O(n) from the description\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.05149978319906\n"
     ]
    }
   ],
   "source": [
    "#--------------R3-33------------------\n",
    "\"\"\"\n",
    "O notation means that there is a constant C such that f(n) < Cg(n)\n",
    "\n",
    "Therefore, if Al's algorithms performs better than A(nlogn) and Bob's algoriothm performs better that B(n^2), \n",
    "we can solve for the value where Anlogn = Bn^2, which we know is true when n=100.  This means that \n",
    "(A/B) = (100)/(log(100)) = 15.05 (see below)\n",
    "\n",
    "That means that Al's runtime on a single iteration is 15 times slower, but since he performs fewer operations overall, he\n",
    "starts to perform better at large values of n\n",
    "\n",
    "\"\"\"\n",
    "import math\n",
    "print(100/math.log(100, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.210340371976184\n",
      "0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#-------------R3-34----------------------\n",
    "\"\"\"\n",
    "If you are visiting a new restaurant, the chance that you will enjoy the meal is 1/j, where j is the total number of \n",
    "restaurants that  you have visited so far (including that one)\n",
    "\n",
    "Therefore, the expected number of meals you will enjoy is the sum of (1/j) for j=1-number_of_restaurant\n",
    "\n",
    "From calculus, the integral of 1/x is ln(x), so for 10,000 meals, the average will be ln(10,000) - ln(1) = 9.2 restaurants\n",
    "\n",
    "\"\"\"\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "print(math.log(10000, math.e))\n",
    "print(math.log(1, math.e))  #This is trivial\n",
    "\n",
    "\n",
    "x = list(range(1, 10000))\n",
    "y = list(map(lambda x: math.log(x, math.e), x))\n",
    "plt.plot(x, y)\n",
    "plt.xlabel('Total Restaurants')\n",
    "plt.ylabel('Enjoyed Restaurants')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creativity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nIf you sort each set, it will take O(nlogn)*3 time, which is still O(nlogn).\\n\\nOnce you have the sequences sorted, you can move along each sequence with indices i, j and k.  \\nAt each iteration, either choose the biggest value from the current positions, or repeat the process with the \\nremaining two indices until they are all equal or greater to that biggest value and start again.  At each step, check\\nif the values are the same and return False if they are.  If you make it to the end, return true\\n\\nSince you are traversing each index once, this part will be done in O(n) time, so the overall is \\nO(nlogn + n), which is O(nlogn) still\\n\\n\\n'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#----------C3-35--------------\n",
    "\"\"\"\n",
    "If you sort each set, it will take O(nlogn)*3 time, which is still O(nlogn).\n",
    "\n",
    "Once you have the sequences sorted, you can move along each sequence with indices i, j and k.  \n",
    "At each iteration, either choose the biggest value from the current positions, or repeat the process with the \n",
    "remaining two indices until they are all equal or greater to that biggest value and start again.  At each step, check\n",
    "if the values are the same and return False if they are.  If you make it to the end, return true\n",
    "\n",
    "Since you are traversing each index once, this part will be done in O(n) time, so the overall is \n",
    "O(nlogn + n), which is O(nlogn) still\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 4, 4, 5, 5, 6, 7, 7, 65]\n",
      "[42, 68, 72, 74, 74, 80, 82, 82, 84, 84]\n",
      "[1, 2, 3, 5, 4]\n"
     ]
    }
   ],
   "source": [
    "#------------C3-36--------------\n",
    "\"\"\"\n",
    "One possibility is to sort the array first O(nlogn) and then choose the last 10 value\n",
    "\n",
    "This would be O(nlogn)\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "def last_10(array):\n",
    "    if len(array)>=10:   return sorted(array)[-10:]\n",
    "    else: return array\n",
    "\n",
    "    \n",
    "print(last_10([1,2,3,4,5,6,7,4,3,2,65,7,5,4]))\n",
    "print(last_10([x^2+3*x for x in range(30)]))\n",
    "print(last_10([1,2,3,5,4]))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x265d329c160>]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#-------------C3-37------------------\n",
    "\"\"\"\n",
    "An increasing oscillating function like x^2(cos(x)+1) would always be positive but neighter bounded by O(n) or Omega(n) \n",
    "\n",
    "It would be bounded by O(n^2) though in this case for C = 2\n",
    "\n",
    "\"\"\"\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "x = list(range(100))\n",
    "y = list(map(lambda x: x**2*(1+math.cos(x)), x))\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nNote: the question is not asking whether computing this sum is O(n), it is saying that the result of the expression is O(n)\\n\\nsum(i**2) = sum ((i-1)**2) + i**2\\n\\nIf sum((i-1)**2) is less than i * (i**2), then sum ((i-1)**2) + i**2 < i*i**2 + i**2 < O(i^3)\\nIn other words, 1^2 + 2^2 + ... (n-1)^2 < n^2 + n^2 + n^2 ..... n^2\\n\\nFor i = 2, 1 + 4 < 9 + 9\\nfor i = 3, 1 + 4 + 9 < 16*3\\n\\nTherefore, since this is true for the first few iterations, it is true by induction\\n\\n\\n\\n'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------------C3-38--------------------\n",
    "\"\"\"\n",
    "Note: the question is not asking whether computing this sum is O(n), it is saying that the result of the expression is O(n)\n",
    "\n",
    "sum(i**2) = sum ((i-1)**2) + i**2\n",
    "\n",
    "If sum((i-1)**2) is less than i * (i**2), then sum ((i-1)**2) + i**2 < i*i**2 + i**2 < O(i^3)\n",
    "In other words, 1^2 + 2^2 + ... (n-1)^2 < n^2 + n^2 + n^2 ..... n^2\n",
    "\n",
    "For i = 2, 1 + 4 < 9 + 9\n",
    "for i = 3, 1 + 4 + 9 < 16*3\n",
    "\n",
    "Therefore, since this is true for the first few iterations, it is true by induction\n",
    "\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nWith some mental gymnastics, we can see that it's possible to rewrite this as sum[k=0-n]( sum[i=k to n]((1/2)*(i)))\\n\\nFor this inner sum, we know that the geometric sum is the geometric sum from 1 to n minus the geometric sum from 1 to k:\\n\\nThe formula is (1/2)*(1-(1/2)**i)/(1-1/2), which means the overall sum is:\\n\\n[1-0.5**i - 1 + 0.5**k], which is consistenly less than 0.5**k since 0.5**i is greater than zero.\\n\\nPutting this through the outer sum gives us:\\n\\n(1-0.5**k)/(1-0.5) = 2 - 0.5**k.  Since 0.5**k is also always above 0, this sum is <= 2\\n\\n\\n\""
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------C3-39-------------------\n",
    "\"\"\"\n",
    "With some mental gymnastics, we can see that it's possible to rewrite this as sum[k=0-n]( sum[i=k to n]((1/2)*(i)))\n",
    "\n",
    "For this inner sum, we know that the geometric sum is the geometric sum from 1 to n minus the geometric sum from 1 to k:\n",
    "\n",
    "The formula is (1/2)*(1-(1/2)**i)/(1-1/2), which means the overall sum is:\n",
    "\n",
    "[1-0.5**i - 1 + 0.5**k], which is consistenly less than 0.5**k since 0.5**i is greater than zero.\n",
    "\n",
    "Putting this through the outer sum gives us:\n",
    "\n",
    "(1-0.5**k)/(1-0.5) = 2 - 0.5**k.  Since 0.5**k is also always above 0, this sum is <= 2\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nfrom the log rules, logb(a) = log2(a)/log2(b), which means that there is a constant 1/log2(b) such that\\nlogb(n) = Clog(b), which satisfies the conditions of theta\\n\\n'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#----------C3-40----------------------\n",
    "\"\"\"\n",
    "from the log rules, logb(a) = log2(a)/log2(b), which means that there is a constant 1/log2(b) such that\n",
    "logb(n) = Clog(b), which satisfies the conditions of theta\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 9) 14 15.0\n",
      "(0, 99999) 165534 150000.0\n"
     ]
    }
   ],
   "source": [
    "#------------C3-41-------------------\n",
    "\"\"\"\n",
    "If you could use 2n comparisons, it would be easy to just compare each number to both the min and max \n",
    "\n",
    "We could try short circuiting the loop by only checking max if the min comparison failed, but that would not be true in all cases\n",
    "(ex. if the array was reverse sorted).  You could hedge against that by randomizing or alternating which call was made first\n",
    "\n",
    "That would bring you to 3n/2 on average.\n",
    "\n",
    "\n",
    "The tournament method is the actual solution, but uses comparisons for array size, which might be considered cheating:\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#Note, we can count the number of calls using a class instead of a function\n",
    "\n",
    "class find_minmax():\n",
    "    def __init__(self):\n",
    "        self._count = 0\n",
    "    \n",
    "    def __call__(self, array):\n",
    "        if len(array) == 1:\n",
    "            return (array[0], array[0])\n",
    "        if len(array) == 2:\n",
    "            self._count += 1\n",
    "            if array[0] >= array[1]:return (array[1], array[0])\n",
    "            else: return (array[0], array[1])\n",
    "        else:\n",
    "            min1, max1 = self(array[:len(array)//2])\n",
    "            min2, max2 = self(array[len(array)//2:])\n",
    "            self._count += 2\n",
    "            return (min([min1, min2]), max([max1, max2])) #Could also just write this as a series of two comparisons\n",
    "\n",
    "        \n",
    "a = find_minmax()\n",
    "print(a(list(range(10))), a._count, 10*3/2)\n",
    "\n",
    "\n",
    "b = find_minmax()\n",
    "print(b(list(range(100000))), b._count, 100000*3/2)\n",
    "\n",
    "#Values are close but not exactly 3n/2 for higher numbers..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nIf bob has n friends and they can visit at most i times, it is legal for all his friends to visit\\n(i-1) times.  Therefore he can only start to get suspicious if the counter is higher than n*(i-1)\\n\\nThe better question is: why is he putting these restrictions on his friends???\\n'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------C3-42-----------------------------------\n",
    "\"\"\"\n",
    "If bob has n friends and they can visit at most i times, it is legal for all his friends to visit\n",
    "(i-1) times.  Therefore he can only start to get suspicious if the counter is higher than n*(i-1)\n",
    "\n",
    "The better question is: why is he putting these restrictions on his friends???\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nTriangle Method:\\n\\nWhen n is odd, we can still draw the same line y = x and then sum up the n half blocks:\\n\\nsum = n*n/2 + n*(1*1/2) = (n^2 + n)/2 = n(n+1)/2\\n\\n\\n\\n\\nBox Method:\\n\\nFor odd numbers, just ignore the middle element and add it to the end so that you now have \\n\\n(n+1)*((n-1)/2) + (1*((n+1)/2))\\nwhich simplifies to (1/2)* ((n+1)n - (n+1) + (n+1)) = n(n+1)/2 as before\\n         ___\\n        |   |\\n   (n+1)|   |_\\n        |   | |\\n        |___|_| (n+1)/2\\n     (n-1)/2  1\\n\\n'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-------------C3-43-----------------\n",
    "\"\"\"\n",
    "Triangle Method:\n",
    "\n",
    "When n is odd, we can still draw the same line y = x and then sum up the n half blocks:\n",
    "\n",
    "sum = n*n/2 + n*(1*1/2) = (n^2 + n)/2 = n(n+1)/2\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Box Method:\n",
    "\n",
    "For odd numbers, just ignore the middle element and add it to the end so that you now have \n",
    "\n",
    "(n+1)*((n-1)/2) + (1*((n+1)/2))\n",
    "which simplifies to (1/2)* ((n+1)n - (n+1) + (n+1)) = n(n+1)/2 as before\n",
    "         ___\n",
    "        |   |\n",
    "   (n+1)|   |_\n",
    "        |   | |\n",
    "        |___|_| (n+1)/2\n",
    "     (n-1)/2  1\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nAn integer of up to 100 bits is 2^100 = 1.2e30\\n\\na) We know from before that you only have to check up to the square root of n, which is 1.13e15\\nIf each check takes 1 microsecond, it will take at least 1.13e9 seconds, which is over a billion seconds!\\nThat is approximately 32 years \\n\\nb) If the number of bytes to store r is logr/8+1, if we want to express it in terms of n the answer would be \\nO(e^n)\\n\\n\\n\\n'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------C3-44--------------------\n",
    "\"\"\"\n",
    "An integer of up to 100 bits is 2^100 = 1.2e30\n",
    "\n",
    "a) We know from before that you only have to check up to the square root of n, which is 1.13e15\n",
    "If each check takes 1 microsecond, it will take at least 1.13e9 seconds, which is over a billion seconds!\n",
    "That is approximately 32 years \n",
    "\n",
    "b) If the number of bytes to store r is logr/8+1, if we want to express it in terms of n the answer would be \n",
    "O(e^n)\n",
    "\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------C3-45----------------------\n",
    "\"\"\"\n",
    "Since you can only use O(1) space, options like dictionaries are off limits since they would grow \n",
    "\n",
    "One option is to just multiply all the numbers from one set and then divide them by the other.  \n",
    "The remainder will be the missing number!! \n",
    "\n",
    "To account for the zero term, add one to all the numbers coming in, then subtract one before making your return\n",
    "\n",
    "\"\"\"\n",
    "def find_missing(S):\n",
    "    total_list = list(range(len(S)+1))\n",
    "    total = 1\n",
    "    for x in total_list:\n",
    "        total *= x+1\n",
    "        \n",
    "    for x in S:\n",
    "        total /= x+1\n",
    "        \n",
    "    return int(total-1)\n",
    "\n",
    "find_missing([0,1,2,3,4,6,7,8,9])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nSide note: Al has a lot of crazy claims!\\n\\nHe hasn't proven that if n is true, then n+1 is true.  He has instead shown that if n is true, n-1 is true \\nand started with n=1.  His claim is true for all 0<n<1, but not for all n>1\\n\\n\\n\""
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------C3-46-------------------\n",
    "\"\"\"\n",
    "Side note: Al has a lot of crazy claims!\n",
    "\n",
    "He hasn't proven that if n is true, then n+1 is true.  He has instead shown that if n is true, n-1 is true \n",
    "and started with n=1.  His claim is true for all 0<n<1, but not for all n>1\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nBase case, 1 line will meet at 0 points\\n2 lines will meet at one point\\n\\nWhen you add a new line, it will meet with every other existing lines once given the constraints\\n\\nTherefore x(n) = (n-1) + x(n-1)\\n\\nwhich means that x(n) = (n-1) + (n-2) + (n-3) + .... + 1+ 0\\n\\nwhich is equal to sum[0 to n-1](n)\\n\\n\\n\\nThis is a geometric series whose solution is (a)(a+1)/2, where a in this case is n-1\\n\\nThis grows at the same rate as Theta(n^2)\\n\\n\\n'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------C3-47--------------------\n",
    "\"\"\"\n",
    "Base case, 1 line will meet at 0 points\n",
    "2 lines will meet at one point\n",
    "\n",
    "When you add a new line, it will meet with every other existing lines once given the constraints\n",
    "\n",
    "Therefore x(n) = (n-1) + x(n-1)\n",
    "\n",
    "which means that x(n) = (n-1) + (n-2) + (n-3) + .... + 1+ 0\n",
    "\n",
    "which is equal to sum[0 to n-1](n)\n",
    "\n",
    "\n",
    "\n",
    "This is a geometric series whose solution is (a)(a+1)/2, where a in this case is n-1\n",
    "\n",
    "This grows at the same rate as Theta(n^2)\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nThis justification mixes up the 'n' as an actual number and 'n' as a representation of the nth number.\\n\\nAs used in the example (as a number of calls), the justification is correct\\n\\nHowever, in terms of the actual value itself, the justification is not correct.\\n\\n\\nAlternate answer:\\n\\nFor big O to be true, there must be a constant C such that d(n) <= Cf(n)\\n\\nFor this justification, C was chosen as 1\\n\\nTherefore, the proof should have been \\nF(1) = 1 <= 1n\\nF(2) = 2 <= 1n\\n\\nfor the induction step, \\nF(n) = F(n-1) + F(n-2) = 1(n-1) + (n-2) = 2n-3, which is not <= 1n as before \\n\\n\\n\""
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------C3-48---------------------\n",
    "\"\"\"\n",
    "This justification mixes up the 'n' as an actual number and 'n' as a representation of the nth number.\n",
    "\n",
    "As used in the example (as a number of calls), the justification is correct\n",
    "\n",
    "However, in terms of the actual value itself, the justification is not correct.\n",
    "\n",
    "\n",
    "Alternate answer:\n",
    "\n",
    "For big O to be true, there must be a constant C such that d(n) <= Cf(n)\n",
    "\n",
    "For this justification, C was chosen as 1\n",
    "\n",
    "Therefore, the proof should have been \n",
    "F(1) = 1 <= 1n\n",
    "F(2) = 2 <= 1n\n",
    "\n",
    "for the induction step, \n",
    "F(n) = F(n-1) + F(n-2) = 1(n-1) + (n-2) = 2n-3, which is not <= 1n as before \n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1.5\n",
      "2 2 2.25\n",
      "3 3 3.375\n",
      "4 5 5.0625\n",
      "5 8 7.59375\n"
     ]
    }
   ],
   "source": [
    "#-------------C3-49--------------------\n",
    "\"\"\"\n",
    "The fibonacci sequence is : 1, 2, 3, 5, 8, 13, 21, 34, etc..\n",
    "The first few steps of the sequence are actually bigger than (3/2)**n, so we can't use them!\n",
    "THe first instance when this is true is for n = 5\n",
    "\n",
    "First step: F(5) = 8 >= (3/2)**5 = 7.59375\n",
    "Second Step: F(6) = 13 >= (3/2)**6 = 11.39\n",
    "\n",
    "Induction Step: F(n) = F(n-1) + F(n-2) > (3/2)^(n-1) + (3/2)^(n-2) >? (3/2)^n\n",
    "\n",
    "((3/2)+1)*(3/2)**(n-2) = (7/2)(3/2)**(n-2) = (1.5555)(3/2)**n\n",
    "\n",
    "Since (1.555)x > x, we have proved that F(n) >= (3/2)^n for all values greater than 5, which\n",
    "satisfies the constraints of Omega\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "def output_fibbo():\n",
    "    smaller = True\n",
    "    F0 = 0\n",
    "    F1 = 1\n",
    "    power = 1\n",
    "    counter = 0\n",
    "    while F1 <= power:\n",
    "        counter += 1\n",
    "        F1, F0 = F1+F0, F1\n",
    "        power *= (3/2)\n",
    "        print (counter, F1, power)\n",
    "        \n",
    "        \n",
    "output_fibbo()\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "86"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------C3-50---------------------\n",
    "\"\"\"\n",
    "a)\n",
    "Loop from 0 to n as i\n",
    "    Loop from 0 to i, calculating the value of xi as ai*=x\n",
    "    \n",
    "This would take n*(n+1)/2 or O(n**2)\n",
    "\n",
    "In other words, every time we increase n, we have to do one extra addition and n multiplications, \n",
    "which means we have an arithmetically increasing sum that \n",
    "\n",
    "\n",
    "b) If you kept a running total of x, you would just need to multiply it again to get the new value of x**i\n",
    "since x**i = x**(i-1)*x\n",
    "\n",
    "\n",
    "So for each step, you say: \n",
    "\n",
    "x = 1\n",
    "\n",
    "for a in polynomials:\n",
    "    total += a*(x_total)\n",
    "    x_total *= x\n",
    "\n",
    "return total\n",
    "\n",
    "This seems like it would only take O(n) time, so I'm not sure...\n",
    "\n",
    "\n",
    "c) Using horner's method, we only need O(n) multiplications and O(n) additions\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "def polynomial(x, coefficients):\n",
    "    x_tot = 1\n",
    "    total = 0\n",
    "    for a in coefficients:\n",
    "        total += a*x_tot\n",
    "        x_tot *= x\n",
    "    return total\n",
    "\n",
    "\n",
    "polynomial(5, [1, 2, 3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nlog(a) + log(b) = log(a*b)\\n\\nTherefore sum(log(i)) is actually log(Prod(i))\\n\\nSince 1X2X3...n < n^n,  log(Prod(i)) < log(n^n) = nlogn\\n\\n\\n'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#---------------C3-51----------------\n",
    "\"\"\"\n",
    "log(a) + log(b) = log(a*b)\n",
    "\n",
    "Therefore sum(log(i)) is actually log(Prod(i))\n",
    "\n",
    "Since 1X2X3...n < n^n,  log(Prod(i)) < log(n^n) = nlogn\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nFor this to be true, sum(log(i)) must be >= C*nlogn\\n\\nIn the second half of the series, each value is at least log(n/2) and the total value is greater than the sum from n/2 to n\\n\\nTherefore, sum(log(i)) >= sum[n/2 to n](log(n/2)) = (n/2)(log(n) - log(2)) which is O(nlogn)\\n\\nTherefore sum(log(i)) is Theta(nlogn) as well\\n\\n\\n'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------C3-52-------------------\n",
    "\"\"\"\n",
    "For this to be true, sum(log(i)) must be >= C*nlogn\n",
    "\n",
    "In the second half of the series, each value is at least log(n/2) and the total value is greater than the sum from n/2 to n\n",
    "\n",
    "Therefore, sum(log(i)) >= sum[n/2 to n](log(n/2)) = (n/2)(log(n) - log(2)) which is O(nlogn)\n",
    "\n",
    "Therefore sum(log(i)) is Theta(nlogn) as well\n",
    "\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nWe can represent any number using log(n) digits in binary.\\n\\nTherefore, assign each number a binary value (ex. bottle 5 is 0000...0000101).\\n\\nEnlist one cup for each binary digit. and add a drop of that wine to the cup if there is a 1 in the binary representation.\\n\\nEx. Wine 5 will be added to the first and third cup.\\n\\nAfter a month, the poison tasters killed will map out the binary representation of the poisoned wine.\\n\\nEx. If wine 5 is poisoned then tasters 1 and 3 (starting from 1) will die but everyone else will live\\n\\nIf wine 10 is poisoned (000...001010), wine tasters 2 and 4 will die but everyone else will live.\\n\\nNote: this assumes that the poison tasters are physically capable of drinking one drop from half of the wines in a day,\\nwhich may not be feasible at huge numbers.\\n\\n\\nSide Note: What makes him an evil king and why are we trying to protect him?\\n\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--------------C3-53----------------------\n",
    "\"\"\"\n",
    "We can represent any number using log(n) digits in binary.\n",
    "\n",
    "Therefore, assign each wine bottle a binary value (ex. bottle 5 is 0000...0000101).\n",
    "\n",
    "Enlist one cup for each binary digit. and add a drop of that wine to the cup if there is a 1 in the binary representation.\n",
    "\n",
    "Ex. Wine 5 will be added to the first and third cup.\n",
    "\n",
    "After a month, the poison tasters killed will map out the binary representation of the poisoned wine.\n",
    "\n",
    "Ex. If wine 5 is poisoned then tasters 1 and 3 (starting from 1) will die but everyone else will live\n",
    "\n",
    "If wine 10 is poisoned (000...001010), wine tasters 2 and 4 will die but everyone else will live.\n",
    "\n",
    "Note: this assumes that the poison tasters are physically capable of drinking one drop from half of the wines in a day,\n",
    "which may not be feasible at huge numbers.\n",
    "\n",
    "\n",
    "Side Note: What makes him an evil king and why are we trying to protect him?\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2339, 956, 1188, 1307, 684, 1406, 3358, 3963, 2671, 3983, 516, 2127, 1996, 3569, 1032, 1237, 2398, 3008, 3473, 475, 251, 1400, 1300, 2224, 2670, 2203, 2201, 986, 2570, 569, 1772, 588, 2936, 218, 658, 1738, 1687, 1425, 1654, 2784, 3553, 148, 989, 1294, 2172, 478, 1570, 3225, 3731, 1996, 2832, 1448, 2866, 3356, 1246, 2771, 2212, 3310, 922, 1885, 1583, 158, 3539, 1713, 3240, 1419, 547, 1657, 1859, 77, 3931, 3390, 616, 3636, 871, 3455, 2855, 1906, 413, 25, 3823, 1268, 1576, 2037, 3345, 1296, 3740, 3773, 3237, 1337, 2933, 3058, 2330, 485, 3031, 2956, 2158, 521, 707, 3984, 1175, 1643, 3726, 2850, 307, 2085, 1310, 1565, 3208, 2003, 997, 3338, 2484, 1115, 446, 2246, 2345, 423, 2957, 230, 2329, 1114, 3463, 3084, 2366, 1516, 1871, 1625, 203, 1587, 454, 808, 3361, 915, 537, 1537, 1155, 3320, 3490, 2318, 2006, 643, 312, 1741, 3264, 749, 1831, 2064, 311, 2794, 3313, 2886, 3001, 3607, 1475, 2885, 519, 742, 2150, 3165, 1193, 2594, 2069, 3955, 1005, 2654, 775, 1567, 283, 2881, 1245, 1310, 607, 1109, 1647, 1555, 1713, 851, 2371, 920, 2014, 1452, 1637, 406, 3369, 617, 885, 1981, 2970, 3208, 3874, 2476, 2079, 1724, 976, 2725, 1943, 1232, 3071, 530, 3144, 3015, 955, 2317, 2022, 256, 835, 2434, 1947, 3253, 2020, 3021, 679, 2853, 2776, 3390, 2332, 3866, 2186, 1492, 368, 1386, 3585, 79, 2574, 240, 1663, 1845, 3299, 2932, 3695, 1754, 2292, 2131, 529, 1276, 916, 2612, 3626, 3237, 73, 2675, 3583, 2839, 2393, 2454, 507, 3661, 3951, 2887, 825, 2163, 1912, 2204, 2288, 1757, 3482, 3058, 1719, 2515, 3018, 3441, 2822, 3206, 1812, 825, 809, 1218, 1172, 2458, 1198, 737, 3732, 3368, 3677, 3824, 3335, 2169, 3932, 1588, 232, 2743, 1164, 625, 1353, 1338, 2108, 875, 1949, 1384, 3987, 2969, 3142, 3169, 75, 2395, 2544, 3553, 3786, 3680, 1361, 1102, 612, 2804, 3793, 2863, 1530, 3957, 3256, 479, 1100, 761, 52, 3726, 733, 2832, 1786, 3582, 179, 1672, 1899, 1088, 3876, 2826, 3214, 2109, 1434, 3692, 2963, 1685, 2954, 1877, 1686, 1081, 2229, 1915, 3530, 1103, 76, 1530, 245, 247, 1311, 3157, 2907, 544, 3951, 2951, 3982, 1289, 2990, 1171, 1440, 2698, 1535, 1778, 492, 3976, 889, 699, 3978, 1617, 1868, 2545, 444, 3140, 3358, 651, 2147, 946, 242, 3247, 337, 3242, 3582, 3224, 3383, 20, 1845, 3551, 3444, 37, 1639, 3611, 1733, 2299, 2102, 3548, 3053, 2251, 3865, 3496, 1900, 270, 3204, 518, 2863, 2549, 3226, 2337, 1493, 2170, 3269, 3538, 2211, 2021, 2168, 3184, 1056, 770, 3515, 1583, 1195, 1480, 3950, 2240, 2627, 2401, 1648, 3046, 1254, 259, 2776, 2751, 1099, 2224, 1619, 3763, 2907, 906, 1731, 1582, 225, 1902, 315, 1620, 1883, 1268, 2191, 3930, 2691, 1171, 3813, 2962, 3233, 1293, 3008, 2449, 2888, 3137, 1287, 3471, 992, 711, 2729, 2290, 1386, 3731, 715, 890, 2003, 1868, 540, 1789, 2525, 1931, 3606, 1670, 3650, 443, 1849, 1442, 3909, 2281, 2226, 1321, 3732, 745, 574, 803, 3649, 2339, 510, 324, 770, 1214, 3315, 2760, 399, 2475, 1750, 3464, 495, 823, 2603, 251, 2347, 1879, 1827, 748, 963, 141, 593, 2076, 2595, 2401, 1990, 2606, 991, 3193, 1935, 1228, 2665, 3210, 3743, 1388, 1124, 1862, 3646, 1071, 1461, 830, 418, 1528, 1160, 1064, 3797, 2299, 502, 1530, 856, 3441, 3366, 1740, 3801, 3697, 1828, 2983, 2675, 2393, 237, 1109, 3686, 392, 8, 3490, 1534, 516, 3645, 3662, 996, 1086, 2013, 3238, 2616, 1791, 2926, 1564, 584, 3778, 955, 1860, 1144, 3039, 326, 2805, 1946, 979, 2637, 2367, 482, 3915, 351, 165, 2501, 1445, 3799, 164, 3658, 1395, 3412, 2191, 2844, 210, 2881, 1068, 2577, 3764, 3917, 2796, 2089, 1578, 2611, 2911, 2249, 1203, 861, 522, 3529, 73, 1081, 2457, 3960, 3641, 1513, 1097, 202, 1437, 2448, 560, 2376, 1248, 1303, 3586, 500, 404, 1486, 3492, 3231, 98, 1795, 722, 3762, 3996, 3437, 3629, 1032, 1728, 207, 3056, 3036, 2688, 2552, 1460, 1604, 3030, 2871, 3400, 3935, 517, 2805, 3083, 3772, 22, 3778, 3349, 2999, 1534, 3707, 2193, 1742, 3149, 3913, 216, 1914, 3263, 399, 3203, 2637, 2238, 465, 432, 443, 119, 3151, 3863, 3360, 3986, 128, 2155, 2831, 807, 353, 2158, 732, 2990, 2001, 1672, 919, 72, 864, 1231, 42, 2735, 1919, 2354, 1779, 2123, 3291, 2489, 1213, 1714, 3204, 447, 2206, 2870, 1583, 1577, 315, 829, 1739, 397, 348, 2506, 810, 19, 2069, 2209, 545, 3305, 3003, 2961, 535, 3385, 58, 990, 1557, 2700, 2734, 1044, 823, 912, 952, 2213, 2642, 1267, 2909, 451, 553, 2987, 3836, 71, 1505, 799, 1980, 759, 193, 3902, 2970, 2082, 3428, 750, 3650, 1904, 3578, 3638, 3043, 1525, 2072, 1000, 3661, 3830, 2239, 1125, 1903, 3362, 604, 1269, 1225, 1074, 2473, 3506, 3383, 402, 1590, 2189, 744, 2173, 1575, 1578, 1691, 2151, 1082, 2903, 471, 2512, 3004, 1232, 967, 2383, 3154, 438, 2707, 3538, 68, 1976, 210, 216, 1654, 909, 3232, 1906, 338, 3159, 2268, 998, 2552, 439, 3535, 3772, 3621, 3620, 975, 2164, 3818, 3335, 2365, 2051, 2693, 2933, 3377, 3376, 1505, 682, 144, 1814, 2779, 1314, 640, 1460, 3463, 3350, 646, 663, 2624, 3998, 3592, 3563, 3320, 3772, 3650, 2645, 2073, 1361, 1031, 594, 2720, 3543, 2550, 3793, 907, 1890, 1673, 2180, 2755, 3, 1330, 601, 180, 1010, 3822, 297, 3698, 3590, 380, 1125, 866, 3154, 651, 210, 231, 117, 3840, 1743, 3626, 3732, 2255, 3073, 175, 1044, 855, 374, 432, 3656, 2955, 1522, 1889, 1458, 1038, 3714, 682, 272, 795, 1287, 1046, 1540, 2267, 3078, 1238, 915, 2815, 2484, 375, 1899, 2313, 1437, 2787, 2744, 1497, 730, 2869, 202, 22, 3433, 2371, 1729, 2026, 3979, 1135, 269, 2379, 3238, 331, 2394, 154, 3514, 1311, 3994, 1789, 2105, 3518, 2014, 114, 1792, 3829, 2159, 2542, 692, 3775, 2014, 202, 3204, 3046, 2570, 3734, 2278, 1175, 2413, 1535, 2321, 3557, 1268, 2688, 1475, 3087, 859, 1456, 2789, 3812, 2665, 1583, 1415, 178, 2032, 37, 158, 78, 1795, 896, 806, 2615, 1105, 516, 2665, 2669, 2447, 85, 2405, 3221, 702, 2949, 140, 1716, 1251, 3659, 1847, 987, 1013, 3563, 3547, 71, 2082, 3787, 3015, 2171, 1935, 2458, 3292, 2386, 863, 1078, 2850, 3778, 1413, 2101, 1800, 662, 769, 819, 3490]\n",
      "1583 4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1583"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#---------------C3-54------------------------------\n",
    "\"\"\"\n",
    "The algorithm below works in O(n) time, but uses O(n) space as well\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "import random\n",
    "\n",
    "def find_most_frequent(n):\n",
    "    S = []\n",
    "    for _ in range(n):\n",
    "        S.append(random.randint(0, 4*n-1))\n",
    "        \n",
    "    print (S)\n",
    "    \n",
    "    \n",
    "    counts = [0]*(4*n)\n",
    "    max_int = 0\n",
    "    for num in S:\n",
    "        counts[num] += 1\n",
    "        if counts[num] >= counts[max_int]:\n",
    "            max_int = num\n",
    "    \n",
    "    print(max_int, counts[max_int])\n",
    "    if counts[max_int] == 1: return False\n",
    "    else: return max_int\n",
    "\n",
    "\n",
    "find_most_frequent(1000)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Projects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total time is  0.0\n",
      "Total time is  0.004987239837646484\n",
      "Total time is  0.5091602802276611\n",
      "Total time is  47.898741722106934\n",
      "Total time is  0.0\n",
      "Total time is  0.001994609832763672\n",
      "Total time is  0.07579708099365234\n",
      "Total time is  7.110187768936157\n",
      "Total time is  0.0\n",
      "Total time is  0.0\n",
      "Total time is  0.0019941329956054688\n",
      "Total time is  0.02792525291442871\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#--------------P3-57----------\n",
    "\"\"\"\n",
    "Note, I'm practicing the use of decorators here, you can replace the decorators\n",
    "by adding the before = time() and after = time() in the main functions to get the same behaviour\n",
    "\n",
    "Side Note: I only tested up to 1e5 for timing reasons, feel free to increase n if you want, but note that it\n",
    "takes 100x as long for each n added\n",
    "\"\"\"\n",
    "import time\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "class Prefix():\n",
    "    def __init__(self):\n",
    "        self._timer_array = []\n",
    "\n",
    "\n",
    "    def timer(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            before = time.time()\n",
    "            for _ in range(20):\n",
    "                func(*args, **kwargs)\n",
    "            after = time.time()\n",
    "            args[0]._timer_array.append((after-before)*100000)  #Note, since the first argument is self, this is how we access self\n",
    "            print ('Total time is ', after-before)\n",
    "        return wrapper\n",
    "            \n",
    "        \n",
    "    @timer\n",
    "    def prefix_average1(self, S):\n",
    "        n = len(S)\n",
    "        A = [0]*n\n",
    "        for j in range(n):\n",
    "            total = 0\n",
    "            for i in range(j+1):\n",
    "                total += S[i]\n",
    "            A[j] = total/(j+1)\n",
    "        return A\n",
    "\n",
    "    @timer\n",
    "    def prefix_average2(self, S):\n",
    "        n = len(S)\n",
    "        A = [0]*n\n",
    "        for j in range(n):\n",
    "            A[j] = sum(S[0:j+1])/(j+1)\n",
    "        return A\n",
    "    \n",
    "    @timer\n",
    "    def prefix_average3(self, S):\n",
    "        n = len(S)\n",
    "        A = [0]*n\n",
    "        total = 0\n",
    "        for j in range(n):\n",
    "            total +=S[j]\n",
    "            A[j] = total/(j+1)\n",
    "        return A\n",
    "    \n",
    "    def _reset_timers(self):\n",
    "        self._timer_array = []\n",
    "        \n",
    "        \n",
    "    def test_timers(self, e_n = 5):\n",
    "        results = {}\n",
    "        for name, func in [('1',self.prefix_average1), ('2', self.prefix_average2), ('3', self.prefix_average3)]:\n",
    "            for i in range(1, e_n):\n",
    "                test_array = list(range(10**i))\n",
    "                func(test_array)\n",
    "            results[name] = self._timer_array\n",
    "            self._reset_timers()\n",
    "            \n",
    "        x = list(map(lambda x: 10**x, range(1, e_n)))\n",
    "        return x, results\n",
    "    \n",
    "    \n",
    "p = Prefix()\n",
    "x, results = p.test_timers(5)\n",
    "\n",
    "for f in results.values():\n",
    "    plt.plot(x, f)\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total time is  0.0\n",
      "Total time is  0.0\n",
      "Total time is  0.0009975433349609375\n",
      "Total time is  0.0\n",
      "Total time is  0.0\n",
      "Total time is  0.0009970664978027344\n",
      "Total time is  0.0\n",
      "Total time is  0.00498652458190918\n",
      "Total time is  0.45677876472473145\n",
      "Total time is  0.0\n",
      "Total time is  0.0009970664978027344\n",
      "Total time is  0.000997781753540039\n",
      "Total time is  0.0009970664978027344\n",
      "Total time is  0.46526145935058594\n",
      "Total time is  455.0140790939331\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#------------------P3-56--------------------\n",
    "#Note, I am subclassing Prefix so you have to run that cell first\n",
    "\n",
    "\"\"\"\n",
    "Note, I'm not worrying about the fact that some of the lower ones are 0.0 due to rounding since adding more tests\n",
    "would slow things down at higher values of n.\n",
    "\n",
    "This is why O(n^3) or O(n^2) are not desirable... they really explode as n gets large\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "class SumTimer(Prefix):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "    def timer(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            before = time.time()\n",
    "            for _ in range(20):\n",
    "                func(*args, **kwargs)\n",
    "            after = time.time()\n",
    "            args[0]._timer_array.append((after-before)*100000)  #Note, since the first argument is self, this is how we access self\n",
    "            print ('Total time is ', after-before)\n",
    "        return wrapper\n",
    "    \n",
    "    \n",
    "    @timer\n",
    "    def example1(self,S):\n",
    "        n = len(S)\n",
    "        total = 0\n",
    "        for j in range(n):\n",
    "            total+= S[j]\n",
    "        return total\n",
    "    \n",
    "    @timer\n",
    "    def example2(self, S):\n",
    "        n = len(S)\n",
    "        total = 0\n",
    "        for j in range(0, n, 2):\n",
    "            total += S[j]\n",
    "        return total\n",
    "    \n",
    "    @timer\n",
    "    def example3(self, S):\n",
    "        n = len(S)\n",
    "        total = 0\n",
    "        for j in range(n):\n",
    "            for k in range(1+j):\n",
    "                total += S[k]\n",
    "        return total\n",
    "    \n",
    "    @timer\n",
    "    def example4(self, S):\n",
    "        n = len(S)\n",
    "        prefix = 0\n",
    "        total = 0\n",
    "        for j in range(n):\n",
    "            prefix += S[j]\n",
    "            total += prefix\n",
    "        return total\n",
    "    \n",
    "    @timer\n",
    "    def example5(self, A,B):\n",
    "        n = len(A)\n",
    "        count = 0\n",
    "        for i in range(n):\n",
    "            total = 0\n",
    "            for j in range(n):\n",
    "                for k in range(1+j):\n",
    "                    total += A[k]\n",
    "            if B[i] == total:\n",
    "                count  += 1\n",
    "        return count\n",
    "    \n",
    "    \n",
    "    \n",
    "    def test_timers(self, e_n = 5):\n",
    "        results = {}\n",
    "        for name, func in [('1',self.example1), ('2', self.example2), ('3', self.example3), ('4', self.example4), ('5', self.example5)]:\n",
    "            for i in range(1, e_n):\n",
    "                test_array = list(range(10**i))\n",
    "                if name == '5': func(test_array, test_array)\n",
    "                else: func(test_array)\n",
    "            results[name] = self._timer_array\n",
    "            self._reset_timers()\n",
    "            \n",
    "        x = list(map(lambda x: 10**x, range(1, e_n)))\n",
    "        return x, results\n",
    "        \n",
    "        \n",
    "s = SumTimer()\n",
    "x, results = s.test_timers(4)  #Note, even at 4 it takes 454 seconds for the last step of example5.  Increase at your own risk!\n",
    "\n",
    "for f in results.values():\n",
    "    plt.plot(x, f)\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'\\nConclusion: it actually performs better for the test cases that we have provided!\\n\\n'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#-----------P3-57----------------------\n",
    "\"\"\"\n",
    "Note, if the method really runs in nlogn time, the output 2^(time/n) should be linear\n",
    "\n",
    "Also note, n_e_max = 5 is already hard on my system so be careful.  It will take about 33 times as long as the\n",
    "previous for every n you add\n",
    "\"\"\"\n",
    "\n",
    "import random\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def test_sorted(n_e_max = 4, num_tests = 10000):\n",
    "    xs = [list(range(2**x)) for x in range(1, n_e_max)]\n",
    "    output_times = []\n",
    "    times = []\n",
    "    nlogns = []\n",
    "    for x in xs:      \n",
    "        random.shuffle(x)\n",
    "        before = time.time()\n",
    "        for _ in range(num_tests):\n",
    "            sorted(x)\n",
    "        after = time.time()\n",
    "        times.append(after-before)\n",
    "        nlogns.append(2**((after-before)/len(x)))\n",
    "    return (times, nlogns)\n",
    "    \n",
    "    \n",
    "    \n",
    "n_e_max = 15\n",
    "times, y = test_sorted(n_e_max)\n",
    "x = [2**x for x in range(1, n_e_max)]\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.show()\n",
    "\n",
    "\"\"\"\n",
    "Conclusion: it actually performs better for the test cases that we have provided!\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total number of tests for Unique1 is 29020000 for n = 5\n",
      "The total number of tests for Unique2 is 74270000 for n = 5\n",
      "The total number of tests for Unique3 is 11090000 for n = 5\n"
     ]
    }
   ],
   "source": [
    "#---------P3-58---------------------\n",
    "import time\n",
    "\n",
    "class Unique():\n",
    "    NUM_TESTS_PER_TIMECHECK = 10000\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def tests_per_minute(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            total_time = 60  #For one minute\n",
    "            counter = 0\n",
    "            while total_time >= 0:\n",
    "                before = time.time()\n",
    "                for _ in range(args[0].NUM_TESTS_PER_TIMECHECK):\n",
    "                    out = func(*args, **kwargs)\n",
    "                after = time.time()\n",
    "                total_time -= after-before\n",
    "                counter += 1\n",
    "                #print (total_time)\n",
    "                \n",
    "            num_tests = counter * args[0].NUM_TESTS_PER_TIMECHECK\n",
    "            return  num_tests\n",
    "        return wrapper\n",
    "\n",
    "\n",
    "    @tests_per_minute\n",
    "    def unique1(self, S):\n",
    "        for j in range(len(S)):\n",
    "            for k in range(j+1, len(S)):\n",
    "                if S[j] == S[k]:\n",
    "                    return False\n",
    "        return True\n",
    "\n",
    "    @tests_per_minute\n",
    "    def unique2(self, S):\n",
    "        temp = sorted(S)\n",
    "        for j in range(1, len(temp)):\n",
    "            if S[j-1] == S[j]:\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "    \n",
    "    #Note, we need this to prevent the decorator from calling itself infinitely\n",
    "    def uniquer(self, S, start = 0, stop = None):\n",
    "        if stop is None: stop = len(S)\n",
    "        if stop-start <= 1: return True\n",
    "        elif not self.uniquer(S, start, stop-1): return False\n",
    "        elif not self.uniquer(S, start+1, stop): return False\n",
    "        else: return S[start] != S[stop-1]\n",
    "    \n",
    "    #This is from the next chapter...\n",
    "    @tests_per_minute\n",
    "    def unique3(self, S, start = 0, stop = None):\n",
    "        if stop is None: stop = len(S)\n",
    "        if stop-start <= 1: return True\n",
    "        elif not self.uniquer(S, start, stop-1): return False\n",
    "        elif not self.uniquer(S, start+1, stop): return False\n",
    "        else: return S[start] != S[stop-1]\n",
    "        \n",
    "    def test_each_algo(self, n):\n",
    "        S = list(range(n))\n",
    "        num_tests = {}\n",
    "        for name, func in [('Unique1', self.unique1), ('Unique2', self.unique2), ('Unique3', self.unique3)]:\n",
    "            num = func(S)\n",
    "            num_tests[name] = num\n",
    "        return num_tests\n",
    "    \n",
    "    \n",
    "n = 5\n",
    "u = Unique()\n",
    "#u.unique3([1,2,3,4,5,6])\n",
    "results = u.test_each_algo(n)\n",
    "for key, value in results.items():\n",
    "    print (f\"The total number of tests for {key} is {value} for n = {n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fin :)"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}