aoc-2019.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AOC 2019\n",
    "\n",
    "Welcome to the Advent of Code 2019 !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic configuration\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install -U advent-of-code-data numpy pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ['AOC_SESSION'] = open('session.txt').read().strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from aocd.models import Puzzle\n",
    "from collections import Counter, defaultdict\n",
    "from itertools import chain, product\n",
    "from numpy.typing import ArrayLike\n",
    "from pprint import pprint\n",
    "from queue import PriorityQueue\n",
    "from statistics import median\n",
    "from typing import Callable, Dict, Iterator, Mapping, Tuple\n",
    "import copy\n",
    "import functools\n",
    "import math\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import operator\n",
    "import re\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_ints(input_data:str, as_nparray:bool=False) -> Iterator[int]:\n",
    "    \"\"\"Transform the input string into a list of integers.\"\"\"\n",
    "    if \"\\n\" in input_data:\n",
    "        if as_nparray:\n",
    "            return np.array([list(x) for x in input_data.splitlines()], dtype=int)\n",
    "        else:\n",
    "            return [int(x) for x in input_data.splitlines()]\n",
    "    \n",
    "    else:\n",
    "        return [int(x) for x in input_data.split(\",\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helpers.functions import *\n",
    "DIR = \"data/2019/\"\n",
    "load_day = functools.partial(load, DIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def intcode_computer(software, idx=0, relative_basis=0, inputs=None, memory=None):\n",
    "\n",
    "    inputs = list(inputs or [])\n",
    "    software_size = len(software)\n",
    "        \n",
    "    if memory is None:\n",
    "        memory = collections.defaultdict(int)\n",
    "\n",
    "    while software[idx] != 99:\n",
    "        instruction = '{:0>5}'.format(software[idx])\n",
    "        # print(f\"Instruction: {instruction}\", end=\": \")\n",
    "        \n",
    "        modes = instruction[2::-1]\n",
    "        assert(all([mod in [\"0\", \"1\", \"2\"] for mod in modes]))\n",
    "        \n",
    "        opcode = software[idx] % 100\n",
    "        \n",
    "        # position, relative or immediate mode\n",
    "        if opcode in [1, 2, 4, 5, 6, 7, 8, 9]:\n",
    "            if modes[0] == \"1\":\n",
    "                left_idx = idx+1\n",
    "            elif modes[0] == \"2\":\n",
    "                left_idx = software[idx+1] + relative_basis\n",
    "            else:\n",
    "                left_idx = software[idx+1]\n",
    "            \n",
    "            if left_idx < 0:\n",
    "                raise ValueError(f\"Negative indexing: {left_idx}\")\n",
    "            elif left_idx >= software_size:\n",
    "                left_term = memory[left_idx]\n",
    "            else:\n",
    "                left_term = software[left_idx]\n",
    "        \n",
    "        if opcode in [1, 2, 5, 6, 7, 8, 9]:\n",
    "            if modes[1] == \"1\":\n",
    "                right_idx = idx+2\n",
    "            elif modes[1] == \"2\":\n",
    "                right_idx = software[idx+2] + relative_basis\n",
    "            else:\n",
    "                right_idx = software[idx+2]\n",
    "\n",
    "            if right_idx < 0:\n",
    "                raise ValueError(f\"Negative indexing: {right_idx}\")\n",
    "            elif right_idx >= software_size:\n",
    "                right_term = memory[right_idx]\n",
    "            else:\n",
    "                right_term = software[right_idx]\n",
    "        \n",
    "        writting_idx = None\n",
    "        writting_data = None\n",
    "\n",
    "        if opcode in [1, 2, 7, 8]:\n",
    "            writting_idx = 3\n",
    "        elif opcode == 3:\n",
    "            writting_idx = 1\n",
    "        \n",
    "        if writting_idx is not None:\n",
    "            if modes[writting_idx - 1] == \"2\":\n",
    "                writting_idx = software[idx + writting_idx] + relative_basis\n",
    "            else:\n",
    "                writting_idx = software[idx + writting_idx]\n",
    "\n",
    "        if opcode == 1:\n",
    "            writting_data = left_term + right_term\n",
    "            idx += 4\n",
    "        elif opcode == 2:\n",
    "            writting_data = left_term * right_term\n",
    "            idx += 4\n",
    "        elif opcode == 3:\n",
    "            if len(inputs):\n",
    "                writting_data = int(inputs.pop(0))\n",
    "                idx += 2\n",
    "            else:\n",
    "                return {\"error\": \"input\", \"idx\": idx, \"relative_basis\": relative_basis}\n",
    "        elif opcode == 4:\n",
    "            return {\"output\": left_term, \"idx\": idx + 2, \"relative_basis\": relative_basis}\n",
    "        elif opcode == 5:\n",
    "            if left_term:\n",
    "                idx = right_term\n",
    "            else:\n",
    "                idx += 3\n",
    "        elif opcode == 6:\n",
    "            if not left_term:\n",
    "                idx = right_term\n",
    "            else:\n",
    "                idx += 3\n",
    "        elif opcode == 7:\n",
    "            writting_data = int(left_term < right_term)\n",
    "            idx += 4\n",
    "        elif opcode == 8:\n",
    "            writting_data = int(left_term == right_term)\n",
    "            idx += 4\n",
    "        elif opcode == 9:\n",
    "            relative_basis += left_term\n",
    "            idx += 2\n",
    "        else:\n",
    "            raise ValueError(\"error, code:\", software[idx], \" position: \", idx)\n",
    "        \n",
    "        if writting_data is not None:\n",
    "            if writting_idx < software_size:\n",
    "                software[writting_idx] = writting_data\n",
    "            else:\n",
    "                memory[writting_idx] = writting_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 1\n",
    "\n",
    "http://adventofcode.com/2019/day/1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fuel(mass):\n",
    "    return mass // 3 - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "\n",
    "for elem in map(int, content):\n",
    "    total += fuel(elem)\n",
    "    \n",
    "print(f'Answer 1: {total}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "\n",
    "for elem in map(int, content):\n",
    "    fuel_mass = fuel(elem)\n",
    "    while fuel_mass > 0:\n",
    "        total += fuel_mass\n",
    "        fuel_mass = fuel(fuel_mass)\n",
    "\n",
    "print(f'Answer 2: {total}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 2\n",
    "\n",
    "http://adventofcode.com/2019/day/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(2)\n",
    "content = list(map(int, content[0].split(',')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_software(noun=12, verb=2):\n",
    "    software = copy.deepcopy(content)\n",
    "    software[1:3] = [noun, verb]\n",
    "    return software"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "software = write_software()\n",
    "intcode_computer(software)\n",
    "print(f'Anwser 1: {software[0]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for noun in range(100):\n",
    "    for verb in range(100):\n",
    "        software = write_software(noun, verb)\n",
    "        intcode_computer(software)\n",
    "        if software[0] == 19690720:\n",
    "            print('Answer 2: {}'.format(noun * 100 + verb))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 3\n",
    "\n",
    "http://adventofcode.com/2019/day/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(3)\n",
    "ex1 = [\"R75,D30,R83,U83,L12,D49,R71,U7,L72\", \"U62,R66,U55,R34,D71,R55,D58,R83\"]\n",
    "ex2 = [\"R98,U47,R26,D63,R33,U87,L62,D20,R33,U53,R51\", \"U98,R91,D20,R16,D67,R40,U7,R15,U6,R7\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = [ c.split(',') for c in content]\n",
    "ex1 = [ c.split(',') for c in ex1]\n",
    "ex2 = [ c.split(',') for c in ex2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def order_to_coords(value, from_coord):\n",
    "    orient = value[0]\n",
    "    length = int(value[1:])\n",
    "    \n",
    "    if orient == 'R':\n",
    "        return [(from_coord[0] + x, from_coord[1]) for x in range(1, length + 1)]\n",
    "    elif orient == 'L':\n",
    "        return [(from_coord[0] - x, from_coord[1]) for x in range(1, length + 1)]\n",
    "    elif orient == 'U':\n",
    "        return [(from_coord[0], from_coord[1] + x) for x in range(1, length + 1)]\n",
    "    elif orient == 'D':\n",
    "        return [(from_coord[0], from_coord[1] - x) for x in range(1, length + 1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paths = []\n",
    "\n",
    "for row in content:\n",
    "    cur_pos = (0, 0)\n",
    "    path = []\n",
    "\n",
    "    for order in row:\n",
    "        points = order_to_coords(order, cur_pos)\n",
    "        path += points\n",
    "        \n",
    "        cur_pos = points[-1]\n",
    "        \n",
    "    paths += [path]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "intersections = set(paths[0]).intersection(set(paths[1]))\n",
    "sorted_intersections = sorted(intersections, key=lambda x: abs(x[0]) + abs(x[1]))\n",
    "print('Answer 1: {}'.format(abs(sorted_intersections[0][0]) + abs(sorted_intersections[0][1])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distances = []\n",
    "for inter in intersections:\n",
    "    distances += [2 + paths[0].index(inter) + paths[1].index(inter)] # initial step for each path is not considered\n",
    "    \n",
    "print('Answer 2: {}'.format(min(distances)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 4\n",
    "\n",
    "http://adventofcode.com/2019/day/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# content = load_day(4)\n",
    "puzzle_input = \"145852-616942\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_input(value):\n",
    "    if not isinstance(value, str):\n",
    "        raise ValueError(\"input should be string\")\n",
    "        \n",
    "    elems = list(value)\n",
    "    \n",
    "    prev_elem = None\n",
    "    before_elem = None\n",
    "    \n",
    "    adjacent = False\n",
    "    decrease = False\n",
    "    \n",
    "    for e in elems:\n",
    "        if prev_elem is not None:\n",
    "            if not adjacent:\n",
    "                adjacent = prev_elem == e\n",
    "            if not decrease:\n",
    "                decrease = ord(prev_elem) > ord(e)\n",
    "\n",
    "        prev_elem = e\n",
    "    return adjacent and not decrease"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "candidates = []\n",
    "for v in range(*map(int, puzzle_input.split('-'))):\n",
    "    inp = str(v)\n",
    "    candidates += [inp] if check_input(inp) else []\n",
    "print(f'Answer 1: {len(candidates)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lengths(value):\n",
    "    le = []\n",
    "    char = ''\n",
    "    count = 1\n",
    "    for v in value[1:]:\n",
    "        if v == char:\n",
    "            count += 1\n",
    "        else:\n",
    "            le.append(count)\n",
    "            count = 1\n",
    "            \n",
    "        char = v\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in candidates:\n",
    "    \n",
    "    total += int(check_input2(str(v)))\n",
    "print(f'Answer 2: {total}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 5\n",
    "\n",
    "http://adventofcode.com/2019/day/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(5)\n",
    "content = list(map(int, content[0].split(',')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pass_all_tests(software, inputs):\n",
    "    memory = collections.defaultdict(int)\n",
    "    idx = 0\n",
    "    relative_basis = 0\n",
    "\n",
    "    while software[idx] != 99:\n",
    "        outputs = intcode_computer(software, idx=idx, relative_basis=relative_basis, inputs=inputs, memory=memory)\n",
    "        # print(outputs[\"output\"])\n",
    "        idx = outputs[\"idx\"]\n",
    "        relative_basis = outputs[\"relative_basis\"]\n",
    "\n",
    "    return outputs[\"output\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "software = copy.deepcopy(content)\n",
    "print(f\"Answer 1: {pass_all_tests(software, [1])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "software = copy.deepcopy(content)\n",
    "print(f\"Answer 2: {pass_all_tests(software, [5])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 6\n",
    "\n",
    "http://adventofcode.com/2019/day/6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "children = collections.defaultdict(list)\n",
    "parents = {}\n",
    "\n",
    "for from_obj, to_obj in map(lambda l: l.split(')'), content):\n",
    "    children[from_obj] += [to_obj]\n",
    "    parents[to_obj] = from_obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "queue = ['COM']\n",
    "scores = {'COM': 0}\n",
    "\n",
    "while queue:\n",
    "    obj = queue.pop(0)\n",
    "    for child in children[obj]:\n",
    "        scores[child] = scores[obj] + 1\n",
    "        queue += [child]\n",
    "\n",
    "print(f\"Answer 1: {sum(scores.values())}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_path(obj):\n",
    "    path = []\n",
    "    while obj != 'COM':\n",
    "        path += [obj]\n",
    "        obj = parents[obj]\n",
    "    return path + [\"COM\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "you_path = get_path(\"YOU\")\n",
    "san_path = get_path(\"SAN\")\n",
    "\n",
    "common_stars = set(you_path) & set(san_path)\n",
    "\n",
    "for idx in range(len(you_path)):\n",
    "    if you_path[idx] in common_stars:\n",
    "        you_length = idx\n",
    "        break\n",
    "\n",
    "for idx in range(len(san_path)):\n",
    "    if san_path[idx] in common_stars:\n",
    "        san_length = idx\n",
    "        break\n",
    "\n",
    "print(f\"Answer 2: {you_length + san_length - 2}\")  # first and last \"transfers\" do not count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 7\n",
    "\n",
    "http://adventofcode.com/2019/day/7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(7)\n",
    "content = list(map(int, content[0].split(',')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_output = 0\n",
    "\n",
    "for perm in map(list, itertools.permutations(range(5))):\n",
    "    input_val = 0\n",
    "\n",
    "    while perm:\n",
    "        software = copy.deepcopy(content)\n",
    "        inputs = [perm.pop(0), input_val]\n",
    "        outputs = intcode_computer(software, idx=0, inputs=inputs)\n",
    "        input_val = outputs[\"output\"]\n",
    "\n",
    "    if input_val > max_output:\n",
    "        max_output = input_val\n",
    "    \n",
    "print(f\"Anwser 1: {max_output}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_output = 0\n",
    "\n",
    "for perm in map(list, itertools.permutations(range(5, 10))):\n",
    "    softwares = [content] * 5\n",
    "    pointers = [0] * 5\n",
    "    outputs = {}\n",
    "\n",
    "    ampli_idx = 0\n",
    "    input_val = 0\n",
    "    \n",
    "    stored_value = 0\n",
    "    \n",
    "    while True:\n",
    "        inputs = [input_val]\n",
    "\n",
    "        if perm:\n",
    "            inputs.insert(0, perm.pop(0))\n",
    "\n",
    "        outputs = intcode_computer(softwares[ampli_idx], idx=pointers[ampli_idx], inputs=inputs)\n",
    "\n",
    "        if softwares[ampli_idx][pointers[ampli_idx]] != 99:\n",
    "            input_val = outputs[\"output\"]\n",
    "            \n",
    "            pointers[ampli_idx] = outputs[\"idx\"]\n",
    "\n",
    "            if ampli_idx == 4:\n",
    "                stored_value = input_val\n",
    "\n",
    "            ampli_idx = (ampli_idx + 1) % 5\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    if stored_value > max_output:\n",
    "        max_output = stored_value\n",
    "print(f\"Anwser 2: {max_output}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 8\n",
    "\n",
    "http://adventofcode.com/2019/day/8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(8)[0]\n",
    "width, height = 25, 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_size = width * height\n",
    "N = len(content)\n",
    "\n",
    "images = []\n",
    "\n",
    "min_zero = img_size\n",
    "result = 0\n",
    "\n",
    "for idx in range(0, N, img_size):\n",
    "    layer = list(content[idx:idx+img_size])\n",
    "    counter = collections.Counter(layer)\n",
    "    \n",
    "    if counter['0'] < min_zero:\n",
    "        min_zero = counter['0']\n",
    "        result = counter['1'] * counter['2']\n",
    "    \n",
    "    images += [ np.array(layer) ]\n",
    "        \n",
    "print(f\"Answer 1: {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_image = np.empty(img_size, dtype=\"str\")\n",
    "\n",
    "for img in images[::-1]:\n",
    "    result_image[img == \"1\"] = \"x\"\n",
    "    result_image[img == \"0\"] = \" \"\n",
    "    \n",
    "res = result_image.tolist()\n",
    "print(\"\\n\".join([''.join(res[width*i:width*(i+1)]) for i in range(height)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 9\n",
    "\n",
    "http://adventofcode.com/2019/day/9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(9)\n",
    "content = list(map(int, content[0].split(',')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "software = copy.deepcopy(content)\n",
    "print(f\"Answer 1: {pass_all_tests(software, [1])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "software = copy.deepcopy(content)\n",
    "print(f\"Answer 2: {pass_all_tests(software, [2])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 10\n",
    "\n",
    "http://adventofcode.com/2019/day/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(10)\n",
    "positions = np.where(np.array(list(map(list, content)))==\"#\")\n",
    "points = list(zip(positions[1], positions[0]))  # points are (x, y), increasing to the right and the bottom\n",
    "\n",
    "nb_points = len(points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_dirs = 0\n",
    "location_idx = None\n",
    "\n",
    "for i_idx in range(nb_points):\n",
    "    source = points[i_idx]\n",
    "    directions = set()\n",
    "\n",
    "    for j_idx in range(nb_points):\n",
    "        dest = points[j_idx]\n",
    "        orient = [dest[0] - source[0], dest[1] - source[1]]\n",
    "\n",
    "        if orient != [0, 0]:\n",
    "            if orient[0] == 0 or orient[1] == 0:\n",
    "                denom = abs(orient[0] + orient[1])\n",
    "            else:\n",
    "                denom = math.gcd(abs(orient[0]), abs(orient[1]))\n",
    "\n",
    "            directions.add((orient[0]//denom, orient[1]//denom))\n",
    "        # print(source, dest, directions)\n",
    "\n",
    "    if len(directions) > max_dirs:\n",
    "        location_idx = i_idx\n",
    "        max_dirs = len(directions)\n",
    "\n",
    "print(f\"Anwser 1: {max_dirs}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_angle(source, target):\n",
    "    x = target[0] - source[0]\n",
    "    y = target[1] - source[1]\n",
    "    return math.atan2(-y, x)  # y goes to down\n",
    "\n",
    "def l2_dist(source, target):\n",
    "    return math.sqrt((source[0]-target[0]) ** 2 + (source[1]-target[1]) ** 2)\n",
    "\n",
    "def find_quadrant(x):\n",
    "    if x <= math.pi/2 and x >= 0:\n",
    "        return 1\n",
    "    elif x > math.pi/2:\n",
    "        return 3\n",
    "    else:\n",
    "        return 2\n",
    "\n",
    "def rotation_compare(x, y):\n",
    "    quadrant_x = find_quadrant(x)\n",
    "    quadrant_y = find_quadrant(y)\n",
    "    \n",
    "    if quadrant_x != quadrant_y:\n",
    "        return quadrant_x - quadrant_y\n",
    "    else:\n",
    "        return y - x\n",
    "    \n",
    "def cmp_to_key(mycmp):\n",
    "    'Convert a cmp= function into a key= function'\n",
    "    class K(object):\n",
    "        def __init__(self, obj, *args):\n",
    "            self.obj = obj\n",
    "        def __lt__(self, other):\n",
    "            return mycmp(self.obj, other.obj) < 0\n",
    "        def __gt__(self, other):\n",
    "            return mycmp(self.obj, other.obj) > 0\n",
    "        def __eq__(self, other):\n",
    "            return mycmp(self.obj, other.obj) == 0\n",
    "        def __le__(self, other):\n",
    "            return mycmp(self.obj, other.obj) <= 0\n",
    "        def __ge__(self, other):\n",
    "            return mycmp(self.obj, other.obj) >= 0\n",
    "        def __ne__(self, other):\n",
    "            return mycmp(self.obj, other.obj) != 0\n",
    "    return K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Checking ordering on angles\n",
    "assert(rotation_compare(math.pi/2, math.pi/4) < 0)\n",
    "assert(rotation_compare(math.pi/3, math.pi/6) < 0)\n",
    "assert(rotation_compare(math.pi/3, 0) < 0)\n",
    "assert(rotation_compare(0, -math.pi/4) < 0)\n",
    "assert(rotation_compare(-math.pi/6, -math.pi/4) < 0)\n",
    "assert(rotation_compare(-math.pi/3, -math.pi/2) < 0)\n",
    "assert(rotation_compare(-math.pi/2, -3*math.pi/4) < 0)\n",
    "assert(rotation_compare(-4*math.pi/6, -3*math.pi/4) < 0)\n",
    "assert(rotation_compare(-3*math.pi/4, math.pi) < 0)\n",
    "assert(rotation_compare(math.pi, 3*math.pi/4) < 0)\n",
    "assert(rotation_compare(3*math.pi/4, 4*math.pi/6) < 0)\n",
    "assert(rotation_compare(4*math.pi/6, 0.000001+math.pi/2) < 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "angles = collections.defaultdict(list)\n",
    "location = points[location_idx]\n",
    "idx_of_interest = 200\n",
    "\n",
    "for j_idx in range(nb_points):\n",
    "    if j_idx != location_idx:\n",
    "        angles[compute_angle(location, points[j_idx])].append(points[j_idx])\n",
    "\n",
    "for (angle, pts) in angles.items():\n",
    "    angles[angle] = sorted(pts, key=lambda x: l2_dist(location, x))\n",
    "\n",
    "ordered_angles = sorted(angles.keys(), key=cmp_to_key(rotation_compare))\n",
    "\n",
    "nb_rounds = (idx_of_interest - 1) // max_dirs\n",
    "angle_idx = (idx_of_interest - 1) % max_dirs\n",
    "answer = angles[ordered_angles[angle_idx]][nb_rounds]\n",
    "\n",
    "print(f\"Answer 2: {answer[0] * 100 + answer[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 11\n",
    "\n",
    "http://adventofcode.com/2019/day/11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(11)\n",
    "content = list(map(int, content[0].split(',')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delta_from_orientation(orientation):    \n",
    "    if orientation == 0:\n",
    "        return (0, 1)\n",
    "    elif orientation == 1:\n",
    "        return (1, 0)\n",
    "    elif orientation == 2:\n",
    "        return (0, -1)\n",
    "    elif orientation == 3:\n",
    "        return (-1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = collections.defaultdict(int)  # keys are (x, y)\n",
    "position = (0, 0)\n",
    "orientation = 0  # maps {0, 1, 2, 3} to [\"T\", \"L\", \"B\", \"R\"]\n",
    "path = set()\n",
    "\n",
    "software = copy.deepcopy(content)\n",
    "memory = collections.defaultdict(int)\n",
    "idx = 0\n",
    "relative_basis = 0\n",
    "inputs = [1, 1]  # for initial input\n",
    "\n",
    "while True:\n",
    "    if inputs:  # 2nd run\n",
    "        inputs.pop()\n",
    "    else:  # 1st run\n",
    "        inputs = [grid[position]]\n",
    "\n",
    "    outputs = intcode_computer(software, idx=idx, relative_basis=relative_basis, inputs=inputs, memory=memory)\n",
    "    if outputs is None:\n",
    "        break\n",
    "\n",
    "    path.add(position)\n",
    "    \n",
    "    if inputs:  # 1sr run\n",
    "        grid[position] = outputs[\"output\"]\n",
    "    else:  # 2nd run: 0 -> L, 1 -> R\n",
    "        orientation = (orientation + (-1) ** outputs[\"output\"]) % 4\n",
    "       \n",
    "        delta = delta_from_orientation(orientation)\n",
    "        position = (position[0] + delta[0], position[1] + delta[1])\n",
    "\n",
    "    idx = outputs[\"idx\"]\n",
    "    relative_basis = outputs[\"relative_basis\"]\n",
    "\n",
    "print(f\"Answer 1: {len(path)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_x = min(map(lambda x: x[0], grid.keys()))\n",
    "max_x = max(map(lambda x: x[0], grid.keys()))\n",
    "min_y = min(map(lambda x: x[1], grid.keys()))\n",
    "max_y = max(map(lambda x: x[1], grid.keys()))\n",
    "\n",
    "max_x -= min_x\n",
    "max_y -= min_y\n",
    "\n",
    "drawing = np.zeros((max_y + 1, max_x + 1))\n",
    "for key, val in grid.items():\n",
    "    drawing[key[1] - min_y][key[0] - min_x] = val\n",
    "print('\\n'.join([''.join(map(lambda x: '#' if x else ' ', line)) for line in drawing[::-1, ::-1].tolist()]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 12\n",
    "\n",
    "http://adventofcode.com/2019/day/12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "positions = np.array(list(map(lambda line: list(map(lambda elem: int(elem.split('=')[1]), line[1:-1].split(','))), content)))\n",
    "velocities = np.zeros(positions.shape, dtype=int)\n",
    "\n",
    "def compute_system_energy():\n",
    "    return (np.abs(positions).sum(axis=1) * np.abs(velocities).sum(axis=1)).sum()\n",
    "\n",
    "for step in range(1000):\n",
    "    for idx in range(positions.shape[0]):\n",
    "        velocities += np.where(positions>positions[idx], -1, 0) + np.where(positions<positions[idx], 1, 0)\n",
    "    positions += velocities\n",
    "\n",
    "print(f\"Answer 1: {compute_system_energy()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "positions = np.array(list(map(lambda line: list(map(lambda elem: int(elem.split('=')[1]), line[1:-1].split(','))), content)))\n",
    "velocities = np.zeros(positions.shape, dtype=int)\n",
    "\n",
    "cycles_length = []\n",
    "\n",
    "for dim in range(3):\n",
    "    history = set()\n",
    "    step = 0\n",
    "    \n",
    "    pos = positions[:, dim]\n",
    "    vel = velocities[:, dim]\n",
    "    \n",
    "    while True:\n",
    "        if step > 0:\n",
    "            for idx in range(positions.shape[0]):\n",
    "                vel += np.where(pos>pos[idx], -1, 0) + np.where(pos<pos[idx], 1, 0)\n",
    "            pos += vel\n",
    "\n",
    "        item = str(pos.tolist() + vel.tolist())\n",
    "        if item in history:\n",
    "            cycles_length.append(step)\n",
    "            break\n",
    "        else:\n",
    "            history.add(item)\n",
    "            step += 1\n",
    "\n",
    "print(f\"Answer 2: {np.lcm.reduce(cycles_length)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 13\n",
    "\n",
    "http://adventofcode.com/2019/day/13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(13)\n",
    "content = list(map(int, content[0].split(',')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "software = copy.deepcopy(content)\n",
    "memory = collections.defaultdict(int)\n",
    "\n",
    "idx = 0\n",
    "relative_basis = 0\n",
    "grid_instructions = []\n",
    "\n",
    "grid = collections.defaultdict(int)\n",
    "\n",
    "while True:\n",
    "    outputs = intcode_computer(software, idx=idx, relative_basis=relative_basis, memory=memory)\n",
    "\n",
    "    if outputs is None or \"error\" in outputs:\n",
    "        break\n",
    "\n",
    "    grid_instructions += [outputs[\"output\"]]\n",
    "    idx = outputs[\"idx\"]\n",
    "    relative_basis = outputs[\"relative_basis\"]\n",
    "        \n",
    "    if len(grid_instructions) == 3:\n",
    "        grid[(grid_instructions[0], grid_instructions[1])] = grid_instructions[2]\n",
    "        grid_instructions = []\n",
    "\n",
    "print(f\"Answer 1: {collections.Counter(grid.values())[2]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAPPING_BLOCKS = [' ', '#', 'W', '_', 'u']\n",
    "\n",
    "def print_grid(software, score):\n",
    "    print(f\"Score: {score}\")\n",
    "    for row in range(23):\n",
    "        print(''.join(map(lambda x: MAPPING_BLOCKS[x], software[639 + 42 * row:639 +42*(row+1)])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "software = copy.deepcopy(content)\n",
    "memory = collections.defaultdict(int)\n",
    "software[0] = 2\n",
    "\n",
    "idx = 0\n",
    "relative_basis = 0\n",
    "grid_instructions = []\n",
    "\n",
    "grid = collections.defaultdict(int)\n",
    "\n",
    "while software[idx] != 99:\n",
    "    outputs = intcode_computer(software, idx=idx, relative_basis=relative_basis, inputs=inputs, memory=memory)\n",
    "    inputs = []\n",
    "\n",
    "    if outputs:\n",
    "        if \"error\" in outputs:\n",
    "            if collections.Counter(grid.values())[2]:\n",
    "                # print_grid(software, grid[(-1, 0)])\n",
    "                inputs = [last_ball_x_pos - last_pad_x_pos]\n",
    "            else:\n",
    "                break\n",
    "\n",
    "        else:\n",
    "            grid_instructions += [outputs[\"output\"]]\n",
    "        \n",
    "            if len(grid_instructions) == 3:\n",
    "                grid[(grid_instructions[0], grid_instructions[1])] = grid_instructions[2]\n",
    "                \n",
    "                if grid_instructions[2] == 3:\n",
    "                    last_pad_x_pos = grid_instructions[0]\n",
    "                elif grid_instructions[2] == 4:\n",
    "                    last_ball_x_pos = grid_instructions[0]\n",
    "                grid_instructions = []\n",
    "\n",
    "        idx = outputs[\"idx\"]\n",
    "        relative_basis = outputs[\"relative_basis\"]\n",
    "\n",
    "print(f\"Answer 2: {grid[(-1, 0)]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 14\n",
    "\n",
    "http://adventofcode.com/2019/day/14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(14)\n",
    "\n",
    "ingredients_for = dict()\n",
    "receipts_with = collections.defaultdict(list)\n",
    "\n",
    "for row in content:\n",
    "    source, target = row.split(' => ')\n",
    "    nb_t, kind_t = target.strip().split(' ')\n",
    "    sources = []\n",
    "    for elem in source.split(','):\n",
    "        nb_s, kind_s = elem.strip().split(' ')\n",
    "        sources.append([int(nb_s), kind_s])\n",
    "        receipts_with[kind_s].append(kind_t)\n",
    "    ingredients_for[kind_t] = [int(nb_t), sources]\n",
    "    \n",
    "heights = collections.defaultdict(int)\n",
    "queue = ['ORE']\n",
    "\n",
    "while queue:\n",
    "    elem = queue.pop(0)\n",
    "    for ing in receipts_with[elem]:\n",
    "        heights[ing] = heights[elem] + 1\n",
    "        queue.append(ing)\n",
    "\n",
    "heights = dict(sorted(heights.items(), key=lambda x: -x[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "requirements = collections.defaultdict(int)\n",
    "requirements['FUEL'] = 1\n",
    "\n",
    "for ing in heights.keys():\n",
    "    if ing == 'ORE':\n",
    "        break\n",
    "    \n",
    "    receipt = ingredients_for[ing]\n",
    "\n",
    "    needed = requirements.pop(ing)    \n",
    "    times = int(math.ceil(needed / receipt[0]))\n",
    "        \n",
    "    for req in receipt[1]:\n",
    "        requirements[req[1]] += req[0] * times\n",
    "\n",
    "cost_per_unit = requirements['ORE']\n",
    "print(f\"Answer 1: {cost_per_unit}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wastes = collections.defaultdict(int)\n",
    "\n",
    "space = 1000000000000\n",
    "units = 0\n",
    "\n",
    "while True:\n",
    "    requirements = collections.defaultdict(int)\n",
    "    \n",
    "    new_units = space // cost_per_unit\n",
    "    requirements['FUEL'] = new_units\n",
    "\n",
    "    for ing in heights.keys():\n",
    "        if ing == 'ORE':\n",
    "            break\n",
    "\n",
    "        receipt = ingredients_for[ing]\n",
    "\n",
    "        needed_for_receipt = requirements.pop(ing)\n",
    "        taken_from_wastes = min(wastes[ing], needed)\n",
    "        needed_to_produce = needed_for_receipt - taken_from_wastes\n",
    "        wastes[ing] -= taken_from_wastes\n",
    "        \n",
    "        times = int(math.ceil(needed_to_produce / receipt[0]))\n",
    "        produced = receipt[0] * times\n",
    "        wastes[ing] += produced - needed_to_produce\n",
    "\n",
    "        for req in receipt[1]:\n",
    "            requirements[req[1]] += req[0] * times\n",
    "    \n",
    "    if new_units and requirements['ORE'] < space:\n",
    "        space -= requirements['ORE']\n",
    "        units += new_units\n",
    "    else:\n",
    "        break\n",
    "\n",
    "print(f\"Answer 2: {units}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 15\n",
    "\n",
    "http://adventofcode.com/2019/day/15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 16\n",
    "\n",
    "http://adventofcode.com/2019/day/16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 17\n",
    "\n",
    "http://adventofcode.com/2019/day/17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 18\n",
    "\n",
    "http://adventofcode.com/2019/day/18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 19\n",
    "\n",
    "http://adventofcode.com/2019/day/19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(19)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 20\n",
    "\n",
    "http://adventofcode.com/2019/day/20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 21\n",
    "\n",
    "http://adventofcode.com/2019/day/21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 22\n",
    "\n",
    "http://adventofcode.com/2019/day/22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(22)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 23\n",
    "\n",
    "http://adventofcode.com/2019/day/23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 24\n",
    "\n",
    "http://adventofcode.com/2019/day/24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(24)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 25\n",
    "\n",
    "http://adventofcode.com/2019/day/25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "content = load_day(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 1__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Part 2__"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}