aoc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to my solution repository for the Advent of Code edition 2024!\n",
    "This repository contains (hopefully) a solution to all exercises.\n",
    "The solutions should be simple enough that anyone with a minor Python knowledge,\n",
    "but a solid internet connection and a curious mind should be able to comprehend all of them.\n",
    "I did my best to implement them in the most readable, yet elegant and *pythonic* way I could imagine.\n",
    "Below, we will quickly revise each of the solutions, building upon what we learned in previous quests.\n",
    "*'T is the season!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 1: *Historian Hysteria*\n",
    "\n",
    "The first two quests are simple, but require knowledge on how to read files in Python.\n",
    "I implemented the solution in the files *aoc_01.py* and *aoc_02.py*,\n",
    "however, it's best practice to keep the interaction with your file system as short as possible.\n",
    "That is why I always declared and implemented the input handling functions in *aoc_utils.py*.\n",
    "\n",
    "For this first day, we're looking at the function ``read_lists_01`` (part of the utilities file),\n",
    "which reads the contents of an input file into two lists *left_list* and *right_list*.\n",
    "\n",
    "```python\n",
    "def read_lists_01(input_file=\"data/24-aoc-01.in\"):\n",
    "    left_list = []\n",
    "    right_list = []\n",
    "\n",
    "    with open(input_file, \"r\") as file:\n",
    "        for line in file:\n",
    "            values = line.split(' ')\n",
    "\n",
    "            left_list.append(int(values[0]))\n",
    "            right_list.append(int(values[-1]))\n",
    "\n",
    "    left_list.sort()\n",
    "    right_list.sort()\n",
    "\n",
    "    return left_list, right_list\n",
    "```\n",
    "\n",
    "\\pagebreak\n",
    "\n",
    "This function has some features that might look unfamiliar to those new to Python.\n",
    "\n",
    "- The function's declaration shows that it takes one argument, called ``input_file``.\n",
    "We also see that this argument is set to *\"data/24-aoc-01.in\"* if it is omitted.\n",
    "This means that if we call the function without specifying an input file,\n",
    "this argument will be set to that standard value.\n",
    "\n",
    "- We are opening a file in *read-only* mode.\n",
    "This is done with the ``with open(filename, mode) as`` statement.\n",
    "This statement opens a file in the required mode (*write*, *read*, *append*) and gives you a handle to the file.\n",
    "With this handle, you can use the file as an iterator which returns the lines of the file in-order.\n",
    "There's some other functionality for these file handles,\n",
    "but that would take us too far for this day.\n",
    "\n",
    "This input handling function is used for both the first and second quest,\n",
    "so naturally I put it in the utility file.\n",
    "I can import this function in another file.\n",
    "This is because the directory is a python package,\n",
    "but I won't go into the details of those right now.\n",
    "It's sufficient to know that you can import these functions as well when you create new files in the same directory as the utility file.\n",
    "\n",
    "Let's now check how we fix the first problem.\n",
    "This boils down to sorting both lists - which is being handled in the input handling function - \n",
    "and then taking the absolute differences between their minimal values,\n",
    "adding these all together to produce the final result.\n",
    "\n",
    "```python\n",
    "from aoc_util import read_lists_01\n",
    "\n",
    "def find_total_distance(input_file=\"data/24-aoc-01.in\"):\n",
    "    \"\"\"\n",
    "    >>> find_total_distance(\"test/24-aoc-01.test\")\n",
    "    11\n",
    "    \"\"\"\n",
    "    left_list, right_list = read_lists_01(input_file)\n",
    "    total_distance = sum(abs(left - right) for left, right in zip(left_list, right_list))\n",
    "    return total_distance\n",
    "```\n",
    "\n",
    "Nothing special happens here,\n",
    "once you understand *list comprehensions* like the one on the second line in ``find_total_distance``'s implementation.\n",
    "I won't go into the intricate details of these types of statements,\n",
    "but it should be apparent that they are equivalent to writing a for loop,\n",
    "yet in this case more readable!\n",
    "For my personal input, you can check the result below.\n",
    "Watch out when re-running the original notebook,\n",
    "as the file used might not exist on your system,\n",
    "making the execution crash!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2166959"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from aoc_01 import find_total_distance\n",
    "find_total_distance()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\pagebreak\n",
    "\n",
    "Once you get your result correct,\n",
    "you are treated with the second quest of day one.\n",
    "As is typical, this is a small change made to the assignment of the first task.\n",
    "In this case, we are tasked with calculating some *similarity score*.\n",
    "The explanation boils down to multiplying each element in the first list by the amount of appearances it has in the second list.\n",
    "Using the same input handling function, this is very simple:\n",
    "\n",
    "```python\n",
    "from aoc_util import read_lists_01\n",
    "\n",
    "def find_total_similarity_score(input_file=\"data/24-aoc-01.in\"):\n",
    "    \"\"\"\n",
    "    >>> find_total_similarity_score(\"test/24-aoc-01.test\")\n",
    "    31\n",
    "    \"\"\"\n",
    "    left_list, right_list = read_lists_01(input_file)\n",
    "    total_similarity = sum(left * right_list.count(left) for left in left_list)\n",
    "    return total_similarity\n",
    "```\n",
    "\n",
    "Once again, nothing out of the ordinary to mention here but a nice and simple list comprehension.\n",
    "My input yields the following result:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23741109"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from aoc_02 import find_total_similarity_score\n",
    "find_total_similarity_score()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Awesome!\n",
    "Let's quickly check what new challenges the second day brings us!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 2: *Red-Nosed Reports*\n",
    "\n",
    "The second day brings us two new quests.\n",
    "This time, we are asked to inspect some sensor data,\n",
    "which is presented in a list of integer sequences.\n",
    "Depending on the values and the way they are sorted,\n",
    "these sequences are considered safe or unsafe.\n",
    "Our task is to efficiently figure out which reports indicate safe or unsafe levels.\n",
    "The solution to these assignments can be found under *aoc_03.py* and *aoc_04.py*.\n",
    "\n",
    "Once again, we start by reading the input from a file.\n",
    "This code is again declared and implemented in *aoc_util.py*.\n",
    "It is a tad bit simpler, as we only have to generate one list of sequences instead of splitting a line over two lists.\n",
    "\n",
    "```python\n",
    "def read_reports_03(input_file=\"data/24-aoc-03.in\"):\n",
    "    reports = []\n",
    "\n",
    "    with open(input_file, \"r\") as file:\n",
    "        for line in file:\n",
    "            report = line.split(' ')\n",
    "            reports.append([int(level) for level in report])\n",
    "\n",
    "    return reports\n",
    "```\n",
    "\n",
    "\\pagebreak\n",
    "\n",
    "Once we have our reports, we can start figuring out which of the reports indicate a safe series of levels or not.\n",
    "For a report to be safe, it has to conform two constraints in the beginning:\n",
    "\n",
    "- The levels have to be in either de- or ascending order.\n",
    "- Two subsequent levels have to differ at least one and at most three in absolute value.\n",
    "\n",
    "To check this, I made use of the ``all`` key-word in my first implementation.\n",
    "Combining this with a list comprehension where I pair each value of the list with it's subsequent value makes checking the constraints very efficient.\n",
    "\n",
    "```python\n",
    "from aoc_util import read_reports_03\n",
    "\n",
    "def is_safe(report):\n",
    "    all_increasing = all(\n",
    "        level <= next_level \n",
    "        for level, next_level\n",
    "        in zip(report, report[1:])\n",
    "    )\n",
    "\n",
    "    all_decreasing = all(\n",
    "        level >= next_level \n",
    "        for level, next_level \n",
    "        in zip(report, report[1:])\n",
    "    )\n",
    "\n",
    "    within_bounds = all(\n",
    "        1 <= abs(level - next_level) <= 3\n",
    "        for level, next_level\n",
    "        in zip(report, report[1:])\n",
    "    )\n",
    "\n",
    "    return (all_increasing or all_decreasing) and within_bounds\n",
    "\n",
    "def find_safe_reports(input_file=\"data/24-aoc-03.in\"):\n",
    "    \"\"\"\n",
    "    >>> find_safe_reports(\"test/24-aoc-03.test\")\n",
    "    2\n",
    "    \"\"\"\n",
    "    reports = read_reports_03(input_file)\n",
    "    safe_reports = sum(is_safe(report) for report in reports)\n",
    "    return safe_reports\n",
    "```\n",
    "\n",
    "Once again, there is nothing out of the ordinary.\n",
    "We broke up the assignment in intuitive, yet simple and atomically solvable parts.\n",
    "By doing this, checking the constraints became almost trivial,\n",
    "as each of those ``all``-statements almost read in human language!\n",
    "\n",
    "The second assignment adds, as expected, an extra layer to the first.\n",
    "This time, we should allow one faulty level, meaning there can be, at most, one level that breaks the constraints.\n",
    "The key to the solution is realizing that when we omit this level, the constraints should be satisfied.\n",
    "We can reuse our ``is_safe`` function!\n",
    "The implementation on the next page defines an extra function.\n",
    "\n",
    "```python\n",
    "from aoc_util import read_reports_03\n",
    "from aoc_03 import is_safe\n",
    "\n",
    "def is_almost_safe(report):\n",
    "    safe = False\n",
    "\n",
    "    idx = 0\n",
    "    while idx < len(report) and not safe:\n",
    "        truncated_report = report[0:idx] + report[idx + 1:]\n",
    "        safe = is_safe(truncated_report)\n",
    "        idx += 1\n",
    "\n",
    "    return safe\n",
    "\n",
    "\n",
    "def find_safe_and_almost_safe_reports(input_file=\"data/24-aoc-03.in\"):\n",
    "    \"\"\"\n",
    "    >>> find_safe_and_almost_safe_reports(\"test/24-aoc-03.test\")\n",
    "    4\n",
    "    \"\"\"\n",
    "    reports = read_reports_03(input_file)\n",
    "    safe_reports = sum(is_almost_safe(report) for report in reports)\n",
    "    return safe_reports\n",
    "```\n",
    "\n",
    "This implementation makes use of list slicing to efficiently omit the $i$-th value in iteration $i$.\n",
    "By having a *while* with two conditions, we can stop once we find a way in which our report is safe.\n",
    "Using these solutions, we get the following values:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "534"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from aoc_03 import find_safe_reports\n",
    "find_safe_reports()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "577"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from aoc_04 import find_safe_and_almost_safe_reports\n",
    "find_safe_and_almost_safe_reports()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be expected, there are more almost safe *and* safe reports than only safe reports.\n",
    "\n",
    "Awesome!\n",
    "We just solved the assignments for the second day.\n",
    "One step closer to saving Christmas this year, all while learning some great skills!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\pagebreak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 3: *Mull It Over*\n",
    "\n",
    "Day 3 treats us with an awesome exercise on *regular expressions*.\n",
    "The task is really simple once you know those,\n",
    "but explaining all of the theory behind it could be a whole separate course.\n",
    "That is why I'll simply link to the [Python \"re\" package](https://docs.python.org/3/library/re.html).\n",
    "The first part of this day asks us to find all instances of a *mul* instruction in dirty memory.\n",
    "Once we know how this instruction looks like, we can easily get all occurrences.\n",
    "After that, we transform the instruction into a real multiplication and count together the results.\n",
    "Reading the input of this task is too simple to look at in-depth, but included for completeness' sake.\n",
    "\n",
    "```python\n",
    "def read_memory_muls(input_file=\"data/24-aoc-05.in\"):\n",
    "    with open(input_file, \"r\") as file:\n",
    "        memory = \"\".join(file)\n",
    "    return memory\n",
    "```\n",
    "\n",
    "The code used for calculating the sum of multiplications then boils down to this:\n",
    "\n",
    "```python\n",
    "from aoc_util import read_memory_muls\n",
    "import re\n",
    "\n",
    "mul_regex = r\"mul\\(\\d{1,3},\\d{1,3}\\)\"\n",
    "\n",
    "def execute_mul(mul_instruction):\n",
    "    truncated_instruction = mul_instruction[4:].replace(\"(\", \"\").replace(\")\", \"\")\n",
    "    factor1, factor2 = truncated_instruction.split(\",\")\n",
    "    return int(factor1) * int(factor2)\n",
    "\n",
    "\n",
    "def find_muls(input_file=\"data/24-aoc-05.in\"):\n",
    "    \"\"\"\"\n",
    "    >>> find_muls(\"test/24-aoc-05.test\")\n",
    "    161\n",
    "    \"\"\"\n",
    "    dirty_memory = read_memory_muls(input_file)\n",
    "    memory = re.finditer(mul_regex, dirty_memory)\n",
    "    result = sum(execute_mul(mul_instruction.group()) for mul_instruction in memory)\n",
    "    return result\n",
    "```\n",
    "\n",
    "Which we can then use to find the solution of the first part:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "175615763"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from aoc_05 import find_muls\n",
    "find_muls()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "random_venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  },
  "title": "Advent of Code 2024"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}