diff --git a/assignment/assignment_programming.ipynb b/assignment/assignment_programming.ipynb
index 299e0bf..2bdadc4 100644
--- a/assignment/assignment_programming.ipynb
+++ b/assignment/assignment_programming.ipynb
@@ -1,185 +1,880 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "f7c24d5d-9973-45a1-83be-8bca8b03e576",
-   "metadata": {},
-   "source": [
-    "# Assignment: Programming Review\n",
-    "## Do Q1 and one other question."
-   ]
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "f7c24d5d-9973-45a1-83be-8bca8b03e576",
+      "metadata": {
+        "id": "f7c24d5d-9973-45a1-83be-8bca8b03e576"
+      },
+      "source": [
+        "# Assignment: Programming Review\n",
+        "## Do Q1 and one other question."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "4a3fb7b5-0345-447d-840a-59f667fe9c0c",
+      "metadata": {
+        "id": "4a3fb7b5-0345-447d-840a-59f667fe9c0c"
+      },
+      "source": [
+        "**Q1.** First, think about your priorities in life. What kind of salary do you want to make after graduation? Do you mind getting more schooling? What kind of work-life balance are you looking for? Where do you want to work, geographically? You don't have to write this down here, just think about it.    \n",
+        "\n",
+        "1. Go to the Occupational Outlook Handbook at [https://www.bls.gov/ooh/](https://www.bls.gov/ooh/). Look up \"Data Scientist.\" Read about the job and start collecting data about it from the job profile (e.g. salary, education required, work setting)\n",
+        "2. Find 7-10 other jobs that appeal to you, and collect the same data as you did for Data Scientist. Put it all in a spreadsheet.\n",
+        "3. Do any of your findings surprise you?\n",
+        "4. Rank the jobs you picked from best to worst, and briefly explain why you did so.\n",
+        "5. Please submit your spreadsheet with the assignment --- you can \"de-identify\" it and remove anything that you find personally identifying or you don't want to share, of course. We'll play with these data later.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "7e9d65ad-3740-43d3-a944-b3653fbeb80c",
+      "metadata": {
+        "id": "7e9d65ad-3740-43d3-a944-b3653fbeb80c"
+      },
+      "source": [
+        "Depends on student opinions."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "3: I was surprised that the Software Development jobs had a high future growth rate. With the rise of AI, I would expect a lot of Software Devleopment jobs to start getting replaced. So, I am surprsied the growth is so high. I was also surprised that teaching has a negative growth. I feel like teaching is a steady job. It is not going to be replaced. It is also a needed job. I was also surprised there are so little aerospace majors. I assumed because it is at most engineering schools, the major's job would be more common.\n",
+        "\n",
+        "4:\n",
+        "1. Data Scientist\n",
+        "2. Software Developers, Quality Assurance Analysts, and Testers\n",
+        "3. Aerospace Engineer\n",
+        "4. Mechanical Engineer\n",
+        "5. Athletes and Sports Competitors\n",
+        "6. Airline and Commercial Pilots\n",
+        "7. Plumbers, Pipefitters, and Steamfitters\n",
+        "8. Automotive Service Technicians and Mechanics\n",
+        "9. Kindergarten and Elementary School Teachers\n",
+        "\n",
+        "I chose this order because I wanted to prioritize projected job growth, median salary, and work setting. Data Scientist and Software Developers are at the top because of their super high growth rate and salary. Aerospace Engineers have a high median salary. Mechanical Engineers and Atheletes have a decent salary and a high growth rate. Pilots are only 6th because of the work setting despite the high salary. Plumbers and Mechanics are low due to their low salary. Kindergarten and Elementary School Teachers are last because of their low median salary and negative growth."
+      ],
+      "metadata": {
+        "id": "F24Nz1VWxyoh"
+      },
+      "id": "F24Nz1VWxyoh"
+    },
+    {
+      "cell_type": "markdown",
+      "id": "7cfa75b2-aaef-4368-a043-93437887879c",
+      "metadata": {
+        "id": "7cfa75b2-aaef-4368-a043-93437887879c"
+      },
+      "source": [
+        "**Q2.** Being able to make basic plots to visualize sets of points is really helpful, particularly with data analysis. The pyplot plots are built up slowly by defining elements of the plot, and then using `plt.show()` to create the final plot. This question gives you some practice doing that **iterative** building process.\n",
+        "\n",
+        "1. Import the `numpy` module as `np` and the `matplotlib.pyplot` package as `plt`.\n",
+        "2. Use `np.linspace` to create a grid of 50 points ranging from 0 to 1.\n",
+        "3. Create a numpy array $y$ containing the values for the natural logarithm function using the `np.log(x)` function. Create a numpy array $z$ containing the values for the exponential function using the `np.exp(x)` function.\n",
+        "4. Use the `plt.scatter(x,y)` method for the $y$ and $z$ vectors to create two scatter plots of the points you've created.\n",
+        "5. Use the `plt.show()` method to create the plot.\n",
+        "\n",
+        "That plot has some problems.\n",
+        "\n",
+        "6. Before the `plt.show()` call, add labels to the $x$ and $y$ axes using `plt.xlabel(label)` and `plt.ylabel(label)`. Add a title to the graph using `plt.title(title)`, like \"Natural Log and Exponential Functions\".\n",
+        "7. That looks a lot better, but we need a legend. When you screate the scatter plots, add the argument `label='Natural Log'` or `label='Exponential'` to the `.scatter` method call. Before the `plt.show()` call, add a `plt.legend(loc = 'lower right')` method call, which creates a legend in the lower right.\n",
+        "\n",
+        "Now do it again, with slightly less direction:\n",
+        "\n",
+        "8. Create a grid of 100 equally spaced points ranging from -6.5 to 6.5.\n",
+        "9. Use the sine and cosine functions in Numpy to compute the values of those functions for each point on your grid. (You'll have to find out what those functions are.)\n",
+        "10. Plot the values of the two functions for the values on the grid on the same plot.\n",
+        "11. The scatter plot looks really noisy. Instead of `plt.scatter(x,y)` to make a scatter plot, use `plt.plot(x,y)` to make a line graph.\n",
+        "12. Make the plot again, with labels for the axes, a title, and a legend in the lower left instead of the lower right.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "9c05ee86-06dc-4ae9-896d-0cb70c4d6c3d",
+      "metadata": {
+        "id": "9c05ee86-06dc-4ae9-896d-0cb70c4d6c3d",
+        "outputId": "0d9769db-dc95-41a5-cdea-a671c8e6d95f",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 637
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "<ipython-input-2-3bb771d0a76b>:8: RuntimeWarning: divide by zero encountered in log\n",
+            "  y = np.log(x)\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<function matplotlib.pyplot.show(close=None, block=None)>"
+            ],
+            "text/html": [
+              "<div style=\"max-width:800px; border: 1px solid var(--colab-border-color);\"><style>\n",
+              "      pre.function-repr-contents {\n",
+              "        overflow-x: auto;\n",
+              "        padding: 8px 12px;\n",
+              "        max-height: 500px;\n",
+              "      }\n",
+              "\n",
+              "      pre.function-repr-contents.function-repr-contents-collapsed {\n",
+              "        cursor: pointer;\n",
+              "        max-height: 100px;\n",
+              "      }\n",
+              "    </style>\n",
+              "    <pre style=\"white-space: initial; background:\n",
+              "         var(--colab-secondary-surface-color); padding: 8px 12px;\n",
+              "         border-bottom: 1px solid var(--colab-border-color);\"><b>matplotlib.pyplot.show</b><br/>def show(*args, **kwargs) -&gt; None</pre><pre class=\"function-repr-contents function-repr-contents-collapsed\" style=\"\"><a class=\"filepath\" style=\"display:none\" href=\"#\">/usr/local/lib/python3.11/dist-packages/matplotlib/pyplot.py</a>Display all open figures.\n",
+              "\n",
+              "Parameters\n",
+              "----------\n",
+              "block : bool, optional\n",
+              "    Whether to wait for all figures to be closed before returning.\n",
+              "\n",
+              "    If `True` block and run the GUI main loop until all figure windows\n",
+              "    are closed.\n",
+              "\n",
+              "    If `False` ensure that all figure windows are displayed and return\n",
+              "    immediately.  In this case, you are responsible for ensuring\n",
+              "    that the event loop is running to have responsive figures.\n",
+              "\n",
+              "    Defaults to True in non-interactive mode and to False in interactive\n",
+              "    mode (see `.pyplot.isinteractive`).\n",
+              "\n",
+              "See Also\n",
+              "--------\n",
+              "ion : Enable interactive mode, which shows / updates the figure after\n",
+              "      every plotting command, so that calling ``show()`` is not necessary.\n",
+              "ioff : Disable interactive mode.\n",
+              "savefig : Save the figure to an image file instead of showing it on screen.\n",
+              "\n",
+              "Notes\n",
+              "-----\n",
+              "**Saving figures to file and showing a window at the same time**\n",
+              "\n",
+              "If you want an image file as well as a user interface window, use\n",
+              "`.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)\n",
+              "``show()`` the figure is closed and thus unregistered from pyplot. Calling\n",
+              "`.pyplot.savefig` afterwards would save a new and thus empty figure. This\n",
+              "limitation of command order does not apply if the show is non-blocking or\n",
+              "if you keep a reference to the figure and use `.Figure.savefig`.\n",
+              "\n",
+              "**Auto-show in jupyter notebooks**\n",
+              "\n",
+              "The jupyter backends (activated via ``%matplotlib inline``,\n",
+              "``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at\n",
+              "the end of every cell by default. Thus, you usually don&#x27;t have to call it\n",
+              "explicitly there.</pre>\n",
+              "      <script>\n",
+              "      if (google.colab.kernel.accessAllowed && google.colab.files && google.colab.files.view) {\n",
+              "        for (const element of document.querySelectorAll('.filepath')) {\n",
+              "          element.style.display = 'block'\n",
+              "          element.onclick = (event) => {\n",
+              "            event.preventDefault();\n",
+              "            event.stopPropagation();\n",
+              "            google.colab.files.view(element.textContent, 569);\n",
+              "          };\n",
+              "        }\n",
+              "      }\n",
+              "      for (const element of document.querySelectorAll('.function-repr-contents')) {\n",
+              "        element.onclick = (event) => {\n",
+              "          event.preventDefault();\n",
+              "          event.stopPropagation();\n",
+              "          element.classList.toggle('function-repr-contents-collapsed');\n",
+              "        };\n",
+              "      }\n",
+              "      </script>\n",
+              "      </div>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 2
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# First Part\n",
+        "\n",
+        "x = np.linspace(0,1)\n",
+        "\n",
+        "y = np.log(x)\n",
+        "z = np.exp(x)\n",
+        "plt.scatter(x,y)\n",
+        "plt.scatter(x,z)\n",
+        "\n",
+        "\n",
+        "plt.show\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# First Part with labels\n",
+        "\n",
+        "x = np.linspace(0,1)\n",
+        "\n",
+        "y = np.log(x)\n",
+        "z = np.exp(x)\n",
+        "plt.scatter(x,y, label='Natural Log')\n",
+        "plt.scatter(x,z, label='Exponential')\n",
+        "\n",
+        "plt.xlabel(\"X axis\")\n",
+        "\n",
+        "plt.ylabel(\"Y axis\")\n",
+        "\n",
+        "plt.title(\"Natural Log and Exponential Functions\")\n",
+        "\n",
+        "plt.legend(loc = 'lower right')\n",
+        "\n",
+        "plt.show\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "l79ujsxA-fCT",
+        "outputId": "9bd22e5c-1edc-45e7-a51c-0d5c5cc09238",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 676
+        }
+      },
+      "id": "l79ujsxA-fCT",
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "<ipython-input-4-fe4eb94cb38f>:5: RuntimeWarning: divide by zero encountered in log\n",
+            "  y = np.log(x)\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<function matplotlib.pyplot.show(close=None, block=None)>"
+            ],
+            "text/html": [
+              "<div style=\"max-width:800px; border: 1px solid var(--colab-border-color);\"><style>\n",
+              "      pre.function-repr-contents {\n",
+              "        overflow-x: auto;\n",
+              "        padding: 8px 12px;\n",
+              "        max-height: 500px;\n",
+              "      }\n",
+              "\n",
+              "      pre.function-repr-contents.function-repr-contents-collapsed {\n",
+              "        cursor: pointer;\n",
+              "        max-height: 100px;\n",
+              "      }\n",
+              "    </style>\n",
+              "    <pre style=\"white-space: initial; background:\n",
+              "         var(--colab-secondary-surface-color); padding: 8px 12px;\n",
+              "         border-bottom: 1px solid var(--colab-border-color);\"><b>matplotlib.pyplot.show</b><br/>def show(*args, **kwargs) -&gt; None</pre><pre class=\"function-repr-contents function-repr-contents-collapsed\" style=\"\"><a class=\"filepath\" style=\"display:none\" href=\"#\">/usr/local/lib/python3.11/dist-packages/matplotlib/pyplot.py</a>Display all open figures.\n",
+              "\n",
+              "Parameters\n",
+              "----------\n",
+              "block : bool, optional\n",
+              "    Whether to wait for all figures to be closed before returning.\n",
+              "\n",
+              "    If `True` block and run the GUI main loop until all figure windows\n",
+              "    are closed.\n",
+              "\n",
+              "    If `False` ensure that all figure windows are displayed and return\n",
+              "    immediately.  In this case, you are responsible for ensuring\n",
+              "    that the event loop is running to have responsive figures.\n",
+              "\n",
+              "    Defaults to True in non-interactive mode and to False in interactive\n",
+              "    mode (see `.pyplot.isinteractive`).\n",
+              "\n",
+              "See Also\n",
+              "--------\n",
+              "ion : Enable interactive mode, which shows / updates the figure after\n",
+              "      every plotting command, so that calling ``show()`` is not necessary.\n",
+              "ioff : Disable interactive mode.\n",
+              "savefig : Save the figure to an image file instead of showing it on screen.\n",
+              "\n",
+              "Notes\n",
+              "-----\n",
+              "**Saving figures to file and showing a window at the same time**\n",
+              "\n",
+              "If you want an image file as well as a user interface window, use\n",
+              "`.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)\n",
+              "``show()`` the figure is closed and thus unregistered from pyplot. Calling\n",
+              "`.pyplot.savefig` afterwards would save a new and thus empty figure. This\n",
+              "limitation of command order does not apply if the show is non-blocking or\n",
+              "if you keep a reference to the figure and use `.Figure.savefig`.\n",
+              "\n",
+              "**Auto-show in jupyter notebooks**\n",
+              "\n",
+              "The jupyter backends (activated via ``%matplotlib inline``,\n",
+              "``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at\n",
+              "the end of every cell by default. Thus, you usually don&#x27;t have to call it\n",
+              "explicitly there.</pre>\n",
+              "      <script>\n",
+              "      if (google.colab.kernel.accessAllowed && google.colab.files && google.colab.files.view) {\n",
+              "        for (const element of document.querySelectorAll('.filepath')) {\n",
+              "          element.style.display = 'block'\n",
+              "          element.onclick = (event) => {\n",
+              "            event.preventDefault();\n",
+              "            event.stopPropagation();\n",
+              "            google.colab.files.view(element.textContent, 569);\n",
+              "          };\n",
+              "        }\n",
+              "      }\n",
+              "      for (const element of document.querySelectorAll('.function-repr-contents')) {\n",
+              "        element.onclick = (event) => {\n",
+              "          event.preventDefault();\n",
+              "          event.stopPropagation();\n",
+              "          element.classList.toggle('function-repr-contents-collapsed');\n",
+              "        };\n",
+              "      }\n",
+              "      </script>\n",
+              "      </div>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 4
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Second Part\n",
+        "x = np.linspace(-6.5, 6.5, num = 100)\n",
+        "s = np.sin(x)\n",
+        "c = np.cos(x)\n",
+        "\n",
+        "plt.scatter(x, s, label='Sin')\n",
+        "plt.scatter(x, c, label='Cos')\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "plt.show\n"
+      ],
+      "metadata": {
+        "id": "-DI37RAATmE3",
+        "outputId": "72939a22-b221-4c9a-cac9-21d26f34267f",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 599
+        }
+      },
+      "id": "-DI37RAATmE3",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<function matplotlib.pyplot.show(close=None, block=None)>"
+            ],
+            "text/html": [
+              "<div style=\"max-width:800px; border: 1px solid var(--colab-border-color);\"><style>\n",
+              "      pre.function-repr-contents {\n",
+              "        overflow-x: auto;\n",
+              "        padding: 8px 12px;\n",
+              "        max-height: 500px;\n",
+              "      }\n",
+              "\n",
+              "      pre.function-repr-contents.function-repr-contents-collapsed {\n",
+              "        cursor: pointer;\n",
+              "        max-height: 100px;\n",
+              "      }\n",
+              "    </style>\n",
+              "    <pre style=\"white-space: initial; background:\n",
+              "         var(--colab-secondary-surface-color); padding: 8px 12px;\n",
+              "         border-bottom: 1px solid var(--colab-border-color);\"><b>matplotlib.pyplot.show</b><br/>def show(*args, **kwargs)</pre><pre class=\"function-repr-contents function-repr-contents-collapsed\" style=\"\"><a class=\"filepath\" style=\"display:none\" href=\"#\">/usr/local/lib/python3.10/dist-packages/matplotlib/pyplot.py</a>Display all open figures.\n",
+              "\n",
+              "Parameters\n",
+              "----------\n",
+              "block : bool, optional\n",
+              "    Whether to wait for all figures to be closed before returning.\n",
+              "\n",
+              "    If `True` block and run the GUI main loop until all figure windows\n",
+              "    are closed.\n",
+              "\n",
+              "    If `False` ensure that all figure windows are displayed and return\n",
+              "    immediately.  In this case, you are responsible for ensuring\n",
+              "    that the event loop is running to have responsive figures.\n",
+              "\n",
+              "    Defaults to True in non-interactive mode and to False in interactive\n",
+              "    mode (see `.pyplot.isinteractive`).\n",
+              "\n",
+              "See Also\n",
+              "--------\n",
+              "ion : Enable interactive mode, which shows / updates the figure after\n",
+              "      every plotting command, so that calling ``show()`` is not necessary.\n",
+              "ioff : Disable interactive mode.\n",
+              "savefig : Save the figure to an image file instead of showing it on screen.\n",
+              "\n",
+              "Notes\n",
+              "-----\n",
+              "**Saving figures to file and showing a window at the same time**\n",
+              "\n",
+              "If you want an image file as well as a user interface window, use\n",
+              "`.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)\n",
+              "``show()`` the figure is closed and thus unregistered from pyplot. Calling\n",
+              "`.pyplot.savefig` afterwards would save a new and thus empty figure. This\n",
+              "limitation of command order does not apply if the show is non-blocking or\n",
+              "if you keep a reference to the figure and use `.Figure.savefig`.\n",
+              "\n",
+              "**Auto-show in jupyter notebooks**\n",
+              "\n",
+              "The jupyter backends (activated via ``%matplotlib inline``,\n",
+              "``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at\n",
+              "the end of every cell by default. Thus, you usually don&#x27;t have to call it\n",
+              "explicitly there.</pre>\n",
+              "      <script>\n",
+              "      if (google.colab.kernel.accessAllowed && google.colab.files && google.colab.files.view) {\n",
+              "        for (const element of document.querySelectorAll('.filepath')) {\n",
+              "          element.style.display = 'block'\n",
+              "          element.onclick = (event) => {\n",
+              "            event.preventDefault();\n",
+              "            event.stopPropagation();\n",
+              "            google.colab.files.view(element.textContent, 482);\n",
+              "          };\n",
+              "        }\n",
+              "      }\n",
+              "      for (const element of document.querySelectorAll('.function-repr-contents')) {\n",
+              "        element.onclick = (event) => {\n",
+              "          event.preventDefault();\n",
+              "          event.stopPropagation();\n",
+              "          element.classList.toggle('function-repr-contents-collapsed');\n",
+              "        };\n",
+              "      }\n",
+              "      </script>\n",
+              "      </div>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 24
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Second Part with Line\n",
+        "x = np.linspace(-6.5, 6.5, num = 100)\n",
+        "s = np.sin(x)\n",
+        "c = np.cos(x)\n",
+        "\n",
+        "plt.plot(x, s, label='Sin')\n",
+        "plt.plot(x, c, label='Cos')\n",
+        "\n",
+        "\n",
+        "\n",
+        "\n",
+        "plt.show\n"
+      ],
+      "metadata": {
+        "id": "Sxpa8N1y_CJz",
+        "outputId": "804ea4e8-8293-4b2e-9100-6d1964c9ce2a",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 599
+        }
+      },
+      "id": "Sxpa8N1y_CJz",
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<function matplotlib.pyplot.show(close=None, block=None)>"
+            ],
+            "text/html": [
+              "<div style=\"max-width:800px; border: 1px solid var(--colab-border-color);\"><style>\n",
+              "      pre.function-repr-contents {\n",
+              "        overflow-x: auto;\n",
+              "        padding: 8px 12px;\n",
+              "        max-height: 500px;\n",
+              "      }\n",
+              "\n",
+              "      pre.function-repr-contents.function-repr-contents-collapsed {\n",
+              "        cursor: pointer;\n",
+              "        max-height: 100px;\n",
+              "      }\n",
+              "    </style>\n",
+              "    <pre style=\"white-space: initial; background:\n",
+              "         var(--colab-secondary-surface-color); padding: 8px 12px;\n",
+              "         border-bottom: 1px solid var(--colab-border-color);\"><b>matplotlib.pyplot.show</b><br/>def show(*args, **kwargs) -&gt; None</pre><pre class=\"function-repr-contents function-repr-contents-collapsed\" style=\"\"><a class=\"filepath\" style=\"display:none\" href=\"#\">/usr/local/lib/python3.11/dist-packages/matplotlib/pyplot.py</a>Display all open figures.\n",
+              "\n",
+              "Parameters\n",
+              "----------\n",
+              "block : bool, optional\n",
+              "    Whether to wait for all figures to be closed before returning.\n",
+              "\n",
+              "    If `True` block and run the GUI main loop until all figure windows\n",
+              "    are closed.\n",
+              "\n",
+              "    If `False` ensure that all figure windows are displayed and return\n",
+              "    immediately.  In this case, you are responsible for ensuring\n",
+              "    that the event loop is running to have responsive figures.\n",
+              "\n",
+              "    Defaults to True in non-interactive mode and to False in interactive\n",
+              "    mode (see `.pyplot.isinteractive`).\n",
+              "\n",
+              "See Also\n",
+              "--------\n",
+              "ion : Enable interactive mode, which shows / updates the figure after\n",
+              "      every plotting command, so that calling ``show()`` is not necessary.\n",
+              "ioff : Disable interactive mode.\n",
+              "savefig : Save the figure to an image file instead of showing it on screen.\n",
+              "\n",
+              "Notes\n",
+              "-----\n",
+              "**Saving figures to file and showing a window at the same time**\n",
+              "\n",
+              "If you want an image file as well as a user interface window, use\n",
+              "`.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)\n",
+              "``show()`` the figure is closed and thus unregistered from pyplot. Calling\n",
+              "`.pyplot.savefig` afterwards would save a new and thus empty figure. This\n",
+              "limitation of command order does not apply if the show is non-blocking or\n",
+              "if you keep a reference to the figure and use `.Figure.savefig`.\n",
+              "\n",
+              "**Auto-show in jupyter notebooks**\n",
+              "\n",
+              "The jupyter backends (activated via ``%matplotlib inline``,\n",
+              "``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at\n",
+              "the end of every cell by default. Thus, you usually don&#x27;t have to call it\n",
+              "explicitly there.</pre>\n",
+              "      <script>\n",
+              "      if (google.colab.kernel.accessAllowed && google.colab.files && google.colab.files.view) {\n",
+              "        for (const element of document.querySelectorAll('.filepath')) {\n",
+              "          element.style.display = 'block'\n",
+              "          element.onclick = (event) => {\n",
+              "            event.preventDefault();\n",
+              "            event.stopPropagation();\n",
+              "            google.colab.files.view(element.textContent, 569);\n",
+              "          };\n",
+              "        }\n",
+              "      }\n",
+              "      for (const element of document.querySelectorAll('.function-repr-contents')) {\n",
+              "        element.onclick = (event) => {\n",
+              "          event.preventDefault();\n",
+              "          event.stopPropagation();\n",
+              "          element.classList.toggle('function-repr-contents-collapsed');\n",
+              "        };\n",
+              "      }\n",
+              "      </script>\n",
+              "      </div>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Second Part: Line Graph\n",
+        "x = np.linspace(-6.5, 6.5, num = 100)\n",
+        "s = np.sin(x)\n",
+        "c = np.cos(x)\n",
+        "\n",
+        "plt.plot(x, s, label='Sin')\n",
+        "plt.plot(x, c, label='Cos')\n",
+        "\n",
+        "\n",
+        "plt.xlabel(\"X axis\")\n",
+        "plt.ylabel(\"Y axis\")\n",
+        "plt.title(\"Sin and Cos Functions\")\n",
+        "\n",
+        "\n",
+        "plt.legend(loc = 'lower left')\n",
+        "\n",
+        "plt.show\n"
+      ],
+      "metadata": {
+        "id": "5aXo8SZiT2LQ",
+        "outputId": "6c0e62ba-937a-4cf9-a120-7ce318d73bfb",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 641
+        }
+      },
+      "id": "5aXo8SZiT2LQ",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<function matplotlib.pyplot.show(close=None, block=None)>"
+            ],
+            "text/html": [
+              "<div style=\"max-width:800px; border: 1px solid var(--colab-border-color);\"><style>\n",
+              "      pre.function-repr-contents {\n",
+              "        overflow-x: auto;\n",
+              "        padding: 8px 12px;\n",
+              "        max-height: 500px;\n",
+              "      }\n",
+              "\n",
+              "      pre.function-repr-contents.function-repr-contents-collapsed {\n",
+              "        cursor: pointer;\n",
+              "        max-height: 100px;\n",
+              "      }\n",
+              "    </style>\n",
+              "    <pre style=\"white-space: initial; background:\n",
+              "         var(--colab-secondary-surface-color); padding: 8px 12px;\n",
+              "         border-bottom: 1px solid var(--colab-border-color);\"><b>matplotlib.pyplot.show</b><br/>def show(*args, **kwargs)</pre><pre class=\"function-repr-contents function-repr-contents-collapsed\" style=\"\"><a class=\"filepath\" style=\"display:none\" href=\"#\">/usr/local/lib/python3.10/dist-packages/matplotlib/pyplot.py</a>Display all open figures.\n",
+              "\n",
+              "Parameters\n",
+              "----------\n",
+              "block : bool, optional\n",
+              "    Whether to wait for all figures to be closed before returning.\n",
+              "\n",
+              "    If `True` block and run the GUI main loop until all figure windows\n",
+              "    are closed.\n",
+              "\n",
+              "    If `False` ensure that all figure windows are displayed and return\n",
+              "    immediately.  In this case, you are responsible for ensuring\n",
+              "    that the event loop is running to have responsive figures.\n",
+              "\n",
+              "    Defaults to True in non-interactive mode and to False in interactive\n",
+              "    mode (see `.pyplot.isinteractive`).\n",
+              "\n",
+              "See Also\n",
+              "--------\n",
+              "ion : Enable interactive mode, which shows / updates the figure after\n",
+              "      every plotting command, so that calling ``show()`` is not necessary.\n",
+              "ioff : Disable interactive mode.\n",
+              "savefig : Save the figure to an image file instead of showing it on screen.\n",
+              "\n",
+              "Notes\n",
+              "-----\n",
+              "**Saving figures to file and showing a window at the same time**\n",
+              "\n",
+              "If you want an image file as well as a user interface window, use\n",
+              "`.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)\n",
+              "``show()`` the figure is closed and thus unregistered from pyplot. Calling\n",
+              "`.pyplot.savefig` afterwards would save a new and thus empty figure. This\n",
+              "limitation of command order does not apply if the show is non-blocking or\n",
+              "if you keep a reference to the figure and use `.Figure.savefig`.\n",
+              "\n",
+              "**Auto-show in jupyter notebooks**\n",
+              "\n",
+              "The jupyter backends (activated via ``%matplotlib inline``,\n",
+              "``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at\n",
+              "the end of every cell by default. Thus, you usually don&#x27;t have to call it\n",
+              "explicitly there.</pre>\n",
+              "      <script>\n",
+              "      if (google.colab.kernel.accessAllowed && google.colab.files && google.colab.files.view) {\n",
+              "        for (const element of document.querySelectorAll('.filepath')) {\n",
+              "          element.style.display = 'block'\n",
+              "          element.onclick = (event) => {\n",
+              "            event.preventDefault();\n",
+              "            event.stopPropagation();\n",
+              "            google.colab.files.view(element.textContent, 482);\n",
+              "          };\n",
+              "        }\n",
+              "      }\n",
+              "      for (const element of document.querySelectorAll('.function-repr-contents')) {\n",
+              "        element.onclick = (event) => {\n",
+              "          event.preventDefault();\n",
+              "          event.stopPropagation();\n",
+              "          element.classList.toggle('function-repr-contents-collapsed');\n",
+              "        };\n",
+              "      }\n",
+              "      </script>\n",
+              "      </div>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 23
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ab57312f-fd41-4763-b38c-3b7c1b062b1c",
+      "metadata": {
+        "id": "ab57312f-fd41-4763-b38c-3b7c1b062b1c"
+      },
+      "source": [
+        "**Q3.** This is a basic review of some statistics along with practice writing functions. Like we talked about, Python is a general purpose programming language and ships without basic data handling or statistical packages coded in. The beginning of the code chunk below generates random values for you to test your work on; since the random values are generates as NumPy arrays, you'll need to use the Numpy methods `np.sum(x)` to sum the vector $x$ and `np.sqrt(x)` to take the square roots of the values in $x$, as well as the Python function `len(x)` to get the length of $x$.\n",
+        "\n",
+        "Try to reuse the functions you've already defined as you work through the following questions, rather than rewriting code you've already written.\n",
+        "\n",
+        "1. Write a function that computes the **sample average** or **mean** of a vector $x$,\n",
+        "$$\n",
+        "\\bar{x} = \\dfrac{x_1 + x_2 + ... + x_N}{N} = \\dfrac{\\sum_{i=1}^N x_i}{N}.\n",
+        "$$\n",
+        "Write a function in the code chunk below to compute this quantity, and then use it to compute the mean of $x$.\n",
+        "2. Write a function that computes the **sample standard deviation** of a vector $x$,\n",
+        "$$\n",
+        "s_x = \\sqrt{\\dfrac{(x_1 - \\bar{x})^2 + ... (x_N - \\bar{x})^2 }{N-1}} = \\sqrt{\\dfrac{ \\sum_{i=1}^N (x_i - \\bar{x})^2 }{N-1}}.\n",
+        "$$\n",
+        "The intuition of this quantity is that it computes roughly the average distance from each point $x_i$ to the sample mean $\\bar{x}$. If it is small, it means all the points are clustered tightly around the mean, and if it is large, it means the points are typically far away from the average. Write a function in the code chunk below to compute this quantity, and then use it to compute the sample standard deviation of $x$.\n",
+        "3. Write a function that calls the previous two to **standardize** the values of the vector as a **$z$-score**:\n",
+        "$$\n",
+        "z = \\dfrac{x-\\bar{x}}{s}.\n",
+        "$$\n",
+        "The intuition of this quantity is that it is recentering all the values of $x$ so the average is zero and then scaling them by the standard deviation. If the data are normally distributed and $N$ is large, the $z$ score will approximately follow a standard normal distribution. Write a function in the code chunk below to compute this quantity, and then use it to compute the z-scores for $x$.\n",
+        "4. The **sample covariance** of two vectors $x=(x_1,...,x_N)$ and $y=(y_1,...,y_N)$ is defined as\n",
+        "$$\n",
+        "cov(x,y) = \\dfrac{(x_1 - \\bar{x})(y_1-\\bar{y}) + (x_2 - \\bar{x})(y_2-\\bar{y}) + ... + (x_N - \\bar{x})(y_{N}-\\bar{y})}{N-1}\n",
+        "$$\n",
+        "$$\n",
+        "= \\dfrac{\\sum_{i=1}^N (x_i - \\bar{x})(y_i - \\bar{y})}{N-1}.\n",
+        "$$\n",
+        "The intuition of this quantity is that it looks at the pairs $(x_i, y_i)$ and compares them to the means $(\\bar{x},\\bar{y})$ to determine whether $x$ and $y$ tend to co-vary in the same direction relative to their means: If the values of $x$ and $y$ are typically both above or below the mean values of $x$ and $y$, then $x$ and $y$ will have a positive covariance, but if $x$ is typically above the mean of $x$ when $y$ is typically below the mean of $y$ or vice versa, then they will have a negative covariance. Write a function in the code chunk below to compute this quantity, and then use it to compute the covariance of the generated $x$ and $y$.\n",
+        "6. The **sample correlation coefficient** of two vectors $x$ and $y$ is defined as\n",
+        "$$\n",
+        "r_{xy} = \\dfrac{cov(x,y)}{s_x s_y}\n",
+        "$$\n",
+        "Use your functions to create a new function that compute this quantity. The intuition of this quantity is that it is like the covariance, but normalized so that its values like between -1 and 1: perfect negative linear association between the variables at -1, no association at 0, and perfect positive linear association between the variables at 1."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "f42ab788-af0c-47a4-a103-46c9a37bfad3",
+      "metadata": {
+        "id": "f42ab788-af0c-47a4-a103-46c9a37bfad3"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import math as math\n",
+        "np.random.seed(100) # Set the seed for the random number generator\n",
+        "rho, sigma_x, sigma_y = -.4, 3, 2 # Variance-Covariance Parameters\n",
+        "vcv = np.array([[sigma_x**2, rho*sigma_x*sigma_y],\n",
+        "                [rho*sigma_x*sigma_y,sigma_y**2]]) # VCV Matrix\n",
+        "mu = np.array([-1,2]) # Population averages\n",
+        "sample = np.random.multivariate_normal(mu,vcv,200) # Multivariate normal draws\n",
+        "x = sample[:,0]\n",
+        "y = sample[:,1]\n",
+        "\n",
+        "#############################################################################\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5924279e-4b74-4941-9819-f028ce3db974",
+      "metadata": {
+        "id": "5924279e-4b74-4941-9819-f028ce3db974"
+      },
+      "source": [
+        "**Q4.** Optimization is at the core of data science and statistics: Picking the best fit or estimate according to some desirable criteria (e.g. Maximum Likelihood Estimation). In this question, you're going to write a function that finds the highest possible value for some function, and returns the value of the function and the maximizing value.\n",
+        "\n",
+        "1. Write a function that creates a grid from some value $a$ to a second value $b$ with $N$ steps, computes the value of a function $f$ on that grid, and then finds the maximizers of the function. Have it return a dictionary with the maximum value and the maximizers themselves.\n",
+        "2. Use your function to maximize $f(x) = 100 - 2x^2 + 3x$ for values of $a=-1$, $b=1$, and for values of $N=3$, $N=10$, $N=100$, $N=1000$ and $N=5000$.\n",
+        "3. The true maximizer of this function is $.75$ and the true maximum value is $101.125$. Is that what you got in the previous step? Why not? How does the quality of the maximization depend on $N$? How does your computed answer change as $N$ gets larger?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c3b32977-7687-4770-8f12-2ab0593f2258",
+      "metadata": {
+        "id": "c3b32977-7687-4770-8f12-2ab0593f2258"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "3c6e5e34-00c0-4101-a1af-34cf61d69ffc",
+      "metadata": {
+        "id": "3c6e5e34-00c0-4101-a1af-34cf61d69ffc"
+      },
+      "source": [
+        "3."
+      ]
+    }
+  ],
+  "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.4"
+    },
+    "colab": {
+      "provenance": [],
+      "toc_visible": true
+    }
   },
-  {
-   "cell_type": "markdown",
-   "id": "4a3fb7b5-0345-447d-840a-59f667fe9c0c",
-   "metadata": {},
-   "source": [
-    "**Q1.** First, think about your priorities in life. What kind of salary do you want to make after graduation? Do you mind getting more schooling? What kind of work-life balance are you looking for? Where do you want to work, geographically? You don't have to write this down here, just think about it.\n",
-    "\n",
-    "1. Go to the Occupational Outlook Handbook at [https://www.bls.gov/ooh/](https://www.bls.gov/ooh/). Look up \"Data Scientist.\" Read about the job and start collecting data about it from the job profile (e.g. salary, education required, work setting)\n",
-    "2. Find 7-10 other jobs that appeal to you, and collect the same data as you did for Data Scientist. Put it all in a spreadsheet.\n",
-    "3. Do any of your findings surprise you?\n",
-    "4. Rank the jobs you picked from best to worst, and briefly explain why you did so.\n",
-    "5. Please submit your spreadsheet with the assignment --- you can \"de-identify\" it and remove anything that you find personally identifying or you don't want to share, of course. We'll play with these data later.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7e9d65ad-3740-43d3-a944-b3653fbeb80c",
-   "metadata": {},
-   "source": [
-    "Depends on student opinions."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7cfa75b2-aaef-4368-a043-93437887879c",
-   "metadata": {},
-   "source": [
-    "**Q2.** Being able to make basic plots to visualize sets of points is really helpful, particularly with data analysis. The pyplot plots are built up slowly by defining elements of the plot, and then using `plt.show()` to create the final plot. This question gives you some practice doing that **iterative** building process.\n",
-    "\n",
-    "1. Import the `numpy` module as `np` and the `matplotlib.pyplot` package as `plt`.\n",
-    "2. Use `np.linspace` to create a grid of 50 points ranging from 0 to 1.\n",
-    "3. Create a numpy array $y$ containing the values for the natural logarithm function using the `np.log(x)` function. Create a numpy array $z$ containing the values for the exponential function using the `np.exp(x)` function.\n",
-    "4. Use the `plt.scatter(x,y)` method for the $y$ and $z$ vectors to create two scatter plots of the points you've created.\n",
-    "5. Use the `plt.show()` method to create the plot.\n",
-    "\n",
-    "That plot has some problems.\n",
-    "\n",
-    "6. Before the `plt.show()` call, add labels to the $x$ and $y$ axes using `plt.xlabel(label)` and `plt.ylabel(label)`. Add a title to the graph using `plt.title(title)`, like \"Natural Log and Exponential Functions\".\n",
-    "7. That looks a lot better, but we need a legend. When you screate the scatter plots, add the argument `label='Natural Log'` or `label='Exponential'` to the `.scatter` method call. Before the `plt.show()` call, add a `plt.legend(loc = 'lower right')` method call, which creates a legend in the lower right.\n",
-    "\n",
-    "Now do it again, with slightly less direction:\n",
-    "\n",
-    "8. Create a grid of 100 equally spaced points ranging from -6.5 to 6.5.\n",
-    "9. Use the sine and cosine functions in Numpy to compute the values of those functions for each point on your grid. (You'll have to find out what those functions are.)\n",
-    "10. Plot the values of the two functions for the values on the grid on the same plot.\n",
-    "11. The scatter plot looks really noisy. Instead of `plt.scatter(x,y)` to make a scatter plot, use `plt.plot(x,y)` to make a line graph.\n",
-    "12. Make the plot again, with labels for the axes, a title, and a legend in the lower left instead of the lower right.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "9c05ee86-06dc-4ae9-896d-0cb70c4d6c3d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ab57312f-fd41-4763-b38c-3b7c1b062b1c",
-   "metadata": {},
-   "source": [
-    "**Q3.** This is a basic review of some statistics along with practice writing functions. Like we talked about, Python is a general purpose programming language and ships without basic data handling or statistical packages coded in. The beginning of the code chunk below generates random values for you to test your work on; since the random values are generates as NumPy arrays, you'll need to use the Numpy methods `np.sum(x)` to sum the vector $x$ and `np.sqrt(x)` to take the square roots of the values in $x$, as well as the Python function `len(x)` to get the length of $x$.\n",
-    "\n",
-    "Try to reuse the functions you've already defined as you work through the following questions, rather than rewriting code you've already written.\n",
-    "\n",
-    "1. Write a function that computes the **sample average** or **mean** of a vector $x$,\n",
-    "$$\n",
-    "\\bar{x} = \\dfrac{x_1 + x_2 + ... + x_N}{N} = \\dfrac{\\sum_{i=1}^N x_i}{N}.\n",
-    "$$\n",
-    "Write a function in the code chunk below to compute this quantity, and then use it to compute the mean of $x$.\n",
-    "2. Write a function that computes the **sample standard deviation** of a vector $x$,\n",
-    "$$\n",
-    "s_x = \\sqrt{\\dfrac{(x_1 - \\bar{x})^2 + ... (x_N - \\bar{x})^2 }{N-1}} = \\sqrt{\\dfrac{ \\sum_{i=1}^N (x_i - \\bar{x})^2 }{N-1}}.\n",
-    "$$\n",
-    "The intuition of this quantity is that it computes roughly the average distance from each point $x_i$ to the sample mean $\\bar{x}$. If it is small, it means all the points are clustered tightly around the mean, and if it is large, it means the points are typically far away from the average. Write a function in the code chunk below to compute this quantity, and then use it to compute the sample standard deviation of $x$.\n",
-    "3. Write a function that calls the previous two to **standardize** the values of the vector as a **$z$-score**:\n",
-    "$$\n",
-    "z = \\dfrac{x-\\bar{x}}{s}.\n",
-    "$$\n",
-    "The intuition of this quantity is that it is recentering all the values of $x$ so the average is zero and then scaling them by the standard deviation. If the data are normally distributed and $N$ is large, the $z$ score will approximately follow a standard normal distribution. Write a function in the code chunk below to compute this quantity, and then use it to compute the z-scores for $x$.\n",
-    "4. The **sample covariance** of two vectors $x=(x_1,...,x_N)$ and $y=(y_1,...,y_N)$ is defined as\n",
-    "$$\n",
-    "cov(x,y) = \\dfrac{(x_1 - \\bar{x})(y_1-\\bar{y}) + (x_2 - \\bar{x})(y_2-\\bar{y}) + ... + (x_N - \\bar{x})(y_{N}-\\bar{y})}{N-1}\n",
-    "$$\n",
-    "$$\n",
-    "= \\dfrac{\\sum_{i=1}^N (x_i - \\bar{x})(y_i - \\bar{y})}{N-1}.\n",
-    "$$\n",
-    "The intuition of this quantity is that it looks at the pairs $(x_i, y_i)$ and compares them to the means $(\\bar{x},\\bar{y})$ to determine whether $x$ and $y$ tend to co-vary in the same direction relative to their means: If the values of $x$ and $y$ are typically both above or below the mean values of $x$ and $y$, then $x$ and $y$ will have a positive covariance, but if $x$ is typically above the mean of $x$ when $y$ is typically below the mean of $y$ or vice versa, then they will have a negative covariance. Write a function in the code chunk below to compute this quantity, and then use it to compute the covariance of the generated $x$ and $y$.\n",
-    "6. The **sample correlation coefficient** of two vectors $x$ and $y$ is defined as\n",
-    "$$\n",
-    "r_{xy} = \\dfrac{cov(x,y)}{s_x s_y}\n",
-    "$$\n",
-    "Use your functions to create a new function that compute this quantity. The intuition of this quantity is that it is like the covariance, but normalized so that its values like between -1 and 1: perfect negative linear association between the variables at -1, no association at 0, and perfect positive linear association between the variables at 1. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f42ab788-af0c-47a4-a103-46c9a37bfad3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import math as math\n",
-    "np.random.seed(100) # Set the seed for the random number generator\n",
-    "rho, sigma_x, sigma_y = -.4, 3, 2 # Variance-Covariance Parameters\n",
-    "vcv = np.array([[sigma_x**2, rho*sigma_x*sigma_y],\n",
-    "                [rho*sigma_x*sigma_y,sigma_y**2]]) # VCV Matrix\n",
-    "mu = np.array([-1,2]) # Population averages\n",
-    "sample = np.random.multivariate_normal(mu,vcv,200) # Multivariate normal draws\n",
-    "x = sample[:,0]\n",
-    "y = sample[:,1]\n",
-    "\n",
-    "#############################################################################\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5924279e-4b74-4941-9819-f028ce3db974",
-   "metadata": {},
-   "source": [
-    "**Q4.** Optimization is at the core of data science and statistics: Picking the best fit or estimate according to some desirable criteria (e.g. Maximum Likelihood Estimation). In this question, you're going to write a function that finds the highest possible value for some function, and returns the value of the function and the maximizing value.\n",
-    "\n",
-    "1. Write a function that creates a grid from some value $a$ to a second value $b$ with $N$ steps, computes the value of a function $f$ on that grid, and then finds the maximizers of the function. Have it return a dictionary with the maximum value and the maximizers themselves.\n",
-    "2. Use your function to maximize $f(x) = 100 - 2x^2 + 3x$ for values of $a=-1$, $b=1$, and for values of $N=3$, $N=10$, $N=100$, $N=1000$ and $N=5000$.\n",
-    "3. The true maximizer of this function is $.75$ and the true maximum value is $101.125$. Is that what you got in the previous step? Why not? How does the quality of the maximization depend on $N$? How does your computed answer change as $N$ gets larger?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "c3b32977-7687-4770-8f12-2ab0593f2258",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3c6e5e34-00c0-4101-a1af-34cf61d69ffc",
-   "metadata": {},
-   "source": [
-    "3. "
-   ]
-  }
- ],
- "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.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/assignment/jobs_data.csv b/assignment/jobs_data.csv
new file mode 100644
index 0000000..c22ca0e
--- /dev/null
+++ b/assignment/jobs_data.csv
@@ -0,0 +1,11 @@
+Job Name,2023 Median Pay (USD,Typical Entry-Level Education,Work Setting ,Projected Growth Percent (2023 - 2033) ,"Number of Jobs, 2023",Work Experience in a Related Occupation,On the Job Training
+Data Scientist,"108,020",Bachelor's degree,Office,36,"202,900",None,"None
"
+"Software Developers, Quality Assurance Analysts, and Testers","130,160",Bachelor's degree,Office,17,"1,897,100",None,"None
"
+"Plumbers, Pipefitters, and Steamfitters","61,550",High school diploma or equivalent,Traveling,6,"473,400","None
","Apprenticeship
"
+Automotive Service Technicians and Mechanics,"47,770",Postsecondary nondegree award,Repair Shop,3,"794,600",None,Short-term on-the-job training
+Airline and Commercial Pilots,"171,210",Bachelor's degree and Flight School,Vehicle,5,"152,800",Comercial or Military Pilot,"Moderate-term on-the-job training
"
+Athletes and Sports Competitors,"70,280","No formal educational credential
",Athletic Facilities,11,"25,100",None,"Long-term on-the-job training
"
+"Mechanical Engineers
","99,510",Bachelor's degree,Office,11,"291,900",None,"None
"
+Aerospace Engineer,"130,720","Bachelor's degree
",Office,6,"68,900",None,"None
"
+"Kindergarten and Elementary School Teachers
+","63,670","Bachelor's degree
",School,-1,"1,563,700",None,"None
"
\ No newline at end of file