03_Building_Fast_Queries_on_a_CSV.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.0"
    },
    "colab": {
      "name": "03-Building-Fast-Queries-on-a-CSV.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/lis-r-barreto/Data-Engineering/blob/main/03_Building_Fast_Queries_on_a_CSV.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgOPlO5gRTBm"
      },
      "source": [
        "# Buildling Fast Queries on a CSV (Performance Analysis)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CXaRJXHWRTBv"
      },
      "source": [
        "Data utilized in this analysis is adapted from [Laptop Prices dataset on Kaggle](https://www.kaggle.com/ionaskel/laptop-prices).\n",
        "<br>I will be performing time analysis of a better version of an algorithm with it's slower cousin for the following 3 case studies:\n",
        ">**|2|** [Querying laptop by its ID](#query-laptop-id)\n",
        "<br>**|3|** [Two-laptops promotion](#2laptops-promotion)\n",
        "<br>**|4|** [What laptops favor the budget?](#within-budget)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WPxypViORTBz"
      },
      "source": [
        "## All imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OKJpKWIbRTB2"
      },
      "source": [
        "import csv\n",
        "import chardet\n",
        "import pandas as pd\n",
        "import time\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "emp-0rzwRTB6"
      },
      "source": [
        "## Determine file encoding"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "174K6DXBRTB9",
        "outputId": "64c10274-fe56-416e-d129-1c5f02d640e1"
      },
      "source": [
        "file = \"laptops.csv\"\n",
        "encoding = \"\"\n",
        "\n",
        "with open(file, mode=\"rb\") as file:\n",
        "    raw_bytes = file.read()\n",
        "    encoding = chardet.detect(raw_bytes)['encoding']\n",
        "\n",
        "print(encoding)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "utf-8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vZmebsW1RTCB"
      },
      "source": [
        "## Familiarize with Inventory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aMoDBZJWRTCC",
        "outputId": "ea563a32-57bc-42f2-faf4-9a52bd777e41"
      },
      "source": [
        "with open(\"laptops.csv\", encoding=encoding, mode=\"r\") as file:\n",
        "    file_reader = csv.reader(file)\n",
        "    laptops = list(file_reader)\n",
        "\n",
        "header = laptops[0]\n",
        "rows = laptops[1:]\n",
        "\n",
        "print(header)\n",
        "pd.DataFrame(rows[:4])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['Id', 'Company', 'Product', 'TypeName', 'Inches', 'ScreenResolution', 'Cpu', 'Ram', 'Memory', 'Gpu', 'OpSys', 'Weight', 'Price']\n"
          ]
        },
        {
          "data": {
            "text/html": [
              "<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>0</th>\n",
              "      <th>1</th>\n",
              "      <th>2</th>\n",
              "      <th>3</th>\n",
              "      <th>4</th>\n",
              "      <th>5</th>\n",
              "      <th>6</th>\n",
              "      <th>7</th>\n",
              "      <th>8</th>\n",
              "      <th>9</th>\n",
              "      <th>10</th>\n",
              "      <th>11</th>\n",
              "      <th>12</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>6571244</td>\n",
              "      <td>Apple</td>\n",
              "      <td>MacBook Pro</td>\n",
              "      <td>Ultrabook</td>\n",
              "      <td>13.3</td>\n",
              "      <td>IPS Panel Retina Display 2560x1600</td>\n",
              "      <td>Intel Core i5 2.3GHz</td>\n",
              "      <td>8GB</td>\n",
              "      <td>128GB SSD</td>\n",
              "      <td>Intel Iris Plus Graphics 640</td>\n",
              "      <td>macOS</td>\n",
              "      <td>1.37kg</td>\n",
              "      <td>1339</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>7287764</td>\n",
              "      <td>Apple</td>\n",
              "      <td>Macbook Air</td>\n",
              "      <td>Ultrabook</td>\n",
              "      <td>13.3</td>\n",
              "      <td>1440x900</td>\n",
              "      <td>Intel Core i5 1.8GHz</td>\n",
              "      <td>8GB</td>\n",
              "      <td>128GB Flash Storage</td>\n",
              "      <td>Intel HD Graphics 6000</td>\n",
              "      <td>macOS</td>\n",
              "      <td>1.34kg</td>\n",
              "      <td>898</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>3362737</td>\n",
              "      <td>HP</td>\n",
              "      <td>250 G6</td>\n",
              "      <td>Notebook</td>\n",
              "      <td>15.6</td>\n",
              "      <td>Full HD 1920x1080</td>\n",
              "      <td>Intel Core i5 7200U 2.5GHz</td>\n",
              "      <td>8GB</td>\n",
              "      <td>256GB SSD</td>\n",
              "      <td>Intel HD Graphics 620</td>\n",
              "      <td>No OS</td>\n",
              "      <td>1.86kg</td>\n",
              "      <td>575</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>9722156</td>\n",
              "      <td>Apple</td>\n",
              "      <td>MacBook Pro</td>\n",
              "      <td>Ultrabook</td>\n",
              "      <td>15.4</td>\n",
              "      <td>IPS Panel Retina Display 2880x1800</td>\n",
              "      <td>Intel Core i7 2.7GHz</td>\n",
              "      <td>16GB</td>\n",
              "      <td>512GB SSD</td>\n",
              "      <td>AMD Radeon Pro 455</td>\n",
              "      <td>macOS</td>\n",
              "      <td>1.83kg</td>\n",
              "      <td>2537</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        0      1            2          3     4   \\\n",
              "0  6571244  Apple  MacBook Pro  Ultrabook  13.3   \n",
              "1  7287764  Apple  Macbook Air  Ultrabook  13.3   \n",
              "2  3362737     HP       250 G6   Notebook  15.6   \n",
              "3  9722156  Apple  MacBook Pro  Ultrabook  15.4   \n",
              "\n",
              "                                   5                           6     7   \\\n",
              "0  IPS Panel Retina Display 2560x1600        Intel Core i5 2.3GHz   8GB   \n",
              "1                            1440x900        Intel Core i5 1.8GHz   8GB   \n",
              "2                   Full HD 1920x1080  Intel Core i5 7200U 2.5GHz   8GB   \n",
              "3  IPS Panel Retina Display 2880x1800        Intel Core i7 2.7GHz  16GB   \n",
              "\n",
              "                    8                             9      10      11    12  \n",
              "0            128GB SSD  Intel Iris Plus Graphics 640  macOS  1.37kg  1339  \n",
              "1  128GB Flash Storage        Intel HD Graphics 6000  macOS  1.34kg   898  \n",
              "2            256GB SSD         Intel HD Graphics 620  No OS  1.86kg   575  \n",
              "3            512GB SSD            AMD Radeon Pro 455  macOS  1.83kg  2537  "
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JER7GKDhRTCF"
      },
      "source": [
        "## De-allocate modules no longer necessary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UM8EKI0fRTCH"
      },
      "source": [
        "del pd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZSMs71zBRTCJ"
      },
      "source": [
        "<br><br>\n",
        "\n",
        "# Inventory Class for all your needs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKbZ1LPmRTCM"
      },
      "source": [
        "## |1| Detect encoding + Read inventory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YygyJtJyRTCO"
      },
      "source": [
        "# v0.0\n",
        "class Inventory():\n",
        "    def __init__(self, csv_filename):\n",
        "        self.encoding = self.detect_encoding(csv_filename)\n",
        "        with open(csv_filename, encoding=self.encoding, mode=\"r\") as file:\n",
        "            file_reader = csv.reader(file)\n",
        "            laptops = list(file_reader)\n",
        "\n",
        "        self.header = laptops[0]\n",
        "        self.rows = laptops[1:]\n",
        "        \n",
        "        for row in self.rows: # Convert str(price) -> int(price)\n",
        "            row[-1] = int(row[-1])\n",
        "\n",
        "    def detect_encoding(self, csv_filename):\n",
        "        with open(csv_filename, mode=\"rb\") as file:\n",
        "            raw_bytes = file.read()\n",
        "        return chardet.detect(raw_bytes)['encoding']\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "akQH36YlRTCP"
      },
      "source": [
        "### TEST |1| Count inventory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "22kNGtTSRTCQ",
        "outputId": "5584bd41-abcf-48a8-8db4-623227acd89d"
      },
      "source": [
        "# v0.0 TEST\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "len(laptops.rows)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1303"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DwlOZ6_WRTCT"
      },
      "source": [
        "<br>\n",
        "<br>The very first thing that I want to start off with is querying the laptop by its ID.\n",
        "<br>Seems straight-forward, until its time performance is measured.\n",
        "\n",
        "<h2 id=\"query-laptop-id\"> |2a| Query inventory by ID </h2>\n",
        "<br>Here's a simple way to query the laptop inventory by its ID by scanning the python list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vw6InptgRTCT"
      },
      "source": [
        "# v0.1\n",
        "class Inventory():\n",
        "    def __init__(self, csv_filename):\n",
        "        self.encoding = self.detect_encoding(csv_filename)\n",
        "        with open(csv_filename, encoding=self.encoding, mode=\"r\") as file:\n",
        "            file_reader = csv.reader(file)\n",
        "            laptops = list(file_reader)\n",
        "\n",
        "        self.header = laptops[0]\n",
        "        self.rows = laptops[1:]\n",
        "        \n",
        "        for row in rows: # Convert str(price) -> int(price)\n",
        "            row[-1] = int(row[-1])\n",
        "\n",
        "    def detect_encoding(self, csv_filename):\n",
        "        with open(csv_filename, mode=\"rb\") as file:\n",
        "            raw_bytes = file.read()\n",
        "        return chardet.detect(raw_bytes)['encoding']\n",
        "\n",
        "    # Query inventory by ID\n",
        "    def get_laptop_from_id(self, laptop_id):\n",
        "        for row in self.rows:\n",
        "            if row[0] == laptop_id:\n",
        "                return row\n",
        "        return None\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UzPMhXy3RTCU"
      },
      "source": [
        "### TEST |2a| Query inventory by ID\n",
        "\n",
        "Test if everything works as expected."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWSaqkBNRTCV",
        "outputId": "5dd0e3a1-a5bf-45d0-d9d9-63c62f0b283d"
      },
      "source": [
        "# v0.1 TEST\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "\n",
        "test_laptop_id = \"3362737\"\n",
        "print(f\"ID {test_laptop_id} Found -> \", laptops.get_laptop_from_id(test_laptop_id))\n",
        "print()\n",
        "\n",
        "test_laptop_id = \"3362736\"\n",
        "print(f\"ID {test_laptop_id} Found -> \", laptops.get_laptop_from_id(test_laptop_id))\n",
        "print()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ID 3362737 Found ->  ['3362737', 'HP', '250 G6', 'Notebook', '15.6', 'Full HD 1920x1080', 'Intel Core i5 7200U 2.5GHz', '8GB', '256GB SSD', 'Intel HD Graphics 620', 'No OS', '1.86kg', '575']\n",
            "\n",
            "ID 3362736 Found ->  None\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SNSU6_SnRTCX"
      },
      "source": [
        "<br>\n",
        "\n",
        "## |2b| Query inventory by ID Fast!\n",
        "A faster version of the same task that uses python dictionary:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ywzad9BRTCY"
      },
      "source": [
        "# v0.2\n",
        "class Inventory():\n",
        "    def __init__(self, csv_filename):\n",
        "        self.encoding = self.detect_encoding(csv_filename)\n",
        "        with open(csv_filename, encoding=self.encoding, mode=\"r\") as file:\n",
        "            file_reader = csv.reader(file)\n",
        "            laptops = list(file_reader)\n",
        "\n",
        "        self.header = laptops[0]\n",
        "        self.rows = laptops[1:]\n",
        "\n",
        "        for row in self.rows: # Convert str(price) -> int(price)\n",
        "            row[-1] = int(row[-1])\n",
        "        self.id_to_row = {row[0]:row for row in self.rows}  # Fast fetch with dict!\n",
        "\n",
        "\n",
        "    def detect_encoding(self, csv_filename):\n",
        "        with open(csv_filename, mode=\"rb\") as file:\n",
        "            raw_bytes = file.read()\n",
        "        return chardet.detect(raw_bytes)['encoding']\n",
        "\n",
        "\n",
        "    # Query inventory by ID\n",
        "    def get_laptop_from_id(self, laptop_id):  # O(N)\n",
        "        for row in self.rows:                 # O(N)\n",
        "            if row[0] == laptop_id:           # O(N)\n",
        "                return row                    # 1\n",
        "        return None                           # 1\n",
        "\n",
        "\n",
        "    # Query inventory by ID fast!\n",
        "    def get_laptop_from_id_fast(self, laptop_id):  # O(1)\n",
        "        return self.id_to_row[laptop_id] if laptop_id in self.id_to_row else None  # 1\n",
        "\n",
        "\n",
        "    # Visual Modeling Time Complexity\n",
        "    def plot(self, fig, values, label, color):\n",
        "        plt.plot(values, label=label, figure=fig, color=color)\n",
        "        plt.xlabel(\"N values\")\n",
        "        plt.ylabel(\"Precious Time (s)\")\n",
        "        ax = fig.axes[0]\n",
        "        ax.spines['left'].set_position(('outward', 10))\n",
        "        ax.spines['bottom'].set_position(('outward', 10))\n",
        "        ax.spines['right'].set_visible(False)\n",
        "        ax.spines['top'].set_visible(False)\n",
        "        ax.yaxis.set_ticks_position('left')\n",
        "        ax.xaxis.set_ticks_position('bottom')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXdQlafiRTCZ"
      },
      "source": [
        "### TEST |2b| Query inventory by ID, Fast!\n",
        "\n",
        "Test if everything works as expected."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZX44y__5RTCa",
        "outputId": "8f2431a9-b785-4340-80e4-2f4a84096a5b"
      },
      "source": [
        "# v0.2 TEST\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "\n",
        "test_laptop_id = \"3362737\"\n",
        "print(f\"ID {test_laptop_id} Found -> \", laptops.get_laptop_from_id_fast(test_laptop_id))\n",
        "print()\n",
        "\n",
        "test_laptop_id = \"3362736\"\n",
        "print(f\"ID {test_laptop_id} Found -> \", laptops.get_laptop_from_id_fast(test_laptop_id))\n",
        "print()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ID 3362737 Found ->  ['3362737', 'HP', '250 G6', 'Notebook', '15.6', 'Full HD 1920x1080', 'Intel Core i5 7200U 2.5GHz', '8GB', '256GB SSD', 'Intel HD Graphics 620', 'No OS', '1.86kg', 575]\n",
            "\n",
            "ID 3362736 Found ->  None\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A_CqPyz5RTCd"
      },
      "source": [
        "<br>\n",
        "\n",
        "## |2a vs 2b| Performance Test"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SKZCuaKrRTCe"
      },
      "source": [
        "Here I will compare the Time complexities of the two fetching methods **`get_laptop_from_id()`** and **`get_laptop_from_id_fast()`** by ***simulating with higher volume of data (about 10 times)*** than the input file."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "andexkVARTCf",
        "outputId": "20222994-a2ea-4c51-c800-83c94dcd8ad3"
      },
      "source": [
        "# v0.2 Time Complexity\n",
        "\n",
        "ids = [str(random.randint(1_000_000, 9_999_999)) for r in range(10_000)]\n",
        "\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "\n",
        "total_time_no_dict = []\n",
        "total_time_dict = []\n",
        "\n",
        "for id in ids:\n",
        "    start = time.time()\n",
        "    laptops.get_laptop_from_id(id)\n",
        "    end = time.time()\n",
        "    total_time_no_dict.append(end-start)\n",
        "    \n",
        "    start = time.time()\n",
        "    laptops.get_laptop_from_id_fast(id)\n",
        "    end = time.time()\n",
        "    total_time_dict.append(end-start)\n",
        "\n",
        "\n",
        "plt.style.use(\"seaborn-talk\")\n",
        "fig = plt.figure()\n",
        "laptops.plot(fig, total_time_no_dict, \"- Dict has O(N) Time Complexity\", \"tab:gray\")\n",
        "laptops.plot(fig, total_time_dict, \"+ Dict has O(1) Time Complexity\", \"tab:blue\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 748.8x514.8 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EPYOMelXRTCg"
      },
      "source": [
        "As you can see, the (without dictionary) `- Dict` line has **O(N) Time Complexity** where N is the number of rows of data from the input file.\n",
        "\n",
        "The (with dictionary) `+ Dict` line has **O(1) Constant-Time Complexity** that's attributed to the use of dictionary that aids in fast querying.\n",
        "<br>\n",
        "<br>\n",
        "\n",
        "### Analysis\n",
        "The dictionary version of query fetch is at least **x30 faster!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3igUTRmURTCh",
        "outputId": "5fede541-3b3c-4f41-efeb-847878e8a38e"
      },
      "source": [
        "sum(total_time_no_dict)/sum(total_time_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "37.66611473653453"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dzF4qCExRTCi"
      },
      "source": [
        "<br><br>\n",
        "\n",
        "<h2 id=\"2laptops-promotion\"> |3| Two-Laptops Promotion </h2>\n",
        "\n",
        "Now let's consider a scenario where the store offers a promotion to certain customers:\n",
        "\n",
        "1. By way of a $2,500 value gift card.\n",
        "\n",
        "2. It's a one-time use gift card whose balance, if any, will be waived!\n",
        "\n",
        "3. The inventory has only three laptops valued at dollars 1339, 898 and 575.\n",
        "\n",
        "4. And, the customer can buy upto 2 laptops.\n",
        "\n",
        "If I was the customer, I would want to buy 2 laptops with the gift card. The maximum I can spend with the available inventory is 2237 (1339 + 898).\n",
        "<br>\n",
        "If it was you, would you forego the balance? I wouldn't.\n",
        "<br>\n",
        "So, given the amount, here's a function that checks if it's possible to spend all of gift-card value leaving no balance favoring 2 laptops purchase:\n",
        "<br>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZVtezLdERTCj"
      },
      "source": [
        "## |3a| Check all of inventory for the laptop combo, looping twice!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9aNitncARTCj"
      },
      "source": [
        "# v0.3\n",
        "class Inventory():\n",
        "    def __init__(self, csv_filename):\n",
        "        self.encoding = self.detect_encoding(csv_filename)\n",
        "        with open(csv_filename, encoding=self.encoding, mode=\"r\") as file:\n",
        "            file_reader = csv.reader(file)\n",
        "            laptops = list(file_reader)\n",
        "\n",
        "        self.header = laptops[0]\n",
        "        self.rows = laptops[1:]\n",
        "        \n",
        "        for row in self.rows: # Convert str(price) -> int(price)\n",
        "            row[-1] = int(row[-1])\n",
        "        self.id_to_row = {row[0]:row for row in self.rows}  # Fast fetch with dict!\n",
        "\n",
        "\n",
        "    def detect_encoding(self, csv_filename):\n",
        "        with open(csv_filename, mode=\"rb\") as file:\n",
        "            raw_bytes = file.read()\n",
        "        return chardet.detect(raw_bytes)['encoding']\n",
        "\n",
        "\n",
        "    # Query inventory by ID\n",
        "    def get_laptop_from_id(self, laptop_id):  # O(N)\n",
        "        for row in self.rows:                 # O(N)\n",
        "            if row[0] == laptop_id:           # O(N)\n",
        "                return row                    # 1\n",
        "        return None                           # 1\n",
        "\n",
        "\n",
        "    # Query inventory by ID fast!\n",
        "    def get_laptop_from_id_fast(self, laptop_id):  # O(1)\n",
        "        return self.id_to_row[laptop_id] if laptop_id in self.id_to_row else None  # 1\n",
        "\n",
        "\n",
        "    # Visual Modeling Time Complexity\n",
        "    def plot(self, fig, values, label, color):\n",
        "        plt.plot(values, label=label, figure=fig, color=color)\n",
        "        plt.xlabel(\"N values\")\n",
        "        plt.ylabel(\"Precious Time (s)\")\n",
        "        ax = fig.axes[0]\n",
        "        ax.spines['left'].set_position(('outward', 10))\n",
        "        ax.spines['bottom'].set_position(('outward', 10))\n",
        "        ax.spines['right'].set_visible(False)\n",
        "        ax.spines['top'].set_visible(False)\n",
        "        ax.yaxis.set_ticks_position('left')\n",
        "        ax.xaxis.set_ticks_position('bottom')\n",
        "\n",
        "\n",
        "    # Two-laptops promotion\n",
        "    # Check all of inventory for the laptop combo, looping twice!\n",
        "    def check_promotion_dollars(self, dollars):  # O(N^2)\n",
        "        for row in self.rows:                    # O(N)\n",
        "            if row[-1] == dollars:               # O(N)\n",
        "                return True                      # 1\n",
        "        for row in self.rows:                    # O(N)\n",
        "            for r in self.rows:                  # O(N^2)\n",
        "                if r[-1]+row[-1] == dollars:     # O(N^2)\n",
        "                    return True                  # 1\n",
        "        return False                             # 1\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YEi4XLm3RTCl"
      },
      "source": [
        "### TEST |3a| Two-laptops promotion\n",
        "\n",
        "Test if everything works as expected."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "62g6cCKoRTCl",
        "outputId": "4aaa5366-b935-455a-ee65-118c9a36a6f7"
      },
      "source": [
        "# v0.3 TEST\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "\n",
        "# True for the given dataset\n",
        "gift_card_value = 1000\n",
        "print(f\"${gift_card_value:,} gift card promotion benefit possible? \",\n",
        "      laptops.check_promotion_dollars(gift_card_value))\n",
        "\n",
        "# False for the given dataset (Worst-case scenario)\n",
        "gift_card_value = 442\n",
        "print(f\"${gift_card_value:,} gift card promotion benefit possible? \", \n",
        "      laptops.check_promotion_dollars(gift_card_value))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "$1,000 gift card promotion benefit possible?  True\n",
            "$442 gift card promotion benefit possible?  False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4TQq07QXRTCn"
      },
      "source": [
        "<br>\n",
        "Thinking about looping twice certainly made me restless. This amounts to Quadratic Time Complexity. There is always a better way to do things. Let's tweak this solution and come up with a faster way to detect the combo.\n",
        "<br><br>\n",
        "\n",
        "## |3b| Check all of inventory for the laptop combo, fast!\n",
        "Here, I use `set()`; a simple and quick check is all i need."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGkOX9npRTCn"
      },
      "source": [
        "# v0.4\n",
        "class Inventory():\n",
        "    def __init__(self, csv_filename):\n",
        "        self.encoding = self.detect_encoding(csv_filename)\n",
        "        with open(csv_filename, encoding=self.encoding, mode=\"r\") as file:\n",
        "            file_reader = csv.reader(file)\n",
        "            laptops = list(file_reader)\n",
        "\n",
        "        self.header = laptops[0]\n",
        "        self.rows = laptops[1:]\n",
        "\n",
        "        for row in self.rows: # Convert str(price) -> int(price)\n",
        "            row[-1] = int(row[-1])\n",
        "        self.id_to_row = {row[0]:row for row in self.rows}  # Fast fetch with dict!\n",
        "        self.prices = set(row[-1] for row in self.rows)  # Fast detect price with set()\n",
        "\n",
        "    def detect_encoding(self, csv_filename):\n",
        "        with open(csv_filename, mode=\"rb\") as file:\n",
        "            raw_bytes = file.read()\n",
        "        return chardet.detect(raw_bytes)['encoding']\n",
        "\n",
        "    # Query inventory by ID\n",
        "    def get_laptop_from_id(self, laptop_id):  # O(N)\n",
        "        for row in self.rows:                 # O(N)\n",
        "            if row[0] == laptop_id:           # O(N)\n",
        "                return row                    # 1\n",
        "        return None                           # 1\n",
        "\n",
        "\n",
        "    # Query inventory by ID fast!\n",
        "    def get_laptop_from_id_fast(self, laptop_id):  # O(1)\n",
        "        return self.id_to_row[laptop_id] if laptop_id in self.id_to_row else None  # 1\n",
        "\n",
        "\n",
        "    # Visual Modeling Time Complexity\n",
        "    def plot(self, fig, values, label, color):\n",
        "        plt.plot(values, label=label, figure=fig, color=color)\n",
        "        plt.xlabel(\"N values\")\n",
        "        plt.ylabel(\"Precious Time (s)\")\n",
        "        ax = fig.axes[0]\n",
        "        ax.spines['left'].set_position(('outward', 10))\n",
        "        ax.spines['bottom'].set_position(('outward', 10))\n",
        "        ax.spines['right'].set_visible(False)\n",
        "        ax.spines['top'].set_visible(False)\n",
        "        ax.yaxis.set_ticks_position('left')\n",
        "        ax.xaxis.set_ticks_position('bottom')\n",
        "\n",
        "\n",
        "    # Two-laptops promotion\n",
        "    # Check all of inventory for the laptop combo, looping twice!\n",
        "    def check_promotion_dollars(self, dollars):  # O(N^2)\n",
        "        for row in self.rows:                    # O(N)\n",
        "            if row[-1] == dollars:               # O(N)\n",
        "                return True                      # 1\n",
        "        for row in self.rows:                    # O(N)\n",
        "            for r in self.rows:                  # O(N^2)\n",
        "                if r[-1]+row[-1] == dollars:     # O(N^2)\n",
        "                    return True                  # 1\n",
        "        return False                             # 1\n",
        "\n",
        "\n",
        "    # Two-laptops promotion\n",
        "    # Check all of inventory for the laptop combo, fast!\n",
        "    def check_promotion_dollars_fast(self, dollars):  # O(N)\n",
        "        if dollars in self.prices:                    # 1\n",
        "            return True                               # 1\n",
        "        for price in self.prices:                     # O(N)\n",
        "            if dollars-price in self.prices:          # O(N)\n",
        "                return True                           # 1\n",
        "        return False                                  # 1\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iT1JxtPYRTCp"
      },
      "source": [
        "### TEST |3b| Two-laptops promotion\n",
        "\n",
        "Test if everything works as expected."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "guj5x-aVRTCq",
        "outputId": "9370885b-1c68-4870-d948-22ef3cd6396f"
      },
      "source": [
        "# v0.4 TEST\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "\n",
        "# True for the given dataset\n",
        "gift_card_value = 1000\n",
        "print(f\"${gift_card_value:,} gift card promotion benefit possible? \",\n",
        "      laptops.check_promotion_dollars_fast(gift_card_value))\n",
        "\n",
        "# False for the given dataset (Worst-case scenario)\n",
        "gift_card_value = 442\n",
        "print(f\"${gift_card_value:,} gift card promotion benefit possible? \",\n",
        "      laptops.check_promotion_dollars_fast(gift_card_value))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "$1,000 gift card promotion benefit possible?  True\n",
            "$442 gift card promotion benefit possible?  False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0pTouSEZRTCr"
      },
      "source": [
        "<br>\n",
        "\n",
        "## |3a vs 3b| Performance Test"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3j1jguEKRTCs"
      },
      "source": [
        "Here I will compare the Time complexities of the two querying methods **`check_promotion_dollars()`** and **`check_promotion_dollars_fast()`** by ***simulating with 5 times more data*** than the input file."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_aWCmFejRTCt",
        "outputId": "c66fd2be-9d9e-42f0-82d6-deac96e3ff70"
      },
      "source": [
        "# v0.4 Time Complexity\n",
        "\n",
        "prices = [random.randint(100, 5_000) for r in range(100)]\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "\n",
        "total_time_no_set = []\n",
        "total_time_set = []\n",
        "\n",
        "for price in prices:\n",
        "    start = time.time()\n",
        "    laptops.check_promotion_dollars(price)\n",
        "    end = time.time()\n",
        "    total_time_no_set.append(end-start)\n",
        "    \n",
        "    start = time.time()\n",
        "    laptops.check_promotion_dollars_fast(price)\n",
        "    end = time.time()\n",
        "    total_time_set.append(end-start)\n",
        "\n",
        "plt.style.use(\"seaborn-talk\")\n",
        "fig = plt.figure()\n",
        "laptops.plot(fig, total_time_no_set, \"- Set has O(N^2) Time Complexity\", \"tab:gray\")\n",
        "laptops.plot(fig, total_time_set, \"+ Set has O(N) Time Complexity\", \"tab:blue\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 748.8x514.8 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lY7cs8YrRTCv"
      },
      "source": [
        "The time-line for the faster query looks flat (almost constant time) on a shared plot.\n",
        "<br>\n",
        "To see the minor variations, here's the plot:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZTFCEwv3RTCw",
        "outputId": "5dc001d3-4ceb-40e0-ed0b-93ce7dcc5272"
      },
      "source": [
        "# v0.4 Time Complexity\n",
        "\n",
        "plt.style.use(\"seaborn-talk\")\n",
        "fig = plt.figure()\n",
        "laptops.plot(fig, total_time_set, \"+ Set has O(N) Time Complexity\", \"tab:blue\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 748.8x514.8 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L7SZQjTFRTCx"
      },
      "source": [
        "<br>\n",
        "\n",
        "### Analysis\n",
        "It's certainly not constant, but linear. But the **performance gain is at least x1000!**\n",
        "<br>See below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TFtrSK5RRTCy",
        "outputId": "4bc471bc-3fd9-4135-e650-e7fc22298789"
      },
      "source": [
        "sum(total_time_no_set)/sum(total_time_set)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1241.4249783174328"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wfJ6eiCiRTCz"
      },
      "source": [
        "<br><br>\n",
        "\n",
        "<h2 id=\"within-budget\"> |4| Laptops with-in budget </h2>\n",
        "\n",
        "Now let's say I want to know what laptops are available that are lesser than a target price (my max budget). A laptop with the target price may exist or not. If it doesn't, I have to find all laptops whose price is at most the `target price`, for which I have to **query for the first laptop whose price is more than my `target price`** if the exact target price doesn't exist in the inventory.\n",
        "<br><br>One efficient strategy to enable this is to sort the inventory by price (**a O(N) time price to pay**) to find the index of the first laptop that is at most the target price."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_opnti6yRTCz"
      },
      "source": [
        "# v0.5\n",
        "class Inventory():\n",
        "    \n",
        "    def __init__(self, csv_filename):\n",
        "        self.encoding = self.detect_encoding(csv_filename)\n",
        "        with open(csv_filename, encoding=self.encoding, mode=\"r\") as file:\n",
        "            file_reader = csv.reader(file)\n",
        "            laptops = list(file_reader)\n",
        "\n",
        "        self.header = laptops[0]\n",
        "        self.rows = laptops[1:]\n",
        "\n",
        "        for row in self.rows: # Convert str(price) -> int(price)\n",
        "            row[-1] = int(row[-1])\n",
        "        self.id_to_row = {row[0]:row for row in self.rows}  # Fast fetch with dict!\n",
        "        self.prices = set(row[-1] for row in self.rows)  # Fast detect price with set()!\n",
        "        self.rows_by_price = sorted(self.rows, key=lambda row: row[-1])  # Sorted price for quick fetch! O(N)\n",
        "\n",
        "        \n",
        "    def detect_encoding(self, csv_filename):\n",
        "        with open(csv_filename, mode=\"rb\") as file:\n",
        "            raw_bytes = file.read()\n",
        "        return chardet.detect(raw_bytes)['encoding']\n",
        "\n",
        "    \n",
        "    # Query inventory by ID\n",
        "    def get_laptop_from_id(self, laptop_id):  # O(N)\n",
        "        for row in self.rows:                 # O(N)\n",
        "            if row[0] == laptop_id:           # O(N)\n",
        "                return row                    # 1\n",
        "        return None                           # 1\n",
        "\n",
        "\n",
        "    # Query inventory by ID fast!\n",
        "    def get_laptop_from_id_fast(self, laptop_id):  # O(1)\n",
        "        return self.id_to_row[laptop_id] if laptop_id in self.id_to_row else None  # 1\n",
        "\n",
        "\n",
        "    # Visual Modeling Time Complexity\n",
        "    def plot(self, fig, values, label, color):\n",
        "        plt.plot(values, label=label, figure=fig, color=color)\n",
        "        plt.xlabel(\"N values\")\n",
        "        plt.ylabel(\"Precious Time (s)\")\n",
        "        ax = fig.axes[0]\n",
        "        ax.spines['left'].set_position(('outward', 10))\n",
        "        ax.spines['bottom'].set_position(('outward', 10))\n",
        "        ax.spines['right'].set_visible(False)\n",
        "        ax.spines['top'].set_visible(False)\n",
        "        ax.yaxis.set_ticks_position('left')\n",
        "        ax.xaxis.set_ticks_position('bottom')\n",
        "\n",
        "\n",
        "    # Two-laptops promotion\n",
        "    # Check all of inventory for the laptop combo, looping twice!\n",
        "    def check_promotion_dollars(self, dollars):  # O(N^2)\n",
        "        for row in self.rows:                    # O(N)\n",
        "            if row[-1] == dollars:               # O(N)\n",
        "                return True                      # 1\n",
        "        for row in self.rows:                    # O(N)\n",
        "            for r in self.rows:                  # O(N^2)\n",
        "                if r[-1]+row[-1] == dollars:     # O(N^2)\n",
        "                    return True                  # 1\n",
        "        return False                             # 1\n",
        "\n",
        "\n",
        "    # Two-laptops promotion\n",
        "    # Check all of inventory for the laptop combo, fast!\n",
        "    def check_promotion_dollars_fast(self, dollars):  # O(N)\n",
        "        if dollars in self.prices:                    # 1\n",
        "            return True                               # 1\n",
        "        for price in self.prices:                     # O(N)\n",
        "            if dollars-price in self.prices:          # O(N)\n",
        "                return True                           # 1\n",
        "        return False                                  # 1\n",
        "    \n",
        "    \n",
        "    # Binary Search: O(log(N))\n",
        "    def find_first_laptop_more_expensive(self, target_price):\n",
        "        range_start = 0\n",
        "        range_end = len(self.rows_by_price) - 1\n",
        "        while range_start < range_end:\n",
        "            range_middle = (range_start + range_end) // 2  # O(log(N)) as search space is halved each iteration.\n",
        "            price = self.rows_by_price[range_middle][-1]\n",
        "            if price <= target_price:\n",
        "                range_start = range_middle + 1\n",
        "            else:\n",
        "                range_end = range_middle\n",
        "\n",
        "        if self.rows_by_price[range_start][-1] <= target_price:\n",
        "            return -1\n",
        "        return range_start\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "10HqxM9VRTC0"
      },
      "source": [
        "### TEST |4| Laptops with-in budget"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nC89CvCbRTC1",
        "outputId": "19ca986c-7f76-46ff-819d-7bd23459bafb"
      },
      "source": [
        "# v0.5 TEST\n",
        "laptops = Inventory(\"laptops.csv\")\n",
        "\n",
        "# True for the given dataset\n",
        "target_price = 1_000\n",
        "print(f\"Target price (budget={target_price:,});\",\n",
        "      (\"All with-in budget!\"\n",
        "          if (i:=laptops.find_first_laptop_more_expensive(target_price)) == -1 \n",
        "          else \"\".join([\"Index at \", str(i)])))\n",
        "\n",
        "# False for the given dataset (Worst-case scenario)\n",
        "target_price = 10_000\n",
        "print(f\"Target price (budget={target_price:,});\",\n",
        "      (\"All with-in budget!\"\n",
        "          if (i:=laptops.find_first_laptop_more_expensive(target_price)) == -1 \n",
        "          else \"\".join([\"Index at \", str(i)])))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Target price (budget=1,000); Index at 683\n",
            "Target price (budget=10,000); All with-in budget!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SOkjA3qYRTC3"
      },
      "source": [
        "### Analysis\n",
        "The overall time complexity for this search termed **Binary Search is O(N)**.\n",
        "<br>This is because, ***O(N) for the price sorting** + **O(log(N)) for the Binary Search*** yeilds **O(N + log(N))** Time.\n",
        "<br>Aligning this with Algorithm Time modeling terms, the most significant term is O(N) and the lesser significant term is O(log(N)).\n",
        "<br>We go with only the most significant term, O(N)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "klgSkuI3RTC3"
      },
      "source": [
        "# Conclusion\n",
        "A faster algorithm that finds the right balance between Time and Space complexities is worth the time investment especially where search is involved.\n",
        "<br>**A stitch in time saves nine!**\n",
        "<br>There's more to build depending on the business need. For now, it's the above three.\n"
      ]
    }
  ]
}