Code_Challenge_Student.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Code_Challenge_Student.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bparra94/wizeline_application_bootcamp/blob/main/Code_Challenge_Student.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Data Bootcamp Selection Challenge\n",
        "#####In this challenge you will calculate various KPIs using a car based dataset, each question will have a single correct answer that will be evaluated through automated unit testing. Use the dictionary provided below to fill in your answers, each question will state the format required for the answer and examples are provided so you know how properly fill the answer dictionary. \n",
        "#####**Use the dataset \"as is\" and do not perform any data cleaning or modify it in any way, doing so could make you answer all your questions incorrectly. Do not modify the structure of the answer dictionary.**\n",
        "\n",
        "#####When you finish this challenge please upload both your notebook and your answer dictionary in pickle format to a public github repository submit their URL to the [google form](https://forms.gle/wWysZEMkoZsjB11Y7) that was provided to you.\n",
        "\n",
        "##### Some unit tests are provided at the end of this notebook to help you verify your answers are in the correct format, however they will not test everything.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "Ab6tQ8XLwqzG"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "1kj3oTmRvWXi"
      },
      "outputs": [],
      "source": [
        "#Use this dictionary to store your answers in the correct format in the cells below , do not modify the keys\n",
        "answer_dict =  {\"Q1\" : None,\n",
        "                \"Q2\" : None,\n",
        "                \"Q3\" : None,\n",
        "                \"Q4\" : None,\n",
        "                \"Q5\" : None,\n",
        "                \"Q6\" : None,\n",
        "                \"Q7\" : None}"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Reading the dataset\n",
        "#####An example is provided to read the dataset using [pandas](https://pandas.pydata.org/), while we reccommend using pandas you may use any python library to solve this challenge. "
      ],
      "metadata": {
        "id": "Z0pZ4Vlx3VZy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "url='https://drive.google.com/file/d/1PCJ7ltluquoXKi6MYTPMfwZQNI_-MIFP/view?usp=sharing'\n",
        "url='https://drive.google.com/uc?id=' + url.split('/')[-2]\n",
        "df = pd.read_csv(url)"
      ],
      "metadata": {
        "id": "7U3UNKSj3oxa"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.head()"
      ],
      "metadata": {
        "id": "J10uW58Qv2B_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 354
        },
        "outputId": "b6960007-341d-447d-ebd7-29f8bce633a6"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "               Make                Model  Year  Engine Displacement  \\\n",
              "0        AM General    DJ Po Vehicle 2WD  1984                  2.5   \n",
              "1        AM General     FJ8c Post Office  1984                  4.2   \n",
              "2        AM General  Post Office DJ5 2WD  1985                  2.5   \n",
              "3        AM General  Post Office DJ8 2WD  1985                  4.2   \n",
              "4  ASC Incorporated                  GNX  1987                  3.8   \n",
              "\n",
              "   Cylinders     Transmission        Drivetrain                Vehicle Class  \\\n",
              "0        4.0  Automatic 3-spd     2-Wheel Drive  Special Purpose Vehicle 2WD   \n",
              "1        6.0  Automatic 3-spd     2-Wheel Drive  Special Purpose Vehicle 2WD   \n",
              "2        4.0  Automatic 3-spd  Rear-Wheel Drive  Special Purpose Vehicle 2WD   \n",
              "3        6.0  Automatic 3-spd  Rear-Wheel Drive  Special Purpose Vehicle 2WD   \n",
              "4        6.0  Automatic 4-spd  Rear-Wheel Drive                 Midsize Cars   \n",
              "\n",
              "  Fuel Type  Fuel Barrels/Year  City MPG  Highway MPG  Combined MPG  \\\n",
              "0   Regular          19.388824        18           17            17   \n",
              "1   Regular          25.354615        13           13            13   \n",
              "2   Regular          20.600625        16           17            16   \n",
              "3   Regular          25.354615        13           13            13   \n",
              "4   Premium          20.600625        14           21            16   \n",
              "\n",
              "   CO2 Emission Grams/Mile  Fuel Cost/Year  \n",
              "0               522.764706            1950  \n",
              "1               683.615385            2550  \n",
              "2               555.437500            2100  \n",
              "3               683.615385            2550  \n",
              "4               555.437500            2550  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-e44bd54f-2319-4685-80eb-29e3cda30504\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Make</th>\n",
              "      <th>Model</th>\n",
              "      <th>Year</th>\n",
              "      <th>Engine Displacement</th>\n",
              "      <th>Cylinders</th>\n",
              "      <th>Transmission</th>\n",
              "      <th>Drivetrain</th>\n",
              "      <th>Vehicle Class</th>\n",
              "      <th>Fuel Type</th>\n",
              "      <th>Fuel Barrels/Year</th>\n",
              "      <th>City MPG</th>\n",
              "      <th>Highway MPG</th>\n",
              "      <th>Combined MPG</th>\n",
              "      <th>CO2 Emission Grams/Mile</th>\n",
              "      <th>Fuel Cost/Year</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>AM General</td>\n",
              "      <td>DJ Po Vehicle 2WD</td>\n",
              "      <td>1984</td>\n",
              "      <td>2.5</td>\n",
              "      <td>4.0</td>\n",
              "      <td>Automatic 3-spd</td>\n",
              "      <td>2-Wheel Drive</td>\n",
              "      <td>Special Purpose Vehicle 2WD</td>\n",
              "      <td>Regular</td>\n",
              "      <td>19.388824</td>\n",
              "      <td>18</td>\n",
              "      <td>17</td>\n",
              "      <td>17</td>\n",
              "      <td>522.764706</td>\n",
              "      <td>1950</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>AM General</td>\n",
              "      <td>FJ8c Post Office</td>\n",
              "      <td>1984</td>\n",
              "      <td>4.2</td>\n",
              "      <td>6.0</td>\n",
              "      <td>Automatic 3-spd</td>\n",
              "      <td>2-Wheel Drive</td>\n",
              "      <td>Special Purpose Vehicle 2WD</td>\n",
              "      <td>Regular</td>\n",
              "      <td>25.354615</td>\n",
              "      <td>13</td>\n",
              "      <td>13</td>\n",
              "      <td>13</td>\n",
              "      <td>683.615385</td>\n",
              "      <td>2550</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>AM General</td>\n",
              "      <td>Post Office DJ5 2WD</td>\n",
              "      <td>1985</td>\n",
              "      <td>2.5</td>\n",
              "      <td>4.0</td>\n",
              "      <td>Automatic 3-spd</td>\n",
              "      <td>Rear-Wheel Drive</td>\n",
              "      <td>Special Purpose Vehicle 2WD</td>\n",
              "      <td>Regular</td>\n",
              "      <td>20.600625</td>\n",
              "      <td>16</td>\n",
              "      <td>17</td>\n",
              "      <td>16</td>\n",
              "      <td>555.437500</td>\n",
              "      <td>2100</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>AM General</td>\n",
              "      <td>Post Office DJ8 2WD</td>\n",
              "      <td>1985</td>\n",
              "      <td>4.2</td>\n",
              "      <td>6.0</td>\n",
              "      <td>Automatic 3-spd</td>\n",
              "      <td>Rear-Wheel Drive</td>\n",
              "      <td>Special Purpose Vehicle 2WD</td>\n",
              "      <td>Regular</td>\n",
              "      <td>25.354615</td>\n",
              "      <td>13</td>\n",
              "      <td>13</td>\n",
              "      <td>13</td>\n",
              "      <td>683.615385</td>\n",
              "      <td>2550</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>ASC Incorporated</td>\n",
              "      <td>GNX</td>\n",
              "      <td>1987</td>\n",
              "      <td>3.8</td>\n",
              "      <td>6.0</td>\n",
              "      <td>Automatic 4-spd</td>\n",
              "      <td>Rear-Wheel Drive</td>\n",
              "      <td>Midsize Cars</td>\n",
              "      <td>Premium</td>\n",
              "      <td>20.600625</td>\n",
              "      <td>14</td>\n",
              "      <td>21</td>\n",
              "      <td>16</td>\n",
              "      <td>555.437500</td>\n",
              "      <td>2550</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e44bd54f-2319-4685-80eb-29e3cda30504')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-e44bd54f-2319-4685-80eb-29e3cda30504 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-e44bd54f-2319-4685-80eb-29e3cda30504');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.info()"
      ],
      "metadata": {
        "id": "LutcGEx8v4GY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7aa03dc7-df64-4c6a-8ebb-bec68ec09aad"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 35952 entries, 0 to 35951\n",
            "Data columns (total 15 columns):\n",
            " #   Column                   Non-Null Count  Dtype  \n",
            "---  ------                   --------------  -----  \n",
            " 0   Make                     35952 non-null  object \n",
            " 1   Model                    35952 non-null  object \n",
            " 2   Year                     35952 non-null  int64  \n",
            " 3   Engine Displacement      35952 non-null  float64\n",
            " 4   Cylinders                35952 non-null  float64\n",
            " 5   Transmission             35952 non-null  object \n",
            " 6   Drivetrain               35952 non-null  object \n",
            " 7   Vehicle Class            35952 non-null  object \n",
            " 8   Fuel Type                35952 non-null  object \n",
            " 9   Fuel Barrels/Year        35952 non-null  float64\n",
            " 10  City MPG                 35952 non-null  int64  \n",
            " 11  Highway MPG              35952 non-null  int64  \n",
            " 12  Combined MPG             35952 non-null  int64  \n",
            " 13  CO2 Emission Grams/Mile  35952 non-null  float64\n",
            " 14  Fuel Cost/Year           35952 non-null  int64  \n",
            "dtypes: float64(4), int64(5), object(6)\n",
            "memory usage: 4.1+ MB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q1. What is the average CO2 emmission per gram/mile of all Volkswagen cars?\n",
        "\n",
        "##### Format: A floating number\n",
        "##### Example answer:\n",
        " `11.547`"
      ],
      "metadata": {
        "id": "kLRp8K_wnEJG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "########## Q1\n",
        "#Your code here\n",
        "volkswagen_df = df[['Make', 'CO2 Emission Grams/Mile']]\n",
        "volkswagen_mask = volkswagen_df['Make'] == \"Volkswagen\"\n",
        "answer_dict[\"Q1\"] = volkswagen_df.loc[volkswagen_mask]['CO2 Emission Grams/Mile'].mean()\n",
        "\n",
        "\n",
        "#Example answer:\n",
        "#answer_dict[\"Q1\"] =  11.547"
      ],
      "metadata": {
        "id": "jBGXf7RRnEoV"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q2. Calculate the top 5 brands(Make) with the most unique models, order your answer in descending order with respect to the number of unique models.\n",
        "##### **NOTE:** Consider only the name of the models and their brand, that is use only the Make and Model columns\n",
        "##### Format: A 5X2 list with each row being the name of the brand followed by the unique number of models, in descending order.\n",
        "#####Hint: You can use the pandas [df.values.tolist()](https://pandas.pydata.org/docs/reference/api/pandas.Series.tolist.html) function to format your answer.\n",
        "\n",
        "##### Example answer: \n",
        "`[[\"Volkswagen\", 1000], [\"Toyota\", 900], [\"Honda\", 800], [\"Subaru\", 700], [\"Ford\", 600]]`"
      ],
      "metadata": {
        "id": "SPNq7yn74kjd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "########## Q2\n",
        "#Your code here\n",
        "\n",
        "df['Model'] = df['Model'].str.upper() # Ensuring unique Models..i.e for BMW Maker 318i/318iS model is similar to 318i/318is\n",
        "distinct_models = df.groupby(['Make']).agg({'Model': ['nunique']}).reset_index()\n",
        "distinct_models.columns = ['Make', 'count_distinct_models']\n",
        "answer_dict[\"Q2\"] = distinct_models.sort_values(by='count_distinct_models', ascending=False).head(5).values.tolist()\n",
        "\n",
        "#Example answer:\n",
        "#answer_dict[\"Q2\"] =  [[\"Volkswagen\", 1000], [\"Toyota\", 900], [\"Honda\", 800], [\"Subaru\", 700], [\"Ford\", 600]] "
      ],
      "metadata": {
        "id": "StipyFue4Dx-"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q3. What are all the different types of fuels in the dataset sorted alphabetically?\n",
        "##### Format: A list of strings sorted alphabetically.\n",
        "##### Example Answer: \n",
        "`['Regular',\n",
        " 'Premium']`"
      ],
      "metadata": {
        "id": "EGxv7N15AiLu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "########## Q3\n",
        "#Your code here\n",
        "answer_dict[\"Q3\"] = sorted(df['Fuel Type'].unique(), key=lambda v: v.upper())  #I have assigned 'Fuel Type' to upper in order to do a real alphabetical ordering\n",
        "\n",
        "#Example answer:\n",
        "#answer_dict[\"Q3\"] =  ['Regular', 'Premium'] "
      ],
      "metadata": {
        "id": "otyDsWpsAjde"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q4. Show the 9 Toyota cars with the most extreme Fuel Barrels/Year in abosolute terms within all Toyota cars. Show the car Model, Year and their Fuel Barrels/Year in standard deviation units([Z-score](https://fredclavel.org/2019/03/18/basics-standardization-and-the-z-score/)) **sorted** in descending order by their Fuel Barrels/Year in absolute terms first and then by year in descending order **BUT** without modifying the negative values (see example).\n",
        "\n",
        "##### Format: A 9X3 list with each row containing the Model, Year and Fuel Barrels/Year in standard deviations units\n",
        "\n",
        "##### Example answer: \n",
        "```\n",
        "[['DJ Po Vehicle 2WD', 2004, -6.407431084026927],\n",
        " ['FJ8c Post Office', 2003, -6.407431084026927],\n",
        " ['Post Office DJ5 2WD', 2005, -6.391684618442447],\n",
        " ['Sierra 2500 Hd 2WD', 2002, -6.391684618442447],\n",
        " ['Camry CNG', 2012, 2.677633075759575],\n",
        " ['Sierra 1500 4WD', 2005, 2.677633075759575],\n",
        " ['Sierra 1500 4WD', 2001, 2.677633075759575],\n",
        " ['V15 Suburban 4WD', 1988, 2.677633075759575],\n",
        " ['V15 Suburban 4WD', 1987, 2.677633075759575]]\n",
        "```\n",
        "#####Note that while the list is sorted by the Fuel Barrels/Year in absolute terms and in standard deviation units, the values are not modified. If the values are the same the rows are sorted by the year.\n"
      ],
      "metadata": {
        "id": "ijpZht03tV5W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "########## Q4\n",
        "#Your code here\n",
        "toyota = df.loc[df['Make'] == 'Toyota'][['Model', 'Year', 'Fuel Barrels/Year']]\n",
        "toyota['Fuel_Barrels/Year_zscore'] = (toyota['Fuel Barrels/Year'] - toyota['Fuel Barrels/Year'].mean())/toyota['Fuel Barrels/Year'].std(ddof=0)\n",
        "toyota['Abs_Fuel_Barrels/Year_zscore'] = abs(toyota['Fuel_Barrels/Year_zscore'])\n",
        "toyota = toyota.sort_values(['Abs_Fuel_Barrels/Year_zscore', 'Year'], ascending=[False, False]).head(9)\n",
        "\n",
        "answer_dict[\"Q4\"] = toyota[['Model', 'Year', 'Fuel_Barrels/Year_zscore']].values.tolist()"
      ],
      "metadata": {
        "id": "de_GgmrFVcvO"
      },
      "execution_count": 74,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q5. Calculate the changes in Combined MPG with their previous model of all Golf cars with Manual 5-spd transmission and Regular Fuel Type. Show the Year, the Combined MPG and the calculated difference of MPG in a list sorted by Year in ascending order.\n",
        "\n",
        "##### Format: A 19X3 list, with the Year and Combined MPG being of type integer **and only the calculated difference is of type float**\n",
        "##### **Note: The value for the first model should be 0.** It does not matter that there are gaps in the years, calculate with respect the previous model.\n",
        "\n",
        "#####Example answer:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "[[1986, 25, 0.0],\n",
        " [1987, 25, 0.0],\n",
        " [1988, 25, 0.0],\n",
        " [1989, 25, 0.0],\n",
        " [1990, 23, -2.0],\n",
        " [1991, 23, 0.0],\n",
        " [1992, 24, 1.0],\n",
        " [1993, 25, 1.0],\n",
        " [1994, 25, 0.0],\n",
        " [1995, 25, 0.0],\n",
        " [1996, 25, 0.0],\n",
        " [1997, 25, 0.0],\n",
        " [1998, 24, -1.0],\n",
        " [1999, 25, 1.0],\n",
        " [2000, 24, -1.0],\n",
        " [2001, 24, 0.0],\n",
        " [2002, 24, 0.0],\n",
        " [2004, 24, 0.0],\n",
        " [2006, 24, 0.0]]\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "7eCpEljJnXzt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "########## Q5\n",
        "#Your code here\n",
        "golf = df.loc[(df['Model'] == 'GOLF')  & (df['Transmission'] == 'Manual 5-spd') & (df['Fuel Type'] == 'Regular')][['Year', 'Combined MPG']]\n",
        "golf['change_combined_mpg'] = golf['Combined MPG'].diff()\n",
        "golf['change_combined_mpg'] = golf['change_combined_mpg'].replace(np.nan, 0)\n",
        "golf_list = golf.values.tolist()\n",
        "\n",
        "rows = len(golf_list)\n",
        "columns = len(golf_list[0])\n",
        "\n",
        "for i in range(rows):\n",
        "  for j in range(columns):\n",
        "    if j == 2:\n",
        "      continue\n",
        "    else:\n",
        "      golf_list[i][j] = int(golf_list[i][j])\n",
        "\n",
        "answer_dict[\"Q5\"] = golf_list"
      ],
      "metadata": {
        "id": "lMlKfEWUH3S9"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q6. What are the top 5 lowest CO2 Emission Grams/Mile emmisions of cars for each of the following brands: Toyota, Ford, Volkswagen, Nissan, Honda\n",
        "\n",
        "#####Format: A 5X6 list with the first element of each row being the Make of the cars and the following five values being floats sorted in ascending order. The Makes should appear in order listed in the question starting with Toyota and ending with Honda (see example).\n",
        "\n",
        "#####Example answer:\n",
        "\n",
        "```\n",
        "[['Toyota', 100.0, 140.0, 140.0, 150.0, 150.0],\n",
        " ['Ford',\n",
        "  100.025641025641,\n",
        "  200.677633075759575,\n",
        "  200.677633075759575,\n",
        "  200.677633075759575,\n",
        "  200.677633075759575],\n",
        " ['Volkswagen', 139.0, 154.0, 166.5, 166.5, 166.5],\n",
        " ['Nissan', 122.0, 122.0, 122.0, 122.0, 160.0],\n",
        " ['Honda', 100.0, 100.0, 100.0, 100.0, 123.91684618442447]]\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "EnHdqUs-nagE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "########## Q6\n",
        "#Your code here\n",
        "min_co2 = df.loc[df['Make'].isin(['Toyota', 'Ford', 'Volkswagen', 'Nissan', 'Honda'])]\n",
        "min_co2 = min_co2.groupby(['Make', 'Model']).agg({'CO2 Emission Grams/Mile': ['min']}).reset_index()\n",
        "min_co2.columns = ['Make', 'Model', 'min_CO2_Emission_Grams/Mil']\n",
        "min_co2 = min_co2.sort_values(['Make', 'min_CO2_Emission_Grams/Mil'], ascending=[False, True])\n",
        "min_co2['rank'] = min_co2.groupby(['Make']).cumcount()\n",
        "min_co2 = min_co2.loc[(min_co2['rank'] <= 4)]\n",
        "min_co2 = min_co2[['Make', 'min_CO2_Emission_Grams/Mil', 'rank']]\n",
        "\n",
        "pivoted = min_co2.pivot(index='Make', columns='rank', values='min_CO2_Emission_Grams/Mil').reset_index()\n",
        "sort_mapping = pd.DataFrame({'Make': ['Toyota', 'Ford', 'Volkswagen', 'Nissan', 'Honda'],}).reset_index().set_index('Make')\n",
        "pivoted['order'] = pivoted['Make'].map(sort_mapping['index'])\n",
        "pivoted = pivoted.sort_values('order')\n",
        "pivoted = pivoted[['Make', 0, 1, 2, 3, 4]]\n",
        "\n",
        "answer_dict[\"Q6\"] = pivoted.values.tolist()"
      ],
      "metadata": {
        "id": "8KKg3bT6na41"
      },
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q7. Form 7 groups of 5 years to calculated the median Combined MPG of each group. The first group is from 1984 to 1988, the second from 1989 to 1993 and so on. The last group will have years not appearing in the dataset.\n",
        "\n",
        "#####Note: The groups ranges are inclusive on both sides, the first group starts with 1984 and cars from 1984 are included in it.\n",
        "#####Format : A 7X2 list with the first element of each row being a tuple of two integers being the lower and uppper range of the year groups and the esecond element being the median Combined MPG of that group, a float number.\n",
        "\n",
        "#####Example answer:\n",
        "\n",
        "\n",
        "```\n",
        "[[(1984, 1988), 11.0],\n",
        " [(1989, 1993), 10.0],\n",
        " [(1994, 1998), 10.0],\n",
        " [(1999, 2003), 14.0],\n",
        " [(2004, 2008), 13.0],\n",
        " [(2009, 2013), 14.0],\n",
        " [(2014, 2018), 15.0]]\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "gDNo1Fcesgk5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "########## Q7\n",
        "#Your code here\n",
        "import math\n",
        "groups = math.ceil(len(sorted(list(df['Year'].unique()))) / 5)\n",
        "\n",
        "vals = []\n",
        "min = df['Year'].min()\n",
        "for i in range(groups):\n",
        "  vals.append((min, min+5-1))\n",
        "  min += 5 \n",
        "\n",
        "medians = []\n",
        "\n",
        "for i in vals:\n",
        "  medians.append(df.loc[(df['Year'] >= i[0])  & (df['Year'] <= i[1])]['Combined MPG'].median())\n",
        "\n",
        "total = []\n",
        "\n",
        "for i in range(len(vals)):\n",
        "  total.append([vals[i], medians[i]])\n",
        "\n",
        "answer_dict[\"Q7\"] = total"
      ],
      "metadata": {
        "id": "1cMEyFXVxBU3"
      },
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Test your answers\n",
        "\n",
        "##### We provide you some tests to make sure your answer dictionary is in the correct format using unittest.\n",
        "##### These tests are not meant to be comprehensive, you should review all your answers carefully."
      ],
      "metadata": {
        "id": "LiGydnlQ4cX4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import unittest\n",
        "\n",
        "class TestAnswers(unittest.TestCase):\n",
        "    def test_if_dict(self):\n",
        "        self.assertIsInstance(answer_dict, dict)\n",
        "\n",
        "    def test_keys(self):\n",
        "        self.assertEqual(list(answer_dict.keys()), ['Q1', 'Q2', 'Q3', 'Q4', 'Q5', 'Q6', 'Q7'])\n",
        "\n",
        "    def test_answers_types(self):\n",
        "        types_values = [type(k) for k in answer_dict.values()]\n",
        "        answer_types = [float, list, list, list, list, list, list]\n",
        "        self.assertEqual(types_values, answer_types)\n",
        "\n",
        "    def test_Q1(self):\n",
        "        self.assertEqual(type(answer_dict['Q1']), float)\n",
        "\n",
        "    def test_Q2_dim(self):\n",
        "        self.assertEqual(np.array(answer_dict['Q2']).shape, (5,2))\n",
        "\n",
        "    def test_Q2_types(self):\n",
        "        dtype1 = type(answer_dict['Q2'][0][0])\n",
        "        dtype2 = type(answer_dict['Q2'][0][1])\n",
        "        self.assertEqual([dtype1, dtype2], [str, int])\n",
        "\n",
        "    def test_Q3_types(self):\n",
        "        q3_types = set([type(item) for item in answer_dict['Q3']])\n",
        "        self.assertEqual(q3_types, {str})\n",
        "\n",
        "    def test_Q4_dim(self):\n",
        "        self.assertEqual(np.array(answer_dict['Q4']).shape, (9,3))\n",
        "\n",
        "    def test_Q4_types(self):\n",
        "        dtype1 = type(answer_dict['Q4'][0][0])\n",
        "        dtype2 = type(answer_dict['Q4'][0][1])\n",
        "        dtype3 = type(answer_dict['Q4'][0][2])\n",
        "        self.assertEqual([dtype1, dtype2, dtype3], [str, int, float])\n",
        "\n",
        "    def test_Q5_dim(self):\n",
        "        self.assertEqual(np.array(answer_dict['Q5']).shape, (19,3))\n",
        "\n",
        "    def test_Q5_types(self):\n",
        "        dtype1 = type(answer_dict['Q5'][0][0])\n",
        "        dtype2 = type(answer_dict['Q5'][0][1])\n",
        "        dtype3 = type(answer_dict['Q5'][0][2])\n",
        "        self.assertEqual([dtype1, dtype2, dtype3], [int, int, float])\n",
        "\n",
        "    def test_Q5_first_zero(self):\n",
        "        self.assertEqual(answer_dict['Q5'][0][2], 0)\n",
        "\n",
        "\n",
        "    def test_Q6_dim(self):\n",
        "        self.assertEqual(np.array(answer_dict['Q6']).shape, (5,6))\n",
        "\n",
        "    def test_Q5_types(self):\n",
        "        dtype1 = type(answer_dict['Q6'][0][0])\n",
        "        dtype2 = type(answer_dict['Q6'][0][1])\n",
        "        dtype3 = type(answer_dict['Q6'][0][2])\n",
        "        dtype4 = type(answer_dict['Q6'][0][3])\n",
        "        dtype5 = type(answer_dict['Q6'][0][4])\n",
        "        dtype6 = type(answer_dict['Q6'][0][5])\n",
        "        self.assertEqual([dtype1, dtype2, dtype3, dtype4, dtype5, dtype6], [str, float, float, float, float, float])\n",
        "\n",
        "    def test_Q6_check_first_and_last_brand(self):\n",
        "        first_brand = answer_dict['Q6'][0][0]\n",
        "        last_brand = answer_dict['Q6'][4][0]\n",
        "\n",
        "        self.assertEqual([first_brand, last_brand], [\"Toyota\", \"Honda\"])\n",
        "\n",
        "    def test_Q7_dim(self):\n",
        "        self.assertEqual(np.array(answer_dict['Q7'], dtype=object).shape, (7,2))\n",
        "\n",
        "    def test_Q7_types(self):\n",
        "        dtype1 = type(answer_dict['Q7'][0][0])\n",
        "        dtype2 = type(answer_dict['Q7'][0][1])\n",
        "        self.assertEqual([dtype1, dtype2], [tuple, float])\n",
        "\n",
        "unittest.main(argv=[''], verbosity=2, exit=False)"
      ],
      "metadata": {
        "id": "iNwVFmHZ4csn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5b22b71b-ec56-4bec-c880-bc5b2c7b5e7e"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "test_Q1 (__main__.TestAnswers) ... ok\n",
            "test_Q2_dim (__main__.TestAnswers) ... ok\n",
            "test_Q2_types (__main__.TestAnswers) ... ok\n",
            "test_Q3_types (__main__.TestAnswers) ... ok\n",
            "test_Q4_dim (__main__.TestAnswers) ... ok\n",
            "test_Q4_types (__main__.TestAnswers) ... ok\n",
            "test_Q5_dim (__main__.TestAnswers) ... ok\n",
            "test_Q5_first_zero (__main__.TestAnswers) ... ok\n",
            "test_Q5_types (__main__.TestAnswers) ... ok\n",
            "test_Q6_check_first_and_last_brand (__main__.TestAnswers) ... ok\n",
            "test_Q6_dim (__main__.TestAnswers) ... ok\n",
            "test_Q7_dim (__main__.TestAnswers) ... ok\n",
            "test_Q7_types (__main__.TestAnswers) ... ok\n",
            "test_answers_types (__main__.TestAnswers) ... ok\n",
            "test_if_dict (__main__.TestAnswers) ... ok\n",
            "test_keys (__main__.TestAnswers) ... ok\n",
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 16 tests in 0.039s\n",
            "\n",
            "OK\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<unittest.main.TestProgram at 0x7fd7e78896d0>"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Save your answers\n",
        "\n",
        "\n",
        "##### First, take a moment to evaluate your answers and make sure you have not missed anything\n",
        "\n",
        "##### Use the following code to save your answers in pickle format, change the filename using the following format:\n",
        "##### FIRSTNAME_LASTNAME_answers.pkl\n",
        "##### Example: Juan_Perez_answers.pkl\n",
        "\n",
        "##### If you are using google colab you can find your file on the left side bar by clicking the folder icon inside the sample_data folder. Remember to upload the pickle file and the notebook to github and submit their URLs to the [google form](https://forms.gle/wWysZEMkoZsjB11Y7)."
      ],
      "metadata": {
        "id": "O_Wx_D0kGjmc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "answer_dict"
      ],
      "metadata": {
        "id": "nCzU1sKMknfH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b9a8705e-a452-4007-e3e6-c5156aaef997"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Q1': 392.7417210857633,\n",
              " 'Q2': [['Mercedes-Benz', 328],\n",
              "  ['BMW', 279],\n",
              "  ['Chevrolet', 253],\n",
              "  ['Ford', 185],\n",
              "  ['GMC', 160]],\n",
              " 'Q3': ['CNG',\n",
              "  'Diesel',\n",
              "  'Gasoline or E85',\n",
              "  'Gasoline or natural gas',\n",
              "  'Gasoline or propane',\n",
              "  'Midgrade',\n",
              "  'Premium',\n",
              "  'Premium and Electricity',\n",
              "  'Premium Gas or Electricity',\n",
              "  'Premium or E85',\n",
              "  'Regular',\n",
              "  'Regular Gas and Electricity',\n",
              "  'Regular Gas or Electricity'],\n",
              " 'Q4': [['CAB/CHASSIS 2WD', 1993, 4.113376218494326],\n",
              "  ['CAB/CHASSIS 2WD', 1992, 4.113376218494326],\n",
              "  ['CAB/CHASSIS 2WD', 1991, 4.113376218494326],\n",
              "  ['CAB/CHASSIS 2WD', 1990, 4.113376218494326],\n",
              "  ['CAB/CHASSIS 2WD', 1989, 4.113376218494326],\n",
              "  ['CAMRY CNG', 1999, -3.933613148435773],\n",
              "  ['CAMRY CNG', 2001, -3.9327135217631954],\n",
              "  ['CAMRY CNG', 2000, -3.9327135217631954],\n",
              "  ['CAB/CHASSIS 2WD', 1993, 3.3800324772464374]],\n",
              " 'Q5': [[1986, 26, 0.0],\n",
              "  [1987, 26, 0.0],\n",
              "  [1988, 25, -1.0],\n",
              "  [1989, 25, 0.0],\n",
              "  [1999, 24, -1.0],\n",
              "  [2000, 24, 0.0],\n",
              "  [2001, 24, 0.0],\n",
              "  [2002, 24, 0.0],\n",
              "  [2003, 24, 0.0],\n",
              "  [2004, 24, 0.0],\n",
              "  [2005, 24, 0.0],\n",
              "  [2006, 24, 0.0],\n",
              "  [2010, 25, 1.0],\n",
              "  [2011, 26, 1.0],\n",
              "  [2012, 26, 0.0],\n",
              "  [2013, 26, 0.0],\n",
              "  [2015, 30, 4.0],\n",
              "  [2016, 30, 0.0],\n",
              "  [2017, 29, -1.0]],\n",
              " 'Q6': [['Toyota', 133.0, 158.0, 170.0, 177.74, 211.0],\n",
              "  ['Ford', 112.0, 129.0, 209.0, 222.0, 247.0],\n",
              "  ['Volkswagen',\n",
              "   200.0,\n",
              "   261.025641025641,\n",
              "   267.8947368421053,\n",
              "   267.8947368421053,\n",
              "   267.8947368421053],\n",
              "  ['Nissan', 249.0, 254.5, 260.0, 261.38235294117646, 284.0],\n",
              "  ['Honda', 130.0, 167.67924528301887, 183.0, 193.19565217391303, 196.0]],\n",
              " 'Q7': [[(1984, 1988), 19.0],\n",
              "  [(1989, 1993), 18.0],\n",
              "  [(1994, 1998), 19.0],\n",
              "  [(1999, 2003), 19.0],\n",
              "  [(2004, 2008), 19.0],\n",
              "  [(2009, 2013), 21.0],\n",
              "  [(2014, 2018), 22.0]]}"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pickle\n",
        "\n",
        "file_name = \"BRANDON_PARRA_answers.pkl\"\n",
        "path = \"\"\n",
        "\n",
        "with open(path+file_name, 'wb') as f:\n",
        "    pickle.dump(answer_dict, f, protocol=pickle.HIGHEST_PROTOCOL)"
      ],
      "metadata": {
        "id": "dEZ-vo0QGTeu"
      },
      "execution_count": 78,
      "outputs": []
    }
  ]
}