Verina-Armanyous/cs110_pcw_4_2.ipynb

## cs110_pcw_4_2.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n",
    "\n",
    "Make sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your name and collaborators below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAME = \"Veirna Armanyous\"\n",
    "COLLABORATORS = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "fe57a13a2ba710371e280641c9f21c35",
     "grade": false,
     "grade_id": "cell-90b6f68e307cf4d7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "# CS110 Pre-class Work 4.2\n",
    "\n",
    "## Part A. The Hire-Assistant Problem.\n",
    "\n",
    "Imagine that you need to hire a new assistant. Every day an agency sends a new assistant for you to interview. If the assistant is better than your current assistant, then you fire your current assistant and you hire the better assistant. You may assume that assistant quality is uniformly distributed between 0 and 1.\n",
    "\n",
    "## Question 1.\n",
    "Write a function, named hire_assistant, that takes applicants (a list of the numbers that represent the level of qualification of the applicants; the higher the number, the better qualified), and returns the number hires if the applicants are presented in the exact same order as the input list applicants. Note that your function should not randomize anything (or else it would be called a randomized algorithm)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "3e823066b88c3701b5aa6feb0b29ea00",
     "grade": false,
     "grade_id": "cell-d011f5f4707fe41a",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def hire_assistant(applicants):\n",
    "    best = float('-inf') # conisdering that we don't have an assistant at first, so the first candidate will always be \n",
    "                    # hired when compared to \"-inf\" \n",
    "    count_hire = 0 # counter for the number of the assistants hired\n",
    "    for i in applicants: #for each element in applicants\n",
    "        if i > best: #compare if the  rank of the candidate is higher than the rank of the hired assistant\n",
    "            best = i # if higher, then hire the candidate and assign its rank to the variable best\n",
    "            count_hire+=1 #increment the counter of the assistants hired by one\n",
    "    return(count_hire) #return the number of assistant hired\n",
    "    \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first I assigned the variable best = 0, but then it gave error for the second test. So, I figured maybe the very first candidate interviewed will always be hired cause there is no one before him to be compared to, which is why I chose best = - infinity. Also based on my understanding of this part from the book, it says that best is the dummiest when we initialize the variable, thus any other candidate coming after will always have higher qualification. Thus, I put best = - infinity.\n",
    "\n",
    "Which one is correct professor? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "1cf91a3b99ed87bfe9ea81d9a9252e16",
     "grade": true,
     "grade_id": "cell-66778b97ad66f71e",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert(hire_assistant([1])==1)\n",
    "assert(hire_assistant([-1, -2, -3, -4])==1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "950e8b4c047988bb6493460be72d1bc7",
     "grade": false,
     "grade_id": "cell-e5d810828093b20d",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 2. \n",
    "Assuming the applicants are presented in a random order, write a function that receives the number of applicants as input and returns the average number of assistants hired.\n",
    "\n",
    "**N.B.:** Don’t forget to run the simulation several times for each given number of applicants to better estimate the number of hires (please refer to task 3 of the Study Guide)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "7038d9d8cc9239d5ca15f5d21aa986e3",
     "grade": true,
     "grade_id": "cell-b223520ca72942a0",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "def experimental_hires(N):\n",
    "    average_count =0 #initialize the variable\n",
    "    for i in range(0,10): #repeat 10 times\n",
    "        \n",
    "        best = float('-inf')\n",
    "        count_hire = 0 # counter for the number of the assistants hired\n",
    "        lst = random.sample(range(1000), N) #return a list that has N elements in range (1000)\n",
    "\n",
    "        for i in lst:\n",
    "            if i > best: #compare if the  rank of the candidate is higher than the rank of the hired assistant\n",
    "                best = i # if higher, then hire the candidate and assign its rank to the variable best\n",
    "                count_hire+=1 #increment the counter of the assistants hired by one\n",
    "        average_count= average_count+count_hire\n",
    "    return(average_count/N) #divide the average_count by the reptition time whhich is 10 in this case\n",
    "    \n",
    "            \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "experimental_hires(10)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7f78b31a96cb5ddc8eb534ab037d9fee",
     "grade": false,
     "grade_id": "cell-a55a7b3d12ef78bb",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 3.\n",
    "\n",
    "Use the function below, `analytical_hires(N)`, which returns the analytical expected number of hires, given the number of applicants, along with the function you created in question 2 to create a graph with two curves such that:\n",
    "* The x-axis shows the total number of applicants (make sure label the x-axis)\n",
    "* The y-axis shows the average number of hires (make sure label the y-axis)\n",
    "* The graph contains two curves;\n",
    "    * Curve 1: the theoretical performance estimates computed calls to the function `analytical_hires`.\n",
    "    * Curve 2: the simulated or experimental estimates using the function you created in question 2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "1e514458253b863a6c69ce09ccd2d9de",
     "grade": false,
     "grade_id": "cell-4092502cb05933d4",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "def analytical_hires(N):\n",
    "    \"\"\"\n",
    "    Return the analytical expected number of hires if there are N applicants\n",
    "    Inputs:\n",
    "    - N: Number of applicants\n",
    "    Outputs:\n",
    "    - hires: Average number of assistants hired\n",
    "    \"\"\"\n",
    "    # from the textbook, we know that the analytical result is \n",
    "    # 1 + 1/2 + 1/3 + ... + 1/N\n",
    "    hires = 0\n",
    "    for n in range(N):\n",
    "        hires += 1/(n+1)\n",
    "    return hires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "055b3a48707a83f9330ab3b00c45144a",
     "grade": true,
     "grade_id": "cell-f9c07920c069ce20",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "x = [100, 300,700,900] #x-axis \n",
    "y1 = [analytical_hires(100), analytical_hires(300), analytical_hires(700), analytical_hires(900)] #y-axis first line\n",
    "y2 = [experimental_hires(100), experimental_hires(300), experimental_hires(700), experimental_hires(900)] #y-axis second line\n",
    "\n",
    "\n",
    "plt.plot(x,y1)  #plot x, and y1\n",
    "plt.plot(x,y2) #plot x, and y2\n",
    "plt.xlabel(\"The total number of applicants\") #label the x-axis\n",
    "plt.legend({'y1 = analytical hires','y = experimental estimates'}) # show the legend\n",
    "plt.show() \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "f5c0fc54ac7e38140eacf7a0d3877a00",
     "grade": false,
     "grade_id": "cell-8720f8d8a6a98422",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 4.\n",
    "\n",
    "Plot a graph with the x-axis showing the total number of applicants and the y-axis showing the probability that exactly one assistant is hired."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "99500575978918dad34be4dfe49fff36",
     "grade": true,
     "grade_id": "cell-d3fe1b7d6d175ad7",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "x = [100,300,500,700]\n",
    "y = [1/100, 1/300,1/500,1/700]\n",
    "plt.scatter(x, y)\n",
    "plt.ylabel('The average number of hires')\n",
    "plt.xlabel (\"The total number of applicants\")\n",
    "\n",
    "plt.title('plot')\n",
    "plt.show()\n",
    "\n",
    "#I am not sure this is right. I think it's because of the y-axis. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "998ef0b673bc47c929e5543e6f86ccb2",
     "grade": false,
     "grade_id": "cell-2bd2500c3ca4cf02",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## [Optional] Question 5.\n",
    "Assume that an assistant is able to perform an amount of work each day that is equal to their “quality”. You have a total amount of work M that needs to be accomplished. Your costs are as follows:\n",
    "* X = daily salary for the assistant,\n",
    "* Y = fee to the employment agency,\n",
    "* Z = retrenchment fee for the old assistant.\n",
    "\n",
    "Try to formulate an optimal stopping rule (ie. at what point should one stop requesting new potential hires from the agency?) Make any necessary assumptions to ensure the problem is well-formulated.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "43b6a51878665a39b0ede1313448eaa6",
     "grade": true,
     "grade_id": "cell-af2f0291eced6982",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-15b94d1fa268>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# YOUR CODE HERE\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;32mraise\u001b[0m \u001b[0mNotImplementedError\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;31mNotImplementedError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "b0c67a7805b6596f1ba87521c45df302",
     "grade": false,
     "grade_id": "cell-92211f5b42929c46",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Part B. The Hat Check Problem.\n",
    "\n",
    "There is a coat check at a party, where an attendant stores everyone’s hat while they attend the party. The attendant receives the N hats from everyone attending (all attendees come with a hat). Unfortunately, the coat check attendant forgets which hat belongs to whom. Rather than admitting a mistake, the attendant simply returns random hats back to the party goers. \n",
    "What is the average number of correct hats returned? Here are some guiding questions to help you to simulate this problem. \n",
    "\n",
    "## Question 1. \n",
    "Knowing that everyone’s hats are unique and every guest has a hat. Do you need to generate a random sample in a similar way as what you did for the hiring assistant problem? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "259c6115bee56676178f28ab36d6db2f",
     "grade": true,
     "grade_id": "cell-e786799fc4eb1499",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "source": [
    "Since the attendant returns random hats back, I think we don't need to randomize the hats. However, I think we can still randomize it so that we get control over which hat is given to which owner."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "c9f8182f3dd59f572cb797f373fb7464",
     "grade": false,
     "grade_id": "cell-e2f68e2bd4c2d099",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 2. \n",
    "Which of the following commands do you think is the Pythonic way to implement that? \n",
    "```\n",
    "import numpy as np\n",
    "n = 100 #the number of party attendants `\n",
    "```\n",
    "**Command 1. **\n",
    "```\n",
    "hat_list = [np.random.integers(0,n) for i in range(n)]`\n",
    "```\n",
    "**Command 2.**\n",
    "```\n",
    "hat_list = list(range(n)) \n",
    "np.random.shuffle(hat_list) \n",
    "```\n",
    "**Command 3.**\n",
    "```\n",
    "hat_list = np.random.sample(n)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "b5e83025692b2772640e9e58f0f36af1",
     "grade": true,
     "grade_id": "cell-b8da78e72c1c0738",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "source": [
    "The first command gives error saying that there is no attribute to integers in numpy library.\n",
    "\n",
    "The second command returns a shuffled list that contains 100 number.\n",
    "\n",
    "The third command returns a list of 100 elements with random float numbers between [0.0, 1.0)\n",
    "\n",
    "Based on the above, I think we can use the the second command to shuffle the order of the hats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ec25d5c32cc709928fa50666f21d9808",
     "grade": false,
     "grade_id": "cell-8915979a0b8cf6ce",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 3.\n",
    "Now write a function `hat_check(N)` that has: \n",
    "* Input: N the number of party attendants. \n",
    "* Output: the number of hats correctly returned despite the fact that hats are randomly handed back to the guests.\n",
    "\n",
    "You should use the command you picked for question 2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "c37f6cdc2ca8cbb92644fa2746445779",
     "grade": true,
     "grade_id": "cell-c8499aeb1b1d76c7",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np #import numpy library \n",
    "def hat_check(N): #define the function to return the count steps\n",
    "    count =0  #initialize the variable that will hold the number of correctly returning that hats to their owners\n",
    "    y=0 #intialize the variable to represent the the index of the attendats_no list\n",
    "    hat_list = list(range(N)) # the variable represents a list with the number of hats\n",
    "    np.random.shuffle(hat_list) # shuffle the hats \n",
    "    attendants_no = list(range(N)) # the variable represent a list that holds the number of attendants\n",
    "    for i in hat_list: \n",
    "        if i == attendants_no[y]: # if the hat belongs to the owner \n",
    "            count+=1 #increment the counter\n",
    "        y+=1 #increment the index counter\n",
    "    return count \n",
    "    \n",
    "    \n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np #import numpy library \n",
    "def hat_check_average(N): #define the function to return the average \n",
    "    count =0  #initialize the variable that will hold the number of correctly returning that hats to their owners\n",
    "    average = 0\n",
    "     #intialize the variable to represent the the index of the attendats_no list\n",
    "    hat_list = list(range(N)) # the variable represents a list with the number of hats\n",
    "    np.random.shuffle(hat_list) # shuffle the hats \n",
    "    attendants_no = list(range(N)) # the variable represent a list that holds the number of attendants\n",
    "    for index in range(0,100):\n",
    "        y = 0 #intialize the index of attendants_no\n",
    "        for i in hat_list: \n",
    "            if i == attendants_no[y]: # if the hat belongs to the owner \n",
    "                count+=1 #increment the counter\n",
    "            y+=1 #increment the index counter\n",
    "        average = average + count\n",
    "    return (average/N) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "1ff8b95312de63513a2107ffb7ab9d5a",
     "grade": false,
     "grade_id": "cell-086d4cc0fc5b0155",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 4.\n",
    "\n",
    "Plot a curve with the x-axis showing the total number of party attendants and the y-axis showing the average number of hats correctly returned. As always, remember to run several trials. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "c4d1251529b962f3d3ce28f6ac9f244e",
     "grade": true,
     "grade_id": "cell-597031ea2a5a512a",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "%matplotlib inline\n",
    "\n",
    "x = [100,200,300,400,500]\n",
    "y = [hat_check_average(100),hat_check_average(200),hat_check_average(300), hat_check_average(400),hat_check_average(500)] \n",
    "\n",
    "\n",
    "plt.ylabel('The average number of hats correctly returned')\n",
    "plt.xlabel (\"The total number of party attendants\")\n",
    "\n",
    "plt.plot(x,y) \n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "aad5d529ed9af56148bfc12691cdb950",
     "grade": false,
     "grade_id": "cell-f74b2078132a5177",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## [Optional] Question 5.\n",
    "As $N$ tends to infinity, the number of correct hats returned tends towards a well-known statistical distribution. State the distribution with all its parameters. Plot several samples using your code. Does the empirical distribution match your theoretical prediction?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "33f94a80e6d5d9c371e6c39790bd67eb",
     "grade": true,
     "grade_id": "cell-32fe26c1d99fdd2a",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "source": [
    "YOUR ANSWER HERE"
   ]
  }
 ],
 "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
}