SHARE
TWEET

Untitled

a guest Oct 21st, 2019 64 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. {
  2.  "cells": [
  3.   {
  4.    "cell_type": "markdown",
  5.    "metadata": {},
  6.    "source": [
  7.     "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",
  8.     "\n",
  9.     "Make sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your name and collaborators below:"
  10.    ]
  11.   },
  12.   {
  13.    "cell_type": "code",
  14.    "execution_count": 1,
  15.    "metadata": {},
  16.    "outputs": [],
  17.    "source": [
  18.     "NAME = \"Alma Gashi\"\n",
  19.     "COLLABORATORS = \"\""
  20.    ]
  21.   },
  22.   {
  23.    "cell_type": "markdown",
  24.    "metadata": {},
  25.    "source": [
  26.     "---"
  27.    ]
  28.   },
  29.   {
  30.    "cell_type": "markdown",
  31.    "metadata": {
  32.     "deletable": false,
  33.     "editable": false,
  34.     "nbgrader": {
  35.      "checksum": "fe57a13a2ba710371e280641c9f21c35",
  36.      "grade": false,
  37.      "grade_id": "cell-90b6f68e307cf4d7",
  38.      "locked": true,
  39.      "schema_version": 1,
  40.      "solution": false
  41.     }
  42.    },
  43.    "source": [
  44.     "# CS110 Pre-class Work 4.2\n",
  45.     "\n",
  46.     "## Part A. The Hire-Assistant Problem.\n",
  47.     "\n",
  48.     "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",
  49.     "\n",
  50.     "## Question 1.\n",
  51.     "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)."
  52.    ]
  53.   },
  54.   {
  55.    "cell_type": "code",
  56.    "execution_count": 2,
  57.    "metadata": {
  58.     "deletable": false,
  59.     "nbgrader": {
  60.      "checksum": "3e823066b88c3701b5aa6feb0b29ea00",
  61.      "grade": false,
  62.      "grade_id": "cell-d011f5f4707fe41a",
  63.      "locked": false,
  64.      "schema_version": 1,
  65.      "solution": true
  66.     }
  67.    },
  68.    "outputs": [
  69.     {
  70.      "data": {
  71.       "text/plain": [
  72.        "3"
  73.       ]
  74.      },
  75.      "execution_count": 2,
  76.      "metadata": {},
  77.      "output_type": "execute_result"
  78.     }
  79.    ],
  80.    "source": [
  81.     "def hire_assistant(applicants):\n",
  82.     "    \"\"\"\n",
  83.     "    Return the number of assistant hired.\n",
  84.     "    Inputs:\n",
  85.     "    - applicants: a list of the numbers that represent the level of qualification of \n",
  86.     "    the applicants; the higher the number, the better qualified\n",
  87.     "    \n",
  88.     "    Outputs:\n",
  89.     "    - hires: Number of assistants hired\n",
  90.     "    \"\"\"\n",
  91.     "    # assign the first variable to the minimal value for comparison reasons\n",
  92.     "    best= float(\"-inf\")\n",
  93.     "    hire=0\n",
  94.     "    # loop over the whole list of applicants and update the best for each greater value than the current one\n",
  95.     "    for i in range(len(applicants)):\n",
  96.     "        if best<applicants[i]:\n",
  97.     "            hire+=1\n",
  98.     "            best=applicants[i]\n",
  99.     "    return hire       \n",
  100.     "        \n",
  101.     "    raise NotImplementedError()\n",
  102.     "hire_assistant([3,4,-6,2,5,-2,1])"
  103.    ]
  104.   },
  105.   {
  106.    "cell_type": "code",
  107.    "execution_count": 3,
  108.    "metadata": {
  109.     "deletable": false,
  110.     "editable": false,
  111.     "nbgrader": {
  112.      "checksum": "1cf91a3b99ed87bfe9ea81d9a9252e16",
  113.      "grade": true,
  114.      "grade_id": "cell-66778b97ad66f71e",
  115.      "locked": true,
  116.      "points": 1,
  117.      "schema_version": 1,
  118.      "solution": false
  119.     }
  120.    },
  121.    "outputs": [],
  122.    "source": [
  123.     "assert(hire_assistant([1])==1)\n",
  124.     "assert(hire_assistant([-1, -2, -3, -4])==1)"
  125.    ]
  126.   },
  127.   {
  128.    "cell_type": "markdown",
  129.    "metadata": {
  130.     "deletable": false,
  131.     "editable": false,
  132.     "nbgrader": {
  133.      "checksum": "950e8b4c047988bb6493460be72d1bc7",
  134.      "grade": false,
  135.      "grade_id": "cell-e5d810828093b20d",
  136.      "locked": true,
  137.      "schema_version": 1,
  138.      "solution": false
  139.     }
  140.    },
  141.    "source": [
  142.     "## Question 2. \n",
  143.     "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",
  144.     "\n",
  145.     "**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)."
  146.    ]
  147.   },
  148.   {
  149.    "cell_type": "code",
  150.    "execution_count": 4,
  151.    "metadata": {
  152.     "deletable": false,
  153.     "nbgrader": {
  154.      "checksum": "7038d9d8cc9239d5ca15f5d21aa986e3",
  155.      "grade": true,
  156.      "grade_id": "cell-b223520ca72942a0",
  157.      "locked": false,
  158.      "points": 0,
  159.      "schema_version": 1,
  160.      "solution": true
  161.     }
  162.    },
  163.    "outputs": [
  164.     {
  165.      "data": {
  166.       "text/plain": [
  167.        "2"
  168.       ]
  169.      },
  170.      "execution_count": 4,
  171.      "metadata": {},
  172.      "output_type": "execute_result"
  173.     }
  174.    ],
  175.    "source": [
  176.     "import random\n",
  177.     "def experimental_hires(N):\n",
  178.     "    # arbitrarily chosen number of iterations\n",
  179.     "    iteration = 60\n",
  180.     "    # initialize hired list\n",
  181.     "    hired=[]\n",
  182.     "    for i in range(iteration):\n",
  183.     "        # initialize a random list\n",
  184.     "        thelist= [random.uniform(0,1) for i in range(N)]\n",
  185.     "        # use of dynamic programing - previous function - to define who gets hired\n",
  186.     "        hired.append(hire_assistant(thelist))\n",
  187.     "        # full division because the number represent people, so a float would not make sense\n",
  188.     "        average= sum(hired)//iteration\n",
  189.     "    return average\n",
  190.     "    raise NotImplementedError()\n",
  191.     "    \n",
  192.     "experimental_hires(6)"
  193.    ]
  194.   },
  195.   {
  196.    "cell_type": "markdown",
  197.    "metadata": {
  198.     "deletable": false,
  199.     "editable": false,
  200.     "nbgrader": {
  201.      "checksum": "7f78b31a96cb5ddc8eb534ab037d9fee",
  202.      "grade": false,
  203.      "grade_id": "cell-a55a7b3d12ef78bb",
  204.      "locked": true,
  205.      "schema_version": 1,
  206.      "solution": false
  207.     }
  208.    },
  209.    "source": [
  210.     "## Question 3.\n",
  211.     "\n",
  212.     "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",
  213.     "* The x-axis shows the total number of applicants (make sure label the x-axis)\n",
  214.     "* The y-axis shows the average number of hires (make sure label the y-axis)\n",
  215.     "* The graph contains two curves;\n",
  216.     "    * Curve 1: the theoretical performance estimates computed calls to the function `analytical_hires`.\n",
  217.     "    * Curve 2: the simulated or experimental estimates using the function you created in question 2.\n"
  218.    ]
  219.   },
  220.   {
  221.    "cell_type": "code",
  222.    "execution_count": 5,
  223.    "metadata": {
  224.     "deletable": false,
  225.     "editable": false,
  226.     "nbgrader": {
  227.      "checksum": "1e514458253b863a6c69ce09ccd2d9de",
  228.      "grade": false,
  229.      "grade_id": "cell-4092502cb05933d4",
  230.      "locked": true,
  231.      "schema_version": 1,
  232.      "solution": false
  233.     }
  234.    },
  235.    "outputs": [],
  236.    "source": [
  237.     "def analytical_hires(N):\n",
  238.     "    \"\"\"\n",
  239.     "    Return the analytical expected number of hires if there are N applicants\n",
  240.     "    Inputs:\n",
  241.     "    - N: Number of applicants\n",
  242.     "    Outputs:\n",
  243.     "    - hires: Average number of assistants hired\n",
  244.     "    \"\"\"\n",
  245.     "    # from the textbook, we know that the analytical result is \n",
  246.     "    # 1 + 1/2 + 1/3 + ... + 1/N\n",
  247.     "    hires = 0\n",
  248.     "    for n in range(N):\n",
  249.     "        hires += 1/(n+1)\n",
  250.     "    return hires"
  251.    ]
  252.   },
  253.   {
  254.    "cell_type": "code",
  255.    "execution_count": 6,
  256.    "metadata": {
  257.     "deletable": false,
  258.     "nbgrader": {
  259.      "checksum": "055b3a48707a83f9330ab3b00c45144a",
  260.      "grade": true,
  261.      "grade_id": "cell-f9c07920c069ce20",
  262.      "locked": false,
  263.      "points": 0,
  264.      "schema_version": 1,
  265.      "solution": true
  266.     }
  267.    },
  268.    "outputs": [
  269.     {
  270.      "data": {
  271.       "text/plain": [
  272.        "Text(0,0.5,'Average Number of Hires')"
  273.       ]
  274.      },
  275.      "execution_count": 6,
  276.      "metadata": {},
  277.      "output_type": "execute_result"
  278.     }
  279.    ],
  280.    "source": [
  281.     "from matplotlib import pyplot as plt\n",
  282.     "# arbitrarily chosen number of applicants\n",
  283.     "numberofapplicants = 60\n",
  284.     "# intialize a list for analytical and empirical approach\n",
  285.     "analytical=[]\n",
  286.     "experimental=[]\n",
  287.     "# loop over number of applicants\n",
  288.     "for i in range(0, numberofapplicants):\n",
  289.     "    analytical.append(analytical_hires(i))\n",
  290.     "    experimental.append(experimental_hires(i))\n",
  291.     "    \n",
  292.     "\n",
  293.     "plt.plot ([i for i in range(0, numberofapplicants)], analytical, 'red')\n",
  294.     "plt.plot ([i for i in range(0, numberofapplicants)], experimental, 'black')\n",
  295.     "plt.xlabel('Applicants', fontsize=15)\n",
  296.     "plt.ylabel('Average Number of Hires', fontsize=15)\n",
  297.     "\n",
  298.     "\n",
  299.     "    "
  300.    ]
  301.   },
  302.   {
  303.    "cell_type": "markdown",
  304.    "metadata": {
  305.     "deletable": false,
  306.     "editable": false,
  307.     "nbgrader": {
  308.      "checksum": "f5c0fc54ac7e38140eacf7a0d3877a00",
  309.      "grade": false,
  310.      "grade_id": "cell-8720f8d8a6a98422",
  311.      "locked": true,
  312.      "schema_version": 1,
  313.      "solution": false
  314.     }
  315.    },
  316.    "source": [
  317.     "## Question 4.\n",
  318.     "\n",
  319.     "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."
  320.    ]
  321.   },
  322.   {
  323.    "cell_type": "code",
  324.    "execution_count": 18,
  325.    "metadata": {
  326.     "deletable": false,
  327.     "nbgrader": {
  328.      "checksum": "99500575978918dad34be4dfe49fff36",
  329.      "grade": true,
  330.      "grade_id": "cell-d3fe1b7d6d175ad7",
  331.      "locked": false,
  332.      "points": 0,
  333.      "schema_version": 1,
  334.      "solution": true
  335.     }
  336.    },
  337.    "outputs": [
  338.     {
  339.      "data": {
  340.       "text/plain": [
  341.        "Text(0,0.5,'Probability')"
  342.       ]
  343.      },
  344.      "execution_count": 18,
  345.      "metadata": {},
  346.      "output_type": "execute_result"
  347.     },
  348.     {
  349.      "data": {
  350.       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEPCAYAAABcA4N7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd8VfX9x/HXJwlJICSQQIgyZCgKqFBlCbhFQa0oah211sGwrtZfbas4cJe6rQMVAUcV90IFJ8WFshRRERSQkYKABgQkjJD3749zEkP2vDfj83w8ziP3nvO953wOXvPJd5zv1yThnHPOlSQm2gE455yr3TxROOecK5UnCuecc6XyROGcc65Uniicc86VyhOFc865UnmicM45VypPFM4550rlicI551yp4qIdQHVo2bKlOnToEO0wnHOuTpk7d+6PktLLKlcvEkWHDh2YM2dOtMNwzrk6xcyWl6ecNz0555wrlScK55xzpfJE4ZxzrlSeKJxzzpXKE4VzzrlSRTRRmNlEM1trZl+VcNzM7F4zW2xm883swEjG55xzrqhI1ygeAwaXcvxYoHO4jQQejEBMzjnnShHRRCHpAyCrlCInAk8o8CnQ3Mx2r6l4Pho7lqsGDCB3x46auoRzztV5ta2Pog2wssD7zHBfEWY20szmmNmcdevWVepis958kzEzZrBp9epKfd455xqC2pYorJh9Kq6gpHGSeknqlZ5e5hPoxUpr0QKArJUryyjpnHMNV21LFJlAuwLv2wKraupiaS1bApC1qsYu4ZxzdV5tSxSTgT+Go58OAn6WVGPtQqlhTSTLm56cc65EEZ0U0MyeBg4HWppZJnAd0AhA0kPAFOA4YDGwBTivJuNJ2z3oJ1+/dm1NXsY55+q0iCYKSWeWcVzAxREKJz9RZHmicM65EtW2pqeISm3bFoCsrNJG7DrnXMPWoBNFYno6jfFE4ZxzpWnQiYLkZNKA9T//HO1InHOu1mrYiSI+njQzsjZtinYkzjlXazXsRAGkxcaStXlztMNwzrlaq8EnitT4eNZnZ0c7DOecq7UafKJIS0wka+vWaIfhnHO1lieKxo3J2r492mE451yt1eATRWrTpmTn5rLVaxXOOVesBp8o0pKTAVi/fn2UI3HOudrJE0WzZoA/dOeccyXxRJGWBniicM65kjT4RJGalygquUqec87Vdw0+UaSFa1Ks9zUpnHOuWJ4oWrUCIOuHH6IciXPO1U4NPlGkZGQQC2StWRPtUJxzrlZq8InCmjWjOZD144/RDsU552qlBp8o8qca91FPzjlXLE8UKSmkAVkbNkQ7Euecq5U8USQnkwpk+eJFzjlXLE8UeTUKX7zIOeeK5Ykir49iy5ZoR+Kcc7WSJ4q4ONLi4tiQnc3OnTujHY1zztU6niiA1MREBPzs/RTOOVeEJwogrUkTwKcad8654nii4Nc1KXwGWeecK8oTBZ4onHOuNJ4ogNTmzQFPFM45VxxPFPy6eJH3UTjnXFGeKIDUFi0Ar1E451xxIp4ozGywmS0ys8VmdmUxx/cws/+a2edmNt/MjqvpmOJTU0nCE4VzzhUnoonCzGKBB4BjgW7AmWbWrVCxa4DnJB0AnAGMrfHAwqezfapx55wrKtI1ij7AYklLJW0HngFOLFRGQEr4uhmwqsajCud7Wu/rZjvnXBFxEb5eG2BlgfeZQN9CZa4H3jazS4EkYGCNR5U3MaDXKJxzrohI1yismH0q9P5M4DFJbYHjgP+YWZE4zWykmc0xsznrqloTyJtq3PsonHOuiEgnikygXYH3bSnatDQMeA5A0idAItCy8IkkjZPUS1Kv9PT0qkXlixc551yJIp0oZgOdzayjmcUTdFZPLlRmBXAUgJl1JUgUNdt5kDfV+KZNSIUrOM4517BFNFFIygEuAd4CviEY3fS1md1oZkPCYpcDI8zsC+Bp4FzV9G/vsEaxbccOsrOza/RSzjlX10S6MxtJU4AphfaNLvB6ATAgokGlpJAavszKyqJJOJusc845fzI7EDY9gXdoO+dcYZ4oAJo2zU8UPt+Tc87tyhMFQGwsaYmJgNconHOuME8UoVRfk8I554rliSKU5mtSOOdcsTxRhJqmpBBn5n0UzjlXiCeKkDVrRmpcnNconHOuEE8UeZKTSYuJ8UThnHOFeKLIkzfVuDc9OefcLjxR5ElJIS0312sUzjlXiCeKPMnJpObkeKJwzrlCPFHkSUkhTfJE4ZxzhXiiyBPO97Rx40ZycnKiHY1zztUanijyhJ3ZABt8ASPnnMvniSJPoanGnXPOBTxR5PGpxp1zrlieKPIUaHryZymcc+5XFUoUZhZbU4FEXXKyNz0551wxKlqj+J+Z3WZmXWskmmgqUKPwROGcc7+qaKJ4GDgV+MrMZprZSDNLqYG4Is87s51zrlgVShSSrpPUCTgaWATcBaw2s6fMbGBNBBgxSUnEmZGSkOB9FM45V0ClOrMlTZP0R2A34FJgH+AtM1tmZtebWevqDDIizIJ+ivh4r1E451wBVR311As4FOgCrAc+BIYDi83sD1U8d+QlJ5PWqJEnCuecK6DCicLM2pvZdWa2BHgP2B04H2gt6WygPUFfxu3VGmkkpKSQ5osXOefcLio6PHYasAQ4D/gP0EnSIEnPSdoOIGknMAnIqO5ga1xKCmm+HKpzzu0iroLlfwSOA96RpFLKzQM6VjqqaElOJtVnkHXOuV1UtOnpfmBGcUnCzJqa2aEAknZIWl4dAUZUgcWLSs+DzjnXcFQ0UfwX6FbCsX3C43VXcjJpO3aQk5PD5s2box2Nc87VChVNFFbKsabAlirEEn0pKaRu3w74fE/OOZenzD6KsDnp8AK7hpvZ4ELFEoHjgS+rL7QoSEkhbetWIHg6e4899ohyQM45F33l6czuS/BQHYCA3wGFl4DbDiwE/l59oUVBcjJpYd+Ed2g751ygzKYnSbdLSpeUDqwAjsh7X2BrI+koSZ+VdT4zG2xmi8xssZldWUKZ08xsgZl9bWaTKn5blZSSkj+md/Xq1RG7rHPO1WYVGh4rqUpDXsNpyh8gmCsqE5htZpMlLShQpjMwChggab2ZtarKNSskOZm8xqZly5ZF7LLOOVeblaeP4jjgI0kbw9elkjSllMN9gMWSlobnfgY4EVhQoMwI4AFJ68PzrS3rmtUmJYUkID01leXL697oXuecqwnlqVG8DhwEzApfi5JHPwkobXGjNsDKAu8zCfpACtobwMw+Ds91vaQ3C5/IzEYCI4Hq63ROCWZMb9+qlScK55wLlSdRdARWF3hdFcUlmMJPtsUBnQlGWrUFPjSz/SRt2OVD0jhgHECvXr2q5+m45GQAOrRowXxvenLOOaAciaLgE9bV8LR1JtCuwPu2wKpiynwqaQfwvZktIkgcs6t47bLl1SiaNeP1zz5DEmalPTrinHP1X5mjnsysSUW2Mk43G+hsZh3NLB44A5hcqMwrwBHhtVsSNEUtrfitVUJYo2jftClbt25l7drIdY8451xtVZ6mp80UbR4qTYl9FJJyzOwS4K2w3ERJX5vZjcAcSZPDY8eY2QJgJ/B3ST9V4PqVF9YoOjRuDAQjnzIy6t4kuM45V53KkyjOp2KJolThqKgphfaNLvBawF/DLbIaN4bYWNrHxwOwfPly+vYt3NfunHMNS3n6KB6LQBy1Q7gcavuYoEXORz4551zVl0Ktf1JSaLZtG82bN/eH7pxzjvI9cDcLOFfSAjObTRnNUJL6VFdwUZGcDJs20b59e69ROOcc5euj+BrILvC6fq/ok5ICGzfSvn17li6NzGAr55yrzcrTR3Fegdfn1mg0tUFyMmzYQIdu3Zg2bZo/S+Gca/Aq3UdhgXSrb79FU1Lym542b97sCxg55xq8CicKMzvOzGYAW4EfgK1mNsPMjq/26KIhbHrq0KED4LPIOudchRKFmV0AvEbwEN5fCBYx+kv4fnJ4vG4r0JkNPkTWOecqtB4FcBUwTtKFhfY/ZGYPAVcDD1dLZNGS1/TULpiSyhOFc66hq2jTUwvgpRKOvQikVS2cWiA5GSRaJCaSlJTkTU/OuQavooniv8BhJRw7DPigauHUAuF8T7Z5sz9L4ZxzlO+Bu24F3t4LjDezFgSzvK4FWgFDgWOB4TURZESFiSLvWQpPFM65hq48fRRfsetDdgZcEG6FV7t7k9JXuKv9wqnG2bSJDh068Omnn0Y3Hueci7LyJIojajyK2qRQjWL9+vVs2rSJ5LwE4pxzDUx5nsx+PxKB1Bp560/873+7DJHdb7/9ohiUc85FT1WezI6pxAp3tV+nThAXB9984w/dOeccFX/gzszsCjNbDOwANhWz1W2NGkHnzvDNN/7QnXPOUfEaxZ+BK4EJBJ3YtwA3At8Cy4CR1Rlc1HTtCt98Q0ZGBgkJCZ4onHMNWkUTxQjgOuC28P0rkm4A9gUWAp2rMbbo6dIFliwhJieHPfbYw5uenHMNWkUTRUdgnqSdBE1PzQEk5QJjgXOqN7wo6doVdu6ExYv9WQrnXINX0UTxE9A0fL0COKDAsVSgcXUEFXVduwY/ww5tr1E45xqyik4K+DHQG5gCTAKuN7M0YDtwMfBe9YYXJfvsE/wMO7TXrl1LdnY2jRvXjzzonHMVUdFEcT3QJnz9T4Kmp3MJahLvAJdWV2BR1bQptGsHCxfSftAgAFasWME+eQnEOecakAo1PUlaJGla+HqbpL9IaiMpTdLpktbWTJhREI588mcpnHMNXVUeuGtrZr3NrE3Zpeugrl2DGoWvS+Gca+AqsxTqhWa2ElgOzARWmFmmmV1U7dFFU9eusGULrXfuJC4uzhOFc67BquiT2aOB+4GpwPFAr/DnVODe8Hj9EI58ilu8mLZt23rTk3OuwapoZ/bFwD8lXVto/5tmtiY8fmO1RBZtXboEP8ORT16jcM41VBVtempMyavYvQ8kVi2cWiQ9HdLS8ju0PVE45xqqiiaKV4CTSzh2CvB61cKpRczyRz61b9+e//3vf2zfvj3aUTnnXMSVmSjM7Li8jaAv4rdmNtXMLjCzoeHPNwn6KspMFGY22MwWmdliM7uylHKnmpnMrFdFbqha5Y18at8eSWRmZkYtFOeci5by9FG8TtElT9sAg4op+yTwdEknMrNY4AHgaCATmG1mkyUtKFQumWCm2pnliK/mdOkC48fTITUVCIbIdurUKaohOedcpJUnUXSsxuv1ARZLWgpgZs8AJwILCpW7iWCG2r9V47UrLhz51D5scvKRT865hqg8S6FWZy9uG2BlgfeZQN+CBczsAKCdpNfNrFYkinZZWZgZixYtimo4zjkXDZV54C7OzE43s/vM7Knw52lmVp7aiRWzTwXOHQPcDVxejjhGmtkcM5uzbt268t9ARbRvD4mJxC9ezKBBg3jkkUf4+eefa+ZazjlXS1X0gbtWwByCfojjgU7hz2cI+hvSyzhFJtCuwPu2wKoC75OB/YDpZrYMOAiYXFyHtqRxknpJ6pWeXtZlKykmJphJ9ptvuOWWW8jKyuKOO+6omWs551wtVdEaxV1AC6CvpE6S+knqRNB81CI8XprZQGcz62hm8cAZwOS8g5J+ltRSUgdJHYBPgSGS5lQwzuoTDpE98MADOf3007nrrrtYs2ZN1MJxzrlIq2iiOA64QtLsgjvD96MIahclkpQDXAK8BXwDPCfpazO70cyGVDCWyOjaFZYvhy1buOmmm9i2bRs333xztKNyzrmIqWiiSAA2lXBsExBf1gkkTZG0t6Q9Jd0S7hstaXIxZQ+Pam0CgkQhwbff0rlzZ4YPH87DDz/M0qVLoxqWc85FSkUTxafAFWaWVHBn+P6K8Hj9UmDOJ4DRo0cTGxvLddddF8WgnHMuciqaKC4H9gVWmtkzZvZvM3uaYMhrN8oxWqnO2XvvoFM7TBStW7fmL3/5C0899RTz58+PcnDOOVfzKrrC3TygMzAOSCd4wroV8BDQWdIX1R5htCUkQKdO+YkC4IorrqBZs2ZcffXVUQzMOecio9yJwswamdkAIF7SlZKOktQt/HmVpB9rMM7oCkc+5UlNTeWKK67g9ddf56OPPopiYM45V/MqUqPYCUwDutZQLLVX167w3XeQk5O/689//jO77bYbN910UxQDc865mlfuRCEpF/gOyKi5cGqpLl1g+3b4/vv8XU2aNOHss8/mv//9L7/88ksUg3POuZpV0c7sq4HRZrZ/TQRTa4VzPhVsfgIYOHAgO3bs4MMPP4xCUM45FxkVTRTXEDyBPc/MVpjZbDObVXCrgRijr4REcfDBBxMfH8+7774bhaCccy4yKrpm9lfh1rA0axYMk33vPbjiivzdTZo0YcCAAZ4onHP1WrkShZk1Jpi+4yvgB+BdSQ1rwqOhQ+HOO2H9eggXMoKg+enqq69m7dq1tGrVKooBOudczSjPUqidgK+B54Hbgf8Ai8zsmBqOrXYZOjQY9fT6rqu9Dhw4EIBp06ZFIyrnnKtx5emjuA3IBQ4BmhA8mf058HANxlX79O4NbdrAyy/vsrtnz540a9aM9957L0qBOedczSpPougHXCPpY0lbJX0DXADsYWa712x4tUhMDJx0Erz5JmzZkr87NjaWI488knfeeQdJpZzAOefqpvIkit2BwlOlLiFYrW63ao+oNjv5ZMjOhrfe2mX3wIEDWb58uc8o65yrl8o7PNb/VAY49FBIS4OXXtpld14/hY9+cs7VR+VNFG+Z2dq8DVgd7n+v4P7wWP0VFwdDhsBrrwVPaoc6d+5Mu3btPFE45+ql8gyPvaHGo6hLTj4ZHnsMpk+HY4KBX2bGwIEDefXVV9m5cyexsbFRDdE556pTmYlCkieKgo4+GpKSguanY34dITxw4EAeffRR5s2bR8+ePaMYoHPOVa+KTuHhEhPhuOPglVdg58783UcddRTg/RTOufrHE0VlDB0Ka9bAp7+u/JqRkcH+++/vicI5V+94oqiM44+H+PgiD98NHDiQDz/8kOzs7CgF5pxz1c8TRWWkpMBRRwX9FAUeshs4cCDbtm1jxowZUQzOOeeqlyeKyjr55GAho/nz83cdeuihxMXFefOTc65e8URRWUOGBNN6FHj4rmnTpvTr188ThXOuXvFEUVmtWsEhh8ATT+zy8N1RRx3F3Llz2bBhQxSDc8656uOJoiquvBKWLYPx4/N3HXzwwUhi5syZ0YvLOeeqkSeKqhg0KJj/6cYb4ZdfAOjbty8xMTF8/PHHUQ7OOeeqhyeKqjCDMWOCZyr+/W8g6Kfo0aOHj3xyztUbniiqqn//oGP71lvhp5/CXf2ZOXMmOTk5UQ7OOeeqzhNFdbjlFti0KUgWBIli8+bNfPnll1EOzDnnqs4TRXXYbz84+2y47z7IzGTAgAEA3vzknKsXIp4ozGywmS0ys8VmdmUxx/9qZgvMbL6ZvWdm7SMdY6XccEMwSeCNN7LHHnvQunVrTxTOuXohoonCzGKBB4BjgW7AmWbWrVCxz4FekroDLwC3RTLGSuvQAS68ECZOxL79lv79+3uicM7VC5GuUfQBFktaKmk78AxwYsECkv4raUv49lOgbYRjrLyrrw6mIb/mGvr378+yZctYtWpVtKNyzrkqiXSiaAOsLPA+M9xXkmHA1OIOmNlIM5tjZnPWrVtXjSFWQatW8Le/wQsvMGBLkOu8VuGcq+sinSismH0qZh9m9gegF3B7cccljZPUS1Kv9PT0agyxiq66CgYM4De33EJiQoInCudcnRfpRJEJtCvwvi1QpG3GzAYCVwNDJG2LUGzVIz4eXniB+ObN6W3GjA8+qNDHc3NzkYrNnc45FxWRThSzgc5m1tHM4oEzgMkFC5jZAcDDBElibYTjqx677QYvvsiA7dv57LPPyN68udwfPfvsszn44IPZsmVL2YWdcy4CIpooJOUAlwBvAd8Az0n62sxuNLMhYbHbgabA82Y2z8wml3C62q1fP/r/6U/skJhz4YXl+siyZct4+umnmTFjBiNHjvSahXOuVoj4cxSSpkjaW9Kekm4J942WNDl8PVBShqTfhNuQ0s9Ye/W74QYAZjz5JLz4YpnlJ0yYAMCFF17IU089xb333luj8TnnXHn4k9k1qGXLluzduTMfN28O55wDpUw9npOTw4QJExg8eDD3338/J510EpdffjnTp0+PXMDOOVcMTxQ1bMDBBzPDDLVqBUceCW+8UWy5N954g9WrVzNy5EhiYmJ4/PHH6dy5M6eddhorVqyIcNTOOfcrTxQ1rH///vy0fj3fPfkkdOkCJ54Ijz5apNwjjzzC7rvvzvHHHw9ASkoKr7zyClu3buXkk08mOzs70qE75xzgiaLG9e/fH4AZ334L06fDUUfB+ecHM86GndUrVqxg6tSpnH/++TRq1Cj/s/vssw9PPvkkc+fO5cILL/TObedcVHiiqGFdunShefPmwYp3ycnw2mtw1llwzTVwySWwcycTJ05EEsOGDSvy+SFDhnDdddfx+OOPM3bs2CjcgXOuoYuLdgD1XUxMzK4TBMbHwxNPQOvWcPvt5CxYwIRFizjmmGPo2LFjsecYPXo0c+fO5bLLLqN79+4ccsghEbwD51xD5zWKCOjfvz8LFixg/fr1wY6YGLjtNhg/njc//ZTM1asZ2bFjflNUYTExMTz55JN06tSJU089lczMzBKvlZWV5SvrOeeqlSeKCDjssMMAOP3001m6dOmvB4YNY9zBB5MRH88JDz0EgwfDypXFnqNZs2a8/PLLbNmyhVNOOYVt23ad2WTLli1ceeWVZGRkMGbMmBq7F+dcw+OJIgIGDBjAfffdxyeffMJ+++3Hrbfeyo4dO8jMzOSNadM4/69/pdHYsfDxx8FqeQ89BDt2FDlPt27dePzxx5k1axYXX3xxfuf2W2+9lX/eJk2aMHly3XyY3TlXS0mq81vPnj1VF6xcuVJDhw4VoO7du+uss84SoCVLlgQFliyRDj9cAqlzZ+npp6WdO4uc56qrrhKgMWPG6MwzzxSgffbZR9OnT9f1118vM9NPP/0U4btzztU1wByV43ds1H/JV8dWVxJFnldeeUVt2rQRoKOPPnrXg7m50muvSd27B/95uneXJk8O9odycnI0ePBgAYqPj9f111+vrVu3SpI++ugjAXrhhRcieUvOuTqovInCm56i4MQTT+Sbb75hzJgx3HnnnbseNIPf/hY+/xwmTYItW2DIEDjooOD99u3ExsYyadIkrrnmGr744guuu+46EhISAOjTpw9Nmzbl3XffjcKdOefqI1M9eIirV69emjNnTrTDqBk7dsBjjwWjpBYvhowMGDECLrgA2ha/SuwJJ5zAwoUL+e677yIbq3OuTjGzuZJ6lVXOaxS1XaNGQWJYtAimToXevYOnujt0gFNOgVdfhUIjoAYOHMjixYtZtmxZhS61adMmrr/+ejZt2lR98Tvn6jxPFHVFTEwwfPa112DJErj8cvjgAzjppGCt7nPPDRLJjh0MHDgQgPfee69ClxgzZgw33HADL7zwQg3cgHOurvJEURd17Ai33gqrVsGbbwY1i1degeOOg913p9utt7Jb8+a8O2VKuU+5evVq7rnnHgDv33DO7cITRV3WqBEMGgQTJ8KaNTB5MgwejL3xBgM3bOC9l14it18/uOmmYC2MYp7NyHPTTTexY8cOBgwYwLvvvlurJyCUxJdfflmrY6yttm7dyuLFi6MdhqtjPFHUFwkJcMIJ8OSTsHYtA6+5hnXAl5s2wXXXBaOmmjeHo48OEsf770M4dfnixYt55JFHGDlyJMOGDWPt2rV89dVX0b2fUjz66KN0796dG2+8Mdqh1DmXXHIJXbt25aOPPop2KK4uKc8Y2tq+1bXnKCJh5cqVAnTHHXdIa9dKzz8vXXqp1KOHZBY8oxEXJx14oM7cc081iY/Xqnfe0fIlSwTorrvuivYtFGvLli1q27atGjVqJECvvvpqtEOqM9avX6/GjRsLUEZGhjIzM6Mdkosy/DmKhq1t27Z06dIl6G9IT4dTT4V774V58yArC15/Hf7+d+Y1asTTS5Zw2fbt7H700eyx777snZDAu3fdFZSfPh1++qna41Mlm43Gjh1LZmYmr776Kj179uTss89m0aJF1Rxd/fTUU0+RnZ3NE088webNm4udM8y5YpUnm9T2zWsUxbvkkkvUpEmT/Ke2i3PssccqNTVV62fPlp58UrrsMl3Upo2SQNuC+WyDLSNDOuww6YILpHvukd58U1q6VNqxo8JxrVixQnvttZduuummCn1uw4YNatGihQYNGiRJWr58uVq2bKkuXbro559/rnAcpcnNzdXEiRPVunVrTZw4sczy9957r/bZZx9t2rSpWuOoLrm5udp///2V9//KCy+8IEAjRoyIcmR1x+DBg/XnP/852mFUK3wKD/fKK68I0PTp04s9Pn36dAG67bbbdtn/0ksvCdAHL78svfWWdMcd0rBhUv/+Umrqr8kjr/lqr72kwYOliy+W7rpLeuklae5c6aefdpl6RJKys7PVu3dvAQL04osvlvt+rr32WgGaO3du/r5p06YpNjZWJ510knYWMy9WZSxcuFCHHXaYAMXFxalLly7KLXQfBeXk5Kh9+/YCdPPNN1dLDNXt008/FaCHH344f9+oUaOK7HPF++yzzwQoISGhXs2j5onCacOGDYqJidG1115b5Fhubq769eun1q1ba8uWLbscy8rKUkxMjEaPHl30pLm5QZ/H++9L48dLo0ZJv/uddOCBUkrKrkkEpORkab/9pGOPVe7w4TrvgAME6NmrrlLf7t3VNClJX3/1VZn38sMPPygpKUmnn356kWN33313tfyS3rp1q66//nrFx8erefPmGjdunCZMmBAkzQ8+KPFzU6dOFaDWrVsrJSVFP/74Y5XiqAnnn3++kpKStHHjxvx9OTk5GjRokBo1aqQZM2ZEMbra78ILL1RcXJwA/fvf/452ONXGE4WTJB100EHq16/fLvtyc3N1zz33CNC4ceOK/VyfPn3Uv3//il0sN1f68cegNvHii0Ht4s9/lk48UerZU2OTkwXo2jCJZIIyQJ3NtKFdO6lfP2noUOlPf5Kuu04aOzY4z0cf6dKUOtmNAAAXx0lEQVSzz1ZsbKy+XbiwmMvm6qyzzpKZ6aGHHir1r/+SfP/99+rSpYsAnXHGGVq9erUkafPmzUpJSdEf/vCHEj87dOhQpaen67PPPpOZ6W9/+1uFrr1x40ZdeeWVGjRoUJFt+PDhVe503rBhg5o0aVJsM9NPP/2kTp06affdd9eqVauqdJ3Kuueee3TLLbcoOzu71HJvv/22hg0bpqysrAhFFti8ebOSk5P1xz/+Ub1799a+++5bqe9YVSxYsEAXX3xxtTexeqJwkqRrrrlGsbGx2rBhg6SgWeXwww8XoCOPPFI7SuhjuOqqqxQbG1ttX8wPP/xQcXFxOm7wYO1cvFj64APpmWf0wSWXKC4mRr9t00Y7jzhC6tZNatFil1rJUlAj0EiQYmOD/pL99gv6TE4+WRoxQr9cfrmO2HNPATps33218IknpC++kFaulDZvLtIEVtAvv/yiHj16qHnz5poyZUqR4xdddFGJTQ6rVq1SbGys/vGPf0iSzjnnHCUmJmrlypXl+nd55ZVX1LZtW5mZevXqpb59++6yJSYmKjk5Wffdd59ycnLK949dyNixYwVo9uzZxR6fP3++mjRpogEDBmjbtm2VukZlffnllzIzAdp77701bdq0ImXWrFmTPyU/kP9vHSl5tcqPPvpIjzzyiAB9/PHHEbt+VlaW9gy/28XW8qvAE4WT9Gs/xHPPPacbbrhhl2aV0tr0p02bJkCTJ0+ucgyZmZnKyMjQXnvtpfXr1xc5fv/99wvQdddd9+vO7dulVaukzz/X2UcdpcRGjZQ5erR01VXSiBHSSSdJhxwSJJaMDCkuTjtB40DNQfGg60FbC/altGwZrPPRu7c0cKB0yinKPe88/b5LFxloysiR0oQJ0nPPBZ31M2ZIX36peVOmCNA9d95ZJPZbbrlFgL799ltJQc0kPj6+zE7izMzM/LVJ9t9//xKbfpYsWaJjjjlGgPr06aN58+aV/x9eQW2rR48eOuCAA0r9K/iZZ54RoIsuuqhC56+qE088USkpKXr22WfVqVMnATr33HP1448/Kjc3VxMmTFBqaqoaNWqk0aNH6/TTT1diYmJEh/b27dtX3bp1U25urjZt2qSmTZvqnHPOici1c3JydOyxx6pRo0bq06ePkpKStGbNmmo7vycKJylod2/SpEl++2rBZpXSZGdnq3HjxhUa5fH999/rgQce0H333bfL1rt3byUlJemrEvoicnNzde655+b/xVTws//6179kZmX/FZmbK/38s/T99/rhnXd05hFHBAs6ZWRo+gUXBH0pF14onXmmdOyx0kEHSd266a5mzQTolsJ9K4W2PqBuoNz4+CDhdOignfvuqw4JCToyNTVoXjvrLGnkSP3lgAMUa6aFf/2rdO+9QfJ5+mnp1VeV8+abuu+vf1VyUpIaJybqX6NGafsPP0jZ2SXWenJzc/XUU08pPT09v/ayffv2cv03mTVrlgA9+OCDZZb9+9//LkATJkwoscz06dNLrJkUlJWVpeeff77EGqskzZgxY5e+pS1btmjUqFGKi4tTy5Yt1a9fPwE65JBDtGDBAklB4mzUqJFGjhxZZgyFLVy4UPfff3+R7+ekSZNKrK3Nmzcv+CPhnnvy911wwQVKTEyMSBPY1VdfLUAPPfSQFi5cqNjY2GodeeWJwuX7/e9/r06dOmnq1KkV+twxxxyjbt26lVlu+/btuvXWW/Mf5iq8xcfHl7mQUnZ2tgYMGFDs59PT0ys10mTq1Knq2LGjAA0bNqzIOd577z3FxsZq6NChyt2xQ8rKkpYvl778Uvr446BW8eyz0oQJGn/GGUHzw1lnSRddJP3xj3orjPeZvfcOHmTs1EnKyNCaJk2UBPpdoWQzL0w4gI4BLSmckMykxo2ltDSpTZtgNNn++0t9+kiHHaafjjhCw8LRVZd16xYkvv/7vyAJ3nCDdOut0r//LT30kPTYY9Izz2j4wIFqkpCgnydPDu5pzpzg/r79NrjXH34I7vuXX7Rj61YNHDhQ8fHxmjVr1i7/VqtXr9YZ4b+BmelPf/pTsbXD3NxcPfPMM8rIyBBQYn9Nbm6uDj30UGVkZBQZUjx//nz169dPqampGj9+fJGa7yWXXKLY2FgtWrSoXN+D7OxsXXvttfkPaRa3jRo1qtjPXnzxxUWaHefOnStA9913X7muX1kvvviiAA0fPjy/NjhixAg1atRI33//fbVcwxOFy1fZjrfbbrtNgP73v/+VWObTTz9V9+7dBejEE0/UokWLtG7dul228j5bsHPnziKfXbduXZmdnKX55Zdf9I9//EOxsbFKT0/Xk08+qdzcXC1btkwtW7ZU165ddxkJVJJNmzbld2jmOeWUU9SyZctin1MZHQ7lnf3229q8YIH+fv75io2NVavUVD31j38o98UXg+dWxo0Lnkv55z+la6+V/va3YJjx+edLZ5wR1FQGDZIOPTRIGPvvr7+EtaD/JCdLTZsGzWrF1IJ+BiWBhpVRWyq4/WimDmZqa6Y1LVtqZ5s2ejg9Xc1jYhRvputat9b/tW6tGNBu8fF6tmdP5Q4dKp1xhpYOHarBbdsKUM9WrXRGODjg6VNOkW6+WbrtNunuu6X779fUSy8VoPvPOSdIxi+9FKzkOHWq9O67yp0+Xdvef1+aNUv6/HPpq6+kRYukJUv0w9y5SmrSRKefdJK0fr20aZO0dauUk1OkVjZt2jR17txZgM466ywtXbq0yPdrxIgRAvT8888X+e6UNJChZ8+e2n///WusU/vrr79W06ZN1bdv312+XytXrlRiYuIu38OqKG+i8IWLXIk+//xzDjzwQJ544gnOPvvsXY5t3LiRq6++mgceeIDWrVtz3333MXTo0ChFWrb58+czcuRIZs6cydFHH82PP/7IkiVLmDVrFvvss0+5znHhhRfy2GOPsWrVKrZt20a7du247LLLuP3224uU3bhxI506daJ9+/ZkZWWxbNkyhg8fzq233kpaWlqV7mXHjh0cffTRzJw5kxkzZnDAAQdATk6wLsm2bbB1K2zdysNPPMGfbriBmePH02evvYL9eWWK27Zvh+3b+XzFCvpPmsSBLVtiEh+vXcvh6ek8tP/+7BMfDzt2MPennxj57bd8tmULxzVtSv+EBG7JyiIWuLlJEy6JjWXntm0cuW0bnwGfAD3C+HOBXsAGYCEQX4l/g2uBm4G5wIGFD8bF8VNcHH/LyeGxnBz2jInhwebNObppU4iLK7Jti4nh8IUL+XLLFmb27Mm+zZpBXByPrVrFefPn88Ghh3LIbrsF5WNjIS6Ocd99xwUffcQnp57KQW3a5O8nNvbXrUD5IvvC7ZecHNZu3vzrvpgYtuXmMmTMGDZu2cLc+++nTUZGsMxAWOYfDz3EHZMmMf/pp9lv771hjz2gRYvKfJXKvXBRxP/6BwYDi4DFwJXFHE8Ang2PzwQ6lHVOr1HUjJ07d6pFixa7dNzl5ubqxRdfVOvWrWVmuvTSS6t9yF5NycnJ0f3336/kcJhuRTvq8x66uvfeezVmzBgBpTZ/3HXXXQLUpUsXvf/++1UNfxdr1qxR27Zt1b59e61bt26XY7m5uZo0aZJatmypHj16VOqv3v/85z8ClJaWpokTJxZ7jh07duiuu+5SUlKSAA0ZMkQrVqzYpczq1avVunVrdezQQT8tXy5lZemZhx8WoCfvvjtoAvv6a2nePGn27GAAwfvvS+++G9QuXntNevnlYIDBU08FTWrjx2vD3XcrrUkTDerSJaip/POf0o03Kvfaa/X4b3+rlo0bKy4mRqN69tSWESOk4cOlc88N+pHOOCN49mfoUOmEE6TBg/W/Qw5RRny89kpM1Po+faTevdUvKUldEhKU262btM8+0p57Sh06SO3aaWNGhpJA58XHB88PJSVJiYlB7S5vLrVStlzQRFBaCU1hcaAPSvjsT6BmoCF5+8rR/1QSamPTExALLAE6Efwh8QXQrVCZi4CHwtdnAM+WdV5PFDXntNNOU5s2bZSbm6vly5frhBNOEKAePXpo5syZ0Q6vUlatWlXp4Y29evXSvvvuq06dOunwww8vtWxOTo7eeuutUqdQqYpZs2YpISFBRx11VH6n8ZIlSzRo0CAB6t27d34ncGW8//77Wrt2bZnlVqxYoenTp5eYkD755BM1atRIxxxzjLKzs7XXXnupe/fuVX6S/o477hCQP6T222+/1ZFHHilA/fr10/z58yt0vrwh3Mcff3x+J3Zpk2OOGDFCjRs3zh96voudO4PpbbKzg+HZP/8czFSwdq0WfvihDjvoIAE6uFcvTRwzRo+NGaPHbrlFj910kx674QbNeeIJ6dNPg36lDz+Upk+X3ntPevttaepU3fLHPwrQx2PGBFPpVFJtTRT9gLcKvB8FjCpU5i2gX/g6DviRcG3vkjZPFDVn3Lhx+Z2SSUlJatKkiW6//fZSR7PUZ3n/HoAmTZoU7XD06KOPCtD//d//6V//+pcaN25c5ecuakLev1vPnj0F6PXXX6/yOfNmEu7bt69uuukmJSQkqFmzZnrwwQcrnYQeeOABAWrbtq3i4+NLfcp+9uzZAjR27Nhynbu4J/8rG+fmzZuVkZGhQw45pEr9JLU1UZwKjC/w/mzg/kJlvgLaFni/BGhZ2nk9UdScpUuX5v9iPPbYY6tttEVdtXHjRjVt2lQtWrSoUid7dbrooovy/xsNHTq03A/7RdrIkSODv6IPPrjaOoHHjx+ff++nnXZalZ8uz83N1XnnnSdAv//978sse8ABByglJUXdunUrc9ttt90E6Mwzz9QPP/xQpTilX5NacQ+Jlld5E0VcmZ0Y1cuK2Ve4N708ZTCzkcBIgD322KPqkblidezYkTFjxrDnnnty6qmnYlbcf56GIzk5mbFjx5KQkEBiYmK0wwHg7rvvpmnTpgwYMIAhQ4ZEO5wS3XvvvaSnp3PWWWdV2/fonHPOYfHixRxyyCEcd9xxVT6fmTF27Fhat27NeeedV2bZO++8kwcffDDvj9pSxcXFcc455zB48OAqxwkwfPhwpkyZQnx8ZYYDVExERz2ZWT/gekmDwvejACSNKVDmrbDMJ2YWB/wApKuUQH3Uk3POVVx5Rz1FeuGi2UBnM+toZvEEndWTC5WZDJwTvj4VmFZaknDOOVezItr0JCnHzC4h6LCOBSZK+trMbiRoK5sMTAD+Y2aLgSyCZOKccy5KIt1HgaQpwJRC+0YXeL0V+F2k43LOOVc8XzPbOedcqTxROOecK5UnCuecc6XyROGcc65Uniicc86Vql5MM25m64Dl5SjakmDuqPqkvt2T30/tV9/uqb7dD5T/ntpLSi+rUL1IFOVlZnPK8xRiXVLf7snvp/arb/dU3+4Hqv+evOnJOedcqTxROOecK1VDSxTjoh1ADahv9+T3U/vVt3uqb/cD1XxPDaqPwjnnXMU1tBqFc865CmowicLMBpvZIjNbbGZXRjueijKziWa21sy+KrAvzczeMbPvwp+p0YyxIsysnZn918y+MbOvzewv4f66fE+JZjbLzL4I7+mGcH9HM5sZ3tOz4RT7dYaZxZrZ52b2evi+rt/PMjP70szmmdmccF9d/t41N7MXzGxh+P9Tv+q+nwaRKMwsFngAOBboBpxpZt2iG1WFPQYUXhrrSuA9SZ2B98L3dUUOcLmkrsBBwMXhf5O6fE/bgCMl9QB+Aww2s4OAW4G7w3taDwyLYoyV8RfgmwLv6/r9ABwh6TcFhpDW5e/dv4E3JXUBehD8t6re+ynPeql1fQP6AW8VeD8KGBXtuCpxHx2Arwq8XwTsHr7eHVgU7RircG+vAkfXl3sCmgCfAX0JHnyKC/fv8l2s7RvQNvxFcyTwOsFSxXX2fsKYlwEtC+2rk987IAX4nrC/uabup0HUKIA2wMoC7zPDfXVdhqTVAOHPVlGOp1LMrANwADCTOn5PYTPNPGAt8A6wBNggKScsUte+e/cA/wByw/ctqNv3AyDgbTOba2Yjw3119XvXCVgHPBo2D443sySq+X4aSqIobiV3H+5VC5hZU+BF4DJJG6MdT1VJ2inpNwR/ifcBuhZXLLJRVY6Z/RZYK2luwd3FFK0T91PAAEkHEjRFX2xmh0Y7oCqIAw4EHpR0APALNdBs1lASRSbQrsD7tsCqKMVSndaY2e4A4c+1UY6nQsysEUGSeErSS+HuOn1PeSRtAKYT9L80N7O81STr0ndvADDEzJYBzxA0P91D3b0fACStCn+uBV4mSOh19XuXCWRKmhm+f4EgcVTr/TSURDEb6ByO1ognWId7cpRjqg6TgXPC1+cQtPPXCWZmBOujfyPprgKH6vI9pZtZ8/B1Y2AgQcfif4FTw2J15p4kjZLUVlIHgv9npkk6izp6PwBmlmRmyXmvgWOAr6ij3ztJPwArzWyfcNdRwAKq+36i3RkTwU6f44BvCdqMr452PJWI/2lgNbCD4K+IYQTtxe8B34U/06IdZwXu52CCJov5wLxwO66O31N34PPwnr4CRof7OwGzgMXA80BCtGOtxL0dDrxe1+8njP2LcPs673dBHf/e/QaYE37vXgFSq/t+/Mls55xzpWooTU/OOecqyROFc865UnmicM45VypPFM4550rlicI551ypPFG4esUC35uZzGyvGrxOh/Aavy2wb5mZ3VFT1ywjnmPM7LJoXNvVf54oXH3Tj2DyRAgeEoukocC9Eb5mnmMATxSuRniicPXNmQTz3cwMX0eMpM8lrYjkNZ2LBE8Urt4I1x35HcH0BROBbmbWvcDxc8Pmot5m9qGZZZvZt2Y2tNB5pocLwYwMm5OyzewNMyt1ltTimp7M7NBwgabNZvZzeO4DwmO7W7Ag1dICsdxccCGgAk1cp5nZw+E5Ms3sBjOLCctcD1wOtA/LysweC4/ta2ZvmlmWmf0SLmxzceX/lV1D5InC1SdHAhkEE9i9QDDdSXG1imcJ5r45GfgSeN7MehQq0w+4FPgrwXQp3QmmRyg3MzucYPqEHQTz7ZwOfMiv03K3BLLCawwGbgfOA+4r5nS3AZsJ5lh6EhjNr/MtjQcmAT+EcfcDbgqPTQZ2An8AhoTnTq7IfTgX9XlKfPOtujaCWsR6ID58/wYFFnUBziWYX+qqAp+JARYCzxTYN53gl3v7AvsGhJ8dHL7vEL7/bYEyy4A7Crz/hGAOHitn/HHA74GtBe4h7zpPFCo7r1DMdwDLCpVpGX52/2j/t/Gtbm9eo3D1gpklEHQmvyxpe7j7aYJftAcVKv5y3gtJuQS1iz6FynwmaXmBch8TTNVcuFxJ8SQRrG73uKRiJ1QLR2hdZmYLzCybIDk9BSQAexQq/nah9wsIpvguTRbBgl0PmdnpZlZXFuNxtYwnCldfHAs0B6aEi803J6gZbKNo81PhufnXEiwXWVqZksqVJJVgkZ/VpZS5DLiTIHGdSJCE8voPEguV3VDo/fZiyuwiTILHEDRJTQR+CPtmDijPDTiXxxOFqy/yksHzBM1P6wn+mk4ATgs7uvMU/su6FUV/oRf313dx5UqynmD50NISy++A5yVdLeltSbMJRmxVG0kLJZ1CkEQHEiSXN/I6wp0rD/+yuDovXE71twRNTUcU2v5K0MF9RIGPDC3w2RiCv+ZnFTrtgWa2R4FyAwgSReFyxZKUN0T3j+EiTcVpTFDjKeis8py/GKXWMCTtkDQNuIsgeTWv5HVcAxRXdhHnar0TgSbAv/XrkpAAmNnHwNUENY4Pw93DzWw7weJCI4C9KL556vVw6GkicCtBv8WbFYjrSuBdYKqZjSOoLfQD5kh6HXgH+LOZzSRYUOusMJbKWAhkmNm54X39CKQQdHI/CywlaA67AvhCUlYlr+MaIK9RuPrgTOC7wkkCgr+kgecIhsImhLvPIKhVvAL0AE6X9Hmhj34CjCVYI3oCwS/fkyoSlKQPgKMJktiTBL+wDyNYoRDgRoJa0M3hz+3AnytyjQKeAx4jGEY7G7ieoG9iDUGinBrezzcEw2SdKzdf4c41GOFf248CyZI2l1JuOvCjpFNLKuNcQ+I1Cuecc6XyROGcc65U3vTknHOuVF6jcM45VypPFM4550rlicI551ypPFE455wrlScK55xzpfJE4ZxzrlT/DwHtkA2qLTlcAAAAAElFTkSuQmCC\n",
  351.       "text/plain": [
  352.        "<Figure size 432x288 with 1 Axes>"
  353.       ]
  354.      },
  355.      "metadata": {},
  356.      "output_type": "display_data"
  357.     }
  358.    ],
  359.    "source": [
  360.     "import math\n",
  361.     "def specific_experimental_hire (N):\n",
  362.     "    # arbitrarily chosen number of iterations\n",
  363.     "    iteration = 60\n",
  364.     "    # initialize hired list\n",
  365.     "    hired=0\n",
  366.     "    for i in range(iteration):\n",
  367.     "        # initialize a random list\n",
  368.     "        thelist= [random.uniform(0,1) for i in range(N)]\n",
  369.     "        # compare the hire assistant to the wanted value\n",
  370.     "        if hire_assistant(thelist)==1:\n",
  371.     "            # append to hired\n",
  372.     "            hired += 1            \n",
  373.     "    return(hired/iteration)\n",
  374.     "\n",
  375.     "# arbitrarily chosen number of applicants\n",
  376.     "numberofapplicants = 60\n",
  377.     "# intialize a list for analytical and empirical approach\n",
  378.     "analytical_new=[]\n",
  379.     "experimental_new=[]\n",
  380.     "# loop over number of applicants\n",
  381.     "for i in range(1, numberofapplicants):\n",
  382.     "    # it appends the factorial (permutation) of all the numbers except the last, over the permutation when the last one is included.\n",
  383.     "    analytical_new.append(math.factorial(i-1)/math.factorial(i))\n",
  384.     "    experimental_new.append(specific_experimental_hire(i))\n",
  385.     "    \n",
  386.     "\n",
  387.     "plt.plot ([i for i in range(1, numberofapplicants)], analytical_new, 'red')\n",
  388.     "plt.plot ([i for i in range(1, numberofapplicants)], experimental_new, 'black')\n",
  389.     "plt.xlabel('Applicants', fontsize=15)\n",
  390.     "plt.ylabel('Probability', fontsize=15)\n",
  391.     "\n",
  392.     "\n",
  393.     "    \n",
  394.     "    \n"
  395.    ]
  396.   },
  397.   {
  398.    "cell_type": "markdown",
  399.    "metadata": {
  400.     "deletable": false,
  401.     "editable": false,
  402.     "nbgrader": {
  403.      "checksum": "998ef0b673bc47c929e5543e6f86ccb2",
  404.      "grade": false,
  405.      "grade_id": "cell-2bd2500c3ca4cf02",
  406.      "locked": true,
  407.      "schema_version": 1,
  408.      "solution": false
  409.     }
  410.    },
  411.    "source": [
  412.     "## [Optional] Question 5.\n",
  413.     "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",
  414.     "* X = daily salary for the assistant,\n",
  415.     "* Y = fee to the employment agency,\n",
  416.     "* Z = retrenchment fee for the old assistant.\n",
  417.     "\n",
  418.     "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"
  419.    ]
  420.   },
  421.   {
  422.    "cell_type": "code",
  423.    "execution_count": null,
  424.    "metadata": {
  425.     "deletable": false,
  426.     "nbgrader": {
  427.      "checksum": "43b6a51878665a39b0ede1313448eaa6",
  428.      "grade": true,
  429.      "grade_id": "cell-af2f0291eced6982",
  430.      "locked": false,
  431.      "points": 0,
  432.      "schema_version": 1,
  433.      "solution": true
  434.     }
  435.    },
  436.    "outputs": [],
  437.    "source": [
  438.     "# YOUR CODE HERE\n",
  439.     "raise NotImplementedError()"
  440.    ]
  441.   },
  442.   {
  443.    "cell_type": "markdown",
  444.    "metadata": {
  445.     "deletable": false,
  446.     "editable": false,
  447.     "nbgrader": {
  448.      "checksum": "b0c67a7805b6596f1ba87521c45df302",
  449.      "grade": false,
  450.      "grade_id": "cell-92211f5b42929c46",
  451.      "locked": true,
  452.      "schema_version": 1,
  453.      "solution": false
  454.     }
  455.    },
  456.    "source": [
  457.     "## Part B. The Hat Check Problem.\n",
  458.     "\n",
  459.     "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",
  460.     "What is the average number of correct hats returned? Here are some guiding questions to help you to simulate this problem. \n",
  461.     "\n",
  462.     "## Question 1. \n",
  463.     "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? "
  464.    ]
  465.   },
  466.   {
  467.    "cell_type": "markdown",
  468.    "metadata": {
  469.     "deletable": false,
  470.     "nbgrader": {
  471.      "checksum": "259c6115bee56676178f28ab36d6db2f",
  472.      "grade": true,
  473.      "grade_id": "cell-e786799fc4eb1499",
  474.      "locked": false,
  475.      "points": 0,
  476.      "schema_version": 1,
  477.      "solution": true
  478.     }
  479.    },
  480.    "source": [
  481.     "Yes, we need a random sample although every guest has a unique hat in order to pick one random hat.\n"
  482.    ]
  483.   },
  484.   {
  485.    "cell_type": "markdown",
  486.    "metadata": {
  487.     "deletable": false,
  488.     "editable": false,
  489.     "nbgrader": {
  490.      "checksum": "c9f8182f3dd59f572cb797f373fb7464",
  491.      "grade": false,
  492.      "grade_id": "cell-e2f68e2bd4c2d099",
  493.      "locked": true,
  494.      "schema_version": 1,
  495.      "solution": false
  496.     }
  497.    },
  498.    "source": [
  499.     "## Question 2. \n",
  500.     "Which of the following commands do you think is the Pythonic way to implement that? \n",
  501.     "```\n",
  502.     "import numpy as np\n",
  503.     "n = 100 #the number of party attendants `\n",
  504.     "```\n",
  505.     "**Command 1. **\n",
  506.     "```\n",
  507.     "hat_list = [np.random.integers(0,n) for i in range(n)]`\n",
  508.     "```\n",
  509.     "**Command 2.**\n",
  510.     "```\n",
  511.     "hat_list = list(range(n)) \n",
  512.     "np.random.shuffle(hat_list) \n",
  513.     "```\n",
  514.     "**Command 3.**\n",
  515.     "```\n",
  516.     "hat_list = np.random.sample(n)\n",
  517.     "```"
  518.    ]
  519.   },
  520.   {
  521.    "cell_type": "markdown",
  522.    "metadata": {
  523.     "deletable": false,
  524.     "nbgrader": {
  525.      "checksum": "b5e83025692b2772640e9e58f0f36af1",
  526.      "grade": true,
  527.      "grade_id": "cell-b8da78e72c1c0738",
  528.      "locked": false,
  529.      "points": 0,
  530.      "schema_version": 1,
  531.      "solution": true
  532.     }
  533.    },
  534.    "source": [
  535.     "Command 1 does not work, because the output would be an error that random.integers is not recognized as a built-in function for the library.\n",
  536.     "\n",
  537.     "Command 2 would works as it shuffles all the elements of the list, returning integers.\n",
  538.     "\n",
  539.     "Command 3 also works, and it returns floats instead. \n",
  540.     "\n",
  541.     "I would go for Command 2 because in this case the desirable output would be an integer."
  542.    ]
  543.   },
  544.   {
  545.    "cell_type": "markdown",
  546.    "metadata": {
  547.     "deletable": false,
  548.     "editable": false,
  549.     "nbgrader": {
  550.      "checksum": "ec25d5c32cc709928fa50666f21d9808",
  551.      "grade": false,
  552.      "grade_id": "cell-8915979a0b8cf6ce",
  553.      "locked": true,
  554.      "schema_version": 1,
  555.      "solution": false
  556.     }
  557.    },
  558.    "source": [
  559.     "## Question 3.\n",
  560.     "Now write a function `hat_check(N)` that has: \n",
  561.     "* Input: N the number of party attendants. \n",
  562.     "* Output: the number of hats correctly returned despite the fact that hats are randomly handed back to the guests.\n",
  563.     "\n",
  564.     "You should use the command you picked for question 2. "
  565.    ]
  566.   },
  567.   {
  568.    "cell_type": "code",
  569.    "execution_count": 11,
  570.    "metadata": {
  571.     "deletable": false,
  572.     "nbgrader": {
  573.      "checksum": "c37f6cdc2ca8cbb92644fa2746445779",
  574.      "grade": true,
  575.      "grade_id": "cell-c8499aeb1b1d76c7",
  576.      "locked": false,
  577.      "points": 0,
  578.      "schema_version": 1,
  579.      "solution": true
  580.     }
  581.    },
  582.    "outputs": [
  583.     {
  584.      "data": {
  585.       "text/plain": [
  586.        "2"
  587.       ]
  588.      },
  589.      "execution_count": 11,
  590.      "metadata": {},
  591.      "output_type": "execute_result"
  592.     }
  593.    ],
  594.    "source": [
  595.     "import numpy as np\n",
  596.     "def hat_check(N):\n",
  597.     "    # a list for correctly identified hats\n",
  598.     "    right=0\n",
  599.     "    # ordered hats\n",
  600.     "    ordered= list(range(N))\n",
  601.     "    # we use shuffle for random selection of integers\n",
  602.     "    np.random.shuffle (ordered)\n",
  603.     "    # loops over the number of hats to check their order\n",
  604.     "    for i in range(N):\n",
  605.     "        if ordered[i] == i:\n",
  606.     "            right += 1\n",
  607.     "    return right\n",
  608.     "\n",
  609.     "hat_check(60)\n"
  610.    ]
  611.   },
  612.   {
  613.    "cell_type": "markdown",
  614.    "metadata": {
  615.     "deletable": false,
  616.     "editable": false,
  617.     "nbgrader": {
  618.      "checksum": "1ff8b95312de63513a2107ffb7ab9d5a",
  619.      "grade": false,
  620.      "grade_id": "cell-086d4cc0fc5b0155",
  621.      "locked": true,
  622.      "schema_version": 1,
  623.      "solution": false
  624.     }
  625.    },
  626.    "source": [
  627.     "## Question 4.\n",
  628.     "\n",
  629.     "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. "
  630.    ]
  631.   },
  632.   {
  633.    "cell_type": "code",
  634.    "execution_count": 16,
  635.    "metadata": {
  636.     "deletable": false,
  637.     "nbgrader": {
  638.      "checksum": "c4d1251529b962f3d3ce28f6ac9f244e",
  639.      "grade": true,
  640.      "grade_id": "cell-597031ea2a5a512a",
  641.      "locked": false,
  642.      "points": 0,
  643.      "schema_version": 1,
  644.      "solution": true
  645.     }
  646.    },
  647.    "outputs": [
  648.     {
  649.      "data": {
  650.       "text/plain": [
  651.        "Text(0,0.5,'Correctly identified')"
  652.       ]
  653.      },
  654.      "execution_count": 16,
  655.      "metadata": {},
  656.      "output_type": "execute_result"
  657.     },
  658.     {
  659.      "data": {
  660.       "image/png": "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\n",
  661.       "text/plain": [
  662.        "<Figure size 432x288 with 1 Axes>"
  663.       ]
  664.      },
  665.      "metadata": {},
  666.      "output_type": "display_data"
  667.     }
  668.    ],
  669.    "source": [
  670.     "def selected_hat_check(N,iteration):\n",
  671.     "    right_sel= []\n",
  672.     "    for i in range(iteration):\n",
  673.     "        right=0\n",
  674.     "        ordered= list (range(0,N))\n",
  675.     "        np.random.shuffle (ordered)\n",
  676.     "        for i in range (0, N):\n",
  677.     "            if ordered[i]==i:\n",
  678.     "                right += 1\n",
  679.     "            right_sel.append(right)\n",
  680.     "            \n",
  681.     "    return sum(right_sel)/iteration\n",
  682.     "\n",
  683.     "numberofhats= 60\n",
  684.     "average_1=[]\n",
  685.     "for i in range (0, numberofhats):\n",
  686.     "    average_1.append(selected_hat_check(i,60))\n",
  687.     "    \n",
  688.     "plt.plot([i for i in range(0, numberofhats)], average_1, 'blue')\n",
  689.     "plt.xlabel ('Number of hats')\n",
  690.     "plt.ylabel ('Correctly identified')\n"
  691.    ]
  692.   },
  693.   {
  694.    "cell_type": "markdown",
  695.    "metadata": {
  696.     "deletable": false,
  697.     "editable": false,
  698.     "nbgrader": {
  699.      "checksum": "aad5d529ed9af56148bfc12691cdb950",
  700.      "grade": false,
  701.      "grade_id": "cell-f74b2078132a5177",
  702.      "locked": true,
  703.      "schema_version": 1,
  704.      "solution": false
  705.     }
  706.    },
  707.    "source": [
  708.     "## [Optional] Question 5.\n",
  709.     "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?"
  710.    ]
  711.   },
  712.   {
  713.    "cell_type": "markdown",
  714.    "metadata": {
  715.     "deletable": false,
  716.     "nbgrader": {
  717.      "checksum": "33f94a80e6d5d9c371e6c39790bd67eb",
  718.      "grade": true,
  719.      "grade_id": "cell-32fe26c1d99fdd2a",
  720.      "locked": false,
  721.      "points": 0,
  722.      "schema_version": 1,
  723.      "solution": true
  724.     }
  725.    },
  726.    "source": [
  727.     "YOUR ANSWER HERE"
  728.    ]
  729.   }
  730.  ],
  731.  "metadata": {
  732.   "kernelspec": {
  733.    "display_name": "Python 3",
  734.    "language": "python",
  735.    "name": "python3"
  736.   },
  737.   "language_info": {
  738.    "codemirror_mode": {
  739.     "name": "ipython",
  740.     "version": 3
  741.    },
  742.    "file_extension": ".py",
  743.    "mimetype": "text/x-python",
  744.    "name": "python",
  745.    "nbconvert_exporter": "python",
  746.    "pygments_lexer": "ipython3",
  747.    "version": "3.6.5"
  748.   }
  749.  },
  750.  "nbformat": 4,
  751.  "nbformat_minor": 2
  752. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top