From 3ed19b4c0d40f408df25c0e6ae0f042886ebeda2 Mon Sep 17 00:00:00 2001 From: Sergio Soutinho Date: Thu, 10 Aug 2023 10:07:58 +0100 Subject: [PATCH] lab done --- .../.ipynb_checkpoints/main-checkpoint.ipynb | 786 ++++++++++++ {data => your-code}/ages_population.csv | 0 {data => your-code}/ages_population2.csv | 0 {data => your-code}/ages_population3.csv | 0 your-code/main.ipynb | 1081 +++++++++++++++-- {data => your-code}/roll_the_dice_hundred.csv | 0 .../roll_the_dice_thousand.csv | 0 7 files changed, 1777 insertions(+), 90 deletions(-) create mode 100644 your-code/.ipynb_checkpoints/main-checkpoint.ipynb rename {data => your-code}/ages_population.csv (100%) rename {data => your-code}/ages_population2.csv (100%) rename {data => your-code}/ages_population3.csv (100%) rename {data => your-code}/roll_the_dice_hundred.csv (100%) rename {data => your-code}/roll_the_dice_thousand.csv (100%) diff --git a/your-code/.ipynb_checkpoints/main-checkpoint.ipynb b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb new file mode 100644 index 0000000..728672d --- /dev/null +++ b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb @@ -0,0 +1,786 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Understanding Descriptive Statistics\n", + "\n", + "Import the necessary libraries here:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Libraries\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import random\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 1\n", + "#### 1.- Define a function that simulates rolling a dice 10 times. Save the information in a dataframe.\n", + "**Hint**: you can use the *choices* function from module *random* to help you with the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Roll
05
12
21
31
44
56
63
72
85
96
\n", + "
" + ], + "text/plain": [ + " Roll\n", + "0 5\n", + "1 2\n", + "2 1\n", + "3 1\n", + "4 4\n", + "5 6\n", + "6 3\n", + "7 2\n", + "8 5\n", + "9 6" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "def dice_roll(num_rolls = 10, num_sides = 6):\n", + " rolls = [random.choice(range(1, num_sides + 1)) for i in range(num_rolls)]\n", + " df = pd.DataFrame({'Roll': rolls})\n", + " return df\n", + "\n", + "\n", + "dice_df = dice_roll()\n", + "dice_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Plot the results sorted by value." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "sorted_dice = dice_df.sort_values(by = \"Roll\", ascending = False)\n", + "\n", + "plt.bar(sorted_dice.index, sorted_dice[\"Roll\"])\n", + "\n", + "plt.xlabel(\"Roll Index\")\n", + "plt.ylabel(\"Roll Value\")\n", + "\n", + "plt.xticks(sorted_dice.index, sorted_dice.index + 1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Calculate the frequency distribution and plot it. What is the relation between this plot and the plot above? Describe it with words." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6 2\n", + "5 2\n", + "2 2\n", + "1 2\n", + "4 1\n", + "3 1\n", + "Name: Roll, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwG0lEQVR4nO3df1RVdb7/8ddR5KAmmD/44RWJyl+oGYEpGKapGJZLK5PuJP7CGpZWGLmaoR8zWd3IKRXN0mzUk6sbooO/uukoTgo6knNRsKlbpuUI0eF6dQwER1A53z9cnm8nEPUIbA77+VhrrzX7c977c96fvabVq8/Zh2NxOBwOAQAAmEgroxsAAABoagQgAABgOgQgAABgOgQgAABgOgQgAABgOgQgAABgOgQgAABgOl5GN9Ac1dTU6Mcff1SHDh1ksViMbgcAAFwDh8OhM2fOqFu3bmrVqv49HgJQHX788UcFBwcb3QYAAHBDcXGxunfvXm8NAagOHTp0kHTpBvr6+hrcDQAAuBbl5eUKDg52/nu8PgSgOlz+2MvX15cABACAh7mWx1d4CBoAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJgOAQgAAJiOoQEoLS1NgwYNUocOHeTv768JEybo8OHDV70uJydHERER8vHx0a233qrly5fXqsnKylJYWJisVqvCwsK0cePGxlgCAADwQIYGoJycHM2ePVuff/65srOzdeHCBcXGxqqysvKK1xw7dkxjx45VTEyMCgoK9MILL+iZZ55RVlaWsyYvL0/x8fFKSEjQoUOHlJCQoEmTJmn//v1NsSwAANDMWRwOh8PoJi77v//7P/n7+ysnJ0fDhg2rs+Y3v/mNtmzZoq+//to5lpSUpEOHDikvL0+SFB8fr/Lycm3bts1Zc//99+vmm29WRkbGVfsoLy+Xn5+fysrK+DV4AAA8xPX8+7tZPQNUVlYmSerUqdMVa/Ly8hQbG+syNmbMGOXn5+v8+fP11uzbt6/OOauqqlReXu5yAACAlsvL6AYuczgcSklJ0T333KP+/ftfsa60tFQBAQEuYwEBAbpw4YJOnjypoKCgK9aUlpbWOWdaWprmzZt344u4Rrf89tMme6/m5B9vPnBD13PfgOaNf0bdw30zRrPZAXrqqaf0xRdfXNNHVBaLxeX88qd4Px+vq+aXY5elpqaqrKzMeRQXF19v+wAAwIM0ix2gp59+Wlu2bFFubq66d+9eb21gYGCtnZwTJ07Iy8tLnTt3rrfml7tCl1mtVlmt1htYAQAA8CSG7gA5HA499dRT2rBhgz777DOFhoZe9ZqoqChlZ2e7jO3YsUORkZFq06ZNvTXR0dEN1zwAAPBYhgag2bNn66OPPtLHH3+sDh06qLS0VKWlpfrXv/7lrElNTdWUKVOc50lJSTp+/LhSUlL09ddfa9WqVVq5cqXmzp3rrElOTtaOHTs0f/58ffPNN5o/f7527typOXPmNOXyAABAM2VoAFq2bJnKyso0fPhwBQUFOY/MzExnjd1uV1FRkfM8NDRUW7du1e7du3XnnXfqtdde05IlS/TII484a6Kjo7V27VqtXr1ad9xxh2w2mzIzMzV48OAmXR8AAGieDH0G6Fr+BJHNZqs1du+99+rgwYP1Xjdx4kRNnDjR3dYAAEAL1my+BQYAANBUCEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0DA1Aubm5GjdunLp16yaLxaJNmzbVWz9t2jRZLJZaR79+/Zw1Nputzppz58418moAAICnMDQAVVZWauDAgVq6dOk11S9evFh2u915FBcXq1OnTnr00Udd6nx9fV3q7Ha7fHx8GmMJAADAA3kZ+eZxcXGKi4u75no/Pz/5+fk5zzdt2qTTp09r+vTpLnUWi0WBgYEN1icAAGhZPPoZoJUrV2rUqFEKCQlxGa+oqFBISIi6d++uBx98UAUFBfXOU1VVpfLycpcDAAC0XB4bgOx2u7Zt26aZM2e6jPfp00c2m01btmxRRkaGfHx8NHToUB05cuSKc6WlpTl3l/z8/BQcHNzY7QMAAAN5bACy2Wzq2LGjJkyY4DI+ZMgQTZ48WQMHDlRMTIzWrVunXr166Z133rniXKmpqSorK3MexcXFjdw9AAAwkqHPALnL4XBo1apVSkhIkLe3d721rVq10qBBg+rdAbJarbJarQ3dJgAAaKY8cgcoJydHR48eVWJi4lVrHQ6HCgsLFRQU1ASdAQAAT2DoDlBFRYWOHj3qPD927JgKCwvVqVMn9ejRQ6mpqSopKdGaNWtcrlu5cqUGDx6s/v3715pz3rx5GjJkiHr27Kny8nItWbJEhYWFevfddxt9PQAAwDMYGoDy8/M1YsQI53lKSookaerUqbLZbLLb7SoqKnK5pqysTFlZWVq8eHGdc/7000968sknVVpaKj8/P4WHhys3N1d333134y0EAAB4FEMD0PDhw+VwOK74us1mqzXm5+ens2fPXvGaRYsWadGiRQ3RHgAAaKE88hkgAACAG0EAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApkMAAgAApmNoAMrNzdW4cePUrVs3WSwWbdq0qd763bt3y2Kx1Dq++eYbl7qsrCyFhYXJarUqLCxMGzdubMRVAAAAT2NoAKqsrNTAgQO1dOnS67ru8OHDstvtzqNnz57O1/Ly8hQfH6+EhAQdOnRICQkJmjRpkvbv39/Q7QMAAA/lZeSbx8XFKS4u7rqv8/f3V8eOHet8LT09XaNHj1ZqaqokKTU1VTk5OUpPT1dGRsaNtAsAAFoIj3wGKDw8XEFBQRo5cqR27drl8lpeXp5iY2NdxsaMGaN9+/Zdcb6qqiqVl5e7HAAAoOXyqAAUFBSkFStWKCsrSxs2bFDv3r01cuRI5ebmOmtKS0sVEBDgcl1AQIBKS0uvOG9aWpr8/PycR3BwcKOtAQAAGM/Qj8CuV+/evdW7d2/neVRUlIqLi/X2229r2LBhznGLxeJyncPhqDX2c6mpqUpJSXGel5eXE4IAAGjBPGoHqC5DhgzRkSNHnOeBgYG1dntOnDhRa1fo56xWq3x9fV0OAADQcnl8ACooKFBQUJDzPCoqStnZ2S41O3bsUHR0dFO3BgAAmilDPwKrqKjQ0aNHnefHjh1TYWGhOnXqpB49eig1NVUlJSVas2aNpEvf8LrlllvUr18/VVdX66OPPlJWVpaysrKccyQnJ2vYsGGaP3++xo8fr82bN2vnzp3au3dvk68PAAA0T4YGoPz8fI0YMcJ5fvk5nKlTp8pms8lut6uoqMj5enV1tebOnauSkhK1bdtW/fr106effqqxY8c6a6Kjo7V27Vq99NJLevnll3XbbbcpMzNTgwcPbrqFAQCAZs3QADR8+HA5HI4rvm6z2VzOn3/+eT3//PNXnXfixImaOHHijbYHAABaKI9/BggAAOB6EYAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpEIAAAIDpGBqAcnNzNW7cOHXr1k0Wi0WbNm2qt37Dhg0aPXq0unbtKl9fX0VFRWn79u0uNTabTRaLpdZx7ty5RlwJAADwJIYGoMrKSg0cOFBLly69pvrc3FyNHj1aW7du1YEDBzRixAiNGzdOBQUFLnW+vr6y2+0uh4+PT2MsAQAAeCAvI988Li5OcXFx11yfnp7ucv7GG29o8+bN+uSTTxQeHu4ct1gsCgwMbKg2AQBAC+PRzwDV1NTozJkz6tSpk8t4RUWFQkJC1L17dz344IO1doh+qaqqSuXl5S4HAABouTw6AC1YsECVlZWaNGmSc6xPnz6y2WzasmWLMjIy5OPjo6FDh+rIkSNXnCctLU1+fn7OIzg4uCnaBwAABvHYAJSRkaFXXnlFmZmZ8vf3d44PGTJEkydP1sCBAxUTE6N169apV69eeuedd644V2pqqsrKypxHcXFxUywBAAAYxNBngNyVmZmpxMRErV+/XqNGjaq3tlWrVho0aFC9O0BWq1VWq7Wh2wQAAM2UWztAx44da+g+rllGRoamTZumjz/+WA888MBV6x0OhwoLCxUUFNQE3QEAAE/gVgC6/fbbNWLECH300Uc39Pd1KioqVFhYqMLCQkmXglVhYaGKiookXfpoasqUKc76jIwMTZkyRQsWLNCQIUNUWlqq0tJSlZWVOWvmzZun7du36/vvv1dhYaESExNVWFiopKQkt/sEAAAti1sB6NChQwoPD9dzzz2nwMBA/frXv9bf/va3654nPz9f4eHhzq+wp6SkKDw8XL/73e8kSXa73RmGJOn999/XhQsXNHv2bAUFBTmP5ORkZ81PP/2kJ598Un379lVsbKxKSkqUm5uru+++252lAgCAFsitZ4D69++vhQsX6g9/+IM++eQT2Ww23XPPPerZs6cSExOVkJCgrl27XnWe4cOHy+FwXPF1m83mcr579+6rzrlo0SItWrToqnUAAMC8buhbYF5eXnrooYe0bt06zZ8/X999953mzp2r7t27a8qUKbLb7Q3VJwAAQIO5oQCUn5+vWbNmKSgoSAsXLtTcuXP13Xff6bPPPlNJSYnGjx/fUH0CAAA0GLc+Alu4cKFWr16tw4cPa+zYsVqzZo3Gjh2rVq0u5anQ0FC9//776tOnT4M2CwAA0BDcCkDLli3TjBkzNH369Cv+5laPHj20cuXKG2oOAACgMbgVgOr7o4KXeXt7a+rUqe5MDwAA0KjcegZo9erVWr9+fa3x9evX68MPP7zhpgAAABqTWwHozTffVJcuXWqN+/v764033rjhpgAAABqTWwHo+PHjCg0NrTUeEhLi8ocLAQAAmiO3ApC/v7+++OKLWuOHDh1S586db7gpAACAxuRWAHrsscf0zDPPaNeuXbp48aIuXryozz77TMnJyXrssccaukcAAIAG5da3wF5//XUdP35cI0eOlJfXpSlqamo0ZcoUngECAADNnlsByNvbW5mZmXrttdd06NAhtW3bVgMGDFBISEhD9wcAANDg3ApAl/Xq1Uu9evVqqF4AAACahFsB6OLFi7LZbPrLX/6iEydOqKamxuX1zz77rEGaAwAAaAxuBaDk5GTZbDY98MAD6t+/vywWS0P3BQAA0GjcCkBr167VunXrNHbs2IbuBwAAoNG59TV4b29v3X777Q3dCwAAQJNwKwA999xzWrx4sRwOR0P3AwAA0Ojc+ghs79692rVrl7Zt26Z+/fqpTZs2Lq9v2LChQZoDAABoDG4FoI4dO+qhhx5q6F4AAACahFsBaPXq1Q3dBwAAQJNx6xkgSbpw4YJ27typ999/X2fOnJEk/fjjj6qoqGiw5gAAABqDWztAx48f1/3336+ioiJVVVVp9OjR6tChg/7whz/o3LlzWr58eUP3CQAA0GDc2gFKTk5WZGSkTp8+rbZt2zrHH3roIf3lL39psOYAAAAag9vfAvvrX/8qb29vl/GQkBCVlJQ0SGMAAACNxa0doJqaGl28eLHW+A8//KAOHTrccFMAAACNya0ANHr0aKWnpzvPLRaLKioq9Pvf/56fxwAAAM2eWx+BLVq0SCNGjFBYWJjOnTunX/3qVzpy5Ii6dOmijIyMhu4RAACgQbkVgLp166bCwkJlZGTo4MGDqqmpUWJioh5//HGXh6IBAACaI7cCkCS1bdtWM2bM0IwZMxqyHwAAgEbnVgBas2ZNva9PmTLFrWYAAACaglsBKDk52eX8/PnzOnv2rLy9vdWuXTsCEAAAaNbc+hbY6dOnXY6KigodPnxY99xzDw9BAwCAZs/t3wL7pZ49e+rNN9+stTtUn9zcXI0bN07dunWTxWLRpk2brnpNTk6OIiIi5OPjo1tvvbXOn93IyspSWFiYrFarwsLCtHHjxutZCgAAaOEaLABJUuvWrfXjjz9ec31lZaUGDhyopUuXXlP9sWPHNHbsWMXExKigoEAvvPCCnnnmGWVlZTlr8vLyFB8fr4SEBB06dEgJCQmaNGmS9u/ff93rAQAALZNbzwBt2bLF5dzhcMhut2vp0qUaOnToNc8TFxenuLi4a65fvny5evTo4fwjjH379lV+fr7efvttPfLII5Kk9PR0jR49WqmpqZKk1NRU5eTkKD09nY/nAACAJDcD0IQJE1zOLRaLunbtqvvuu08LFixoiL7qlJeXp9jYWJexMWPGaOXKlTp//rzatGmjvLw8Pfvss7Vqfv6Xq3+pqqpKVVVVzvPy8vIG7RsAADQvbgWgmpqahu7jmpSWliogIMBlLCAgQBcuXNDJkycVFBR0xZrS0tIrzpuWlqZ58+Y1Ss+AkW757adGt2CYf7z5gNvXmvW+3cg9AzxNgz4D1BQsFovLucPhqDVeV80vx34uNTVVZWVlzqO4uLgBOwYAAM2NWztAKSkp11y7cOFCd96iToGBgbV2ck6cOCEvLy917ty53ppf7gr9nNVqldVqbbA+AQBA8+ZWACooKNDBgwd14cIF9e7dW5L07bffqnXr1rrrrrucdfXturgjKipKn3zyicvYjh07FBkZqTZt2jhrsrOzXZ4D2rFjh6Kjoxu0FwAA4LncCkDjxo1Thw4d9OGHH+rmm2+WdOmPI06fPl0xMTF67rnnrmmeiooKHT161Hl+7NgxFRYWqlOnTurRo4dSU1NVUlLi/OmNpKQkLV26VCkpKXriiSeUl5enlStXuny7Kzk5WcOGDdP8+fM1fvx4bd68WTt37tTevXvdWSoAAGiB3HoGaMGCBUpLS3OGH0m6+eab9frrr1/Xt8Dy8/MVHh6u8PBwSZc+WgsPD9fvfvc7SZLdbldRUZGzPjQ0VFu3btXu3bt155136rXXXtOSJUucX4GXpOjoaK1du1arV6/WHXfcIZvNpszMTA0ePNidpQIAgBbIrR2g8vJy/e///q/69evnMn7ixAmdOXPmmucZPny48yHmuthstlpj9957rw4ePFjvvBMnTtTEiROvuQ8AAGAubu0APfTQQ5o+fbr+9Kc/6YcfftAPP/ygP/3pT0pMTNTDDz/c0D0CAAA0KLd2gJYvX665c+dq8uTJOn/+/KWJvLyUmJiot956q0EbBAAAaGhuBaB27drpvffe01tvvaXvvvtODodDt99+u9q3b9/Q/QEAADS4G/pDiHa7XXa7Xb169VL79u3rfZ4HAACguXArAJ06dUojR45Ur169NHbsWNntdknSzJkzr/kr8AAAAEZxKwA9++yzatOmjYqKitSuXTvneHx8vP785z83WHMAAACNwa1ngHbs2KHt27ere/fuLuM9e/bU8ePHG6QxAACAxuLWDlBlZaXLzs9lJ0+e5De1AABAs+dWABo2bJjz5ymkS7/5VVNTo7feeksjRoxosOYAAAAag1sfgb311lsaPny48vPzVV1dreeff15fffWV/vnPf+qvf/1rQ/cIAADQoNzaAQoLC9MXX3yhu+++W6NHj1ZlZaUefvhhFRQU6LbbbmvoHgEAABrUde8AnT9/XrGxsXr//fc1b968xugJAACgUV33DlCbNm305ZdfymKxNEY/AAAAjc6tj8CmTJmilStXNnQvAAAATcKth6Crq6v1xz/+UdnZ2YqMjKz1G2ALFy5skOYAAAAaw3UFoO+//1633HKLvvzyS911112SpG+//dalho/GAABAc3ddAahnz56y2+3atWuXpEs/fbFkyRIFBAQ0SnMAAACN4bqeAfrlr71v27ZNlZWVDdoQAABAY3PrIejLfhmIAAAAPMF1BSCLxVLrGR+e+QEAAJ7mup4BcjgcmjZtmvMHT8+dO6ekpKRa3wLbsGFDw3UIAADQwK4rAE2dOtXlfPLkyQ3aDAAAQFO4rgC0evXqxuoDAACgydzQQ9AAAACeiAAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMhwAEAABMx/AA9N577yk0NFQ+Pj6KiIjQnj17rlg7bdo05y/S//zo16+fs8Zms9VZc+7cuaZYDgAA8ACGBqDMzEzNmTNHL774ogoKChQTE6O4uDgVFRXVWb948WLZ7XbnUVxcrE6dOunRRx91qfP19XWps9vt8vHxaYolAQAAD2BoAFq4cKESExM1c+ZM9e3bV+np6QoODtayZcvqrPfz81NgYKDzyM/P1+nTpzV9+nSXOovF4lIXGBjYFMsBAAAewrAAVF1drQMHDig2NtZlPDY2Vvv27bumOVauXKlRo0YpJCTEZbyiokIhISHq3r27HnzwQRUUFNQ7T1VVlcrLy10OAADQchkWgE6ePKmLFy8qICDAZTwgIEClpaVXvd5ut2vbtm2aOXOmy3ifPn1ks9m0ZcsWZWRkyMfHR0OHDtWRI0euOFdaWpr8/PycR3BwsHuLAgAAHsHwh6AtFovLucPhqDVWF5vNpo4dO2rChAku40OGDNHkyZM1cOBAxcTEaN26derVq5feeeedK86VmpqqsrIy51FcXOzWWgAAgGfwMuqNu3TpotatW9fa7Tlx4kStXaFfcjgcWrVqlRISEuTt7V1vbatWrTRo0KB6d4CsVqusVuu1Nw8AADyaYTtA3t7eioiIUHZ2tst4dna2oqOj6702JydHR48eVWJi4lXfx+FwqLCwUEFBQTfULwAAaDkM2wGSpJSUFCUkJCgyMlJRUVFasWKFioqKlJSUJOnSR1MlJSVas2aNy3UrV67U4MGD1b9//1pzzps3T0OGDFHPnj1VXl6uJUuWqLCwUO+++26TrAkAADR/hgag+Ph4nTp1Sq+++qrsdrv69++vrVu3Or/VZbfba/1NoLKyMmVlZWnx4sV1zvnTTz/pySefVGlpqfz8/BQeHq7c3Fzdfffdjb4eAADgGQwNQJI0a9YszZo1q87XbDZbrTE/Pz+dPXv2ivMtWrRIixYtaqj2AABAC2T4t8AAAACaGgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYDgEIAACYjuEB6L333lNoaKh8fHwUERGhPXv2XLF29+7dslgstY5vvvnGpS4rK0thYWGyWq0KCwvTxo0bG3sZAADAgxgagDIzMzVnzhy9+OKLKigoUExMjOLi4lRUVFTvdYcPH5bdbncePXv2dL6Wl5en+Ph4JSQk6NChQ0pISNCkSZO0f//+xl4OAADwEIYGoIULFyoxMVEzZ85U3759lZ6eruDgYC1btqze6/z9/RUYGOg8Wrdu7XwtPT1do0ePVmpqqvr06aPU1FSNHDlS6enpjbwaAADgKQwLQNXV1Tpw4IBiY2NdxmNjY7Vv3756rw0PD1dQUJBGjhypXbt2ubyWl5dXa84xY8bUO2dVVZXKy8tdDgAA0HIZFoBOnjypixcvKiAgwGU8ICBApaWldV4TFBSkFStWKCsrSxs2bFDv3r01cuRI5ebmOmtKS0uva05JSktLk5+fn/MIDg6+gZUBAIDmzsvoBiwWi8u5w+GoNXZZ79691bt3b+d5VFSUiouL9fbbb2vYsGFuzSlJqampSklJcZ6Xl5cTggAAaMEM2wHq0qWLWrduXWtn5sSJE7V2cOozZMgQHTlyxHkeGBh43XNarVb5+vq6HAAAoOUyLAB5e3srIiJC2dnZLuPZ2dmKjo6+5nkKCgoUFBTkPI+Kiqo1544dO65rTgAA0LIZ+hFYSkqKEhISFBkZqaioKK1YsUJFRUVKSkqSdOmjqZKSEq1Zs0bSpW943XLLLerXr5+qq6v10UcfKSsrS1lZWc45k5OTNWzYMM2fP1/jx4/X5s2btXPnTu3du9eQNQIAgObH0AAUHx+vU6dO6dVXX5Xdblf//v21detWhYSESJLsdrvL3wSqrq7W3LlzVVJSorZt26pfv3769NNPNXbsWGdNdHS01q5dq5deekkvv/yybrvtNmVmZmrw4MFNvj4AANA8Gf4Q9KxZszRr1qw6X7PZbC7nzz//vJ5//vmrzjlx4kRNnDixIdoDAAAtkOE/hQEAANDUCEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0CEAAAMB0DA9A7733nkJDQ+Xj46OIiAjt2bPnirUbNmzQ6NGj1bVrV/n6+ioqKkrbt293qbHZbLJYLLWOc+fONfZSAACAhzA0AGVmZmrOnDl68cUXVVBQoJiYGMXFxamoqKjO+tzcXI0ePVpbt27VgQMHNGLECI0bN04FBQUudb6+vrLb7S6Hj49PUywJAAB4AC8j33zhwoVKTEzUzJkzJUnp6enavn27li1bprS0tFr16enpLudvvPGGNm/erE8++UTh4eHOcYvFosDAwEbtHQAAeC7DdoCqq6t14MABxcbGuozHxsZq37591zRHTU2Nzpw5o06dOrmMV1RUKCQkRN27d9eDDz5Ya4fol6qqqlReXu5yAACAlsuwAHTy5EldvHhRAQEBLuMBAQEqLS29pjkWLFigyspKTZo0yTnWp08f2Ww2bdmyRRkZGfLx8dHQoUN15MiRK86TlpYmPz8/5xEcHOzeogAAgEcw/CFoi8Xicu5wOGqN1SUjI0OvvPKKMjMz5e/v7xwfMmSIJk+erIEDByomJkbr1q1Tr1699M4771xxrtTUVJWVlTmP4uJi9xcEAACaPcOeAerSpYtat25da7fnxIkTtXaFfikzM1OJiYlav369Ro0aVW9tq1atNGjQoHp3gKxWq6xW67U3DwAAPJphO0De3t6KiIhQdna2y3h2draio6OveF1GRoamTZumjz/+WA888MBV38fhcKiwsFBBQUE33DMAAGgZDP0WWEpKihISEhQZGamoqCitWLFCRUVFSkpKknTpo6mSkhKtWbNG0qXwM2XKFC1evFhDhgxx7h61bdtWfn5+kqR58+ZpyJAh6tmzp8rLy7VkyRIVFhbq3XffNWaRAACg2TE0AMXHx+vUqVN69dVXZbfb1b9/f23dulUhISGSJLvd7vI3gd5//31duHBBs2fP1uzZs53jU6dOlc1mkyT99NNPevLJJ1VaWio/Pz+Fh4crNzdXd999d5OuDQAANF+GBiBJmjVrlmbNmlXna5dDzWW7d+++6nyLFi3SokWLGqAzAADQUhn+LTAAAICmRgACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmQwACAACmY3gAeu+99xQaGiofHx9FRERoz5499dbn5OQoIiJCPj4+uvXWW7V8+fJaNVlZWQoLC5PValVYWJg2btzYWO0DAAAPZGgAyszM1Jw5c/Tiiy+qoKBAMTExiouLU1FRUZ31x44d09ixYxUTE6OCggK98MILeuaZZ5SVleWsycvLU3x8vBISEnTo0CElJCRo0qRJ2r9/f1MtCwAANHOGBqCFCxcqMTFRM2fOVN++fZWenq7g4GAtW7aszvrly5erR48eSk9PV9++fTVz5kzNmDFDb7/9trMmPT1do0ePVmpqqvr06aPU1FSNHDlS6enpTbQqAADQ3HkZ9cbV1dU6cOCAfvvb37qMx8bGat++fXVek5eXp9jYWJexMWPGaOXKlTp//rzatGmjvLw8Pfvss7Vq6gtAVVVVqqqqcp6XlZVJksrLy69nSdespupso8zb3N3o/eS+XT+z3jOJ++YO/hl1D/fNPY3x79jLczocjqvWGhaATp48qYsXLyogIMBlPCAgQKWlpXVeU1paWmf9hQsXdPLkSQUFBV2x5kpzSlJaWprmzZtXazw4OPhal4Nr4JdudAeeifvmHu7b9eOeuYf75p7GvG9nzpyRn59fvTWGBaDLLBaLy7nD4ag1drX6X45f75ypqalKSUlxntfU1Oif//ynOnfuXO91nqa8vFzBwcEqLi6Wr6+v0e14DO7b9eOeuYf75h7um3ta4n1zOBw6c+aMunXrdtVawwJQly5d1Lp161o7MydOnKi1g3NZYGBgnfVeXl7q3LlzvTVXmlOSrFarrFary1jHjh2vdSkex9fXt8X8n70pcd+uH/fMPdw393Df3NPS7tvVdn4uM+whaG9vb0VERCg7O9tlPDs7W9HR0XVeExUVVat+x44dioyMVJs2beqtudKcAADAfAz9CCwlJUUJCQmKjIxUVFSUVqxYoaKiIiUlJUm69NFUSUmJ1qxZI0lKSkrS0qVLlZKSoieeeEJ5eXlauXKlMjIynHMmJydr2LBhmj9/vsaPH6/Nmzdr586d2rt3ryFrBAAAzY+hASg+Pl6nTp3Sq6++Krvdrv79+2vr1q0KCQmRJNntdpe/CRQaGqqtW7fq2Wef1bvvvqtu3bppyZIleuSRR5w10dHRWrt2rV566SW9/PLLuu2225SZmanBgwc3+fqaG6vVqt///ve1Pu5D/bhv14975h7um3u4b+4x+32zOK7lu2IAAAAtiOE/hQEAANDUCEAAAMB0CEAAAMB0CEAAAMB0CEAmkJubq3Hjxqlbt26yWCzatGmT0S01e2lpaRo0aJA6dOggf39/TZgwQYcPHza6rWZv2bJluuOOO5x/WC0qKkrbtm0zui2PkpaWJovFojlz5hjdSrP3yiuvyGKxuByBgYFGt9XslZSUaPLkyercubPatWunO++8UwcOHDC6rSZHADKByspKDRw4UEuXLjW6FY+Rk5Oj2bNn6/PPP1d2drYuXLig2NhYVVZWGt1as9a9e3e9+eabys/PV35+vu677z6NHz9eX331ldGteYT//u//1ooVK3THHXcY3YrH6Nevn+x2u/P4+9//bnRLzdrp06c1dOhQtWnTRtu2bdP//M//aMGCBS361w+uxPDfAkPji4uLU1xcnNFteJQ///nPLuerV6+Wv7+/Dhw4oGHDhhnUVfM3btw4l/P/+I//0LJly/T555+rX79+BnXlGSoqKvT444/rgw8+0Ouvv250Ox7Dy8uLXZ/rMH/+fAUHB2v16tXOsVtuucW4hgzEDhBwDcrKyiRJnTp1MrgTz3Hx4kWtXbtWlZWVioqKMrqdZm/27Nl64IEHNGrUKKNb8ShHjhxRt27dFBoaqscee0zff/+90S01a1u2bFFkZKQeffRR+fv7Kzw8XB988IHRbRmCAARchcPhUEpKiu655x7179/f6Haavb///e+66aabZLValZSUpI0bNyosLMzotpq1tWvX6uDBg0pLSzO6FY8yePBgrVmzRtu3b9cHH3yg0tJSRUdH69SpU0a31mx9//33WrZsmXr27Knt27crKSlJzzzzjPMnp8yEj8CAq3jqqaf0xRdf8Hty16h3794qLCzUTz/9pKysLE2dOlU5OTmEoCsoLi5WcnKyduzYIR8fH6Pb8Sg//2h/wIABioqK0m233aYPP/xQKSkpBnbWfNXU1CgyMlJvvPGGJCk8PFxfffWVli1bpilTphjcXdNiBwiox9NPP60tW7Zo165d6t69u9HteARvb2/dfvvtioyMVFpamgYOHKjFixcb3VazdeDAAZ04cUIRERHy8vKSl5eXcnJytGTJEnl5eenixYtGt+gx2rdvrwEDBujIkSNGt9JsBQUF1fqPkb59+7r87qZZsAME1MHhcOjpp5/Wxo0btXv3boWGhhrdksdyOByqqqoyuo1ma+TIkbW+uTR9+nT16dNHv/nNb9S6dWuDOvM8VVVV+vrrrxUTE2N0K83W0KFDa/1Jj2+//db5I+RmQgAygYqKCh09etR5fuzYMRUWFqpTp07q0aOHgZ01X7Nnz9bHH3+szZs3q0OHDiotLZUk+fn5qW3btgZ313y98MILiouLU3BwsM6cOaO1a9dq9+7dtb5Vh/+vQ4cOtZ4ta9++vTp37swzZ1cxd+5cjRs3Tj169NCJEyf0+uuvq7y8XFOnTjW6tWbr2WefVXR0tN544w1NmjRJf/vb37RixQqtWLHC6NaangMt3q5duxySah1Tp041urVmq677JcmxevVqo1tr1mbMmOEICQlxeHt7O7p27eoYOXKkY8eOHUa35XHuvfdeR3JystFtNHvx8fGOoKAgR5s2bRzdunVzPPzww46vvvrK6LaavU8++cTRv39/h9VqdfTp08exYsUKo1syhMXhcDgMyl4AAACG4CFoAABgOgQgAABgOgQgAABgOgQgAABgOgQgAABgOgQgAABgOgQgAABgOgQgAABgOgQgAKYxfPhwzZkzx+g2ADQDBCAAHmHcuHEaNWpUna/l5eXJYrHo4MGDTdwVAE9FAALgERITE/XZZ5/p+PHjtV5btWqV7rzzTt11110GdAbAExGAAHiEBx98UP7+/rLZbC7jZ8+eVWZmpiZMmKB///d/V/fu3dWuXTsNGDBAGRkZ9c5psVi0adMml7GOHTu6vEdJSYni4+N18803q3Pnzho/frz+8Y9/NMyiABiGAATAI3h5eWnKlCmy2Wz6+W84r1+/XtXV1Zo5c6YiIiL0X//1X/ryyy/15JNPKiEhQfv373f7Pc+ePasRI0bopptuUm5urvbu3aubbrpJ999/v6qrqxtiWQAMQgAC4DFmzJihf/zjH9q9e7dzbNWqVXr44Yf1b//2b5o7d67uvPNO3XrrrXr66ac1ZswYrV+/3u33W7t2rVq1aqU//vGPGjBggPr27avVq1erqKjIpQcAnsfL6AYA4Fr16dNH0dHRWrVqlUaMGKHvvvtOe/bs0Y4dO3Tx4kW9+eabyszMVElJiaqqqlRVVaX27du7/X4HDhzQ0aNH1aFDB5fxc+fO6bvvvrvR5QAwEAEIgEdJTEzUU089pXfffVerV69WSEiIRo4cqbfeekuLFi1Senq6BgwYoPbt22vOnDn1flRlsVhcPk6TpPPnzzv/d01NjSIiIvSf//mfta7t2rVrwy0KQJMjAAHwKJMmTVJycrI+/vhjffjhh3riiSdksVi0Z88ejR8/XpMnT5Z0KbwcOXJEffv2veJcXbt2ld1ud54fOXJEZ8+edZ7fddddyszMlL+/v3x9fRtvUQCaHM8AAfAoN910k+Lj4/XCCy/oxx9/1LRp0yRJt99+u7Kzs7Vv3z59/fXX+vWvf63S0tJ657rvvvu0dOlSHTx4UPn5+UpKSlKbNm2crz/++OPq0qWLxo8frz179ujYsWPKyclRcnKyfvjhh8ZcJoBGRgAC4HESExN1+vRpjRo1Sj169JAkvfzyy7rrrrs0ZswYDR8+XIGBgZowYUK98yxYsEDBwcEaNmyYfvWrX2nu3Llq166d8/V27dopNzdXPXr00MMPP6y+fftqxowZ+te//sWOEODhLI5ffgAOAADQwrEDBAAATIcABAAATIcABAAATIcABAAATIcABAAATIcABAAATIcABAAATIcABAAATIcABAAATIcABAAATIcABAAATOf/AYt2jUIUsVhzAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "freq_distribution = sorted_dice[\"Roll\"].value_counts()\n", + "print(freq_distribution)\n", + "\n", + "plt.bar(freq_distribution.index, freq_distribution.values)\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 2\n", + "Now, using the dice results obtained in *challenge 1*, your are going to define some functions that will help you calculate the mean of your data in two different ways, the median and the four quartiles. \n", + "\n", + "#### 1.- Define a function that computes the mean by summing all the observations and dividing by the total number of observations. You are not allowed to use any methods or functions that directly calculate the mean value. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.5" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "def mean_dice(data):\n", + " mean = data.sum()/len(data)\n", + " return mean\n", + "\n", + "mean_dice(dice_df[\"Roll\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- First, calculate the frequency distribution. Then, calculate the mean using the values of the frequency distribution you've just computed. You are not allowed to use any methods or functions that directly calculate the mean value. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequency Distribution:\n", + "5 2\n", + "2 2\n", + "1 2\n", + "6 2\n", + "4 1\n", + "3 1\n", + "Name: Roll, dtype: int64\n", + "The mean is 3.5\n" + ] + } + ], + "source": [ + "# your code here\n", + "freq_distribution = dice_df[\"Roll\"].value_counts()\n", + "\n", + "sum_values = 0\n", + "total_count = 0\n", + "\n", + "for value, count in freq_distribution.items():\n", + " sum_values += value * count\n", + " total_count += count\n", + "\n", + "mean_value = sum_values / total_count\n", + "\n", + "print(\"Frequency Distribution:\")\n", + "print(freq_distribution)\n", + "print(f\"The mean is {mean_value}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Define a function to calculate the median. You are not allowed to use any methods or functions that directly calculate the median value. \n", + "**Hint**: you might need to define two computation cases depending on the number of observations used to calculate the median." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The median is 3.5\n" + ] + } + ], + "source": [ + "# your code here\n", + "def median_dice(data):\n", + " sorted_data = sorted(data)\n", + " n = len(sorted_data)\n", + " \n", + " if n % 2 == 1:\n", + " median_index = n // 2\n", + " median = sorted_data[median_index]\n", + " else:\n", + " upper_median_index = n // 2\n", + " lower_median_index = upper_median_index - 1\n", + " median = (sorted_data[lower_median_index] + sorted_data[upper_median_index]) / 2.0\n", + " \n", + " return median\n", + "\n", + "\n", + "median_dice = median_dice(dice_df[\"Roll\"])\n", + "\n", + "print(f\"The median is {median_dice}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Define a function to calculate the four quartiles. You can use the function you defined above to compute the median but you are not allowed to use any methods or functions that directly calculate the quartiles. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'float' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[10], line 12\u001b[0m\n\u001b[0;32m 8\u001b[0m q3 \u001b[38;5;241m=\u001b[39m median_dice(sorted_data[n\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m2\u001b[39m:]) \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m calculate_median(sorted_data[n\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m:])\n\u001b[0;32m 10\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m q1, q2, q3\n\u001b[1;32m---> 12\u001b[0m q1, q2, q3 \u001b[38;5;241m=\u001b[39m \u001b[43mquartiles_dice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdice_df\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mRoll\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 14\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe first quartile is \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mq1\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 15\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe second quartile is \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mq2\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[1;32mIn[10], line 6\u001b[0m, in \u001b[0;36mquartiles_dice\u001b[1;34m(data)\u001b[0m\n\u001b[0;32m 3\u001b[0m sorted_data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28msorted\u001b[39m(data)\n\u001b[0;32m 4\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(sorted_data)\n\u001b[1;32m----> 6\u001b[0m q1 \u001b[38;5;241m=\u001b[39m \u001b[43mmedian_dice\u001b[49m\u001b[43m(\u001b[49m\u001b[43msorted_data\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43mn\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 7\u001b[0m q2 \u001b[38;5;241m=\u001b[39m median_dice(sorted_data)\n\u001b[0;32m 8\u001b[0m q3 \u001b[38;5;241m=\u001b[39m median_dice(sorted_data[n\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m2\u001b[39m:]) \u001b[38;5;28;01mif\u001b[39;00m n \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m calculate_median(sorted_data[n\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m:])\n", + "\u001b[1;31mTypeError\u001b[0m: 'float' object is not callable" + ] + } + ], + "source": [ + "# your code here\n", + "def quartiles_dice(data):\n", + " sorted_data = sorted(data)\n", + " n = len(sorted_data)\n", + " \n", + " q1 = calculate_median(sorted_data[:n//2])\n", + " q2 = calculate_median(sorted_data)\n", + " q3 = calculate_median(sorted_data[n//2:]) if n % 2 == 0 else calculate_median(sorted_data[n//2 + 1:])\n", + " \n", + " return q1, q2, q3\n", + "\n", + "q1, q2, q3 = quartiles_dice(dice_df[\"Roll\"])\n", + "\n", + "print(f\"The first quartile is {q1}\")\n", + "print(f\"The second quartile is {q2}\")\n", + "print(f\"The third quartile is {q3}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 3\n", + "Read the csv `roll_the_dice_hundred.csv` from the `data` folder.\n", + "#### 1.- Sort the values and plot them. What do you see?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Using the functions you defined in *challenge 2*, calculate the mean value of the hundred dice rolls." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Now, calculate the frequency distribution.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Plot the histogram. What do you see (shape, values...) ? How can you connect the mean value to the histogram? " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.- Read the `roll_the_dice_thousand.csv` from the `data` folder. Plot the frequency distribution as you did before. Has anything changed? Why do you think it changed?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 4\n", + "In the `data` folder of this repository you will find three different files with the prefix `ages_population`. These files contain information about a poll answered by a thousand people regarding their age. Each file corresponds to the poll answers in different neighbourhoods of Barcelona.\n", + "\n", + "#### 1.- Read the file `ages_population.csv`. Calculate the frequency distribution and plot it as we did during the lesson. Try to guess the range in which the mean and the standard deviation will be by looking at the plot. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Calculate the exact mean and standard deviation and compare them with your guesses. Do they fall inside the ranges you guessed?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Now read the file `ages_population2.csv` . Calculate the frequency distribution and plot it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- What do you see? Is there any difference with the frequency distribution in step 1?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.- Calculate the mean and standard deviation. Compare the results with the mean and standard deviation in step 2. What do you think?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 5\n", + "Now is the turn of `ages_population3.csv`.\n", + "\n", + "#### 1.- Read the file `ages_population3.csv`. Calculate the frequency distribution and plot it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Calculate the mean and standard deviation. Compare the results with the plot in step 1. What is happening?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Calculate the four quartiles. Use the results to explain your reasoning for question in step 2. How much of a difference is there between the median and the mean?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Calculate other percentiles that might be useful to give more arguments to your reasoning." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bonus challenge\n", + "Compare the information about the three neighbourhoods. Prepare a report about the three of them. Remember to find out which are their similarities and their differences backing your arguments in basic statistics." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/data/ages_population.csv b/your-code/ages_population.csv similarity index 100% rename from data/ages_population.csv rename to your-code/ages_population.csv diff --git a/data/ages_population2.csv b/your-code/ages_population2.csv similarity index 100% rename from data/ages_population2.csv rename to your-code/ages_population2.csv diff --git a/data/ages_population3.csv b/your-code/ages_population3.csv similarity index 100% rename from data/ages_population3.csv rename to your-code/ages_population3.csv diff --git a/your-code/main.ipynb b/your-code/main.ipynb index a0a5b66..b95189e 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -11,11 +11,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 292, "metadata": {}, "outputs": [], "source": [ - "# Libraries" + "# Libraries\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import random\n", + "import seaborn as sns\n", + "from scipy import stats as st\n" ] }, { @@ -29,11 +35,113 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 293, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Roll
Trial
11
25
36
45
56
66
74
86
92
106
\n", + "
" + ], + "text/plain": [ + " Roll\n", + "Trial \n", + "1 1\n", + "2 5\n", + "3 6\n", + "4 5\n", + "5 6\n", + "6 6\n", + "7 4\n", + "8 6\n", + "9 2\n", + "10 6" + ] + }, + "execution_count": 293, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "def dice_roll(x):\n", + "\n", + " dice_df = np.random.randint(1,7,x)\n", + " dice_df = pd.DataFrame(dice_df, columns=[\"Roll\"])\n", + " dice_df.index=np.arange(1, len(dice_df)+1)\n", + " dice_df.index.name=\"Trial\"\n", + " \n", + " return dice_df\n", + "\n", + "dice_roll(10)" ] }, { @@ -45,11 +153,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 363, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "sorted_dice = dice_df.sort_values(by = \"Roll\", ascending = False)\n", + "\n", + "plt.bar(sorted_dice.index, sorted_dice[\"Roll\"])\n", + "\n", + "plt.xlabel(\"Roll Index\")\n", + "plt.ylabel(\"Roll Value\")\n", + "plt.xticks(sorted_dice.index, sorted_dice.index + 1)\n", + "\n", + "plt.show()" ] }, { @@ -61,18 +189,127 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 295, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(array([1, 2, 3, 5, 6]), array([2, 4, 2, 1, 1], dtype=int64))" + ] + }, + "execution_count": 295, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "freq_distribution = np.unique(dice_df, return_counts=True)\n", + "freq_distribution" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 296, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sfsou\\AppData\\Local\\Temp\\ipykernel_12156\\2033459259.py:1: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(freq_distribution)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 296, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(freq_distribution)" + ] + }, + { + "cell_type": "code", + "execution_count": 297, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2 4\n", + "3 2\n", + "1 2\n", + "6 1\n", + "5 1\n", + "Name: Roll, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "freq_distribution = sorted_dice[\"Roll\"].value_counts()\n", + "print(freq_distribution)\n", + "\n", + "plt.bar(freq_distribution.index, freq_distribution.values)\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 298, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 298, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -91,11 +328,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 299, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "2.7" + ] + }, + "execution_count": 299, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "def mean_dice(data):\n", + " mean = data.sum()/len(data)\n", + " return mean\n", + "\n", + "mean_dice(dice_df[\"Roll\"])" ] }, { @@ -107,11 +360,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 300, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequency Distribution:\n", + "2 4\n", + "3 2\n", + "1 2\n", + "6 1\n", + "5 1\n", + "Name: Roll, dtype: int64\n", + "The mean is 2.7\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "freq_distribution = dice_df[\"Roll\"].value_counts()\n", + "\n", + "sum_values = 0\n", + "total_count = 0\n", + "\n", + "for value, count in freq_distribution.items():\n", + " sum_values += value * count\n", + " total_count += count\n", + "\n", + "mean_value = sum_values / total_count\n", + "\n", + "print(\"Frequency Distribution:\")\n", + "print(freq_distribution)\n", + "print(f\"The mean is {mean_value}\")" ] }, { @@ -124,11 +406,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 301, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The median is 2.0\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "def median_dice(data):\n", + " sorted_data = sorted(data)\n", + " n = len(sorted_data)\n", + " \n", + " if n % 2 == 1:\n", + " median_index = n // 2\n", + " median = sorted_data[median_index]\n", + " else:\n", + " upper_median_index = n // 2\n", + " lower_median_index = upper_median_index - 1\n", + " median = (sorted_data[lower_median_index] + sorted_data[upper_median_index]) / 2.0\n", + " \n", + " return median\n", + "\n", + "\n", + "median_dice = median_dice(dice_df[\"Roll\"])\n", + "\n", + "print(f\"The median is {median_dice}\")" ] }, { @@ -140,11 +448,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 302, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Q1 = 2.0, Q2 = 2.0 e Q3 = 3.0\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "def calc_median(dice):\n", + " #\n", + " q1 = np.quantile(dice_df, 0.25)\n", + " q2 = np.quantile(dice_df, 0.50)\n", + " q3 = np.quantile(dice_df, 0.75)\n", + "\n", + " return print(f\"Q1 = {q1}, Q2 = {q2} e Q3 = {q3}\")\n", + "\n", + "\n", + "calc_median(dice_df)" ] }, { @@ -158,18 +484,191 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 381, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0rollvalue
0001
1112
2226
3331
4446
............
9595954
9696966
9797971
9898983
9999996
\n", + "

100 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 roll value\n", + "0 0 0 1\n", + "1 1 1 2\n", + "2 2 2 6\n", + "3 3 3 1\n", + "4 4 4 6\n", + ".. ... ... ...\n", + "95 95 95 4\n", + "96 96 96 6\n", + "97 97 97 1\n", + "98 98 98 3\n", + "99 99 99 6\n", + "\n", + "[100 rows x 3 columns]" + ] + }, + "execution_count": 381, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "data = pd.read_csv(\"roll_the_dice_hundred.csv\")\n", + "data\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 382, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sfsou\\AppData\\Local\\Temp\\ipykernel_12156\\2676058639.py:3: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(sorted_values)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sorted_values = data.sort_values(by = \"value\", ascending = False)\n", + "\n", + "sns.distplot(sorted_values)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 305, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 305, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -185,11 +684,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 383, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of mean is: 3.74\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "def mean_dice(data):\n", + " mean = data.sum() / len(data)\n", + " return mean\n", + "\n", + "print(\"The value of mean is:\", mean_dice(data[\"value\"]))" ] }, { @@ -201,11 +713,54 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 384, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "6 23\n", + "4 22\n", + "2 17\n", + "3 14\n", + "1 12\n", + "5 12\n", + "Name: value, dtype: int64" + ] + }, + "execution_count": 384, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "freq_distribution = data[\"value\"].value_counts()\n", + "freq_distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 385, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "plt.bar(freq_distribution.index, freq_distribution.values)\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" ] }, { @@ -217,18 +772,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 386, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 386, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "plt.hist(data[\"value\"])\n", + "x = data[\"value\"]\n", + "plt.axvline(x.mean(), color = \"orange\")\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 310, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 310, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -244,18 +834,64 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 387, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 175\n", + "3 175\n", + "4 168\n", + "2 167\n", + "6 166\n", + "5 149\n", + "Name: value, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "\n", + "data = pd.read_csv(\"roll_the_dice_thousand.csv\")\n", + "data\n", + "\n", + "freq_distribution = data[\"value\"].value_counts()\n", + "print(freq_distribution)\n", + "\n", + "plt.bar(freq_distribution.index, freq_distribution.values)\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 312, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 312, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -274,11 +910,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 392, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "ages_population = pd.read_csv(\"ages_population.csv\")\n", + "ages_population\n", + "\n", + "freq_distribution = ages_population[\"observation\"].value_counts()\n", + "\n", + "plt.bar(freq_distribution.index, freq_distribution.values)\n", + "plt.xlabel(\"Age\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" ] }, { @@ -290,18 +946,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 393, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The mean is 36.56\n", + "The standard deviation is 12.816499625976762\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "mean = ages_population[\"observation\"].mean()\n", + "print(f\"The mean is {mean}\")\n", + "\n", + "std_dev = ages_population[\"observation\"].std()\n", + "print(f\"The standard deviation is {std_dev}\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 315, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 315, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -317,11 +998,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 394, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "ages_population_2 = pd.read_csv(\"ages_population2.csv\")\n", + "ages_population_2\n", + "\n", + "freq_distribution = ages_population_2[\"observation\"].value_counts()\n", + "\n", + "plt.bar(freq_distribution.index, freq_distribution.values)\n", + "plt.xlabel(\"Age\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" ] }, { @@ -333,9 +1034,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 317, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 317, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -351,18 +1063,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 395, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The mean for population 2 is 27.155\n", + "The standard deviation for population 2 is 2.969813932689186\n", + "The mean for population is 36.56\n", + "The standard deviation for population is 12.816499625976762\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "mean = ages_population_2[\"observation\"].mean()\n", + "print(f\"The mean for population 2 is {mean}\")\n", + "\n", + "std_dev = ages_population_2[\"observation\"].std()\n", + "print(f\"The standard deviation for population 2 is {std_dev}\")\n", + "\n", + "mean = ages_population[\"observation\"].mean()\n", + "print(f\"The mean for population is {mean}\")\n", + "\n", + "std_dev = ages_population[\"observation\"].std()\n", + "print(f\"The standard deviation for population is {std_dev}\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 319, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 319, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -381,11 +1126,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 396, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "ages_population_3 = pd.read_csv(\"ages_population3.csv\")\n", + "ages_population_3\n", + "\n", + "freq_distribution = ages_population_3[\"observation\"].value_counts()\n", + "\n", + "plt.bar(freq_distribution.index, freq_distribution.values)\n", + "plt.xlabel(\"Age\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()" ] }, { @@ -397,18 +1162,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 397, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The mean for population 3 is 41.989\n", + "The standard deviation for population 3 is 16.144705959865934\n", + "The mean for population 1 is 36.56\n", + "The standard deviation for population 1 is 12.816499625976762\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "mean = ages_population_3[\"observation\"].mean()\n", + "print(f\"The mean for population 3 is {mean}\")\n", + "\n", + "std_dev = ages_population_3[\"observation\"].std()\n", + "print(f\"The standard deviation for population 3 is {std_dev}\")\n", + "\n", + "mean = ages_population[\"observation\"].mean()\n", + "print(f\"The mean for population 1 is {mean}\")\n", + "\n", + "std_dev = ages_population[\"observation\"].std()\n", + "print(f\"The standard deviation for population 1 is {std_dev}\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 322, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 322, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -424,18 +1222,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 398, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The first quartile is 30.0\n", + "The second quartile is 40.0\n", + "The third quartile is 53.0\n", + "The fourth quartile is 77.0\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "q1 = np.quantile(ages_population_3, 0.25)\n", + "print(f\"The first quartile is {q1}\")\n", + "q2 = np.quantile(ages_population_3, 0.50)\n", + "print(f\"The second quartile is {q2}\")\n", + "q3 = np.quantile(ages_population_3, 0.75)\n", + "print(f\"The third quartile is {q3}\")\n", + "q4 = np.quantile(ages_population_3, 1)\n", + "print(f\"The fourth quartile is {q4}\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 324, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 324, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -451,18 +1279,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 400, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The 10th percentile is 22.0\n", + "The 90th percentile is 67.0\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "p10 = np.percentile(ages_population_3, 10)\n", + "p90 = np.percentile(ages_population_3, 90)\n", + "\n", + "print(f\"The 10th percentile is {p10}\")\n", + "print(f\"The 90th percentile is {p90}\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 326, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 326, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -479,18 +1332,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 401, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdAAAAHqCAYAAAAEZWxJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABii0lEQVR4nO3de3hU1dn38d9IYAiYRAHJJAIh1oCFAEVQDh4IAtEY8UDrCZWg1oeWg6SgyKGWoYUE8JWiULFaClhEqBUojygSFWIpUgGJIFpEDRCVmIohgQDhkPX+4ZNpJtmBJExmz0y+n+va18Vee+2de2Uy3Fl31uztMMYYAQAAAAAAAAAALxfYHQAAAAAAAAAAAIGIAjoAAAAAAAAAABYooAMAAAAAAAAAYIECOgAAAAAAAAAAFiigAwAAAAAAAABggQI6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYIECOuAnixcvlsPh8GxhYWFq06aNHnzwQX399dd2hydJGj58uNq3b1+nc5ctW6a5c+daHnM4HHK73XWOq66OHDmiCRMmKDk5WZdccoltcQAAghs53F3nuOrq3Xff1UMPPaQrrrhCzZs316WXXqrbbrtN27dv93ssAIDgRP521zmuusrJyVFqaqratWun8PBwtWjRQn369NHSpUv9HgvgS2F2BwA0NIsWLdIVV1yh48eP67333lNmZqays7O1a9cuNW/e3O7w6mzZsmX6+OOPlZ6eXuXY+++/rzZt2vg9pkOHDumFF15Qt27ddPvtt+tPf/qT32MAAIQOcrj/LFiwQIcOHdLYsWPVqVMn/ec//9HTTz+t3r1766233tINN9zg95gAAMGJ/O0/hw8fVtu2bXXvvffq0ksvVUlJiV5++WU98MAD2rdvn37961/7PSbAFyigA36WmJionj17SpL69++vM2fO6He/+51Wr16t++67z+bo6kfv3r1t+bpxcXEqLCyUw+HQd999RwEdAHBeyOH+84c//EGtW7f2arvpppt0+eWXKyMjgwI6AKDGyN/+k5SUpKSkJK+2W265Rbm5uXrhhRcooCNocQsXwGbliW3//v2SpBMnTmjSpEmKj49XkyZNdOmll2rUqFE6fPiw13nt27fXLbfcolWrVqlr165q2rSpLrvsMj377LNe/co/trZv3z6v9o0bN8rhcGjjxo1nje8Pf/iDrr/+erVu3VrNmzdXly5dNHv2bJ06dcrTJykpSWvXrtX+/fu9PiJXzurjYx9//LFuu+02XXzxxWratKl+8pOfaMmSJZYxvvLKK5oyZYpiY2MVGRmpgQMHas+ePWeNu/zrVowDAABfIofXXw6vXDyXpAsvvFCdOnVSXl7eOc8HAKA65O/6y9/VadWqlcLCWMOL4MVPL2Czzz//XJJ0ySWXyBij22+/Xe+8844mTZqk6667Tjt37tTUqVP1/vvv6/3335fT6fScm5OTo/T0dLndbrlcLr388ssaO3asTp48qccee8wn8X3xxRcaOnSo55eJjz76SDNmzNC///1v/fnPf5YkPffcc/qf//kfffHFF1q1atU5r7lnzx717dtXrVu31rPPPquWLVtq6dKlGj58uL799ltNmDDBq//kyZN1zTXX6E9/+pOKi4v1xBNPaPDgwfr000/VqFEjn4wTAIDaIof7N4cXFRXpww8/ZPU5AOC8kL/rP3+XlZWprKxMhYWFevXVV/XWW29p/vz5dfuGAIHAAPCLRYsWGUlmy5Yt5tSpU+bIkSPm9ddfN5dccomJiIgw+fn5Zt26dUaSmT17tte5K1asMJLMCy+84GmLi4szDofD5OTkePUdNGiQiYyMNCUlJV5fNzc316vfhg0bjCSzYcMGT1taWpqJi4urdgxnzpwxp06dMi+99JJp1KiR+f777z3HUlNTqz1Xkpk6dapn/5577jFOp9McOHDAq19KSopp1qyZOXz4sFeMN998s1e/v/71r0aSef/996uNtbL//Oc/VeIAAKAmyOFTPft25PBy9913nwkLCzPbtm2r9bkAgIaH/D3Vs+/v/D1ixAgjyUgyTZo0Mc8991yNzgMCFbdwAfysd+/eaty4sSIiInTLLbfI5XLpzTffVHR0tN59911JPzyJu6I777xTzZs31zvvvOPV3rlzZ3Xr1s2rbejQoSouLtaHH37ok3h37NihW2+9VS1btlSjRo3UuHFjDRs2TGfOnNFnn31Wp2u+++67GjBggNq2bevVPnz4cB07dkzvv/++V/utt97qtd+1a1dJ//3IHQAA/kAOty+HP/nkk3r55Zf1+9//Xj169KhD5ACAhor87f/8PXnyZG3dulVr167VQw89pNGjR+v//b//V6fYgUDALVwAP3vppZf04x//WGFhYYqOjlZMTIzn2KFDhxQWFqZLLrnE6xyHwyGXy6VDhw55tbtcrirXL2+r3LcuDhw4oOuuu04dO3bUM888o/bt26tp06b64IMPNGrUKB0/frxO1z106JDXuMvFxsZ6jlfUsmVLr/3yj9DV9esDAFAX5HB7cvi0adM0ffp0zZgxQ6NHj65tyACABo787f/83a5dO7Vr106SdPPNN0uSJk2apLS0tCrfayAYUEAH/OzHP/6x5wnglbVs2VKnT5/Wf/7zH6+kYoxRfn6+rrrqKq/++fn5Va5R3lae8Jo2bSpJKi0t9er33XffnTPW1atXq6SkRCtXrlRcXJynPScn55znnk3Lli118ODBKu3ffPONpB8eMAIAQKAhh/s/h0+bNk1ut1tut1uTJ0/26bUBAA0D+dv+OfjVV1+t559/Xl9++SUFdAQlbuECBJABAwZIkpYuXerV/tprr6mkpMRzvNzu3bv10UcfebUtW7ZMERERuvLKKyX98KRwSdq5c6dXvzVr1pwznvKneFd8aIoxRi+++GKVvk6ns8Z/jR4wYIDeffddT7Iu99JLL6lZs2aep6IDABAsyOG+z+G/+93v5Ha79etf/1pTp0712XUBAChH/vbPHHzDhg264IILdNlll9Xr1wHqCyvQgQAyaNAg3XjjjXriiSdUXFysa665xvME8O7du+uBBx7w6h8bG6tbb71VbrdbMTExWrp0qbKysjRr1iw1a9ZMknTVVVepY8eOeuyxx3T69GldfPHFWrVqlTZt2lSjeJo0aaJ7771XEyZM0IkTJ7RgwQIVFhZW6dulSxetXLlSCxYsUI8ePXTBBRdU+1f+qVOn6vXXX1f//v31m9/8Ri1atNDLL7+stWvXavbs2YqKiqrDd8/am2++qZKSEh05ckSS9Mknn+hvf/ubpB8+Slb+fQIA4HyQw32bw59++mn95je/0U033aTU1FRt2bLF6zh/bAcA+AL527f5+3/+538UGRmpq6++WtHR0fruu+/06quvasWKFXr88cdZfY7gZecTTIGGpPxJ3Fu3bj1rv+PHj5snnnjCxMXFmcaNG5uYmBjzy1/+0hQWFnr1i4uLM6mpqeZvf/ub6dy5s2nSpIlp3769mTNnTpVrfvbZZyY5OdlERkaaSy65xIwZM8asXbu2Rk8A/9///V/TrVs307RpU3PppZeaxx9/3Lz55ptVzv3+++/Nz372M3PRRRcZh8NhKv73okpPADfGmF27dpnBgwebqKgo06RJE9OtWzezaNEirz7lTwB/9dVXvdpzc3ONpCr9rcTFxXme/l15q/xUdAAArJDDp3pd1x85vF+/ftXmb6YwAICaIH9P9bquP/L3n//8Z3PdddeZVq1ambCwMHPRRReZfv36mb/85S9nPQ8IdA5jjKnvIj0A32vfvr0SExP1+uuv2x0KAACoBXI4AADBh/wNNFzcAx0AAAAAAAAAAAsU0AEAAAAAAAAAsMAtXAAAAAAAAAAAsMAKdAAAAAAAAAAALFBABwAAAAAAAADAAgV0AAAAAAAAAAAshNkdQH0rKyvTN998o4iICDkcDrvDAQDAizFGR44cUWxsrC64gL9rV0QOBwAEKvJ39cjfAIBAVpccHvIF9G+++UZt27a1OwwAAM4qLy9Pbdq0sTuMgEIOBwAEOvJ3VeRvAEAwqE0OD/kCekREhKQfvimRkZE2RwMAgLfi4mK1bdvWk6/wX+RwAECgIn9Xj/wNAAhkdcnhIV9AL//IWGRkJMkbABCw+IhzVeRwAECgI39XRf4GAASD2uRwbtYGAAAAAAAAAIAFCugAAAAAAAAAAFiggA4AAAAAAAAAgAUK6AAAAAAAAAAAWKCADgAAAAAAAACABQroAAAAAAAAAABYoIAOAAAAAAAAAIAFCugAAAAAAAAAAFiggA4AAAAAAAAAgAUK6AAAwMt7772nwYMHKzY2Vg6HQ6tXr66274gRI+RwODR37lyv9tLSUo0ZM0atWrVS8+bNdeutt+qrr76q38ABAAAAAPAxCugAAMBLSUmJunXrpvnz55+13+rVq/Wvf/1LsbGxVY6lp6dr1apVWr58uTZt2qSjR4/qlltu0ZkzZ+orbAAAAAAAfC7M7gAAAEBgSUlJUUpKyln7fP311xo9erTeeustpaameh0rKirSwoUL9Ze//EUDBw6UJC1dulRt27bV22+/rRtvvLHeYgcAAAAAwJdYgQ4AAGqlrKxMDzzwgB5//HF17ty5yvHt27fr1KlTSk5O9rTFxsYqMTFRmzdv9meoAAAAAACcF1agAwCAWpk1a5bCwsL06KOPWh7Pz89XkyZNdPHFF3u1R0dHKz8/v9rrlpaWqrS01LNfXFzsm4ABAAAAAKgjVqADAIAa2759u5555hktXrxYDoejVucaY856TmZmpqKiojxb27ZtzzdcAAAAAADOCwV0AABQY//4xz9UUFCgdu3aKSwsTGFhYdq/f7/Gjx+v9u3bS5JcLpdOnjypwsJCr3MLCgoUHR1d7bUnTZqkoqIiz5aXl1efQwEAAAAA4JwooAMAgBp74IEHtHPnTuXk5Hi22NhYPf7443rrrbckST169FDjxo2VlZXlOe/gwYP6+OOP1bdv32qv7XQ6FRkZ6bUBAAAAAGAn7oEONGDtJ6712t83M9WmSAAEkqNHj+rzzz/37Ofm5ionJ0ctWrRQu3bt1LJlS6/+jRs3lsvlUseOHSVJUVFRevjhhzV+/Hi1bNlSLVq00GOPPaYuXbpo4MCBfh0LAGuVfweoC35vAACEIubJACqjgA4AALxs27ZN/fv39+yPGzdOkpSWlqbFixfX6Bq///3vFRYWprvuukvHjx/XgAEDtHjxYjVq1Kg+QgYAAAAAoF5QQAcAAF6SkpJkjKlx/3379lVpa9q0qebNm6d58+b5MDIAAAAAAPyLe6ADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYIECOgAAAAAAAAAAFiigAwAAAAAAAABggQI6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYIECOgAAAAAAAAAAFiigAwAAAAAAAABggQI6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAA3AggUL1LVrV0VGRioyMlJ9+vTRm2++6Tk+fPhwORwOr6137942RgwAgP3C7A4AAAAAAADUvzZt2mjmzJm6/PLLJUlLlizRbbfdph07dqhz586SpJtuukmLFi3ynNOkSRNbYgUAIFBQQAcAAAAAoAEYPHiw1/6MGTO0YMECbdmyxVNAdzqdcrlcdoQHAEBA4hYuAAAAAAA0MGfOnNHy5ctVUlKiPn36eNo3btyo1q1bq0OHDnrkkUdUUFBgY5QAANiPFegAAAAAADQQu3btUp8+fXTixAldeOGFWrVqlTp16iRJSklJ0Z133qm4uDjl5ubqySef1A033KDt27fL6XRaXq+0tFSlpaWe/eLiYr+MAwAAf6GADgAAAABAA9GxY0fl5OTo8OHDeu2115SWlqbs7Gx16tRJd999t6dfYmKievbsqbi4OK1du1ZDhgyxvF5mZqamTZvmr/ABAPA7buECAAAAAEAD0aRJE11++eXq2bOnMjMz1a1bNz3zzDOWfWNiYhQXF6e9e/dWe71JkyapqKjIs+Xl5dVX6AAA2IIV6AAAAAAANFDGGK9bsFR06NAh5eXlKSYmptrznU5ntbd3AQAgFFBABwAAAACgAZg8ebJSUlLUtm1bHTlyRMuXL9fGjRu1bt06HT16VG63Wz/96U8VExOjffv2afLkyWrVqpXuuOMOu0MHAMA2FNABAAAAAGgAvv32Wz3wwAM6ePCgoqKi1LVrV61bt06DBg3S8ePHtWvXLr300ks6fPiwYmJi1L9/f61YsUIRERF2hw4AgG0ooAMAAAAA0AAsXLiw2mPh4eF66623/BgNAADBgYeIAgAAAAAAAABggQI6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYIECOgAAAAAAAAAAFiigAwAAAAAAAABggQI6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYCFgCuiZmZlyOBxKT0/3tBlj5Ha7FRsbq/DwcCUlJWn37t32BQkAAAAAAAAAaDDC7A5AkrZu3aoXXnhBXbt29WqfPXu25syZo8WLF6tDhw6aPn26Bg0apD179igiIsKmaAEAAAD/aD9x7XlfY9/MVB9EAgAAADRMtq9AP3r0qO677z69+OKLuvjiiz3txhjNnTtXU6ZM0ZAhQ5SYmKglS5bo2LFjWrZsmY0RAwAAAAAAAAAaAtsL6KNGjVJqaqoGDhzo1Z6bm6v8/HwlJyd72pxOp/r166fNmzf7O0wAAAAAAAAAQANj6y1cli9frg8//FBbt26tciw/P1+SFB0d7dUeHR2t/fv3V3vN0tJSlZaWevaLi4t9FC0AAAAAAAAAoCGxbQV6Xl6exo4dq6VLl6pp06bV9nM4HF77xpgqbRVlZmYqKirKs7Vt29ZnMQMAAAAAAAAAGg7bCujbt29XQUGBevToobCwMIWFhSk7O1vPPvuswsLCPCvPy1eilysoKKiyKr2iSZMmqaioyLPl5eXV6zgAAAAAAAAAAKHJtlu4DBgwQLt27fJqe/DBB3XFFVfoiSee0GWXXSaXy6WsrCx1795dknTy5EllZ2dr1qxZ1V7X6XTK6XTWa+wAAAAAAAAAgNBnWwE9IiJCiYmJXm3NmzdXy5YtPe3p6enKyMhQQkKCEhISlJGRoWbNmmno0KF2hAwAAAAAAAAAaEBsfYjouUyYMEHHjx/XyJEjVVhYqF69emn9+vWKiIiwOzQAAAAAAAAAQIiz7R7oVjZu3Ki5c+d69h0Oh9xutw4ePKgTJ04oOzu7yqp1AADgW++9954GDx6s2NhYORwOrV692nPs1KlTeuKJJ9SlSxc1b95csbGxGjZsmL755huva5SWlmrMmDFq1aqVmjdvrltvvVVfffWVn0cCAAAAAMD5CagCOgAAsF9JSYm6deum+fPnVzl27Ngxffjhh3ryySf14YcfauXKlfrss8906623evVLT0/XqlWrtHz5cm3atElHjx7VLbfcojNnzvhrGAAAAAAAnLeAvoULAADwv5SUFKWkpFgei4qKUlZWllfbvHnzdPXVV+vAgQNq166dioqKtHDhQv3lL3/RwIEDJUlLly5V27Zt9fbbb+vGG2+s9zEAAAAAAOALrEAHAADnpaioSA6HQxdddJEkafv27Tp16pSSk5M9fWJjY5WYmKjNmzfbFCUAAAAAALXHCnQAAFBnJ06c0MSJEzV06FBFRkZKkvLz89WkSRNdfPHFXn2jo6OVn59f7bVKS0tVWlrq2S8uLq6foAEAAAAAqCEK6AAAoE5OnTqle+65R2VlZXruuefO2d8YI4fDUe3xzMxMTZs2zZchAn7TfuJan1xn38xUn1wHAAAAgG9wCxcAAFBrp06d0l133aXc3FxlZWV5Vp9Lksvl0smTJ1VYWOh1TkFBgaKjo6u95qRJk1RUVOTZ8vLy6i1+AAAAAABqggI6AAColfLi+d69e/X222+rZcuWXsd79Oihxo0bez1s9ODBg/r444/Vt2/faq/rdDoVGRnptQEAAAAAYCdu4QIAALwcPXpUn3/+uWc/NzdXOTk5atGihWJjY/Wzn/1MH374oV5//XWdOXPGc1/zFi1aqEmTJoqKitLDDz+s8ePHq2XLlmrRooUee+wxdenSRQMHDrRrWAAAAAAA1BoFdAAA4GXbtm3q37+/Z3/cuHGSpLS0NLndbq1Zs0aS9JOf/MTrvA0bNigpKUmS9Pvf/15hYWG66667dPz4cQ0YMECLFy9Wo0aN/DIGAAAAAAB8gQI6AADwkpSUJGNMtcfPdqxc06ZNNW/ePM2bN8+XoQEAAAAA4FfcAx0AAAAAAAAAAAsU0AEAAAAAAAAAsEABHQAAAAAAAAAAC9wDHQAAAAAAADhP7Seu9drfNzP1vPoBCAysQAcAAAAAAAAAwAIFdAAAAAAAAAAALFBABwAAAAAAAADAAgV0AAAAAAAAAAAs8BBRAAAAAD5R+aFodcGD1AAAABBIWIEOAAAAAEADsGDBAnXt2lWRkZGKjIxUnz599Oabb3qOG2PkdrsVGxur8PBwJSUlaffu3TZGDACA/SigAwAAAADQALRp00YzZ87Utm3btG3bNt1www267bbbPEXy2bNna86cOZo/f762bt0ql8ulQYMG6ciRIzZHDgCAfSigAwAAAADQAAwePFg333yzOnTooA4dOmjGjBm68MILtWXLFhljNHfuXE2ZMkVDhgxRYmKilixZomPHjmnZsmV2hw4AgG0ooAMAAAAA0MCcOXNGy5cvV0lJifr06aPc3Fzl5+crOTnZ08fpdKpfv37avHmzjZECAGAvHiIKAAAAAEADsWvXLvXp00cnTpzQhRdeqFWrVqlTp06eInl0dLRX/+joaO3fv7/a65WWlqq0tNSzX1xcXD+BAwBgE1agAwAAAADQQHTs2FE5OTnasmWLfvnLXyotLU2ffPKJ57jD4fDqb4yp0lZRZmamoqKiPFvbtm3rLXYAAOxAAR0AAAAAgAaiSZMmuvzyy9WzZ09lZmaqW7dueuaZZ+RyuSRJ+fn5Xv0LCgqqrEqvaNKkSSoqKvJseXl59Ro/AAD+RgEdAAAAAIAGyhij0tJSxcfHy+VyKSsry3Ps5MmTys7OVt++fas93+l0KjIy0msDACCUcA90AAAAAAAagMmTJyslJUVt27bVkSNHtHz5cm3cuFHr1q2Tw+FQenq6MjIylJCQoISEBGVkZKhZs2YaOnSo3aEDAGAbCugAzqn9xLWef++bmWpjJAAAAADq6ttvv9UDDzyggwcPKioqSl27dtW6des0aNAgSdKECRN0/PhxjRw5UoWFherVq5fWr1+viIgImyMHAMA+FNABAAAAAGgAFi5ceNbjDodDbrdbbrfbPwEBABAEuAc6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYIGHiAIAAAAAAAABpv3EtV77+2am2hQJ0LCxAh0AAAAAAAAAAAsU0AEAAAAAAAAAsEABHQAAAAAAAAAACxTQAQAAAAAAAACwQAEdAAAAAAAAAAALFNABAAAAAAAAALBAAR0AAAAAAAAAAAsU0AEAAAAAAAAAsEABHQAAAAAAAAAACxTQAQAAAAAAAACwEGZ3AEAoaj9xreff+2am2hgJAAAAAAAAgLpiBToAAAAAAAAAABYooAMAAAAAAAAAYIECOgAAAAAAAAAAFiigAwAAAAAAAABggQI6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYCHM7gAA1E77iWu99vfNTLUpEgAAAAAAACC0sQIdAAB4ee+99zR48GDFxsbK4XBo9erVXseNMXK73YqNjVV4eLiSkpK0e/durz6lpaUaM2aMWrVqpebNm+vWW2/VV1995cdRAAAAAABw/iigAwAALyUlJerWrZvmz59veXz27NmaM2eO5s+fr61bt8rlcmnQoEE6cuSIp096erpWrVql5cuXa9OmTTp69KhuueUWnTlzxl/DAAAAAADgvHELFwAA4CUlJUUpKSmWx4wxmjt3rqZMmaIhQ4ZIkpYsWaLo6GgtW7ZMI0aMUFFRkRYuXKi//OUvGjhwoCRp6dKlatu2rd5++23deOONfhsLAAAAAADngxXoAACgxnJzc5Wfn6/k5GRPm9PpVL9+/bR582ZJ0vbt23Xq1CmvPrGxsUpMTPT0sVJaWqri4mKvDQAAAAAAO1FABwAANZafny9Jio6O9mqPjo72HMvPz1eTJk108cUXV9vHSmZmpqKiojxb27ZtfRw9AAAAAAC1QwEdAADUmsPh8No3xlRpq+xcfSZNmqSioiLPlpeX55NYAQAAAACoKwroAACgxlwulyRVWUleUFDgWZXucrl08uRJFRYWVtvHitPpVGRkpNcGAAAAAICdeIgogFprP3Gt1/6+mamWbQBCT3x8vFwul7KystS9e3dJ0smTJ5Wdna1Zs2ZJknr06KHGjRsrKytLd911lyTp4MGD+vjjjzV79mzbYgcAAAAAoLYooAMAAC9Hjx7V559/7tnPzc1VTk6OWrRooXbt2ik9PV0ZGRlKSEhQQkKCMjIy1KxZMw0dOlSSFBUVpYcffljjx49Xy5Yt1aJFCz322GPq0qWLBg4caNewAAAAAACoNQroAADAy7Zt29S/f3/P/rhx4yRJaWlpWrx4sSZMmKDjx49r5MiRKiwsVK9evbR+/XpFRER4zvn973+vsLAw3XXXXTp+/LgGDBigxYsXq1GjRn4fDwAAAAAAdUUBHQAAeElKSpIxptrjDodDbrdbbre72j5NmzbVvHnzNG/evHqIEDg/lW87VhfcqgwAAABoGCigAwAAAAAAAPWA54UBwe8CuwMAAAAAAAAAACAQUUAHAAAAAAAAAMACBXQAAAAAAAAAACxQQAcAAAAAAAAAwAIPEQVCAA8lAQAAAAAAAHyPFegAAAAAADQAmZmZuuqqqxQREaHWrVvr9ttv1549e7z6DB8+XA6Hw2vr3bu3TREDAGA/CugAAAAAADQA2dnZGjVqlLZs2aKsrCydPn1aycnJKikp8ep300036eDBg57tjTfesCliAADsxy1cAAAAAABoANatW+e1v2jRIrVu3Vrbt2/X9ddf72l3Op1yuVz+Dg8AgIBk6wr0BQsWqGvXroqMjFRkZKT69OmjN99803PcGCO3263Y2FiFh4crKSlJu3fvtjFiAAAAAABCQ1FRkSSpRYsWXu0bN25U69at1aFDBz3yyCMqKCio9hqlpaUqLi722gAACCW2rkBv06aNZs6cqcsvv1yStGTJEt12223asWOHOnfurNmzZ2vOnDlavHixOnTooOnTp2vQoEHas2ePIiIi7AwdAAAAAICgZYzRuHHjdO211yoxMdHTnpKSojvvvFNxcXHKzc3Vk08+qRtuuEHbt2+X0+mscp3MzExNmzbNn6ED59R+4lqv/X0zU22KpObOJ+ZAG2+gxQOcL1tXoA8ePFg333yzOnTooA4dOmjGjBm68MILtWXLFhljNHfuXE2ZMkVDhgxRYmKilixZomPHjmnZsmV2hg0AAAAAQFAbPXq0du7cqVdeecWr/e6771ZqaqoSExM1ePBgvfnmm/rss8+0du1ay+tMmjRJRUVFni0vL88f4QMA4DcB8xDRM2fOaPny5SopKVGfPn2Um5ur/Px8JScne/o4nU7169dPmzdvtjFSAAAAAACC15gxY7RmzRpt2LBBbdq0OWvfmJgYxcXFae/evZbHnU6n57as5RsAAKHE9oeI7tq1S3369NGJEyd04YUXatWqVerUqZOnSB4dHe3VPzo6Wvv376/2eqWlpSotLfXsc/81AAAAAAB+uG3LmDFjtGrVKm3cuFHx8fHnPOfQoUPKy8tTTEyMHyIEACDw2F5A79ixo3JycnT48GG99tprSktLU3Z2tue4w+Hw6m+MqdJWEfdfQ7Co73uCVb5+ZdyDDAAAAGhYRo0apWXLlunvf/+7IiIilJ+fL0mKiopSeHi4jh49KrfbrZ/+9KeKiYnRvn37NHnyZLVq1Up33HGHzdEDAGAP22/h0qRJE11++eXq2bOnMjMz1a1bNz3zzDNyuVyS5Eno5QoKCqqsSq+I+68BAAAAAFDVggULVFRUpKSkJMXExHi2FStWSJIaNWqkXbt26bbbblOHDh2UlpamDh066P3331dERITN0QMAYA/bV6BXZoxRaWmp4uPj5XK5lJWVpe7du0uSTp48qezsbM2aNava851Op+WTwQEAAAAAaMiMMWc9Hh4errfeestP0QAAEBxsLaBPnjxZKSkpatu2rY4cOaLly5dr48aNWrdunRwOh9LT05WRkaGEhAQlJCQoIyNDzZo109ChQ+0MGwAAAAAAAADQANhaQP/222/1wAMP6ODBg4qKilLXrl21bt06DRo0SJI0YcIEHT9+XCNHjlRhYaF69eql9evX89ExAAAAAAAAAEC9s7WAvnDhwrMedzgccrvdcrvd/gkIAAAAAAAAAID/Y/tDRAEAAAAAAAAACEQB9xBRAAAAACjXfuJan1xn38xUn1wHABCcKucT8kL1rHIv3y80ZBTQgQBXMXGFQsIKtfEAAAAAAAAgdHELFwAAAAAAAAAALFBABwAAAAAAAADAAgV0AAAAAAAAAAAsUEAHAAAAAAAAAMACBXQAAAAAAAAAACxQQAcAAAAAAAAAwAIFdAAAAAAAAAAALFBABwAAAAAAAADAAgV0AAAAAAAAAAAsUEAHAAAAAAAAAMACBXQAAAAAAAAAACxQQAcAAAAAAAAAwEKdCui5ubm+jgMAAJwn8jMAAKGLPA8AgD3qVEC//PLL1b9/fy1dulQnTpzwdUwAAKAOyM8AAIQu8jwAAPaoUwH9o48+Uvfu3TV+/Hi5XC6NGDFCH3zwga9jAwAAtUB+BgAgdJHnAQCwR50K6ImJiZozZ46+/vprLVq0SPn5+br22mvVuXNnzZkzR//5z398HScAADgH8jMAAKGLPA8AgD3O6yGiYWFhuuOOO/TXv/5Vs2bN0hdffKHHHntMbdq00bBhw3Tw4EFfxQkAAGqI/AwAQOgizwMA4F/nVUDftm2bRo4cqZiYGM2ZM0ePPfaYvvjiC7377rv6+uuvddttt/kqTgB+0n7iWq8NQPAhPwMAELrI8wAA+FdYXU6aM2eOFi1apD179ujmm2/WSy+9pJtvvlkXXPBDPT4+Pl5//OMfdcUVV/g0WAAAUD3yMwAAoYs8DwCAPepUQF+wYIEeeughPfjgg3K5XJZ92rVrp4ULF55XcAAAoObIzwAAhC7yPIDzVflT5vtmpvr1fNQ/XqP6UacC+t69e8/Zp0mTJkpLS6vL5QEAQB2QnwEACF3keQAA7FGne6AvWrRIr776apX2V199VUuWLDnvoAAAQO35Kz+fPn1av/71rxUfH6/w8HBddtll+u1vf6uysjJPH2OM3G63YmNjFR4erqSkJO3evdtnMQAA0NAwDwcAwB51KqDPnDlTrVq1qtLeunVrZWRknHdQAACg9vyVn2fNmqXnn39e8+fP16effqrZs2frqaee0rx58zx9Zs+erTlz5mj+/PnaunWrXC6XBg0apCNHjvgsDgAAGhLm4QAA2KNOBfT9+/crPj6+SntcXJwOHDhw3kEBAIDa81d+fv/993XbbbcpNTVV7du3189+9jMlJydr27Ztkn5YfT537lxNmTJFQ4YMUWJiopYsWaJjx45p2bJlPosDAICGhHk4AAD2qFMBvXXr1tq5c2eV9o8++kgtW7Y876AAAEDt+Ss/X3vttXrnnXf02Wefea6/adMm3XzzzZKk3Nxc5efnKzk52XOO0+lUv379tHnzZp/FAQBAQ8I8HAAAe9TpIaL33HOPHn30UUVEROj666+XJGVnZ2vs2LG65557fBogEOh4wjGAQOGv/PzEE0+oqKhIV1xxhRo1aqQzZ85oxowZuvfeeyVJ+fn5kqTo6Giv86Kjo7V///5qr1taWqrS0lLPfnFxsc9iBgAg2DEPBwDAHnUqoE+fPl379+/XgAEDFBb2wyXKyso0bNgw7r0GAIBN/JWfV6xYoaVLl2rZsmXq3LmzcnJylJ6ertjYWKWlpXn6ORwOr/OMMVXaKsrMzNS0adN8FicAAKGEeTgAAPaoUwG9SZMmWrFihX73u9/po48+Unh4uLp06aK4uDhfxwcAAGrIX/n58ccf18SJEz2r3bp06aL9+/crMzNTaWlpcrlckn5YiR4TE+M5r6CgoMqq9IomTZqkcePGefaLi4vVtm1bn8YOAECwYh4OAIA96lRAL9ehQwd16NDBV7EAAAAfqO/8fOzYMV1wgfdjVBo1aqSysjJJUnx8vFwul7KystS9e3dJ0smTJ5Wdna1Zs2ZVe12n0ymn01lvcQMAEAqYhwMA4F91KqCfOXNGixcv1jvvvKOCggLPhLncu+++65PgAABAzfkrPw8ePFgzZsxQu3bt1LlzZ+3YsUNz5szRQw89JOmHW7ekp6crIyNDCQkJSkhIUEZGhpo1a6ahQ4f6JAYAABoa5uGA7wXjM82CMebqhNJYENrqVEAfO3asFi9erNTUVCUmJp71fqYAAMA//JWf582bpyeffFIjR45UQUGBYmNjNWLECP3mN7/x9JkwYYKOHz+ukSNHqrCwUL169dL69esVERFRLzEBABDqmIcDAGCPOhXQly9frr/+9a+6+eabfR0PAACoI3/l54iICM2dO1dz586tto/D4ZDb7Zbb7a7XWAAAaCiYhwMAYI86P0T08ssv93UsAADgPJCfEWoqf6y3LvgoMIBQQZ4HAMAeF5y7S1Xjx4/XM888I2OMr+MBAAB1RH4GACB0kecBALBHnVagb9q0SRs2bNCbb76pzp07q3Hjxl7HV65c6ZPgADvxMAsAwYb8DABA6CLPAwBgjzoV0C+66CLdcccdvo4FAACcB/IzAAChyxd5PjMzUytXrtS///1vhYeHq2/fvpo1a5Y6duzo6WOM0bRp0/TCCy94HgT+hz/8QZ07dz7fIQAAEJTqVEBftGiRr+MAAADnifwMAEDo8kWez87O1qhRo3TVVVfp9OnTmjJlipKTk/XJJ5+oefPmkqTZs2drzpw5Wrx4sTp06KDp06dr0KBB2rNnjyIiIs47BgAAgk2d7oEuSadPn9bbb7+tP/7xjzpy5Igk6ZtvvtHRo0d9FhwAAKgd8jMAAKHrfPP8unXrNHz4cHXu3FndunXTokWLdODAAW3fvl3SD6vP586dqylTpmjIkCFKTEzUkiVLdOzYMS1btqzexgUAQCCr0wr0/fv366abbtKBAwdUWlqqQYMGKSIiQrNnz9aJEyf0/PPP+zpOAABwDuRnAABCV33k+aKiIklSixYtJEm5ubnKz89XcnKyp4/T6VS/fv20efNmjRgxwjeDAQAgiNRpBfrYsWPVs2dPFRYWKjw83NN+xx136J133vFZcAAAoObIzwAAhC5f53ljjMaNG6drr71WiYmJkqT8/HxJUnR0tFff6Ohoz7HKSktLVVxc7LUBABBK6rQCfdOmTfrnP/+pJk2aeLXHxcXp66+/9klgAACgdsjPAACELl/n+dGjR2vnzp3atGlTlWMOh8Nr3xhTpa1cZmampk2bVuuvDwS79hPXeu3vm5lqUyQA6ludVqCXlZXpzJkzVdq/+uorHioCAIBNyM8AAIQuX+b5MWPGaM2aNdqwYYPatGnjaXe5XJJUZbV5QUFBlVXp5SZNmqSioiLPlpeXV6tYAAAIdHUqoA8aNEhz58717DscDh09elRTp07VzTff7KvYgJDRfuJarw0A6gP5GQCA0OWLPG+M0ejRo7Vy5Uq9++67io+P9zoeHx8vl8ulrKwsT9vJkyeVnZ2tvn37Wl7T6XQqMjLSawMAIJTU6RYuv//979W/f3916tRJJ06c0NChQ7V37161atVKr7zyiq9jBAAANUB+BgAgdPkiz48aNUrLli3T3//+d0VERHhWmkdFRSk8PFwOh0Pp6enKyMhQQkKCEhISlJGRoWbNmmno0KH1OTwAAAJWnQrosbGxysnJ0SuvvKIPP/xQZWVlevjhh3Xfffd5PcwEAAD4D/kZAIDQ5Ys8v2DBAklSUlKSV/uiRYs0fPhwSdKECRN0/PhxjRw5UoWFherVq5fWr1/P7eAAAA1WnQrokhQeHq6HHnpIDz30kC/jAQAA54H8DABA6DrfPG+MOWcfh8Mht9stt9tdp68BAECoqVMB/aWXXjrr8WHDhtUpGAAAUHfkZwAAQhd5HgAAe9SpgD527Fiv/VOnTunYsWNq0qSJmjVrRuIGAMAG5GcAAEIXeR4AAHtcUJeTCgsLvbajR49qz549uvbaa3lIGQAANiE/AwAQusjzAADYo04FdCsJCQmaOXNmlb+KAwAA+5CfAQAIXeR5AADqX50fImqlUaNG+uabb3x5SQAAcJ7IzwAAhC7yPIJN+4lrvfb3zUz1y7lAqPH1+6Hy9XxxzVBRpwL6mjVrvPaNMTp48KDmz5+va665xieBAf5W8T8K/oPwjZr8Z84vQIDvkJ8BAAhd5HkAAOxRpwL67bff7rXvcDh0ySWX6IYbbtDTTz/ti7gAAEAtkZ8BAAhd5HkAAOxRpwJ6WVmZr+MAAADnifwMAEDoIs8DAGAPnz1EFAAAAAAAAACAUFKnFejjxo2rcd85c+bU5UsAAIBaIj8DABC6yPMAANijTgX0HTt26MMPP9Tp06fVsWNHSdJnn32mRo0a6corr/T0czgcvokSAACcE/kZAIDQRZ4HAMAedSqgDx48WBEREVqyZIkuvvhiSVJhYaEefPBBXXfddRo/frxPgwQAAOdGfgYAIHSR5wEAsEed7oH+9NNPKzMz05O0Jeniiy/W9OnTefo3AAA2IT8DABC6yPMAANijTgX04uJiffvtt1XaCwoKdOTIkfMOCgAA1B75GQCA0EWeBwDAHnW6hcsdd9yhBx98UE8//bR69+4tSdqyZYsef/xxDRkyxKcBAg1J+4lrvfb3zUy1KRIAwYj8DABA6CLPA9aYRwcHXicEszoV0J9//nk99thjuv/++3Xq1KkfLhQWpocfflhPPfWUTwMEAAA1Q34GACB0kecBALBHnQrozZo103PPPaennnpKX3zxhYwxuvzyy9W8eXNfxwcAAGqI/AwAQOgizwMAYI863QO93MGDB3Xw4EF16NBBzZs3lzHGV3EBAIA6Ij8DABC6yPMAAPhXnQrohw4d0oABA9ShQwfdfPPNOnjwoCTp5z//ucaPH+/TAAEAQM2QnwEACF3keQAA7FGnAvqvfvUrNW7cWAcOHFCzZs087XfffbfWrVvns+AAAEDNkZ8BAAhd5HkAAOxRp3ugr1+/Xm+99ZbatGnj1Z6QkKD9+/f7JDAAAFA75GcAAEIXeR4AAHvUaQV6SUmJ11+8y3333XdyOp3nHRQAAKg98jMAAKGLPA8AgD3qVEC//vrr9dJLL3n2HQ6HysrK9NRTT6l///4+Cw4AANQc+RkAgNBFngcAwB51uoXLU089paSkJG3btk0nT57UhAkTtHv3bn3//ff65z//6esYAQBADZCfAQAIXeR5AADsUacV6J06ddLOnTt19dVXa9CgQSopKdGQIUO0Y8cO/ehHP/J1jAAAoAbIzwAAhC7yPAAA9qj1CvRTp04pOTlZf/zjHzVt2rT6iAkAANQS+RkAgNBFnkeoaz9xrdf+vpmpNkViLdDjOx/BMLZgiDGQWX3/+J7WTq1XoDdu3Fgff/yxHA7HeX/xzMxMXXXVVYqIiFDr1q11++23a8+ePV59jDFyu92KjY1VeHi4kpKStHv37vP+2gAAhBJf5mcAABBYyPMAANinTrdwGTZsmBYuXHjeXzw7O1ujRo3Sli1blJWVpdOnTys5OVklJSWePrNnz9acOXM0f/58bd26VS6XS4MGDdKRI0fO++sDABBKfJWfAQBA4CHPAwBgjzo9RPTkyZP605/+pKysLPXs2VPNmzf3Oj5nzpwaXWfdunVe+4sWLVLr1q21fft2XX/99TLGaO7cuZoyZYqGDBkiSVqyZImio6O1bNkyjRgxoi7hAwAQknyVnwEAQOAhzwMAYI9aFdC//PJLtW/fXh9//LGuvPJKSdJnn33m1ed8PlJWVFQkSWrRooUkKTc3V/n5+UpOTvb0cTqd6tevnzZv3kwBHQAA1X9+BgAA9iHPAwBgr1oV0BMSEnTw4EFt2LBBknT33Xfr2WefVXR09HkHYozRuHHjdO211yoxMVGSlJ+fL0lVrh8dHa39+/dbXqe0tFSlpaWe/eLi4vOODQCAQFaf+RkAANiLPA8AgL1qdQ90Y4zX/ptvvul1v/LzMXr0aO3cuVOvvPJKlWOV/5pujKn2L+yZmZmKiorybG3btvVJfID0w5OLK24AEAjqMz9X5+uvv9b999+vli1bqlmzZvrJT36i7du3e8XEQ8ABADh/duR5AADwX3V6iGi5yom8rsaMGaM1a9Zow4YNatOmjafd5XJJ+u9K9HIFBQXV/rV90qRJKioq8mx5eXk+iREAgGDhq/xcncLCQl1zzTVq3Lix3nzzTX3yySd6+umnddFFF3n68BBwAADqR33neQAA4K1Wt3BxOBxVVn6fz73WjDEaM2aMVq1apY0bNyo+Pt7reHx8vFwul7KystS9e3dJPzw4JTs7W7NmzbK8ptPplNPprHNMAAAEG1/n53OZNWuW2rZtq0WLFnna2rdv7/k3DwEHEAx88WnCfTNTfRAJcHb+zvMAAMBbrQroxhgNHz7cU6A+ceKEfvGLX1R5+vfKlStrdL1Ro0Zp2bJl+vvf/66IiAjPSvOoqCiFh4fL4XAoPT1dGRkZSkhIUEJCgjIyMtSsWTMNHTq0NqEDABCyfJ2fz2XNmjW68cYbdeeddyo7O1uXXnqpRo4cqUceeUQSDwEHAMCX/J3nAQCAt1oV0NPS0rz277///vP64gsWLJAkJSUlebUvWrRIw4cPlyRNmDBBx48f18iRI1VYWKhevXpp/fr1ioiIOK+vDQBAqPB1fj6XL7/8UgsWLNC4ceM0efJkffDBB3r00UfldDo1bNiwOj0EXOJB4AAAWPF3ngcAAN5qVUCv+FFtX6jJvdscDofcbrfcbrdPvzYAAKHC1/n5XMrKytSzZ09lZGRIkrp3767du3drwYIFGjZsmKdfbR4CLv3wIPBp06bVT9AAAAQpf+d5AADg7bweIgoAABqemJgYderUyavtxz/+sQ4cOCCpbg8Bl3gQOAAAAAAg8FBABwAAtXLNNddoz549Xm2fffaZ4uLiJHk/BLxc+UPA+/btW+11nU6nIiMjvTYAAAAAAOxUq1u4AKGi/cS1Xvv7ZqbaFAlqyuo1q9jGawj4z69+9Sv17dtXGRkZuuuuu/TBBx/ohRde0AsvvCBJPAQcAAAAABAyKKADAIBaueqqq7Rq1SpNmjRJv/3tbxUfH6+5c+fqvvvu8/ThIeAAAAAAgFDALVwAAECt3XLLLdq1a5dOnDihTz/9VI888ojX8fKHgB88eFAnTpxQdna2EhMTbYoWAABI0nvvvafBgwcrNjZWDodDq1ev9jo+fPhwORwOr6137972BAsAQICggA4AAAAAQANQUlKibt26af78+dX2uemmm3Tw4EHP9sYbb/gxQgAAAg+3cAEAAAAAoAFISUlRSkrKWfs4nU65XC4/RQQAQOBjBToAAAAAAJAkbdy4Ua1bt1aHDh30yCOPqKCgwO6QAACwFSvQAQAAAACAUlJSdOeddyouLk65ubl68skndcMNN2j79u1yOp2W55SWlqq0tNSzX1xc7K9wAQDwCwroAAAAAABAd999t+ffiYmJ6tmzp+Li4rR27VoNGTLE8pzMzExNmzbNXyGiAWk/ca3X/r6ZqTZFgrPhdfIPvs/24hYuAAAAAACgipiYGMXFxWnv3r3V9pk0aZKKioo8W15enh8jBACg/rECHSGPv9IBAAAAQO0dOnRIeXl5iomJqbaP0+ms9vYuAACEAgroAAAAAAA0AEePHtXnn3/u2c/NzVVOTo5atGihFi1ayO1266c//aliYmK0b98+TZ48Wa1atdIdd9xhY9QAANiLAjoAAAAAAA3Atm3b1L9/f8/+uHHjJElpaWlasGCBdu3apZdeekmHDx9WTEyM+vfvrxUrVigiIsKukAEAsB0FdAAAAAAAGoCkpCQZY6o9/tZbb/kxGgAAggMPEQUAAAAAAAAAwAIFdAAAAAAAAAAALFBABwAAAAAAAADAAgV0AAAAAAAAAAAs8BBRAAAAAAAA1Fj7iWu99vfNTLUpElQnWF+jmsYdrONDcKKAjpDCf6ChgdcRAAAAAAAAgYBbuAAAAAAAAAAAYIECOgAAAAAAAAAAFiigAwAAAAAAAABggQI6AAAAAAAAAAAWKKADAAAAAAAAAGCBAjoAAAAAAAAAABYooAMAAAAAAAAAYCHM7gCA89F+4lq7Q0AAqfzzsG9mqk2RAAAAAAAAIBSwAh0AAAAAAAAAAAusQAcAAAAAAAAQcvikOnyBFegAAAAAAAAAAFiggA4AAAAAAAAAgAUK6AAAAAAAAAAAWKCADgAAAAAAAACABQroAAAAAAAAAABYoIAOAAAAAAAAAICFMLsDAIBg1n7iWs+/981MtTESAAAAAAAA+Bor0AEAAAAAAAAAsEABHQAAAAAAAAAAC9zCBQAAAAAAoIGreHtKiVtUAv5g9b7jvRh4WIEOAAAAAAAAAIAFCugAAAAAAAAAAFiggA4AAAAAAAAAgAUK6AAAAAAAAAAAWOAhoggaPEQBvlLxZ4mfIwAAAAAAAFSHFegAAAAAAAAAAFiggA4AAAAAAAAAgAUK6AAAAAAAAAAAWKCADgAAAAAAAACABQroAADgvGRmZsrhcCg9Pd3TZoyR2+1WbGyswsPDlZSUpN27d9sXJAAAAAAAdRBmdwAAACB4bd26VS+88IK6du3q1T579mzNmTNHixcvVocOHTR9+nQNGjRIe/bsUUREhE3RAgAAoDbaT1xbpW3fzNQa9d03M9WyDUBw4X1MAR0AANTR0aNHdd999+nFF1/U9OnTPe3GGM2dO1dTpkzRkCFDJElLlixRdHS0li1bphEjRtgVMuqJ1eS6thriL+IAAAAAAh+3cAEAAHUyatQopaamauDAgV7tubm5ys/PV3JysqfN6XSqX79+2rx5c7XXKy0tVXFxsdcGAAAAAICdWIGOgMTHQ2A3Pn4InN3y5cv14YcfauvWrVWO5efnS5Kio6O92qOjo7V///5qr5mZmalp06b5NlAAAAAAAM4DK9ABAECt5OXlaezYsVq6dKmaNm1abT+Hw+G1b4yp0lbRpEmTVFRU5Nny8vJ8FjMAAAAAAHXBCnQAAFAr27dvV0FBgXr06OFpO3PmjN577z3Nnz9fe/bskfTDSvSYmBhPn4KCgiqr0ityOp1yOp31FzgAAAAAALXECnQAAFArAwYM0K5du5STk+PZevbsqfvuu085OTm67LLL5HK5lJWV5Tnn5MmTys7OVt++fW2MHACAhu29997T4MGDFRsbK4fDodWrV3sdN8bI7XYrNjZW4eHhSkpK0u7du+0JFgCAAEEBHQAA1EpERIQSExO9tubNm6tly5ZKTEyUw+FQenq6MjIytGrVKn388ccaPny4mjVrpqFDh9odPgAADVZJSYm6deum+fPnWx6fPXu25syZo/nz52vr1q1yuVwaNGiQjhw54udIAQAIHNzCBQAA+NyECRN0/PhxjRw5UoWFherVq5fWr1+viIgIu0MDAKDBSklJUUpKiuUxY4zmzp2rKVOmaMiQIZKkJUuWKDo6WsuWLdOIESP8GSoAAAGDAjoAADhvGzdu9Np3OBxyu91yu922xAMAAGonNzdX+fn5Sk5O9rQ5nU7169dPmzdvrraAXlpaqtLSUs9+cXFxvccKAIA/UUAHAAAAAKCBy8/Pl6QqD/yOjo7W/v37qz0vMzNT06ZNq9fYcH7aT1zrtb9vZqpNkQCBgfcEaot7oAMAAAAAAEk/fIqsImNMlbaKJk2apKKiIs+Wl5dX3yECAOBXrEAH0ODx12cAAAA0dC6XS9IPK9FjYmI87QUFBVVWpVfkdDrldDrrPT4AAOzCCnQAAAAAABq4+Ph4uVwuZWVledpOnjyp7Oxs9e3b18bIAACwFyvQAQAAAABoAI4eParPP//cs5+bm6ucnBy1aNFC7dq1U3p6ujIyMpSQkKCEhARlZGSoWbNmGjp0qI1RAwBgLwroAAAAAAA0ANu2bVP//v09++PGjZMkpaWlafHixZowYYKOHz+ukSNHqrCwUL169dL69esVERFhV8gAANiOAjoAAAAAAA1AUlKSjDHVHnc4HHK73XK73f4LCgCAAEcBHQAAoIGo/NDkuuJhywAAAAAaCh4iCgAAAAAAAACABQroAAAAAAAAAABY4BYuDVzlj3Lb9ZHsinHwsXAAAAAAAAAAgYACOgAAAAAAQAio6SK5QFlMB/gSP9eoL9zCBQAAAAAAAAAACxTQAQAAAAAAAACwYGsB/b333tPgwYMVGxsrh8Oh1atXex03xsjtdis2Nlbh4eFKSkrS7t277QkWAAAAAAAAANCg2FpALykpUbdu3TR//nzL47Nnz9acOXM0f/58bd26VS6XS4MGDdKRI0f8HCkAAAAAAAAAoKGx9SGiKSkpSklJsTxmjNHcuXM1ZcoUDRkyRJK0ZMkSRUdHa9myZRoxYoQ/QwUAAAAAAAAANDABew/03Nxc5efnKzk52dPmdDrVr18/bd682cbIAAAAAAAAAAANga0r0M8mPz9fkhQdHe3VHh0drf3791d7XmlpqUpLSz37xcXF9RMgAAAAAFTSfuLa877GvpmpPogEAAAAvhCwBfRyDofDa98YU6WtoszMTE2bNq2+w2pwKk8EavpLfV3PAwAAAAAAAAC7BewtXFwul6T/rkQvV1BQUGVVekWTJk1SUVGRZ8vLy6vXOAEAAAAAAAAAoSlgV6DHx8fL5XIpKytL3bt3lySdPHlS2dnZmjVrVrXnOZ1OOZ1Of4UJAAAAAADgd3ziG/Cdmr6feN/9oKF9H2wtoB89elSff/65Zz83N1c5OTlq0aKF2rVrp/T0dGVkZCghIUEJCQnKyMhQs2bNNHToUBujBgAAAAAAAAA0BLYW0Ldt26b+/ft79seNGydJSktL0+LFizVhwgQdP35cI0eOVGFhoXr16qX169crIiLCrpABAAAAAAAAAA2ErQX0pKQkGWOqPe5wOOR2u+V2u/0XFAAAAAAAAAAACuCHiAIAAAAAAAAAYCcK6AAAAAAAAAAAWLD1Fi4AUN8a2pOhAQAAAAAA4DusQAcAAAAAAAAAwAIFdAAAAAAAAAAALFBABwAAAAAAAADAAgV0AAAAAAAAAAAsUEAHAAAAAAAAAMACBXQAAAAAAAAAACxQQAcAAAAAAAAAwAIFdAAAAAAAAAAALITZHQCCV/uJaz3/3jcz1Wu/vA2ANd4vAAAAAAAAgY8V6AAAAAAAAAAAWKCADgAAAAAAAACABQroAAAAAAAAAABYoIAOAAAAAAAAAIAFCugAAAAAAAAAAFgIszsAAAAAAAAAAAgk7Seu9drfNzO1xv1qem4oCeXvAwV0AAAAAAhglSefdRWsk1YAAAA7cQsXAAAAAAAAAAAssAIdfhcqH98ArNjxkSXeU/C3zMxMrVy5Uv/+978VHh6uvn37atasWerYsaOnjzFG06ZN0wsvvKDCwkL16tVLf/jDH9S5c2cbIwcAAAAAoHZYgQ4AAGolOztbo0aN0pYtW5SVlaXTp08rOTlZJSUlnj6zZ8/WnDlzNH/+fG3dulUul0uDBg3SkSNHbIwcAAAAAIDaYQU6AAColXXr1nntL1q0SK1bt9b27dt1/fXXyxijuXPnasqUKRoyZIgkacmSJYqOjtayZcs0YsQIO8IGAAAAAKDWWIEOAADOS1FRkSSpRYsWkqTc3Fzl5+crOTnZ08fpdKpfv37avHlztdcpLS1VcXGx1wYAAPzL7XbL4XB4bS6Xy+6wAACwDQV0AABQZ8YYjRs3Ttdee60SExMlSfn5+ZKk6Ohor77R0dGeY1YyMzMVFRXl2dq2bVt/gQMAgGp17txZBw8e9Gy7du2yOyQAAGzDLVwAAECdjR49Wjt37tSmTZuqHHM4HF77xpgqbRVNmjRJ48aN8+wXFxdTRAcAwAZhYWGsOgcA4P+wAh0AANTJmDFjtGbNGm3YsEFt2rTxtJdPuCuvNi8oKKiyKr0ip9OpyMhIrw0AAPjf3r17FRsbq/j4eN1zzz368ssvq+3LLdgAAKGOAjoAAKgVY4xGjx6tlStX6t1331V8fLzX8fj4eLlcLmVlZXnaTp48qezsbPXt29ff4QIAgFro1auXXnrpJb311lt68cUXlZ+fr759++rQoUOW/bkFm3+0n7jWawMA+A+3cEEVlZPxvpmpNkUCAAhEo0aN0rJly/T3v/9dERERnpXmUVFRCg8Pl8PhUHp6ujIyMpSQkKCEhARlZGSoWbNmGjp0qM3RAwCAs0lJSfH8u0uXLurTp49+9KMfacmSJV63WivHLdgAAKGOAjoAAKiVBQsWSJKSkpK82hctWqThw4dLkiZMmKDjx49r5MiRKiwsVK9evbR+/XpFRET4OVoAAHA+mjdvri5dumjv3r2Wx51Op5xOp5+jAgDAfyigAwCAWjHGnLOPw+GQ2+2W2+2u/4AAAEC9KS0t1aeffqrrrrvO7lAAALAF90AHAAAAAACSpMcee0zZ2dnKzc3Vv/71L/3sZz9TcXGx0tLS7A4NAABbsAIdAAAgAPniAWE8xwQAUFtfffWV7r33Xn333Xe65JJL1Lt3b23ZskVxcXF2hwYAgC0ooAMAAAAAAEnS8uXL7Q4BAICAwi1cAAAAAAAAAACwQAEdAAAAAAAAAAALFNABAAAAAAAAALDAPdCDVMUHi/GAMAAAAAAAAADwPQroAAAAAAAANqi4OE5igRwABCJu4QIAAAAAAAAAgAUK6AAAAAAAAAAAWKCADgAAAAAAAACABQroAAAAAAAAAABYoIAOAAAAAAAAAICFMLsDAAAACGbtJ64972vsm5nqg0gAAAAAAL5GAR0AAkTFIlx1xbTKhTpfF91qEgMAAAAAAEBDwS1cAAAAAAAAAACwQAEdAAAAAAAAAAAL3MIFAAAAAAAAAOpRfd+SFfWHFegAAAAAAAAAAFiggA4AAAAAAAAAgAUK6AAAAAAAAAAAWKCADgAAAAAAAACABQroAAAAAAAAAABYCLM7ANQfq6f7Vmzjab9Aw1aTJ4DzlHAAAAAAANCQsQIdAAAAAAAAAAALFNABAAAAAAAAALBAAR0AAAAAAAAAAAsU0AEAAAAAAAAAsMBDRAEAAAAAQFCp6cPua9rP16y+bqDHDAD+EIz/F1JABwAAAIAGqPLEtK4o7gEAgFDGLVwAAAAAAAAAALBAAR0AAAAAAAAAAAvcwqWWzuc+Zv6+FoDgFgj/twAAAAAAADRkrEAHAAAAAAAAAMACBXQAAAAAAAAAACxQQAcAAAAAAAAAwAIFdAAAAAAAAAAALFBABwAAAAAAAADAQpjdAQAAAAAAAFSn/cS1Xvv7Zqb65XpW/WraBgCouUD/f5QV6AAAAAAAAAAAWGAFuh9V/GtKbf6SEuh/hQHQsNRlJU5tVvUEqrr+H47AUfnnrS547QHg3Pj/FgAAhBJWoAMAAAAAAAAAYIECOgAAAAAAAAAAFriFCwAAAAAg4HFrGAAAYIegWIH+3HPPKT4+Xk2bNlWPHj30j3/8w+6QAABADZDDAQAITuRwAAB+EPAF9BUrVig9PV1TpkzRjh07dN111yklJUUHDhywOzQAAHAW5HAAAIITORwAgP8K+AL6nDlz9PDDD+vnP/+5fvzjH2vu3Llq27atFixYYHdoAADgLMjhAAAEJ3I4AAD/FdAF9JMnT2r79u1KTk72ak9OTtbmzZttigoAAJwLORwAgOBEDgcAwFtAP0T0u+++05kzZxQdHe3VHh0drfz8fMtzSktLVVpa6tkvKiqSJBUXF/skprLSY177xcXFlm3nOre68+rS5u/zAvlalQX7ePje1P+1AiEGX1+rskAZj5Wa/v8ZCGoynroov5YxxmfXDATBkMPrwiqWYLquL65ZX9fle1t/1+V7W3/X5XtQf9f158/t+Vwn1PK3VPscXt/5W/LdPLy+zm1IbYEWD2287rTVX1ugxWNrDjcB7OuvvzaSzObNm73ap0+fbjp27Gh5ztSpU40kNjY2Nja2oNry8vL8kVr9hhzOxsbGxtYQtlDL38bUPoeTv9nY2NjYgnGrTQ4P6BXorVq1UqNGjar8lbugoKDKX8PLTZo0SePGjfPsl5WV6fvvv1fLli3lcDjqFEdxcbHatm2rvLw8RUZG1ukadiF2ewRz7FJwx0/s9gnm+O2M3RijI0eOKDY21q9ft74FSg63WzC/L84lVMcWquOSQndsjCv4hMLYQjV/S7XP4czBqxcq45BCZyyMI/CEylgYR+Cpbix1yeEBXUBv0qSJevTooaysLN1xxx2e9qysLN12222W5zidTjmdTq+2iy66yCfxREZGBu0PD7HbI5hjl4I7fmK3TzDHb1fsUVFRfv+a9S3Qcrjdgvl9cS6hOrZQHZcUumNjXMEn2McWivlbqn0OZw5+bqEyDil0xsI4Ak+ojIVxBB6rsdQ2hwd0AV2Sxo0bpwceeEA9e/ZUnz599MILL+jAgQP6xS9+YXdoAADgLMjhAAAEJ3I4AAD/FfAF9LvvvluHDh3Sb3/7Wx08eFCJiYl64403FBcXZ3doAADgLMjhAAAEJ3I4AAD/FfAFdEkaOXKkRo4cadvXdzqdmjp1apWPpQUDYrdHMMcuBXf8xG6fYI4/mGMPdHbncLuF8s9WqI4tVMclhe7YGFfwCeWxhRI7c3io/IyEyjik0BkL4wg8oTIWxhF4fDkWhzHG+CAmAAAAAAAAAABCygV2BwAAAAAAAAAAQCCigA4AAAAAAAAAgAUK6AAAAAAAAAAAWKCAfg7PPfec4uPj1bRpU/Xo0UP/+Mc/7A7J0nvvvafBgwcrNjZWDodDq1ev9jpujJHb7VZsbKzCw8OVlJSk3bt32xNsBZmZmbrqqqsUERGh1q1b6/bbb9eePXu8+gRq7JK0YMECde3aVZGRkYqMjFSfPn305ptveo4HcuyVZWZmyuFwKD093dMWqPG73W45HA6vzeVyeY4HatwVff3117r//vvVsmVLNWvWTD/5yU+0fft2z/FAHUP79u2rfO8dDodGjRolKXDjlqTTp0/r17/+teLj4xUeHq7LLrtMv/3tb1VWVubpE8jxw371mbNee+01derUSU6nU506ddKqVavqaxhVnGtcp06d0hNPPKEuXbqoefPmio2N1bBhw/TNN9+c9bqLFy+2/P/ixIkT9T0kj5q8ZsOHD68SY+/evc957UB+zSRZfu8dDoeeeuqpaq8bCK9Zff1uZefrJZ19XMH8HjvX6xWM7y/YL1jm4BUF63y8smCfn5cLpXl6RcE0Z68sFObw5YJ1Ll9ZMM/tK/LbPN+gWsuXLzeNGzc2L774ovnkk0/M2LFjTfPmzc3+/fvtDq2KN954w0yZMsW89tprRpJZtWqV1/GZM2eaiIgI89prr5ldu3aZu+++28TExJji4mJ7Av4/N954o1m0aJH5+OOPTU5OjklNTTXt2rUzR48e9fQJ1NiNMWbNmjVm7dq1Zs+ePWbPnj1m8uTJpnHjxubjjz82xgR27BV98MEHpn379qZr165m7NixnvZAjX/q1Kmmc+fO5uDBg56toKDAczxQ4y73/fffm7i4ODN8+HDzr3/9y+Tm5pq3337bfP75554+gTqGgoICr+97VlaWkWQ2bNgQ0HEbY8z06dNNy5Ytzeuvv25yc3PNq6++ai688EIzd+5cT59Ajh/2q6+ctXnzZtOoUSOTkZFhPv30U5ORkWHCwsLMli1b/DGsc47r8OHDZuDAgWbFihXm3//+t3n//fdNr169TI8ePc563UWLFpnIyEiv/zMOHjzojyF51OQ1S0tLMzfddJNXjIcOHTrrdQP9NTPGVPm+//nPfzYOh8N88cUX1V43EF6z+vjdyu7Xy5izjyuY32Pner2C8f0FewXTHLyiYJ2PVxbs8/NyoTJPryjY5uyVBfscvlwwz+UrC+a5fUX+mudTQD+Lq6++2vziF7/warviiivMxIkTbYqoZion7LKyMuNyuczMmTM9bSdOnDBRUVHm+eeftyHC6hUUFBhJJjs72xgTXLGXu/jii82f/vSnoIn9yJEjJiEhwWRlZZl+/fp5knEgxz916lTTrVs3y2OBHHe5J554wlx77bXVHg+GMZQbO3as+dGPfmTKysoCPu7U1FTz0EMPebUNGTLE3H///caY4Pq+IzD4Kmfddddd5qabbvJqu/HGG80999xTP4GfQ+VxWfnggw+MpLMWNBYtWmSioqLqIcK6sxpbWlqaue2222p1nWB8zW677TZzww03nPU6gfiaGXP+v1sF2utVrnxcVoL1PWaM97hC4f0F/wrWOXhFwTwfrywU5uflgm2eXlEwztkrC/Y5fLlQmstXFkxz+4r8Nc/nFi7VOHnypLZv367k5GSv9uTkZG3evNmmqOomNzdX+fn5XmNxOp3q169fwI2lqKhIktSiRQtJwRX7mTNntHz5cpWUlKhPnz5BE/uoUaOUmpqqgQMHerUHevx79+5VbGys4uPjdc899+jLL7+UFPhxS9KaNWvUs2dP3XnnnWrdurW6d++uF1980XM8GMYg/fD/5NKlS/XQQw/J4XAEfNzXXnut3nnnHX322WeSpI8++kibNm3SzTffLCl4vu8IHL7KWe+//36V3zduvPFG237uKo+ruj4Oh0MXXXTRWa919OhRxcXFqU2bNrrlllu0Y8cOX4Zaa9WNbePGjWrdurU6dOigRx55RAUFBWe9TrC9Zt9++63Wrl2rhx9++JzXCqTXzFe/WwXa61V5XFaC8T1W3biC/f0F/wmlOXhFwfw7ZjDPz8sF6zy9omCds1cWzHP4cqEyl68s2Ob2Fflrnh/m27BDx3fffaczZ84oOjraqz06Olr5+fk2RVU35fFajWX//v12hGTJGKNx48bp2muvVWJioqTgiH3Xrl3q06ePTpw4oQsvvFCrVq1Sp06dPG/EQI59+fLl+vDDD7V169YqxwL5e9+rVy+99NJL6tChg7799ltNnz5dffv21e7duwM67nJffvmlFixYoHHjxmny5Mn64IMP9Oijj8rpdGrYsGFBMQZJWr16tQ4fPqzhw4dLCuyfGUl64oknVFRUpCuuuEKNGjXSmTNnNGPGDN17772SAj9+BBZf5qz8/PyA+X3DalyVnThxQhMnTtTQoUMVGRlZ7bWuuOIKLV68WF26dFFxcbGeeeYZXXPNNfroo4+UkJBQX0OoVnVjS0lJ0Z133qm4uDjl5ubqySef1A033KDt27fL6XRaXivYXrMlS5YoIiJCQ4YMOeu1AuU18/XvVoHyelU3rsqC7T12tnEF+/sL/hVKc/CKgvV3zGCdn5cL5nl6RcE6Z68s2Ofw5UJlLl9ZsM3tK/LXPJ8C+jk4HA6vfWNMlbZgEehjGT16tHbu3KlNmzZVORbIsXfs2FE5OTk6fPiwXnvtNaWlpSk7O9tzPFBjz8vL09ixY7V+/Xo1bdq02n6BGH9KSorn3126dFGfPn30ox/9SEuWLPE8mCoQ4y5XVlamnj17KiMjQ5LUvXt37d69WwsWLNCwYcM8/QJ5DJK0cOFCpaSkKDY21qs9UONesWKFli5dqmXLlqlz587KyclRenq6YmNjlZaW5ukXqPEjsPg6ZwXKz93ZxiX98LDDe+65R2VlZXruuefOeq3evXt7PSzwmmuu0ZVXXql58+bp2Wef9WncNVHd2O6++27PvxMTE9WzZ0/FxcVp7dq1Zy04B8trJkl//vOfdd99950130uB85rVx+9WgfB6VTeuikX0YHyPnW1cwf7+gj1C9fUPtnEF6/y8XLDO0ysK5jl7ZcE+hy8XKnP5yoJtbl+Rv+b53MKlGq1atVKjRo2q/KW7oKCgyl8tAl35k40DeSxjxozRmjVrtGHDBrVp08bTHgyxN2nSRJdffrl69uypzMxMdevWTc8880zAx759+3YVFBSoR48eCgsLU1hYmLKzs/Xss88qLCzME2Ogxl9R8+bN1aVLF+3duzfgv++SFBMTU2XF2Y9//GMdOHBAUnD83O/fv19vv/22fv7zn3vaAj3uxx9/XBMnTtQ999yjLl266IEHHtCvfvUrZWZmSgr8+BE4fJ2zXC5XQPzcVTeucqdOndJdd92l3NxcZWVlnXVlrJULLrhAV111lfbu3eurkGvsXGOrKCYmRnFxcWeNM1heM0n6xz/+oT179nj9f11Tdr1mvv7dKlBer+rGVS5Y32PnGldFwfT+gv+F0hy8omD8HTOY5+flgnWeXlEozdkrC7Y5fLlQmMtXFoxz+4r8Nc+ngF6NJk2aqEePHsrKyvJqz8rKUt++fW2Kqm7i4+Plcrm8xnLy5EllZ2fbPhZjjEaPHq2VK1fq3XffVXx8vNfxQI69OsYYlZaWBnzsAwYM0K5du5STk+PZevbsqfvuu085OTm67LLLAjr+ikpLS/Xpp58qJiYm4L/v0g8rxPbs2ePV9tlnnykuLk5ScPzcL1q0SK1bt1ZqaqqnLdDjPnbsmC64wDvtNWrUSGVlZZICP37Yr75yVp8+far8vrF+/Xq//dyda1zSfwt7e/fu1dtvv62WLVvW6evk5OQoJibGF2HX+Guea2yVHTp0SHl5eWeNMxhes3ILFy5Ujx491K1btzp9HX+/ZtXFcT6/W9n9elWnfFxS8L7HqoujfFyVBcP7C/YJpTl4RcH0O2Yozs/LBcs8vaJQmrNXFmxz+HKhMJevLBjn9hX5bZ5f48eNNkDLly83jRs3NgsXLjSffPKJSU9PN82bNzf79u2zO7Qqjhw5Ynbs2GF27NhhJJk5c+aYHTt2mP379xtjjJk5c6aJiooyK1euNLt27TL33nuviYmJMcXFxbbG/ctf/tJERUWZjRs3moMHD3q2Y8eOefoEauzGGDNp0iTz3nvvmdzcXLNz504zefJkc8EFF5j169cbYwI7disVn+htTODGP378eLNx40bz5Zdfmi1btphbbrnFREREeN6bgRp3uQ8++MCEhYWZGTNmmL1795qXX37ZNGvWzCxdutTTJ5DHcObMGdOuXTvzxBNPVDkWyHGnpaWZSy+91Lz++usmNzfXrFy50rRq1cpMmDDB0yeQ44f9fJWzHnjgATNx4kTP/j//+U/TqFEjM3PmTPPpp5+amTNnmrCwMLNly5aAGNepU6fMrbfeatq0aWNycnK8+pSWllY7LrfbbdatW2e++OILs2PHDvPggw+asLAw869//csv46rJ2I4cOWLGjx9vNm/ebHJzc82GDRtMnz59zKWXXhrUr1m5oqIi06xZM7NgwQLL6wTia+aL360C7fU617iC+T12tnEF6/sL9gqmOXhFwTofryzY5+flQm2eXlGwzNkrC/Y5fLlgn8tXFqxz+4r8Nc+ngH4Of/jDH0xcXJxp0qSJufLKK012drbdIVnasGGDkVRlS0tLM8YYU1ZWZqZOnWpcLpdxOp3m+uuvN7t27bI3aGMsY5ZkFi1a5OkTqLEbY8xDDz3k+fm45JJLzIABAzxJ2ZjAjt1K5WQcqPHffffdJiYmxjRu3NjExsaaIUOGmN27d3uOB2rcFf3v//6vSUxMNE6n01xxxRXmhRde8DoeyGN46623jCSzZ8+eKscCOe7i4mIzduxY065dO9O0aVNz2WWXmSlTpngVJwI5ftjPVzmrX79+nvxc7tVXXzUdO3Y0jRs3NldccYV57bXX/DCiH5xrXLm5udX22bBhQ7XjSk9PN+3atfPkyOTkZLN582a/jasmYzt27JhJTk42l1xyiWncuLFp166dSUtLMwcOHPC6TrC9ZuX++Mc/mvDwcHP48GHL6wTia+aL360C7fUy5uzjCub32NnGFazvL9gvWObgFQXrfLyyYJ+flwu1eXpFwTJnrywU5vDlgnkuX1mwzu0r8tc832GMMTVfrw4AAAAAAAAAQMPAPdABAAAAAAAAALBAAR0AAAAAAAAAAAsU0AEAAAAAAAAAsEABHQAAAAAAAAAACxTQAQAAAAAAAACwQAEdAAAAAAAAAAALFNABAAAAAAAAALBAAR0AAAAAAAAAAAsU0AEAAAAAAAAAsEABHYDH5s2b1ahRI9100012hwIAAGqI/A0AQHAihwPBwWGMMXYHASAw/PznP9eFF16oP/3pT/rkk0/Url07u0MCAADnQP4GACA4kcOB4MAKdACSpJKSEv31r3/VL3/5S91yyy1avHix1/E1a9YoISFB4eHh6t+/v5YsWSKHw6HDhw97+mzevFnXX3+9wsPD1bZtWz366KMqKSnx70AAAGhAyN8AAAQncjgQPCigA5AkrVixQh07dlTHjh11//33a9GiRSr/gMq+ffv0s5/9TLfffrtycnI0YsQITZkyxev8Xbt26cYbb9SQIUO0c+dOrVixQps2bdLo0aPtGA4AAA0C+RsAgOBEDgeCB7dwASBJuuaaa3TXXXdp7NixOn36tGJiYvTKK69o4MCBmjhxotauXatdu3Z5+v/617/WjBkzVFhYqIsuukjDhg1TeHi4/vjHP3r6bNq0Sf369VNJSYmaNm1qx7AAAAhp5G8AAIITORwIHqxAB6A9e/bogw8+0D333CNJCgsL0913360///nPnuNXXXWV1zlXX3211/727du1ePFiXXjhhZ7txhtvVFlZmXJzc/0zEAAAGhDyNwAAwYkcDgSXMLsDAGC/hQsX6vTp07r00ks9bcYYNW7cWIWFhTLGyOFweJ1T+cMrZWVlGjFihB599NEq1+dBKAAA+B75GwCA4EQOB4ILBXSggTt9+rReeuklPf3000pOTvY69tOf/lQvv/yyrrjiCr3xxhtex7Zt2+a1f+WVV2r37t26/PLL6z1mAAAaOvI3AADBiRwOBB/ugQ40cKtXr9bdd9+tgoICRUVFeR2bMmWK3njjDa1cuVIdO3bUr371Kz388MPKycnR+PHj9dVXX+nw4cOKiorSzp071bt3bz344IN65JFH1Lx5c3366afKysrSvHnzbBodAAChifwNAEBwIocDwYd7oAMN3MKFCzVw4MAqiVv64a/fOTk5Kiws1N/+9jetXLlSXbt21YIFCzxPAHc6nZKkrl27Kjs7W3v37tV1112n7t2768knn1RMTIxfxwMAQENA/gYAIDiRw4Hgwwp0AHUyY8YMPf/888rLy7M7FAAAUEPkbwAAghM5HLAP90AHUCPPPfecrrrqKrVs2VL//Oc/9dRTT2n06NF2hwUAAM6C/A0AQHAihwOBgwI6gBrZu3evpk+fru+//17t2rXT+PHjNWnSJLvDAgAAZ0H+BgAgOJHDgcDBLVwAAAAAAAAAALDAQ0QBAAAAAAAAALBAAR0AAAAAAAAAAAsU0AEAAAAAAAAAsEABHQAAAAAAAAAACxTQAQAAAAAAAACwQAEdAAAAAAAAAAALFNABAAAAAAAAALBAAR0AAAAAAAAAAAsU0AEAAAAAAAAAsPD/AUotTs/G/PK4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "# Plot for Population 1\n", + "freq_distribution = ages_population[\"observation\"].value_counts()\n", + "axes[0].bar(freq_distribution.index, freq_distribution.values)\n", + "axes[0].set_xlabel(\"Age\")\n", + "axes[0].set_ylabel(\"Frequency\")\n", + "axes[0].set_title(\"Population 1\")\n", + "\n", + "# Plot for Population 2\n", + "freq_distribution = ages_population_2[\"observation\"].value_counts()\n", + "axes[1].bar(freq_distribution.index, freq_distribution.values)\n", + "axes[1].set_xlabel(\"Age\")\n", + "axes[1].set_ylabel(\"Frequency\")\n", + "axes[1].set_title(\"Population 2\")\n", + "\n", + "# Plot for Population 3\n", + "freq_distribution = ages_population_3[\"observation\"].value_counts()\n", + "axes[2].bar(freq_distribution.index, freq_distribution.values)\n", + "axes[2].set_xlabel(\"Age\")\n", + "axes[2].set_ylabel(\"Frequency\")\n", + "axes[2].set_title(\"Population 3\")\n", + "\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 328, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 328, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "your comments here\n", @@ -500,9 +1401,9 @@ ], "metadata": { "kernelspec": { - "display_name": "ironhack-3.7", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "ironhack-3.7" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -514,7 +1415,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.10.9" } }, "nbformat": 4, diff --git a/data/roll_the_dice_hundred.csv b/your-code/roll_the_dice_hundred.csv similarity index 100% rename from data/roll_the_dice_hundred.csv rename to your-code/roll_the_dice_hundred.csv diff --git a/data/roll_the_dice_thousand.csv b/your-code/roll_the_dice_thousand.csv similarity index 100% rename from data/roll_the_dice_thousand.csv rename to your-code/roll_the_dice_thousand.csv