Solution.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Solution.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNTXiqKCkIocinNhY7u3PRM",
      "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/waqasisme/FestoCodingChallenge2022/blob/main/Solution.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **CodeFest 22 Solution Notebook**\n",
        "[link to competition website](https://2022.coding-challenge.festo.com/)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "4o9E-4N2Rr9s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Introduction**\n",
        "https://2022.coding-challenge.festo.com/puzzle/0"
      ],
      "metadata": {
        "id": "8hEzQGhIhu5i"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 793,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "wU4fsF7aVaNm",
        "outputId": "b4d2071f-40fb-4299-a1ce-9e0bf59821a4"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                         Username      ID  AccessKey FirstLoginTime\n",
              "0  immenseResearch                 500025        211          08:04\n",
              "1  great.night                     648341          6          09:04\n",
              "2  gray_basket                     478873         82          07:15\n",
              "3  bubblyPerson                    294887        208          09:03\n",
              "4  WorriedLine                     489479        231          07:47"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-caec7e26-3440-464d-b95b-4c242fc3794a\">\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>Username</th>\n",
              "      <th>ID</th>\n",
              "      <th>AccessKey</th>\n",
              "      <th>FirstLoginTime</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>immenseResearch</td>\n",
              "      <td>500025</td>\n",
              "      <td>211</td>\n",
              "      <td>08:04</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>great.night</td>\n",
              "      <td>648341</td>\n",
              "      <td>6</td>\n",
              "      <td>09:04</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>gray_basket</td>\n",
              "      <td>478873</td>\n",
              "      <td>82</td>\n",
              "      <td>07:15</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>bubblyPerson</td>\n",
              "      <td>294887</td>\n",
              "      <td>208</td>\n",
              "      <td>09:03</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>WorriedLine</td>\n",
              "      <td>489479</td>\n",
              "      <td>231</td>\n",
              "      <td>07:47</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-caec7e26-3440-464d-b95b-4c242fc3794a')\"\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-caec7e26-3440-464d-b95b-4c242fc3794a 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-caec7e26-3440-464d-b95b-4c242fc3794a');\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": 793
        }
      ],
      "source": [
        "import pandas as pd\n",
        "df = pd.read_csv('office_database.csv', names= [\"Username\", \"ID\", \"AccessKey\", \"FirstLoginTime\"])\n",
        "df.head()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id_match = df['ID'].apply(lambda f: \"814\" in str(f)) # matching ID numbers\n",
        "sum(id_match)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C25yp7hlWgw7",
        "outputId": "8f9c5310-2ebb-4163-8442-8c6ea78046e7"
      },
      "execution_count": 794,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "91"
            ]
          },
          "metadata": {},
          "execution_count": 794
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "can_go_kitchen = df['AccessKey'].apply(lambda f: f & 8 != 0) # people with access to module 5\n",
        "sum(can_go_kitchen)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MD9vVIuXVNpH",
        "outputId": "760f5a96-de9e-448a-cfba-9f2f31f77d26"
      },
      "execution_count": 795,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "93"
            ]
          },
          "metadata": {},
          "execution_count": 795
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from datetime import datetime\n",
        "# cleaning up first login time column to trim strings and fix format\n",
        "df['FirstLoginTime'] = df['FirstLoginTime'].apply(lambda f: f.strip())\n",
        "df['FirstLoginTime'] = df['FirstLoginTime'].apply(lambda f: '12:12' if f == '99:99' else f)\n",
        "df['FirstLoginTime'] = pd.to_datetime(df.FirstLoginTime, format='%H:%M')\n",
        "# python turned them into full date time objects, in hindsight should've just used epoch \n",
        "could_be_there = df['FirstLoginTime'].apply(lambda d: d < datetime.strptime('1900-01-01 07:14:00', '%Y-%m-%d %H:%M:%S'))\n",
        "sum(could_be_there)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wamMr9pQVOO0",
        "outputId": "a7293546-e748-4536-9d40-bc81b73ae5d4"
      },
      "execution_count": 796,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "86"
            ]
          },
          "metadata": {},
          "execution_count": 796
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction Solution"
      ],
      "metadata": {
        "id": "tgUbryu_WMa7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# people that meet each condition\n",
        "df[id_match & can_go_kitchen & could_be_there] # answer to introduction (HQ)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 81
        },
        "id": "lbsgc9pLVN_g",
        "outputId": "e36f225c-2096-4210-c220-c20439e8f630"
      },
      "execution_count": 797,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                            Username      ID  AccessKey      FirstLoginTime\n",
              "4574  mystery_man                     814217         26 1900-01-01 07:08:00"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-e4e4119e-a6b5-451c-9ed0-96f10618d1c6\">\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>Username</th>\n",
              "      <th>ID</th>\n",
              "      <th>AccessKey</th>\n",
              "      <th>FirstLoginTime</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>4574</th>\n",
              "      <td>mystery_man</td>\n",
              "      <td>814217</td>\n",
              "      <td>26</td>\n",
              "      <td>1900-01-01 07:08:00</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e4e4119e-a6b5-451c-9ed0-96f10618d1c6')\"\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-e4e4119e-a6b5-451c-9ed0-96f10618d1c6 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-e4e4119e-a6b5-451c-9ed0-96f10618d1c6');\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": 797
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Episode 1** \n",
        "https://2022.coding-challenge.festo.com/puzzle/10"
      ],
      "metadata": {
        "id": "jKgKpjGAVnwx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# our person class for easy mapping with a helper function for later (to determine picoBots in blood)\n",
        "from typing import List\n",
        "class Person:\n",
        "  name: str\n",
        "  id: int\n",
        "  home_planet: str\n",
        "  blood_sample: List[str]\n",
        "\n",
        "  def __init__(self, name, id, home_planet, blood_sample):\n",
        "    self.name = name\n",
        "    self.id = id\n",
        "    self.home_planet = home_planet\n",
        "    self.blood_sample = blood_sample\n",
        "    \n",
        "  # checks blood sample and it's transpose for the word pico\n",
        "  def has_pico_bots(self) -> bool:\n",
        "    rotated_blood_sample = [\"\".join(s) for s in zip(*self.blood_sample)]\n",
        "    return any('pico' in line or 'ocip' in line for line in self.blood_sample) \\\n",
        "    or any('pico' in line or 'ocip' in line for line in rotated_blood_sample) \n",
        "                                                                                       "
      ],
      "metadata": {
        "id": "KgfrdRBTknXj"
      },
      "execution_count": 798,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# utility function to test different blood samples from clean and gen1 files\n",
        "def arg_cleaner(arg):\n",
        "  '''+--------+\n",
        "  |    pico|\n",
        "  | ppco ci|\n",
        "  |op c    |\n",
        "  |c c poco|\n",
        "  |pcp  cpi|\n",
        "  |ciccccoo|\n",
        "  +--------+'''\n",
        "  arg = [line.strip()[1:-1] for line in arg.split('\\n')[1:-1]]\n",
        "  return arg\n",
        "\n",
        "clean = Person(None, None, None, arg_cleaner('''+--------+\n",
        "  |    piio|\n",
        "  | ppco ci|\n",
        "  |op c    |\n",
        "  |c c poco|\n",
        "  |pcp  cpi|\n",
        "  |ciccccoo|\n",
        "  +--------+'''))\n",
        "hasBots = Person(None, None, None, arg_cleaner('''+--------+\n",
        "  |    pccc|\n",
        "  | ppcp ci|\n",
        "  |op ci   |\n",
        "  |c c coco|\n",
        "  |pcp ocpi|\n",
        "  |ciccccoo|\n",
        "  +--------+'''))\n",
        "print(clean.has_pico_bots())\n",
        "print(hasBots.has_pico_bots())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pP9osB8M1sjQ",
        "outputId": "e6030e79-ed84-4080-c226-556ec178b321"
      },
      "execution_count": 799,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **(1.1) Puzzle 1**"
      ],
      "metadata": {
        "id": "gPDgNf7di1Xj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def read_population_data(fileName: str) -> List[Person]:\n",
        "  population = []\n",
        "  l = []\n",
        "  with open(fileName, 'r') as file:\n",
        "      l = file.readlines()\n",
        "\n",
        "  # loop over data 14 lines at a time to clean it up and store as person objects\n",
        "  for i in range(0, len(l), 14):\n",
        "    person = l[i:i + 14]\n",
        "    name = \" \".join(person[0].split()[1:]) # skip 'Name: ' \n",
        "    id = int(person[1].split()[1]) # skip 'ID: '\n",
        "    home = \" \".join(person[2].split()[2:]) # skip 'home planet: '\n",
        "    bs = [line.strip()[1:-1] for line in person[3:][2:8]] # read blood_sample as list of str, trimming whitespace removing | and +- lines (only storing chars)\n",
        "    population.append(Person(name, id, home, bs))\n",
        "\n",
        "  return population"
      ],
      "metadata": {
        "id": "5d8DVRV-c8s-"
      },
      "execution_count": 800,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# compile population dataset\n",
        "population = read_population_data('population.txt')\n",
        "print(len(population)) # check/verify size of pop with file"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RElM2H5X5xje",
        "outputId": "a7db2060-5f01-41bf-e287-4f3eb1eb04d8"
      },
      "execution_count": 801,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12732\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "populationWithPicoBots = {person for person in population if person.has_pico_bots()}\n",
        "len(populationWithPicoBots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZJ7RJJPcMtiw",
        "outputId": "2cce9973-aa95-4eb6-96cd-f78b6c79b5fa"
      },
      "execution_count": 802,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "422"
            ]
          },
          "metadata": {},
          "execution_count": 802
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum(person.id for person in population if person.has_pico_bots()) # answer to puzzle 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9BuKjkNaxSQE",
        "outputId": "40c4b55a-fb9c-4f88-e4b3-8ce0be9fe525"
      },
      "execution_count": 803,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2288948789"
            ]
          },
          "metadata": {},
          "execution_count": 803
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **(1.2) Puzzle 2**"
      ],
      "metadata": {
        "id": "1sEsn_duj6Kt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "\n",
        "# make a dict for galaxy_map with (name, coordinates)\n",
        "galaxy_map = {}\n",
        "x, y, z = [], [], []\n",
        "\n",
        "with open('galaxy_map.txt') as glx:\n",
        "  lines = [line.split(':') for line in glx.readlines()]\n",
        "  for line in lines:\n",
        "    planet = line[0].strip()\n",
        "    coordinates = tuple(map(int, line[1].strip()[1:-1].split(',')))\n",
        "    galaxy_map[planet] = coordinates \n",
        "    x.append(coordinates[0])\n",
        "    y.append(coordinates[1])\n",
        "    z.append(coordinates[2])\n",
        "\n",
        "# plot galaxy to visualize outliers\n",
        "fig = plt.figure(figsize=(8, 8))\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "ax.scatter(x, y, z)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 466
        },
        "id": "GvOGi5Oz9F7R",
        "outputId": "aa6bd410-4437-4dab-eaab-7ad1e24cc754"
      },
      "execution_count": 804,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install scikit-spatial"
      ],
      "metadata": {
        "id": "_XcyafIVL3gi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7445854-5eb8-421e-89b7-992ef86d4859"
      },
      "execution_count": 805,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: scikit-spatial in /usr/local/lib/python3.7/dist-packages (6.4.1)\n",
            "Requirement already satisfied: matplotlib<4,>=3 in /usr/local/lib/python3.7/dist-packages (from scikit-spatial) (3.2.2)\n",
            "Requirement already satisfied: importlib-metadata<2,>=1 in /usr/local/lib/python3.7/dist-packages (from scikit-spatial) (1.7.0)\n",
            "Requirement already satisfied: numpy<2.0,>=1.20 in /usr/local/lib/python3.7/dist-packages (from scikit-spatial) (1.21.6)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata<2,>=1->scikit-spatial) (3.8.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3->scikit-spatial) (1.4.3)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3->scikit-spatial) (0.11.0)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3->scikit-spatial) (3.0.9)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3->scikit-spatial) (2.8.2)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4,>=3->scikit-spatial) (4.1.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4,>=3->scikit-spatial) (1.15.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from skspatial.objects import Plane\n",
        "from skspatial.objects import Points\n",
        "from skspatial.plotting import plot_3d\n",
        "\n",
        "# find best fitting plane for our coordinates\n",
        "points = Points(list(galaxy_map.values()))\n",
        "plane = Plane.best_fit(points)\n",
        "distances = { k: plane.distance_point(v) for k, v in galaxy_map.items() }\n",
        "outliers = { k: v for k, v in distances.items() if v > 2 } # outlier limit specified in question\n",
        "outliers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tEOUNH3OXSJp",
        "outputId": "59a11e22-7c19-4bf5-869a-3fb894650376"
      },
      "execution_count": 806,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Algo Major': 17.094076994006272,\n",
              " 'Alpha Andron': 18.570147347806227,\n",
              " 'Alpha Aurnus': 15.30644512387339,\n",
              " 'Alpha Carsa': 16.558030382638748,\n",
              " 'Alpha Lupisci': 17.01317619023222,\n",
              " 'Alpha Menax Minor': 14.679062809785268,\n",
              " 'Andros Major': 18.15572354742764,\n",
              " 'Aquarth': 17.330929522841473,\n",
              " 'Beta Dela IV': 19.695138612851604,\n",
              " 'Carda III': 15.722061712776394,\n",
              " 'Cerenis V': 18.505882337039477,\n",
              " 'Cralis III': 15.23428215897532,\n",
              " 'Dralis II': 17.43018479591629,\n",
              " 'Earia': 20.09897682279569,\n",
              " 'Equila Minor': 17.092541439010297,\n",
              " 'Erinix': 17.83350330363349,\n",
              " 'Forale': 18.473352389560475,\n",
              " 'Gamma Bores': 15.069918330075517,\n",
              " 'Gamma Carinus Major': 17.048515571908123,\n",
              " 'Minoces': 16.853352118091596,\n",
              " 'Phoeni V': 17.54729203485332,\n",
              " 'Pisci': 16.763092834422906,\n",
              " 'Vens IV': 18.294465731222203,\n",
              " 'Venta': 17.39189067372093,\n",
              " 'Viria II': 19.426604266384306}"
            ]
          },
          "metadata": {},
          "execution_count": 806
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum([person.id for person in population if person.home_planet in outliers.keys()]) # answer to puzzle 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "06OqFjfCXqPp",
        "outputId": "09ad36f5-a1ed-44e6-ad15-a65a597327c7"
      },
      "execution_count": 807,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2438905648"
            ]
          },
          "metadata": {},
          "execution_count": 807
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **(1.3) Puzzle 3**"
      ],
      "metadata": {
        "id": "Mmn1LJIAlEH3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# sequence of places retrieved from Jelly Jones' fitbit watch\n",
        "jelly_jones_sequence = ['Junkyard', 'Pod Racing Track', 'Pod Racing Track', 'Palace', 'Factory']"
      ],
      "metadata": {
        "id": "NJ0eXXricHKu"
      },
      "execution_count": 808,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# read data from security_log\n",
        "with open('security_log.txt', 'r') as file:\n",
        "  lines = file.readlines()\n",
        "# into a structure with { people: [places]} (places are inserted in order file order)\n",
        "\n",
        "# convert 24hr to minute of day\n",
        "def minute_of_day(time):\n",
        "  hours, minutes = list(map(int, time.split(':')))\n",
        "  return hours * 60 + minutes\n",
        "\n",
        "people = {}\n",
        "blacklist = set()\n",
        "i = 0\n",
        "while i < len(lines):\n",
        "  line = lines[i]\n",
        "  if 'Place' in line:\n",
        "    last_place = line.split(':')[1].strip()\n",
        "  elif 'in:' in line or 'out:' in line: # in/out list colon added to avoid names like 'edwin'\n",
        "    last_people = line.split(':')[1].strip().split(', ')  \n",
        "    for person in last_people:\n",
        "      if person not in people:\n",
        "        people[person] = {}\n",
        "      people[person][last_time] = last_place\n",
        "\n",
        "      # we are interested in people only if they visited JUST the places from jelly_jones_sequence\n",
        "      if last_place not in jelly_jones_sequence:\n",
        "        blacklist.add(person)\n",
        "  elif ':' in line: # time\n",
        "    last_time = minute_of_day(line.strip())\n",
        "  i += 1\n",
        "\n",
        "len(people)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8UOHqSQzldLX",
        "outputId": "08ce17b6-b87b-4894-f97b-d45ad0457d54"
      },
      "execution_count": 809,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12732"
            ]
          },
          "metadata": {},
          "execution_count": 809
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# people who only visited the places we want\n",
        "person_of_interest = [person for person in people if person not in blacklist]\n",
        "\n",
        "# next we go over the given places and determine people who visited them in the desired entry-exit sequence\n",
        "target_sequence = []\n",
        "for item in zip(jelly_jones_sequence, jelly_jones_sequence): # generate entry exit sequence for fitness tracker \n",
        "  target_sequence.append(item[0])\n",
        "  target_sequence.append(item[1])\n",
        "\n",
        "# peoples visits ordered (by time) for Monday\n",
        "routines = {}\n",
        "for person in person_of_interest:\n",
        "  routines[person] = [item[1] for item in sorted(people[person].items())] # ordered by entry and exit times\n",
        "\n",
        "# people whose visit sequence and frequency matches with desired sequence\n",
        "populationWithMatchingRoutines = [person for person in routines if routines[person] == target_sequence]\n",
        "len(populationWithMatchingRoutines)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iU8q3va-lpwf",
        "outputId": "72731496-c795-4c1c-cd76-5b0d4e7d75b5"
      },
      "execution_count": 810,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "607"
            ]
          },
          "metadata": {},
          "execution_count": 810
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum([person.id for person in population if person.name in populationWithMatchingRoutines]) # answer to puzzle 3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bvian5OC2yQ7",
        "outputId": "25fec922-7f07-4fb6-eb1c-7454e4a24b12"
      },
      "execution_count": 811,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3362264068"
            ]
          },
          "metadata": {},
          "execution_count": 811
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Episode 1 Solution"
      ],
      "metadata": {
        "id": "cFj52QkTXG3F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "[person.name for person in population \\\n",
        " if person.has_pico_bots() and \\\n",
        " #person.home_planet in outliers.keys()] # and \\\n",
        " person.name in populationWithMatchingRoutines]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bNuHJQ4b_655",
        "outputId": "8156ac11-3acb-4256-aee1-161277580945"
      },
      "execution_count": 812,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Tun Kazem']"
            ]
          },
          "metadata": {},
          "execution_count": 812
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Episode 2** \n",
        "\n",
        "https://2022.coding-challenge.festo.com/puzzle/20"
      ],
      "metadata": {
        "id": "V0SsSx_6XvJL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# compile population dataset using our previously defined function\n",
        "population = read_population_data('population.txt')\n",
        "\n",
        "print(len(population)) # check/verify size of pop with file"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cq8OefZeXZjz",
        "outputId": "01fe8535-6e0c-495e-9936-1031678cf0e2"
      },
      "execution_count": 813,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12732\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(2.1) Puzzle 1**"
      ],
      "metadata": {
        "id": "JQVpwRnqapHF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# now we add a function to our person class to detect gen2 picobots\n",
        "def has_gen2_pico_bots(self) -> bool:\n",
        "  # we can only go up, down, left, right, while respecting edges\n",
        "  get_neighbors = lambda i, j: [n for n in [(i-1, j), (i+1, j), (i, j-1), (i, j+1)] if n[0] >= 0 and n[0] < 6 and n[1] >= 0 and n[1] < 8] \n",
        "  \n",
        "  # recursive solution checking for remaining 'picoico' string in neighbors\n",
        "  def has_gen2_pico_bots_helper(sample, i, j, target_string) -> bool:\n",
        "    if len(target_string) == 0: # found complete chain\n",
        "      return True\n",
        "\n",
        "    if sample[i][j] != target_string[0]: # current target letter not found chain is broken\n",
        "      return False\n",
        "    neighbors = get_neighbors(i, j) # [(n[0], n[1])]\n",
        "    return any([has_gen2_pico_bots_helper(sample, n[0], n[1], target_string[1:]) for n in neighbors])\n",
        "\n",
        "\n",
        "  for i in range(len(self.blood_sample)):\n",
        "    for j in range(len(self.blood_sample[i])):\n",
        "      if has_gen2_pico_bots_helper(self.blood_sample, i, j, 'picoico'):\n",
        "        return True\n",
        "\n",
        "  return False\n",
        "        \n",
        "\n",
        "Person.has_gen2_pico_bots = has_gen2_pico_bots"
      ],
      "metadata": {
        "id": "nq6m3MjhdKY4"
      },
      "execution_count": 814,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# check if our function is working by taking data from clean/infected datasets and verifying for all\n",
        "def run_gen2_blood_test(files) -> bool:\n",
        "  clean = files[0]\n",
        "  dirty = files[1]\n",
        "  \n",
        "  with open(clean, 'r') as clean_file:\n",
        "    lines = clean_file.readlines()\n",
        "\n",
        "  clean_samples = []\n",
        "  for i in range(0, len(lines), 11):\n",
        "      clean_samples.append(arg_cleaner(\"\".join(lines[i+1:i+11]).strip()))\n",
        "  all_clean = not any([Person(None, None, None, sample).has_gen2_pico_bots() for sample in clean_samples])\n",
        "  \n",
        "  with open(dirty, 'r') as dirty_file:\n",
        "    lines = dirty_file.readlines()\n",
        "\n",
        "  dirty_samples = []\n",
        "  for i in range(0, len(lines), 11):\n",
        "      dirty_samples.append(arg_cleaner(\"\".join(lines[i+1:i+11]).strip()))\n",
        "  all_dirty = all([Person(None, None, None, sample).has_gen2_pico_bots() for sample in dirty_samples])\n",
        "  return all_clean and all_dirty\n",
        "\n",
        "\n",
        "# 1st file should be all false on function, 2nd all true\n",
        "run_gen2_blood_test(['lab_blood_clean.txt', 'lab_blood_gen2.txt']) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OL3tkSNmdnDM",
        "outputId": "b8111ef1-2d0b-41d3-bea0-ddd60dc63d00"
      },
      "execution_count": 815,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 815
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "populationWithGen2PicoBots = [person for person in population if person.has_gen2_pico_bots()]\n",
        "sum([person.id for person in populationWithGen2PicoBots]) # answer to puzzle 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iTxScRRWljoc",
        "outputId": "8814d7fe-0077-4655-fb6d-c8d3e12f6a11"
      },
      "execution_count": 816,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2105304392"
            ]
          },
          "metadata": {},
          "execution_count": 816
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(populationWithGen2PicoBots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w4ptzdCZuNDw",
        "outputId": "8eed66fa-e4b6-480f-eab4-10335f67b321"
      },
      "execution_count": 817,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "393"
            ]
          },
          "metadata": {},
          "execution_count": 817
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(2.2) Puzzle 2**"
      ],
      "metadata": {
        "id": "ImvJkVBEu1Ez"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# make a dict for galaxy_map with (name, coordinates)\n",
        "\n",
        "galaxy_map = {}\n",
        "x, y, z = [], [], []\n",
        "\n",
        "with open('galaxy_map.txt') as glx:\n",
        "  lines = [line.split(':') for line in glx.readlines()]\n",
        "  for line in lines:\n",
        "    planet = line[0].strip()\n",
        "    coordinates = tuple(map(int, line[1].strip()[1:-1].split(',')))\n",
        "    galaxy_map[planet] = coordinates"
      ],
      "metadata": {
        "id": "MwHnjoUmurDk"
      },
      "execution_count": 818,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(galaxy_map.keys())) # verify we have all planets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vwmQD8uqwvZM",
        "outputId": "5f98579c-3250-442a-e5df-ec5186b7a70a"
      },
      "execution_count": 819,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1046\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# read trade route data, only consider trade routes that are marked as Ok\n",
        "trade_routes = []\n",
        "\n",
        "with open('trade_routes.txt', 'r') as tr: \n",
        "  lines = tr.readlines()\n",
        "  for line in lines:\n",
        "    if 'Ok' in line:\n",
        "      planets = line.split(':')[0]\n",
        "      planets = tuple(map(lambda p: p.strip(), planets.strip().split('-')))\n",
        "      trade_routes.append((planets[0], planets[1]))\n",
        "trade_routes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H2qoXTLvwyma",
        "outputId": "17668a35-3daf-45ab-ea05-4c78e3c5f044"
      },
      "execution_count": 820,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('Scurus V', 'Tauries VII'), ('Beta Drado VI', 'Uranis')]"
            ]
          },
          "metadata": {},
          "execution_count": 820
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import math\n",
        "\n",
        "# helper function to find distance between point and segment\n",
        "def lineseg_dist(p, a, b):\n",
        "    d = np.divide(b - a, np.linalg.norm(b - a))\n",
        "    s = np.dot(a - p, d)\n",
        "    t = np.dot(p - b, d)\n",
        "    h = np.maximum.reduce([s, t, 0])\n",
        "    c = np.cross(p - a, d)\n",
        "    return np.hypot(h, np.linalg.norm(c))\n",
        "\n",
        "planetsCloseToTradeRoutes = set()\n",
        "for planet in galaxy_map:\n",
        "  distances_to_routes = []\n",
        "  for route in trade_routes:\n",
        "    # check nearest distance of this planet to trade route between planets a and b\n",
        "    p = np.asarray(galaxy_map[planet]) \n",
        "    a = np.asarray(galaxy_map[route[0]])\n",
        "    b = np.asarray(galaxy_map[route[1]])\n",
        "    distances_to_routes.append(lineseg_dist(p, a, b))\n",
        "  if all([d <= 10 for d in distances_to_routes]): # if this planet is close to all the Ok trade routes\n",
        "    planetsCloseToTradeRoutes.add(planet)\n",
        "print(len(planetsCloseToTradeRoutes))\n",
        "planetsCloseToTradeRoutes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F52dvBv4yAKv",
        "outputId": "73c0b512-9d33-4562-e5b4-2cad91719249"
      },
      "execution_count": 821,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Alpha Algolum V',\n",
              " 'Alpha Aurus',\n",
              " 'Alpha Cena',\n",
              " 'Antlis VI',\n",
              " 'Arius IV',\n",
              " 'Beta Pupis',\n",
              " 'Cane IV',\n",
              " 'Cephina',\n",
              " 'Cetices',\n",
              " 'Charida',\n",
              " 'Crales',\n",
              " 'Deleo',\n",
              " 'Gamma Cani VII',\n",
              " 'Gemina',\n",
              " 'Orius V',\n",
              " 'Perpis',\n",
              " 'Scurus V',\n",
              " 'Venis',\n",
              " 'Vulutor'}"
            ]
          },
          "metadata": {},
          "execution_count": 821
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "populationCloseToTradeRoutes = [person for person in population if person.home_planet in planetsCloseToTradeRoutes]\n",
        "sum([person.id for person in populationCloseToTradeRoutes]) # answer to puzzle 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8GBHohlvycb6",
        "outputId": "4789fc88-64fc-493a-95c9-c3505ce07757"
      },
      "execution_count": 822,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "966181533"
            ]
          },
          "metadata": {},
          "execution_count": 822
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(populationCloseToTradeRoutes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_IYMq2kFDya9",
        "outputId": "37c8bd3f-0cb9-4693-c6f7-b57e60e82817"
      },
      "execution_count": 823,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "167"
            ]
          },
          "metadata": {},
          "execution_count": 823
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(2.3) Puzzle 3**"
      ],
      "metadata": {
        "id": "QAKhKVtSQruP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# we need to check how long every person stayed at a location on Monday from the security log\n",
        "# every stay at a location can be either free time or work time (number_of_minutes = amount_earned)\n",
        "\n",
        "target_salary = 79 # from the question\n",
        "\n",
        "# read data from security_log\n",
        "with open('security_log.txt', 'r') as file:\n",
        "  lines = file.readlines()\n",
        "\n",
        "\n",
        "# put into a structure with { people: { duration_at_a_place, ... } } \n",
        "# for the same place, a person has to first enter and then exit the location, taking the difference between both those times\n",
        "# we get the duration for that location, the type of place does not matter as salary is the same everywhere\n",
        "# so we can discard the place label and keep only a list of durations\n",
        "\n",
        "people = {}\n",
        "i = 0\n",
        "while i < len(lines):\n",
        "  line = lines[i]\n",
        "\n",
        "  if 'Place' in line:\n",
        "    last_place = line.split(':')[1].strip()\n",
        "  elif 'in:' in line or 'out:' in line: # in/out list, colon added to avoid names like 'edwin'\n",
        "    last_people = line.split(':')[1].strip().split(', ')  \n",
        "    for person in last_people:\n",
        "      if person not in people: # person entering this place for the first time\n",
        "        people[person] = [(last_time, )]\n",
        "        # person exiting this place\n",
        "      elif len(people[person][-1]) == 1:  # odd means last index has an entry time, add exit time\n",
        "        people[person][-1] = (people[person][-1][0], last_time)\n",
        "      else: # even, last index is full with entry and exist, add new entry time  \n",
        "        people[person].append((last_time, )) # update last position in list\n",
        "\n",
        "  elif ':' in line: # time\n",
        "    last_time = minute_of_day(line.strip())\n",
        "  i += 1\n",
        "len(people)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VUrvWCDaSUY-",
        "outputId": "dfcf8837-662f-41a5-b072-a4210b1c9624"
      },
      "execution_count": 824,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12732"
            ]
          },
          "metadata": {},
          "execution_count": 824
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "people['Shakuntala Lee'] # verify location duration history is correct with file"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U3N9_k4LXfyX",
        "outputId": "5b650aee-c408-47dc-9c0f-b6486a564969"
      },
      "execution_count": 825,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(338, 361), (978, 1026), (400, 450), (675, 808)]"
            ]
          },
          "metadata": {},
          "execution_count": 825
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# now that we have information about how long everyone stayed at a place on Monday we can get work on the durations\n",
        "# we simply find a possible subset of the durations for a person that sums up to 79\n",
        "# if such a subset exists they could have earned 79 GAL on Monday.\n",
        "\n",
        "\n",
        "# NOTE: this is the subset sum problem (https://en.wikipedia.org/wiki/Subset_sum_problem) and can be solved using DP\n",
        "# however since there are only a max of 12 locations, if a person visited all of them that would have 2^12 possible subsets\n",
        "# which is tractable with brute force\n",
        "# for the DP solution see: https://www.geeksforgeeks.org/python-program-for-subset-sum-problem-dp-25/\n",
        "\n",
        "from itertools import chain, combinations\n",
        "\n",
        "def powerset(iterable):\n",
        "    \"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\"\n",
        "    s = list(iterable)\n",
        "    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))\n",
        "\n",
        "\n",
        "# first we get only the numeric durations for every person's day\n",
        "# then generate powerset of those durations\n",
        "# checking the sum for each subset\n",
        "# at the first sum that matches the target, we stop\n",
        "populationWithPossibleEarning = set()\n",
        "for person in people: # in order to optimize subset calculation we get rid of durations which cannot contribute to the answer\n",
        "  durations = [n for n in [b - a for a, b in people[person]] if n <= target_salary]\n",
        "  if any([sum(subset) == target_salary for subset in powerset(durations)]):\n",
        "    populationWithPossibleEarning.add(person)\n",
        "  \n",
        "\n",
        "len(populationWithPossibleEarning)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bh4cBGPPXRi8",
        "outputId": "4f3574b0-968d-4942-fda8-21a496ddd77d"
      },
      "execution_count": 826,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "601"
            ]
          },
          "metadata": {},
          "execution_count": 826
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum([person.id for person in population if person.name in populationWithPossibleEarning]) # answer to puzzle 3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EWEWA7oce8a9",
        "outputId": "81e624f1-e87c-46c3-c339-23e7ac1fec61"
      },
      "execution_count": 827,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3288804647"
            ]
          },
          "metadata": {},
          "execution_count": 827
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Episode 2 Solution"
      ],
      "metadata": {
        "id": "LHbUVUHaSYzc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "[person.name for person in populationCloseToTradeRoutes if person.has_gen2_pico_bots() and person.name in populationWithPossibleEarning]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b5CToQF2SZyL",
        "outputId": "ea4abced-fcd6-4272-9650-134a24580638"
      },
      "execution_count": 828,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Jianwei Yakubu']"
            ]
          },
          "metadata": {},
          "execution_count": 828
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Episode 3** \n",
        "\n",
        "https://2022.coding-challenge.festo.com/puzzle/30"
      ],
      "metadata": {
        "id": "cFcNwiMSwweC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# compile population dataset using our previously defined function\n",
        "population = read_population_data('population.txt')\n",
        "\n",
        "print(len(population)) # check/verify size of pop with file"
      ],
      "metadata": {
        "id": "W0OYhj-JxJWq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "230aaf65-5cd9-489a-cc67-fcb922f69e11"
      },
      "execution_count": 829,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12732\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(3.1) Puzzle 1**"
      ],
      "metadata": {
        "id": "RJ0WN0ocw6Ju"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# now we add a function to our person class to detect gen3 picobots\n",
        "# This type of pico-bots starts out with the twelve cells picopicopico and splits itself into four fragments: pic, opi, cop and ico. \n",
        "# The four fragment can either be separated throughout the sample, or they can touch, but they cannot intersect (one cell cannot be part of two fragments). \n",
        "# As in generation 2, the fragments can bend and change direction.\n",
        "from collections import Counter\n",
        "\n",
        "def has_gen3_pico_bots(self) -> bool:\n",
        "  # we can only go up, down, left, right, while respecting edges and our required neighbor never matches the middle character\n",
        "  def get_required_neighbors(sample, i, j, remaining_fragment):\n",
        "    return {(x, y) for x, y in [(i-1, j), (i+1, j), (i, j-1), (i, j+1)] if 0 <= x < 6 and 0 <= y < 8 and sample[x][y] in remaining_fragment}\n",
        "  \n",
        "  def letters(locs):\n",
        "    return set(map(lambda xy: self.blood_sample[xy[0]][xy[1]], locs))\n",
        "  \n",
        "  def letters_with_rep(locs):\n",
        "    return \"\".join(map(lambda xy: self.blood_sample[xy[0]][xy[1]], locs))\n",
        "\n",
        "  def has_gen3_pico_bots_helper(used_cells, remaining_fragments):\n",
        "    if len(remaining_fragments) == 0:\n",
        "      return len(used_cells) >= 12\n",
        "\n",
        "    for fragment in remaining_fragments[0]:\n",
        "      if not used_cells & fragment: # if no overlap of new fragment with already used cells, move toward checking next fragment\n",
        "        if has_gen3_pico_bots_helper(used_cells.union(fragment), remaining_fragments[1:]):\n",
        "          return True\n",
        "    \n",
        "    return False\n",
        "\n",
        "  fragments = ['pic', 'opi', 'cop', 'ico']\n",
        "  fragment_locations = {f: [] for f in fragments}\n",
        "  combined = set()\n",
        "  for fragment in fragment_locations:\n",
        "    for i in range(len(self.blood_sample)):\n",
        "      for j in range(len(self.blood_sample[i])):\n",
        "        if self.blood_sample[i][j] == fragment[1]: # middle of fragment found, now check neighbors for surrounding letters\n",
        "          nl = get_required_neighbors(self.blood_sample, i, j, [fragment[0], fragment[2]])\n",
        "          if len(letters(nl)) == 2: # we have a valid fragment\n",
        "            # generate multiple location combinations if (i, j) surrounded by multiple options for first and third letter \n",
        "            if len(nl) > 2:\n",
        "              zero = {xy for xy in nl if self.blood_sample[xy[0]][xy[1]] == fragment[0]}\n",
        "              two = {xy for xy in nl if self.blood_sample[xy[0]][xy[1]] == fragment[2]}\n",
        "              for z in zero:\n",
        "                for t in two:\n",
        "                  fragment_locations[fragment].append({z, (i, j), t})\n",
        "                  combined.update({z, (i, j), t})\n",
        "            else:\n",
        "              nl.add((i, j))\n",
        "              fragment_locations[fragment].append(nl)\n",
        "              combined.update(nl)\n",
        "    if len(fragment_locations[fragment]) == 0: # we couldn't find this fragment, pico not possible\n",
        "      return False\n",
        "\n",
        "  # not enough unique cells to form the full sequence (picopicopico)\n",
        "  if any([c < 3 for c in Counter(letters_with_rep(combined)).values()]):\n",
        "    return False\n",
        "\n",
        "  fragments = list(fragment_locations.values())\n",
        "  # we have enough cells and all fragments exist, we check if we can form them all without overlap\n",
        "  return any(has_gen3_pico_bots_helper(curr_fragment, fragments[1:]) for curr_fragment in fragments[0])\n",
        "\n",
        "Person.has_gen3_pico_bots = has_gen3_pico_bots\n"
      ],
      "metadata": {
        "id": "779DdWzic08b"
      },
      "execution_count": 830,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# check if our function is working by taking data from clean/infected datasets and verifying for all\n",
        "def run_gen3_blood_test(files) -> bool:\n",
        "  clean = files[0]\n",
        "  dirty = files[1]\n",
        "  \n",
        "  with open(clean, 'r') as clean_file:\n",
        "    lines = clean_file.readlines()\n",
        "\n",
        "  clean_samples = []\n",
        "  for i in range(0, len(lines), 11):\n",
        "      clean_samples.append(arg_cleaner(\"\".join(lines[i+1:i+11]).strip()))\n",
        "  all_clean = not any([Person(None, None, None, sample).has_gen3_pico_bots() for sample in clean_samples])\n",
        "  \n",
        "  with open(dirty, 'r') as dirty_file:\n",
        "    lines = dirty_file.readlines()\n",
        "  dirty_samples = []\n",
        "  for i in range(0, len(lines), 11):\n",
        "    dirty_samples.append(arg_cleaner(\"\".join(lines[i+1:i+11]).strip()))\n",
        "  \n",
        "  all_dirty = all([Person(None, None, None, sample).has_gen3_pico_bots() for sample in dirty_samples])\n",
        "\n",
        "  return all_clean and all_dirty\n",
        "\n",
        "# 1st file should be all false on function, 2nd all true\n",
        "run_gen3_blood_test(['lab_blood_clean.txt', 'lab_blood_gen3.txt']) "
      ],
      "metadata": {
        "id": "vEWH2OlNiQRW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ac7d576e-530d-4617-b1fa-00263f205f37"
      },
      "execution_count": 831,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 831
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "populationWithGen3PicoBots = {person for person in population if person.has_gen3_pico_bots()} \n",
        "len(populationWithGen3PicoBots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wNxK47dRMaE_",
        "outputId": "9d30ee77-c031-4f74-f297-08416d03452a"
      },
      "execution_count": 832,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "356"
            ]
          },
          "metadata": {},
          "execution_count": 832
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum(person.id for person in populationWithGen3PicoBots) # answer to puzzle 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "beJqQU6vMDaU",
        "outputId": "eebd556a-4858-4b9c-dea6-6782271bd91e"
      },
      "execution_count": 833,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1924306984"
            ]
          },
          "metadata": {},
          "execution_count": 833
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(3.2) Puzzle 2**"
      ],
      "metadata": {
        "id": "lcuqeYQdw7nU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# make a dict for galaxy_map with (name, coordinates)\n",
        "galaxy_map = {}\n",
        "\n",
        "with open('galaxy_map.txt') as glx:\n",
        "  lines = [line.split(':') for line in glx.readlines()]\n",
        "  for line in lines:\n",
        "    planet = line[0].strip()\n",
        "    coordinates = tuple(map(int, line[1].strip()[1:-1].split(',')))\n",
        "    galaxy_map[planet] = coordinates"
      ],
      "metadata": {
        "id": "c2ZQ7cEbLSOk"
      },
      "execution_count": 834,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(galaxy_map.keys())) # verify we have all planets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xMTz2cpFLUNM",
        "outputId": "c5c8593d-24be-4938-fce5-f44b2bfd2691"
      },
      "execution_count": 835,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1046\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to identify potential sources for the signal we need to narrow down which planets are neighboring in each other, i.e withing 50 gal units of each other\n",
        "import numpy as np\n",
        "dist = lambda x, y: np.linalg.norm(np.asarray(y) - np.asarray(x))\n",
        "\n",
        "galaxy_graph = {}\n",
        "for planet in galaxy_map:\n",
        "  galaxy_graph[planet] = set()\n",
        "  for neighbor in galaxy_map:\n",
        "    if planet != neighbor and dist(galaxy_map[planet], galaxy_map[neighbor]) <= 50: # add planets next to each other as graphs\n",
        "      galaxy_graph[planet].add(neighbor)\n",
        "\n",
        "print(len(galaxy_graph))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HJFGzWOcLdCb",
        "outputId": "830c46db-f181-41da-8157-3ea1cd8d6688"
      },
      "execution_count": 836,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1046\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import deque\n",
        "\n",
        "# now that we know the neighbors of each planet, we simply perform a BFS and try to find planets that are 'n' neighbors away from the following planets:\n",
        "signal_delay = {'Venis': 2, 'Cetung' : 4, 'Phoensa': 9}\n",
        "\n",
        "def getNthNeighborsByBFS(glx_graph, source, n):\n",
        "  q = deque([(source, 0)]) # store curr_length of path, source is at 0\n",
        "  visited = set()\n",
        "  distances = {} # to maintain distance of all planets from source\n",
        "  \n",
        "  while q and q[0][1] < n: # generate paths until we reach distance 'n'\n",
        "    curr, path = q.popleft()\n",
        "\n",
        "    for neighbor in glx_graph[curr]:\n",
        "      if not neighbor in visited:\n",
        "        visited.add(neighbor) \n",
        "        q.append((neighbor, path + 1))\n",
        "        distances[neighbor] = path + 1 # track distance\n",
        "\n",
        "  return {planet for planet, dist in distances.items() if dist == n} # get all n'th neighbors from source\n",
        "\n",
        "potential_sources = getNthNeighborsByBFS(galaxy_graph, 'Venis', 2)\n",
        "potential_sources = {planet for planet in potential_sources if 'Cetung' in getNthNeighborsByBFS(galaxy_graph, planet, 4)}\n",
        "potential_sources = {planet for planet in potential_sources if 'Phoensa' in getNthNeighborsByBFS(galaxy_graph, planet, 9)}\n",
        "print(len(potential_sources))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ujfvyN96Uy7F",
        "outputId": "8fb1ab6f-b52e-4451-9023-15b290c767d0"
      },
      "execution_count": 837,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "populationWithhPotentialSourceAsHomePlanet = {person for person in population if person.home_planet in potential_sources}\n",
        "len(populationWithhPotentialSourceAsHomePlanet)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PaMbJKX9dUyG",
        "outputId": "06340608-3954-4758-a265-03ac1c4057e7"
      },
      "execution_count": 838,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "423"
            ]
          },
          "metadata": {},
          "execution_count": 838
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum([person.id for person in populationWithhPotentialSourceAsHomePlanet]) # answer to puzzle 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5d52nRJ8TgKF",
        "outputId": "c60cd85f-13f4-4b8e-e859-e44703e74907"
      },
      "execution_count": 839,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2389136693"
            ]
          },
          "metadata": {},
          "execution_count": 839
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(3.3) Puzzle 3**"
      ],
      "metadata": {
        "id": "7uNdSuCbw7vl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# we need to check who has a long enough gap in their schedule on Monday from the security log\n",
        "\n",
        "# read data about how long it takes to travel from place to place within the system\n",
        "travel_times = {}\n",
        "with open('travel_times.txt', 'r') as file:\n",
        "  for line in file:\n",
        "    place, time = line.split(':')\n",
        "    travel_times[place.strip()] = int(time.strip())\n",
        "travel_times"
      ],
      "metadata": {
        "id": "FF57iHvBKN9g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e0ad0a15-0f72-4175-ce9b-a70b1d091123"
      },
      "execution_count": 840,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Bio-Lab': 21,\n",
              " 'Factory': 18,\n",
              " 'Food Plant': 20,\n",
              " 'Gym': 7,\n",
              " 'Happy-Center': 27,\n",
              " 'Junkyard': 16,\n",
              " 'Mining Outpost': 15,\n",
              " 'Office Station': 20,\n",
              " 'Palace': 37,\n",
              " 'Pod Racing Track': 19,\n",
              " 'Shopping Mall': 17,\n",
              " 'Starship Garage': 16}"
            ]
          },
          "metadata": {},
          "execution_count": 840
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# read data from security_log\n",
        "with open('security_log.txt', 'r') as file:\n",
        "  lines = file.readlines()\n",
        "\n",
        "# since we have data about how long it takes to travel from place to place\n",
        "# we find out where everyone was right before 11 and right after 13\n",
        "# and analyze that gap\n",
        "# if someone 'entered' a place between these hours it needs to be with enough of a gap\n",
        "# to travel from a to b without having waited at the crime scene for 20 minutes\n",
        "\n",
        "people = {}\n",
        "\n",
        "i = 0\n",
        "while i < len(lines):\n",
        "  line = lines[i]\n",
        "  if 'Place' in line:\n",
        "    last_place = line.split(':')[1].strip()\n",
        "  elif 'in:' in line or 'out:' in line: # in/out list, colon added to avoid names like 'edwin'\n",
        "    last_people = line.split(':')[1].strip().split(', ')  \n",
        "    for person in last_people:\n",
        "      if person not in people:\n",
        "        people[person] = {}\n",
        "      people[person][last_time] = last_place\n",
        "  elif ':' in line: # time\n",
        "    last_time = minute_of_day(line.strip())\n",
        "  i += 1\n",
        "\n",
        "\n",
        "len(people)"
      ],
      "metadata": {
        "id": "353qJZiSIDTy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "104a3588-5f0c-41c8-f100-fd2d439f600f"
      },
      "execution_count": 841,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12732"
            ]
          },
          "metadata": {},
          "execution_count": 841
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "people['Agnes Carter']"
      ],
      "metadata": {
        "id": "hhUJWcUhJ2de",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "360c3028-509d-44a0-bc35-1faafccf049b"
      },
      "execution_count": 842,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{466: 'Mining Outpost',\n",
              " 522: 'Mining Outpost',\n",
              " 1095: 'Junkyard',\n",
              " 1127: 'Junkyard',\n",
              " 1183: 'Bio-Lab',\n",
              " 1196: 'Bio-Lab'}"
            ]
          },
          "metadata": {},
          "execution_count": 842
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# now that we have a timeline for everyone's day\n",
        "# we simply check where everyone was before 11 then check what time they arrived at their next destination\n",
        "# we check: 'time when left A' + time to travel to b + time to crime < 'time of arrival at b' \n",
        "# this person is clear\n",
        "\n",
        "window_start = minute_of_day('11:00') # we are interested in people leaving a place after this time\n",
        "window_end= minute_of_day('13:00') # we are interested in people arriving at a place before this time\n",
        "time_to_crime = 20\n",
        "potential_suspects = set()\n",
        "\n",
        "for person in people:\n",
        "  routine = sorted(people[person].items())\n",
        "  last = routine.pop(0)\n",
        "  isEntry = False\n",
        "  for time, place in routine:\n",
        "    last_time, last_place = last\n",
        "    \n",
        "    if isEntry and time >= window_start:\n",
        "      # if no activity all window\n",
        "      was_missing = last_time <= window_start and time >= window_end\n",
        "      \n",
        "      # had enough of a gap to travel and commit the crime, would have arrived no earlier than 11 and left no later than 13\n",
        "      earliest_arrival = max(last_time + travel_times[last_place], window_start)\n",
        "      latest_departure = min(time - travel_times[place], window_end)\n",
        "      had_time_to_crime = latest_departure - earliest_arrival >= time_to_crime\n",
        "      if was_missing or had_time_to_crime:\n",
        "        potential_suspects.add(person)\n",
        "        break\n",
        "      \n",
        "      # if window is already over and no gap found\n",
        "      if window_end >= last_time >= time:\n",
        "        break \n",
        "\n",
        "    last = time, place\n",
        "    isEntry = not isEntry\n",
        "\n",
        "len(potential_suspects)"
      ],
      "metadata": {
        "id": "RXqgDRJ7SnZp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "23c40961-8c28-4327-ff6a-a9eb519f38d3"
      },
      "execution_count": 843,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "407"
            ]
          },
          "metadata": {},
          "execution_count": 843
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "populationWithoutAlibis = {person for person in population if person.name in potential_suspects}\n",
        "len(populationWithoutAlibis)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lhQv4GeB8EGE",
        "outputId": "5dfa0b8c-8c0f-4678-ed1e-d99f496c8846"
      },
      "execution_count": 844,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "407"
            ]
          },
          "metadata": {},
          "execution_count": 844
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum([person.id for person in populationWithoutAlibis]) # answer to puzzle 3"
      ],
      "metadata": {
        "id": "Q-AAX9WvD1XQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80055ed0-3a1d-448a-a905-d319f6cf8fcd"
      },
      "execution_count": 845,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2178367787"
            ]
          },
          "metadata": {},
          "execution_count": 845
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Episode 3 Solution"
      ],
      "metadata": {
        "id": "J_Lo6u8PxEC1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "[person.name for person in populationWithGen3PicoBots & populationWithhPotentialSourceAsHomePlanet & populationWithoutAlibis]"
      ],
      "metadata": {
        "id": "aep6lMURcalJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "495af631-3f40-4c50-98fc-b290dcec0f49"
      },
      "execution_count": 846,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Agnes Carter']"
            ]
          },
          "metadata": {},
          "execution_count": 846
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Final Episode (Optional Finale)** \n",
        "\n",
        "https://2022.coding-challenge.festo.com/puzzle/40"
      ],
      "metadata": {
        "id": "jr19z3pmjqlJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(4.1) Puzzle 1**"
      ],
      "metadata": {
        "id": "amONxQzLj4CP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# we need to identify which passages can be cleared and return their indices in ascending order\n",
        "# first read data about the passages into a directed graph structure where direction signifies dependencies (dest depends on source) \n",
        "passages = {}\n",
        "with open('scrap_scan.txt', 'r') as file:\n",
        "  for line in file:\n",
        "    if 'Passage' in line:\n",
        "      idx = line.split(' ')[1].strip()\n",
        "      passages[idx] = {} # idx\n",
        "    elif ':' in line:\n",
        "      dest, sources = line.split(':')\n",
        "      sources = sources.strip().split(',')\n",
        "      for source in sources:\n",
        "        passages[idx][source.strip()] = passages[idx].get(source.strip(), []) + [dest.strip()]\n"
      ],
      "metadata": {
        "id": "cLFrx8cFj1z1"
      },
      "execution_count": 847,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "passages['1'] # '-' key is the root element of our graph"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NMMgquJKoIcY",
        "outputId": "5e239e27-506b-4042-c143-d40dd9626b59"
      },
      "execution_count": 848,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'-': ['futuristic tray'],\n",
              " 'black window': ['blue container', 'broken engine', 'mysterious cabinet'],\n",
              " 'blue container': ['broken engine'],\n",
              " 'expensive gun': ['black window',\n",
              "  'blue container',\n",
              "  'broken engine',\n",
              "  'mysterious cabinet'],\n",
              " 'futuristic tray': ['blue container',\n",
              "  'broken engine',\n",
              "  'expensive gun',\n",
              "  'over-sized drill'],\n",
              " 'mysterious cabinet': ['black window', 'blue container', 'old-school robot'],\n",
              " 'old-school robot': ['blue container', 'broken engine'],\n",
              " 'over-sized drill': ['blue container', 'broken engine']}"
            ]
          },
          "metadata": {},
          "execution_count": 848
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# we simply check if our graph has a cyclic dependency or if debris can be cleared in order through topological sort\n",
        "from enum import Enum\n",
        "\n",
        "class STATUS(Enum):\n",
        "  untouched = 0\n",
        "  visited = 1\n",
        "  explored = 2\n",
        "\n",
        "def topologicalSortDFS(graph, curr, status, cycle):\n",
        "  status[curr] = STATUS.visited\n",
        "  for v in graph.get(curr, []):\n",
        "    if v not in status:\n",
        "      status[v] = STATUS.untouched\n",
        "    if (status[v] is STATUS.explored):\n",
        "      continue\n",
        "    elif (status[v] is STATUS.visited):\n",
        "      cycle[0] = True\n",
        "    else:\n",
        "      topologicalSortDFS(graph, v, status, cycle)\n",
        "\n",
        "  status[curr] = STATUS.explored\n",
        " \n",
        "def check_cycle(graph):\n",
        "  status = {v: STATUS.untouched for v in graph}\n",
        "  cycle = [False]\n",
        "  for v in graph:\n",
        "    if status[v] is STATUS.untouched:\n",
        "      topologicalSortDFS(graph, v, status, cycle)\n",
        "      if cycle[0]:\n",
        "        return True\n",
        "  \n",
        "  return False"
      ],
      "metadata": {
        "id": "ojyE3Acloxr-"
      },
      "execution_count": 849,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"-\".join(map(str, sorted(map(int, {idx for idx, graph in passages.items() if not check_cycle(graph)})))) # answer to puzzle 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "wFBQPhQmDdrS",
        "outputId": "7ac17cee-0c99-4292-fe03-310ff18db418"
      },
      "execution_count": 850,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'395-431-777-865-912'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 850
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(4.2) Puzzle 2**"
      ],
      "metadata": {
        "id": "xNkUh2elj6Sp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# we need to identify which bunkers can be opened without alerting neighboring bunkers and accumulate the maximum amount of gold\n",
        "\n",
        "# first read the file into a structure of { planet_name: [[row1], [row2]] }\n",
        "bunkers = {}\n",
        "with open('bunker_gold.txt', 'r') as file:\n",
        "  lines = file.readlines()\n",
        "  \n",
        "  gold_reserves = {lines[i].strip(): [list(map(int, lines[i+1].split(', '))), list(map(int, lines[i+2].split(', ')))] for i in range(0, len(lines) - 3, 4)}\n",
        "\n",
        "print(gold_reserves['Erida'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aMjxRJRyEb-B",
        "outputId": "4e2289b6-e1d3-431a-d32d-6462b6cc53a9"
      },
      "execution_count": 851,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[91, 8, 18, 45, 107, 4, 27, 83, 13, 6, 48, 37, 102, 46, 73, 177, 24, 119, 42, 236, 22, 10, 15, 29, 32, 19, 2, 36, 47], [1, 48, 12, 50, 81, 88, 83, 143, 44, 43, 365, 195, 58, 83, 10, 28, 136, 114, 33, 76, 108, 88, 72, 251, 38, 46, 154, 58, 10]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from functools import lru_cache\n",
        "\n",
        "\n",
        "# now we simply check for a given grid if we can greedily traverse the 2 rows accumulating gold.\n",
        "# at every 2 reserves we have the option to take top, bot or neither.\n",
        "def rob_reserves(grid):\n",
        "  rows = len(grid)\n",
        "  cols = len(grid[0])\n",
        "  \n",
        "  @lru_cache(None)\n",
        "  def maxSum(grid, taken, col):\n",
        "    if col == len(grid[0]) - 1: # is last column /only 1 column given\n",
        "      return max(grid[0][col], grid[1][col]) if taken == None else grid[0][col] if taken == 1 else grid[1][col]\n",
        "\n",
        "    # multiple columns: can take top, take bot or take none, depending on what we chose last time\n",
        "    options = [maxSum(grid, None, col + 1)] # not taking either column is always an option\n",
        "    top = grid[0][col] \n",
        "    bot = grid[1][col]\n",
        "    \n",
        "    if taken == None or taken == 0:\n",
        "      options.append(bot + maxSum(grid, 1, col + 1))\n",
        "\n",
        "    if taken == None or taken == 1:\n",
        "      options.append(top + maxSum(grid, 0, col + 1))\n",
        "    \n",
        "    return max(options) # whichever path gives highest sum\n",
        "\n",
        "  return maxSum(tuple(tuple(row) for row in grid), None, 0)\n",
        "\n",
        "sample = [[3, 1, 1, 5], [2, 4, 3, 3]]\n",
        "rob_reserves(sample)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B9jFXod0IbDl",
        "outputId": "4b396f28-d1a1-40cb-b201-c5623d56ca27"
      },
      "execution_count": 852,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {},
          "execution_count": 852
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "total_haul = {planet: rob_reserves(reserves) for planet, reserves in gold_reserves.items()}\n",
        "max_haul = max(total_haul, key=total_haul.get)\n",
        "f'{max_haul}{total_haul[max_haul]}' # answer to puzzle 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "VtXPwmyAAw0E",
        "outputId": "59b95f18-0f7d-4169-9adf-401b24134040"
      },
      "execution_count": 853,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Scorvus4112'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 853
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **(4.3) Puzzle 3**"
      ],
      "metadata": {
        "id": "OEx0t8FLj6ao"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install networkx"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qhe3xgvThT2d",
        "outputId": "a6010898-f975-446a-9086-2b1673dabd88"
      },
      "execution_count": 854,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.7/dist-packages (2.6.3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We need to determine best order to cut cables such that we disconnect A->Z, each cable has a thickness so we simply determine shortest path from A to Z\n",
        "import networkx as nx\n",
        "# First read the file into a graph structure\n",
        "G = nx.MultiGraph()\n",
        "indices = {}\n",
        "weights = {}\n",
        "with open('machine_room.txt', 'r') as file:\n",
        "  lines = file.readlines()\n",
        "  for line in lines:\n",
        "    idx, components, thickness = line.split(':')\n",
        "    components = tuple(c.strip() for c in components.strip().split('-'))\n",
        "    G.add_edge(components[0], components[1], key=int(idx), weight=int(thickness), capacity=int(thickness))\n",
        "    \n",
        "    indices[components] = indices[components[::-1]] = int(idx)\n",
        "    weights[components] = weights[components[::-1]] = int(thickness)\n",
        "\n",
        "len(G.nodes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7TH7XCuzevhn",
        "outputId": "53f75db8-f0b2-40fe-8821-7e0b415ebdc7"
      },
      "execution_count": 855,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "26"
            ]
          },
          "metadata": {},
          "execution_count": 855
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from more_itertools import pairwise\n",
        "# In order to identify which order to cut the cables in for the least amount of time to disconnect components\n",
        "# We simply Greedily remove the smallest edge which is part of the shortest path from A->Z\n",
        "# If our current sequence, goes over our best time (so far) we backtrack and remove some other edge\n",
        "\n",
        "\n",
        "# to get total duration of cutting cables in a sequence\n",
        "mapSequenceToMinutes = lambda edges: sum(map(lambda e: weights[(e[0], e[1])], edges)) \n",
        "# index needs order of cables sorted via index\n",
        "mapSequenceToIndices = lambda edges: \"-\".join(sorted(map(lambda e: str(indices[(e[0], e[1])]), edges)))\n",
        "\n",
        "def GreedyMinCut(G, removed_edges, best_sequences, best_time):\n",
        "  # if A and Z disconnected, sequence complete, record time and return\n",
        "  if not nx.has_path(G, 'A', 'Z'):\n",
        "    total_time = mapSequenceToMinutes(removed_edges)\n",
        "    sequence = mapSequenceToIndices(removed_edges)\n",
        "    if total_time < best_time[0]: # newer improved time\n",
        "      best_sequences[sequence] = total_time\n",
        "      best_time[0] = total_time\n",
        "    return True\n",
        "\n",
        "  shortest_path = nx.shortest_path(G, 'A', 'Z', weight='weight', method='bellman-ford')\n",
        "\n",
        "  # get the edges of this shortest path sorted by weight (to move greedily)\n",
        "  shortest_path_pairs = sorted(((s, t) for s, t in pairwise(shortest_path)), key=weights.get)\n",
        "  # remove 1 edge at a time and check if path A->Z disconnected\n",
        "  for s, t in shortest_path_pairs:\n",
        "    G.remove_edge(s, t)\n",
        "    removed_edges.append((s, t, weights[(s, t)]))\n",
        "    # recursively remove more edges until our sequence A->Z disconnected\n",
        "    GreedyMinCut(G, removed_edges, best_sequences, best_time)\n",
        "    better = mapSequenceToMinutes(removed_edges) < best_time[0]\n",
        "    edge = removed_edges.pop()\n",
        "    G.add_edge(edge[0], edge[1], edge[2])\n",
        "    if not better: # this sequence is worse than our best sequence, backtrack (add last edge back) and try another\n",
        "      return False\n",
        "    \n",
        "  return True\n",
        "\n",
        "best_sequences = {}\n",
        "GreedyMinCut(G, [], best_sequences, [math.inf])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oDD7Qk2M9TVD",
        "outputId": "76b80b52-2886-4b0e-a33d-ee92005933eb"
      },
      "execution_count": 856,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 856
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fastest_sequence = min(best_sequences, key=best_sequences.get)\n",
        "fastest_sequence, best_sequences[fastest_sequence] # answer to puzzle 3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a2bWItLN_-pG",
        "outputId": "d074c0e3-e6f7-4628-d1ed-e2c01c38e2ca"
      },
      "execution_count": 857,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('15-17-18-23-30-34-35', 23)"
            ]
          },
          "metadata": {},
          "execution_count": 857
        }
      ]
    }
  ]
}