Force string type for answer value.

.drone.yml

@@ -0,0 +1,12 @@
+---
+kind: pipeline
+type: docker
+name: default
+
+steps:
+  - name: tests
+    image: python:3.10-slim
+    commands:
+      - pip install poetry
+      - poetry install
+      - poetry run poe lint

.gitignore

@@ -1 +1,6 @@
+# python / VS Code
 venv
+__pycache__
+.ruff_cache
+.vscode
+build

2022/day1.py

@@ -1,19 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-from pathlib import Path
-
-with open(Path(__file__).parent.joinpath("inputs", "day1.txt")) as fp:
-    lines = fp.readlines()
-
-values: list[int] = [0]
-for line in lines:
-    if not line.strip():
-        values = values + [0]
-    else:
-        values[-1] += int(line.strip())
-
-# part 1
-print(f"max is {max(values)}")
-
-# part 2
-print(f"sum of top 3 is {sum(sorted(values)[-3:])}")

README.md

@@ -0,0 +1,36 @@
+# Holt59 - Advent Of Code
+
+Installation (with [`poetry`](https://python-poetry.org/)):
+
+```bash
+poetry install
+```
+
+To run any day:
+
+```bash
+holt59-aoc $day
+```
+
+You can use `-v` / `--verbose` for extra outputs in some case, `-t` / `--test` to run
+the code on the test data (one of the test data if multiple are present) or even
+`-u XXX` / `--user XXX` to run the code on a specific input after putting the input
+file under `src/holt59/aoc/inputs/XXX/$year/$day`.
+
+Full usage:
+
+```bash
+usage: Holt59 Advent-Of-Code Runner [-h] [-v] [-t] [-u USER] [-i INPUT] [-y YEAR] day
+
+positional arguments:
+  day                   day to run
+
+options:
+  -h, --help            show this help message and exit
+  -v, --verbose         verbose mode
+  -t, --test            test mode
+  -u USER, --user USER  user input to use
+  -i INPUT, --input INPUT
+                        input to use (override user and test)
+  -y YEAR, --year YEAR  year to run
+```

pyproject.toml

@@ -0,0 +1,43 @@
+[tool.poetry]
+name = "holt59-advent-of-code"
+version = "0.1.0"
+description = ""
+authors = ["Mikael CAPELLE <capelle.mikael@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "holt59", from = "src" }]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+numpy = "^2.1.3"
+tqdm = "^4.67.1"
+parse = "^1.20.2"
+scipy = "^1.14.1"
+sympy = "^1.13.3"
+networkx = "^3.4.2"
+pandas = "^2.2.3"
+
+[tool.poetry.group.dev.dependencies]
+pyright = "^1.1.389"
+ruff = "^0.8.1"
+poethepoet = "^0.31.1"
+ipykernel = "^6.29.5"
+networkx-stubs = "^0.0.1"
+types-networkx = "^3.4.2.20241115"
+
+[tool.poetry.scripts]
+holt59-aoc = "holt59.aoc.__main__:main"
+
+[tool.poe.tasks]
+format-imports = "ruff check --select I src --fix"
+format-ruff = "ruff format src"
+format.sequence = ["format-imports", "format-ruff"]
+lint-ruff = "ruff check src"
+lint-ruff-format = "ruff format --check src"
+lint-pyright = "pyright src"
+lint.sequence = ["lint-ruff", "lint-ruff-format", "lint-pyright"]
+lint.ignore_fail = "return_non_zero"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

setup.cfg

@@ -0,0 +1,6 @@
+[flake8]
+# Use black line length:
+max-line-length = 88
+extend-ignore =
+    # See https://github.com/PyCQA/pycodestyle/issues/373
+    E203, E231

src/holt59/aoc/2015/day1.py

@@ -0,0 +1,12 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        floor = 0
+        floors = [(floor := floor + (1 if c == "(" else -1)) for c in input]
+
+        yield floors[-1]
+        yield floors.index(-1)

src/holt59/aoc/2015/day10.py

@@ -0,0 +1,147 @@
+import itertools
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+# see http://www.se16.info/js/lands2.htm for the explanation of 'atoms' (or elements)
+#
+# see also https://www.youtube.com/watch?v=ea7lJkEhytA (video link from AOC) and this
+# CodeGolf answer https://codegolf.stackexchange.com/a/8479/42148
+
+# fmt: off
+ATOMS: list[tuple[str, tuple[int, ...]]] = [
+    ("22", (0, )),  # 0
+    ("13112221133211322112211213322112", (71, 90, 0, 19, 2, )),  # 1
+    ("312211322212221121123222112", (1, )),  # 2
+    ("111312211312113221133211322112211213322112", (31, 19, 2, )),  # 3
+    ("1321132122211322212221121123222112", (3, )),  # 4
+    ("3113112211322112211213322112", (4, )),  # 5
+    ("111312212221121123222112", (5, )),  # 6
+    ("132112211213322112", (6, )),  # 7
+    ("31121123222112", (7, )),  # 8
+    ("111213322112", (8, )),  # 9
+    ("123222112", (9, )),  # 10
+    ("3113322112", (60, 10, )),  # 11
+    ("1113222112", (11, )),  # 12
+    ("1322112", (12, )),  # 13
+    ("311311222112", (66, 13, )),  # 14
+    ("1113122112", (14, )),  # 15
+    ("132112", (15, )),  # 16
+    ("3112", (16, )),  # 17
+    ("1112", (17, )),  # 18
+    ("12", (18, )),  # 19
+    ("3113112221133112", (66, 90, 0, 19, 26, )),  # 20
+    ("11131221131112", (20, )),  # 21
+    ("13211312", (21, )),  # 22
+    ("31132", (22, )),  # 23
+    ("111311222112", (23, 13, )),  # 24
+    ("13122112", (24, )),  # 25
+    ("32112", (25, )),  # 26
+    ("11133112", (29, 26, )),  # 27
+    ("131112", (27, )),  # 28
+    ("312", (28, )),  # 29
+    ("13221133122211332", (62, 19, 88, 0, 19, 29, )),  # 30
+    ("31131122211311122113222", (66, 30, )),  # 31
+    ("11131221131211322113322112", (31, 10, )),  # 32
+    ("13211321222113222112", (32, )),  # 33
+    ("3113112211322112", (33, )),  # 34
+    ("11131221222112", (34, )),  # 35
+    ("1321122112", (35, )),  # 36
+    ("3112112", (36, )),  # 37
+    ("1112133", (37, 91, )),  # 38
+    ("12322211331222113112211", (38, 0, 19, 42, )),  # 39
+    ("1113122113322113111221131221", (67, 39, )),  # 40
+    ("13211322211312113211", (40, )),  # 41
+    ("311322113212221", (41, )),  # 42
+    ("132211331222113112211", (62, 19, 42, )),  # 43
+    ("311311222113111221131221", (66, 43, )),  # 44
+    ("111312211312113211", (44, )),  # 45
+    ("132113212221", (45, )),  # 46
+    ("3113112211", (46, )),  # 47
+    ("11131221", (47, )),  # 48
+    ("13211", (48, )),  # 49
+    ("3112221", (60, 49, )),  # 50
+    ("1322113312211", (62, 19, 50, )),  # 51
+    ("311311222113111221", (66, 51, )),  # 52
+    ("11131221131211", (52, )),  # 53
+    ("13211321", (53, )),  # 54
+    ("311311", (54, )),  # 55
+    ("11131", (55, )),  # 56
+    ("1321133112", (56, 0, 19, 26, )),  # 57
+    ("31131112", (57, )),  # 58
+    ("111312", (58, )),  # 59
+    ("132", (59, )),  # 60
+    ("311332", (60, 19, 29, )),  # 61
+    ("1113222", (61, )),  # 62
+    ("13221133112", (62, 19, 26, )),  # 63
+    ("3113112221131112", (66, 63, )),  # 64
+    ("111312211312", (64, )),  # 65
+    ("1321132", (65, )),  # 66
+    ("311311222", (66, 60, )),  # 67
+    ("11131221133112", (67, 19, 26, )),  # 68
+    ("1321131112", (68, )),  # 69
+    ("311312", (69, )),  # 70
+    ("11132", (70, )),  # 71
+    ("13112221133211322112211213322113", (71, 90, 0, 19, 73, )),  # 72
+    ("312211322212221121123222113", (72, )),  # 73
+    ("111312211312113221133211322112211213322113", (31, 19, 73, )),  # 74
+    ("1321132122211322212221121123222113", (74, )),  # 75
+    ("3113112211322112211213322113", (75, )),  # 76
+    ("111312212221121123222113", (76, )),  # 77
+    ("132112211213322113", (77, )),  # 78
+    ("31121123222113", (78, )),  # 79
+    ("111213322113", (79, )),  # 80
+    ("123222113", (80, )),  # 81
+    ("3113322113", (60, 81, )),  # 82
+    ("1113222113", (82, )),  # 83
+    ("1322113", (83, )),  # 84
+    ("311311222113", (66, 84, )),  # 85
+    ("1113122113", (85, )),  # 86
+    ("132113", (86, )),  # 87
+    ("3113", (87, )),  # 88
+    ("1113", (88, )),  # 89
+    ("13", (89, )),  # 90
+    ("3", (90, )),  # 91
+]
+# fmt: on
+
+STARTERS = [
+    "1",
+    "11",
+    "21",
+    "1211",
+    "111221",
+    "312211",
+    "13112221",
+    "1113213211",
+    "31131211131221",
+]
+
+
+def look_and_say_length(s: str, n: int) -> int:
+    if n == 0:
+        return len(s)
+
+    if s in STARTERS:
+        return look_and_say_length(
+            "".join(f"{len(list(g))}{k}" for k, g in itertools.groupby(s)), n - 1
+        )
+
+    counts = {i: 0 for i in range(len(ATOMS))}
+    idx = next(i for i, (a, _) in enumerate(ATOMS) if s == a)
+    counts[idx] = 1
+
+    for _ in range(n):
+        c2 = {i: 0 for i in range(len(ATOMS))}
+        for i in counts:
+            for j in ATOMS[i][1]:
+                c2[j] += counts[i]
+        counts = c2
+
+    return sum(counts[i] * len(a[0]) for i, a in enumerate(ATOMS))
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any] | None:
+        yield look_and_say_length(input, 40)
+        yield look_and_say_length(input, 50)

src/holt59/aoc/2015/day11.py

@@ -0,0 +1,49 @@
+import itertools
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def is_valid(p: str) -> bool:
+    if any(c in "iol" for c in p):
+        return False
+
+    if not any(
+        ord(a) + 1 == ord(b) and ord(b) + 1 == ord(c)
+        for a, b, c in zip(p, p[1:], p[2:])
+    ):
+        return False
+
+    if sum(len(list(g)) >= 2 for _, g in itertools.groupby(p)) < 2:
+        return False
+
+    return True
+
+
+assert not is_valid("hijklmmn")
+assert not is_valid("abbceffg")
+assert not is_valid("abbcegjk")
+assert is_valid("abcdffaa")
+assert is_valid("ghjaabcc")
+
+
+def increment(p: str) -> str:
+    if p[-1] == "z":
+        return increment(p[:-1]) + "a"
+    elif p[-1] in "iol":
+        return p[:-1] + chr(ord(p[-1]) + 2)
+    else:
+        return p[:-1] + chr(ord(p[-1]) + 1)
+
+
+def find_next_password(p: str) -> str:
+    while not is_valid(p):
+        p = increment(p)
+    return p
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        answer_1 = find_next_password(input)
+        yield answer_1
+        yield find_next_password(increment(answer_1))

src/holt59/aoc/2015/day12.py

@@ -0,0 +1,27 @@
+import json
+from typing import Any, Iterator, TypeAlias
+
+from ..base import BaseSolver
+
+JsonObject: TypeAlias = dict[str, "JsonObject"] | list["JsonObject"] | int | str
+
+
+def json_sum(value: JsonObject, ignore: str | None = None) -> int:
+    if isinstance(value, str):
+        return 0
+    elif isinstance(value, int):
+        return value
+    elif isinstance(value, list):
+        return sum(json_sum(v, ignore=ignore) for v in value)
+    elif ignore not in value.values():
+        return sum(json_sum(v, ignore=ignore) for v in value.values())
+    else:
+        return 0
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        data: JsonObject = json.loads(input)
+
+        yield json_sum(data)
+        yield json_sum(data, "red")

src/holt59/aoc/2015/day13.py

@@ -0,0 +1,40 @@
+import itertools
+from collections import defaultdict
+from typing import Any, Iterator, Literal, cast
+
+import parse  # type: ignore
+
+from ..base import BaseSolver
+
+
+def max_change_in_happiness(happiness: dict[str, dict[str, int]]) -> int:
+    guests = list(happiness)
+    return max(
+        sum(
+            happiness[o][d] + happiness[d][o]
+            for o, d in zip((guests[0],) + order, order + (guests[0],))
+        )
+        for order in map(tuple, itertools.permutations(guests[1:]))
+    )
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        happiness: dict[str, dict[str, int]] = defaultdict(dict)
+        for line in lines:
+            u1, gain_or_loose, hap, u2 = cast(
+                tuple[str, Literal["gain", "lose"], int, str],
+                parse.parse(  # type: ignore
+                    "{} would {} {:d} happiness units by sitting next to {}.", line
+                ),
+            )
+            happiness[u1][u2] = hap if gain_or_loose == "gain" else -hap
+
+        yield max_change_in_happiness(happiness)
+        for guest in list(happiness):
+            happiness["me"][guest] = 0
+            happiness[guest]["me"] = 0
+
+        yield max_change_in_happiness(happiness)

src/holt59/aoc/2015/day14.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import Any, Iterator, Literal, cast
+
+import parse  # type: ignore
+
+from ..base import BaseSolver
+
+
+@dataclass(frozen=True)
+class Reindeer:
+    name: str
+    speed: int
+    fly_time: int
+    rest_time: int
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        reindeers: list[Reindeer] = []
+        for line in lines:
+            reindeer, speed, speed_time, rest_time = cast(
+                tuple[str, int, int, int],
+                parse.parse(  # type: ignore
+                    "{} can fly {:d} km/s for {:d} seconds, "
+                    "but then must rest for {:d} seconds.",
+                    line,
+                ),
+            )
+            reindeers.append(
+                Reindeer(
+                    name=reindeer, speed=speed, fly_time=speed_time, rest_time=rest_time
+                )
+            )
+
+        target = 1000 if len(reindeers) <= 2 else 2503
+
+        states: dict[Reindeer, tuple[Literal["resting", "flying"], int]] = {
+            reindeer: ("resting", 0) for reindeer in reindeers
+        }
+        distances: dict[Reindeer, int] = {reindeer: 0 for reindeer in reindeers}
+        points: dict[Reindeer, int] = {reindeer: 0 for reindeer in reindeers}
+
+        for time in self.progress.wrap(range(target)):
+            for reindeer in reindeers:
+                if states[reindeer][0] == "flying":
+                    distances[reindeer] += reindeer.speed
+
+            top_distance = max(distances.values())
+            for reindeer in reindeers:
+                if distances[reindeer] == top_distance:
+                    points[reindeer] += 1
+
+            for reindeer in reindeers:
+                if states[reindeer][1] == time:
+                    if states[reindeer][0] == "resting":
+                        states[reindeer] = ("flying", time + reindeer.fly_time)
+                    else:
+                        states[reindeer] = ("resting", time + reindeer.rest_time)
+
+        yield max(distances.values())
+        yield max(points.values()) - 1

src/holt59/aoc/2015/day15.py

@@ -0,0 +1,56 @@
+import math
+from typing import Any, Iterator, Sequence, cast
+
+import parse  # type: ignore
+
+from ..base import BaseSolver
+
+
+def score(ingredients: list[list[int]], teaspoons: Sequence[int]) -> int:
+    return math.prod(
+        max(
+            0,
+            sum(
+                ingredient[prop] * teaspoon
+                for ingredient, teaspoon in zip(ingredients, teaspoons)
+            ),
+        )
+        for prop in range(len(ingredients[0]) - 1)
+    )
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        ingredients: list[list[int]] = []
+        for line in lines:
+            _, *scores = cast(
+                tuple[str, int, int, int, int, int],
+                parse.parse(  # type: ignore
+                    "{}: capacity {:d}, durability {:d}, flavor {:d}, "
+                    "texture {:d}, calories {:d}",
+                    line,
+                ),
+            )
+            ingredients.append(scores)
+
+        total_teaspoons = 100
+        calories: list[int] = []
+        scores: list[int] = []
+
+        for a in range(total_teaspoons + 1):
+            for b in range(total_teaspoons + 1 - a):
+                for c in range(total_teaspoons + 1 - a - b):
+                    teaspoons = (a, b, c, total_teaspoons - a - b - c)
+
+                    scores.append(score(ingredients, teaspoons))
+                    calories.append(
+                        sum(
+                            ingredient[-1] * teaspoon
+                            for ingredient, teaspoon in zip(ingredients, teaspoons)
+                        )
+                    )
+
+        yield max(scores)
+        yield max(score for score, calory in zip(scores, calories) if calory == 500)

src/holt59/aoc/2015/day16.py

@@ -0,0 +1,57 @@
+import operator as op
+import re
+from collections import defaultdict
+from typing import Any, Callable, Iterator
+
+from ..base import BaseSolver
+
+MFCSAM: dict[str, int] = {
+    "children": 3,
+    "cats": 7,
+    "samoyeds": 2,
+    "pomeranians": 3,
+    "akitas": 0,
+    "vizslas": 0,
+    "goldfish": 5,
+    "trees": 3,
+    "cars": 2,
+    "perfumes": 1,
+}
+
+
+def match(
+    aunts: list[dict[str, int]], operators: dict[str, Callable[[int, int], bool]]
+) -> int:
+    return next(
+        i
+        for i, aunt in enumerate(aunts, start=1)
+        if all(operators[k](aunt[k], MFCSAM[k]) for k in aunt)
+    )
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        aunts: list[dict[str, int]] = [
+            {
+                match[1]: int(match[2])
+                for match in re.findall(
+                    R"((?P<compound>[^:, ]+): (?P<quantity>\d+))", line
+                )
+            }
+            for line in lines
+        ]
+
+        yield match(aunts, defaultdict(lambda: op.eq))
+
+        yield match(
+            aunts,
+            defaultdict(
+                lambda: op.eq,
+                trees=op.gt,
+                cats=op.gt,
+                pomeranians=op.lt,
+                goldfish=op.lt,
+            ),
+        )

src/holt59/aoc/2015/day17.py

@@ -0,0 +1,34 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def iter_combinations(value: int, containers: list[int]) -> Iterator[tuple[int, ...]]:
+    if value < 0:
+        return
+
+    if value == 0:
+        yield ()
+
+    for i in range(len(containers)):
+        for combination in iter_combinations(
+            value - containers[i], containers[i + 1 :]
+        ):
+            yield (containers[i],) + combination
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        containers = [int(c) for c in input.split()]
+        total = 25 if len(containers) <= 5 else 150
+
+        combinations = [
+            combination for combination in iter_combinations(total, containers)
+        ]
+
+        yield len(combinations)
+
+        min_containers = min(len(combination) for combination in combinations)
+        yield sum(
+            1 for combination in combinations if len(combination) == min_containers
+        )

src/holt59/aoc/2015/day18.py

@@ -0,0 +1,66 @@
+import itertools
+from typing import Any, Iterator
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        grid0 = np.array([[c == "#" for c in line] for line in input.splitlines()])
+
+        # add an always off circle around
+        grid0 = np.concatenate(
+            [
+                np.zeros((grid0.shape[0] + 2, 1), dtype=bool),
+                np.concatenate(
+                    [
+                        np.zeros((1, grid0.shape[1]), dtype=bool),
+                        grid0,
+                        np.zeros((1, grid0.shape[1]), dtype=bool),
+                    ]
+                ),
+                np.zeros((grid0.shape[0] + 2, 1), dtype=bool),
+            ],
+            axis=1,
+        )
+
+        moves = list(itertools.product([-1, 0, 1], repeat=2))
+        moves.remove((0, 0))
+
+        jjs, iis = np.meshgrid(
+            np.arange(1, grid0.shape[0] - 1, dtype=int),
+            np.arange(1, grid0.shape[1] - 1, dtype=int),
+        )
+        iis, jjs = iis.flatten(), jjs.flatten()
+
+        ins = iis[:, None] + np.array(moves)[:, 0]
+        jns = jjs[:, None] + np.array(moves)[:, 1]
+
+        def game_of_life(grid: NDArray[np.bool_]) -> NDArray[np.bool_]:
+            neighbors_on = grid[ins, jns].sum(axis=1)
+            cells_on = grid[iis, jjs]
+
+            grid = np.zeros_like(grid)
+            grid[iis, jjs] = (neighbors_on == 3) | (cells_on & (neighbors_on == 2))
+
+            return grid
+
+        grid = grid0
+        n_steps = 4 if len(grid) < 10 else 100
+        for _ in range(n_steps):
+            grid = game_of_life(grid)
+
+        yield grid.sum()
+
+        n_steps = 5 if len(grid) < 10 else 100
+        grid = grid0
+        for _ in range(n_steps):
+            grid[[1, 1, -2, -2], [1, -2, 1, -2]] = True
+            grid = game_of_life(grid)
+
+        grid[[1, 1, -2, -2], [1, -2, 1, -2]] = True
+
+        yield sum(cell for line in grid for cell in line)

src/holt59/aoc/2015/day19.py

@@ -0,0 +1,58 @@
+from collections import defaultdict
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        replacements_s, molecule = input.split("\n\n")
+
+        REPLACEMENTS: dict[str, list[str]] = defaultdict(list)
+        for replacement_s in replacements_s.splitlines():
+            p = replacement_s.split(" => ")
+            REPLACEMENTS[p[0]].append(p[1])
+        molecule = molecule.strip()
+
+        generated = [
+            molecule[:i] + replacement + molecule[i + len(symbol) :]
+            for symbol, replacements in REPLACEMENTS.items()
+            for replacement in replacements
+            for i in range(len(molecule))
+            if molecule[i:].startswith(symbol)
+        ]
+
+        yield len(set(generated))
+
+        inversion: dict[str, str] = {
+            replacement: symbol
+            for symbol, replacements in REPLACEMENTS.items()
+            for replacement in replacements
+        }
+
+        # there is actually only one way to create the molecule, and we can greedily replace
+        # tokens with their replacements, e.g., if H => OH then we can replace OH by H directly
+        # without thinking
+
+        count = 0
+        while molecule != "e":
+            i = 0
+            m2 = ""
+            while i < len(molecule):
+                found = False
+                for replacement in inversion:
+                    if molecule[i:].startswith(replacement):
+                        m2 += inversion[replacement]
+                        i += len(replacement)
+                        count += 1
+                        found = True
+                        break
+
+                if not found:
+                    m2 += molecule[i]
+                    i += 1
+
+            # print(m2)
+            molecule = m2
+
+        yield count

src/holt59/aoc/2015/day2.py

@@ -0,0 +1,24 @@
+from typing import Any, Iterator
+
+import numpy as np
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        length, width, height = np.array(
+            [[int(c) for c in line.split("x")] for line in input.splitlines()]
+        ).T
+
+        lw, wh, hl = (length * width, width * height, height * length)
+
+        yield np.sum(2 * (lw + wh + hl) + np.min(np.stack([lw, wh, hl]), axis=0))
+
+        yield np.sum(
+            length * width * height
+            + 2
+            * np.min(
+                np.stack([length + width, length + height, height + width]), axis=0
+            )
+        )

src/holt59/aoc/2015/day20.py

@@ -0,0 +1,29 @@
+import itertools
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def presents(n: int, elf: int, max: int) -> int:
+    count = 0
+    k = 1
+    while k * k < n:
+        if n % k == 0:
+            if n // k <= max:
+                count += elf * k
+            if k <= max:
+                count += elf * (n // k)
+        k += 1
+
+    if k * k == n and k <= max:
+        count += elf * k
+
+    return count
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        target = int(input)
+
+        yield next(n for n in itertools.count(1) if presents(n, 10, target) >= target)
+        yield next(n for n in itertools.count(1) if presents(n, 11, 50) >= target)

src/holt59/aoc/2015/day21.py

@@ -0,0 +1,64 @@
+import itertools
+from math import ceil
+from typing import Any, Iterator, TypeAlias
+
+from ..base import BaseSolver
+
+Modifier: TypeAlias = tuple[str, int, int, int]
+
+WEAPONS: list[Modifier] = [
+    ("Dagger", 8, 4, 0),
+    ("Shortsword", 10, 5, 0),
+    ("Warhammer", 25, 6, 0),
+    ("Longsword", 40, 7, 0),
+    ("Greataxe", 74, 8, 0),
+]
+
+ARMORS: list[Modifier] = [
+    ("", 0, 0, 0),
+    ("Leather", 13, 0, 1),
+    ("Chainmail", 31, 0, 2),
+    ("Splintmail", 53, 0, 3),
+    ("Bandedmail", 75, 0, 4),
+    ("Platemail", 102, 0, 5),
+]
+
+RINGS: list[Modifier] = [
+    ("", 0, 0, 0),
+    ("Damage +1", 25, 1, 0),
+    ("Damage +2", 50, 2, 0),
+    ("Damage +3", 100, 3, 0),
+    ("Defense +1", 20, 0, 1),
+    ("Defense +2", 40, 0, 2),
+    ("Defense +3", 80, 0, 3),
+]
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        player_hp = 100
+
+        boss_attack = int(lines[1].split(":")[1].strip())
+        boss_armor = int(lines[2].split(":")[1].strip())
+        boss_hp = int(lines[0].split(":")[1].strip())
+
+        min_cost, max_cost = 1_000_000, 0
+        for equipments in itertools.product(WEAPONS, ARMORS, RINGS, RINGS):
+            if equipments[-1][0] != "" and equipments[-2] == equipments[-1]:
+                continue
+
+            cost, player_attack, player_armor = (
+                sum(equipment[1:][k] for equipment in equipments) for k in range(3)
+            )
+
+            if ceil(boss_hp / max(1, player_attack - boss_armor)) <= ceil(
+                player_hp / max(1, boss_attack - player_armor)
+            ):
+                min_cost = min(cost, min_cost)
+            else:
+                max_cost = max(cost, max_cost)
+
+        yield min_cost
+        yield max_cost

src/holt59/aoc/2015/day22.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import heapq
+from typing import Any, Iterator, Literal, TypeAlias, cast
+
+from ..base import BaseSolver
+
+PlayerType: TypeAlias = Literal["player", "boss"]
+SpellType: TypeAlias = Literal["magic missile", "drain", "shield", "poison", "recharge"]
+BuffType: TypeAlias = Literal["shield", "poison", "recharge"]
+Node: TypeAlias = tuple[
+    PlayerType,
+    int,
+    int,
+    int,
+    int,
+    int,
+    tuple[tuple[BuffType, int], ...],
+    tuple[tuple[SpellType, int], ...],
+]
+
+ATTACK_SPELLS: list[tuple[SpellType, int, int, int]] = [
+    ("magic missile", 53, 4, 0),
+    ("drain", 73, 2, 2),
+]
+BUFF_SPELLS: list[tuple[BuffType, int, int]] = [
+    ("shield", 113, 6),
+    ("poison", 173, 6),
+    ("recharge", 229, 5),
+]
+
+
+def play(
+    player_hp: int,
+    player_mana: int,
+    player_armor: int,
+    boss_hp: int,
+    boss_attack: int,
+    hard_mode: bool,
+) -> tuple[tuple[SpellType, int], ...]:
+    winning_node: tuple[tuple[SpellType, int], ...] | None = None
+
+    visited: set[
+        tuple[PlayerType, int, int, int, int, tuple[tuple[BuffType, int], ...]]
+    ] = set()
+    nodes: list[Node] = [
+        ("player", 0, player_hp, player_mana, player_armor, boss_hp, (), ())
+    ]
+
+    while winning_node is None:
+        (
+            player,
+            mana,
+            player_hp,
+            player_mana,
+            player_armor,
+            boss_hp,
+            buffs,
+            spells,
+        ) = heapq.heappop(nodes)
+
+        if (player, player_hp, player_mana, player_armor, boss_hp, buffs) in visited:
+            continue
+
+        visited.add((player, player_hp, player_mana, player_armor, boss_hp, buffs))
+        new_buffs: list[tuple[BuffType, int]] = []
+        for buff, length in buffs:
+            length = length - 1
+            match buff:
+                case "poison":
+                    boss_hp = max(boss_hp - 3, 0)
+                case "shield":
+                    if length == 0:
+                        player_armor -= 7
+                case "recharge":
+                    player_mana += 101
+
+            if length > 0:
+                new_buffs.append((buff, length))
+
+        if hard_mode and player == "player":
+            player_hp = player_hp - 1
+
+        if player_hp <= 0:
+            continue
+
+        if boss_hp <= 0:
+            winning_node = spells
+            continue
+
+        buffs = tuple(new_buffs)
+
+        if player == "boss":
+            heapq.heappush(
+                nodes,
+                (
+                    "player",
+                    mana,
+                    max(0, player_hp - max(boss_attack - player_armor, 1)),
+                    player_mana,
+                    player_armor,
+                    boss_hp,
+                    buffs,
+                    spells,
+                ),
+            )
+        else:
+            buff_types = {b for b, _ in buffs}
+
+            for spell, cost, damage, regeneration in ATTACK_SPELLS:
+                if player_mana < cost:
+                    continue
+
+                heapq.heappush(
+                    nodes,
+                    (
+                        "boss",
+                        mana + cost,
+                        player_hp + regeneration,
+                        player_mana - cost,
+                        player_armor,
+                        max(0, boss_hp - damage),
+                        buffs,
+                        spells + cast("tuple[tuple[SpellType, int]]", ((spell, cost),)),
+                    ),
+                )
+
+            for buff_type, buff_cost, buff_length in BUFF_SPELLS:
+                if buff_type in buff_types:
+                    continue
+
+                if player_mana < buff_cost:
+                    continue
+
+                heapq.heappush(
+                    nodes,
+                    (
+                        "boss",
+                        mana + buff_cost,
+                        player_hp,
+                        player_mana - buff_cost,
+                        player_armor + 7 * (buff_type == "shield"),
+                        boss_hp,
+                        buffs
+                        + cast(
+                            "tuple[tuple[BuffType, int]]", ((buff_type, buff_length),)
+                        ),
+                        spells
+                        + cast(
+                            "tuple[tuple[SpellType, int]]", ((buff_type, buff_cost),)
+                        ),
+                    ),
+                )
+
+    return winning_node
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        player_hp = 50
+        player_mana = 500
+        player_armor = 0
+
+        boss_hp = int(lines[0].split(":")[1].strip())
+        boss_attack = int(lines[1].split(":")[1].strip())
+
+        yield sum(
+            c
+            for _, c in play(
+                player_hp, player_mana, player_armor, boss_hp, boss_attack, False
+            )
+        )
+
+        # 1242 (not working)
+        yield sum(
+            c
+            for _, c in play(
+                player_hp, player_mana, player_armor, boss_hp, boss_attack, True
+            )
+        )

src/holt59/aoc/2015/day3.py

@@ -0,0 +1,33 @@
+from collections import defaultdict
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def process(directions: str) -> dict[tuple[int, int], int]:
+    counts: dict[tuple[int, int], int] = defaultdict(lambda: 0)
+    counts[0, 0] = 1
+    x, y = (0, 0)
+
+    for c in directions:
+        match c:
+            case ">":
+                x += 1
+            case "<":
+                x -= 1
+            case "^":
+                y -= 1
+            case "v":
+                y += 1
+            case _:
+                raise ValueError()
+
+        counts[x, y] += 1
+
+    return counts
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        yield len(process(input))
+        yield len(process(input[::2]) | process(input[1::2]))

src/holt59/aoc/2015/day4.py

@@ -0,0 +1,20 @@
+import hashlib
+import itertools
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        it = iter(itertools.count(1))
+        yield next(
+            i
+            for i in it
+            if hashlib.md5(f"{input}{i}".encode()).hexdigest().startswith("00000")
+        )
+        yield next(
+            i
+            for i in it
+            if hashlib.md5(f"{input}{i}".encode()).hexdigest().startswith("000000")
+        )

src/holt59/aoc/2015/day5.py

@@ -0,0 +1,36 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+VOWELS = "aeiou"
+FORBIDDEN = {"ab", "cd", "pq", "xy"}
+
+
+def is_nice_1(s: str) -> bool:
+    if sum(c in VOWELS for c in s) < 3:
+        return False
+
+    if not any(a == b for a, b in zip(s[:-1:], s[1::])):
+        return False
+
+    if any(s.find(f) >= 0 for f in FORBIDDEN):
+        return False
+
+    return True
+
+
+def is_nice_2(s: str) -> bool:
+    if not any(s.find(s[i : i + 2], i + 2) >= 0 for i in range(len(s))):
+        return False
+
+    if not any(a == b for a, b in zip(s[:-1:], s[2::])):
+        return False
+
+    return True
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+        yield sum(map(is_nice_1, lines))
+        yield sum(map(is_nice_2, lines))

src/holt59/aoc/2015/day6.py

@@ -0,0 +1,32 @@
+from typing import Any, Iterator, Literal, cast
+
+import numpy as np
+import parse  # type: ignore
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lights_1 = np.zeros((1000, 1000), dtype=bool)
+        lights_2 = np.zeros((1000, 1000), dtype=int)
+        for line in input.splitlines():
+            action, sx, sy, ex, ey = cast(
+                tuple[Literal["turn on", "turn off", "toggle"], int, int, int, int],
+                parse.parse("{} {:d},{:d} through {:d},{:d}", line),  # type: ignore
+            )
+            ex, ey = ex + 1, ey + 1
+
+            match action:
+                case "turn on":
+                    lights_1[sx:ex, sy:ey] = True
+                    lights_2[sx:ex, sy:ey] += 1
+                case "turn off":
+                    lights_1[sx:ex, sy:ey] = False
+                    lights_2[sx:ex, sy:ey] = np.maximum(lights_2[sx:ex, sy:ey] - 1, 0)
+                case "toggle":
+                    lights_1[sx:ex, sy:ey] = ~lights_1[sx:ex, sy:ey]
+                    lights_2[sx:ex, sy:ey] += 2
+
+        yield lights_1.sum()
+        yield lights_2.sum()

src/holt59/aoc/2015/day7.py

@@ -0,0 +1,96 @@
+import operator
+from typing import Any, Callable, Iterator
+
+from ..base import BaseSolver
+
+OPERATORS = {
+    "AND": operator.and_,
+    "OR": operator.or_,
+    "LSHIFT": operator.lshift,
+    "RSHIFT": operator.rshift,
+}
+
+ValueGetter = Callable[[dict[str, int]], int]
+Signals = dict[
+    str,
+    tuple[
+        tuple[str, str],
+        tuple[ValueGetter, ValueGetter],
+        Callable[[int, int], int],
+    ],
+]
+
+
+def zero_op(_a: int, _b: int) -> int:
+    return 0
+
+
+def value_of(key: str) -> tuple[str, Callable[[dict[str, int]], int]]:
+    try:
+        return "", lambda _p, _v=int(key): _v
+    except ValueError:
+        return key, lambda values: values[key]
+
+
+def process(
+    signals: Signals,
+    values: dict[str, int],
+) -> dict[str, int]:
+    while signals:
+        signal = next(s for s in signals if all(p in values for p in signals[s][0]))
+        _, deps, command = signals[signal]
+        values[signal] = command(deps[0](values), deps[1](values)) % 65536
+        del signals[signal]
+
+    return values
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any] | None:
+        lines = input.splitlines()
+
+        signals: Signals = {}
+        values: dict[str, int] = {"": 0}
+
+        for line in lines:
+            command, signal = line.split(" -> ")
+
+            if command.startswith("NOT"):
+                name = command.split(" ")[1]
+                signals[signal] = (
+                    (name, ""),
+                    (lambda values, _n=name: values[_n], lambda _v: 0),
+                    lambda a, _b: ~a,
+                )
+
+            elif not any(command.find(name) >= 0 for name in OPERATORS):
+                try:
+                    values[signal] = int(command)
+                except ValueError:
+                    signals[signal] = (
+                        (command, ""),
+                        (lambda values, _c=command: values[_c], lambda _v: 0),
+                        lambda a, _b: a,
+                    )
+
+            else:
+                op: Callable[[int, int], int] = zero_op
+                lhs_s, rhs_s = "", ""
+
+                for name in OPERATORS:
+                    if command.find(name) >= 0:
+                        op = OPERATORS[name]
+                        lhs_s, rhs_s = command.split(f" {name} ")
+                        break
+
+                lhs_s, lhs_fn = value_of(lhs_s)
+                rhs_s, rhs_fn = value_of(rhs_s)
+
+                signals[signal] = ((lhs_s, rhs_s), (lhs_fn, rhs_fn), op)
+
+        values_1 = process(signals.copy(), values.copy())
+        for k in sorted(values_1):
+            self.logger.info(f"{k}: {values_1[k]}")
+        yield values_1["a"]
+
+        yield process(signals.copy(), values | {"b": values_1["a"]})["a"]

src/holt59/aoc/2015/day8.py

@@ -0,0 +1,32 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        yield sum(
+            # left and right quotes (not in memory)
+            2
+            # each \\ adds one character in the literals (compared to memory)
+            + line.count(R"\\")
+            # each \" adds one character in the literals (compared to memory)
+            + line[1:-1].count(R"\"")
+            # each \xFF adds 3 characters in the literals (compared to memory), but we must not
+            # count A\\x (A != \), but we must count A\\\x (A != \) - in practice we should also
+            # avoid \\\\x, etc., but this does not occur in the examples and the actual input
+            + 3 * (line.count(R"\x") - line.count(R"\\x") + line.count(R"\\\x"))
+            for line in lines
+        )
+
+        yield sum(
+            # needs to wrap in quotes (2 characters)
+            2
+            # needs to escape every \ with an extra \
+            + line.count("\\")
+            # needs to escape every " with an extra \ (including the first and last ones)
+            + line.count('"')
+            for line in lines
+        )

src/holt59/aoc/2015/day9.py

@@ -0,0 +1,28 @@
+import itertools
+from collections import defaultdict
+from typing import Any, Iterator, cast
+
+import parse  # type: ignore
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        distances: dict[str, dict[str, int]] = defaultdict(dict)
+        for line in lines:
+            origin, destination, length = cast(
+                tuple[str, str, int],
+                parse.parse("{} to {} = {:d}", line),  # type: ignore
+            )
+            distances[origin][destination] = distances[destination][origin] = length
+
+        distance_of_routes = {
+            route: sum(distances[o][d] for o, d in zip(route[:-1], route[1:]))
+            for route in map(tuple, itertools.permutations(distances))
+        }
+
+        yield min(distance_of_routes.values())
+        yield max(distance_of_routes.values())

src/holt59/aoc/2021/day1.py

@@ -0,0 +1,17 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        values = [int(line) for line in lines]
+
+        # part 1
+        yield sum(v2 > v1 for v1, v2 in zip(values[:-1], values[1:]))
+
+        # part 2
+        runnings = [sum(values[i : i + 3]) for i in range(len(values) - 2)]
+        yield sum(v2 > v1 for v1, v2 in zip(runnings[:-1], runnings[1:]))

src/holt59/aoc/2021/day10.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day11.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day12.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day13.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day14.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day15.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day16.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day17.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day18.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day19.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day2.py

@@ -0,0 +1,38 @@
+from math import prod
+from typing import Any, Iterator, Literal, TypeAlias, cast
+
+from ..base import BaseSolver
+
+Command: TypeAlias = Literal["forward", "up", "down"]
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        commands: list[tuple[Command, int]] = [
+            (cast(Command, (p := line.split())[0]), int(p[1])) for line in lines
+        ]
+
+        def depth_and_position(use_aim: bool):
+            aim, pos, depth = 0, 0, 0
+            for command, value in commands:
+                d_depth = 0
+                match command:
+                    case "forward":
+                        pos += value
+                        depth += value * aim
+                    case "up":
+                        d_depth = -value
+                    case "down":
+                        d_depth = value
+
+                if use_aim:
+                    aim += d_depth
+                else:
+                    depth += value
+
+            return depth, pos
+
+        yield prod(depth_and_position(False))
+        yield prod(depth_and_position(True))

src/holt59/aoc/2021/day20.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day21.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day22.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day23.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day24.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day25.py

@@ -0,0 +1,7 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]: ...

src/holt59/aoc/2021/day3.py

@@ -0,0 +1,43 @@
+from collections import Counter
+from typing import Any, Iterator, Literal
+
+from ..base import BaseSolver
+
+
+def generator_rating(
+    values: list[str], most_common: bool, default: Literal["0", "1"]
+) -> str:
+    index = 0
+    most_common_idx = 0 if most_common else 1
+
+    while len(values) > 1:
+        cnt = Counter(value[index] for value in values)
+        bit = cnt.most_common(2)[most_common_idx][0]
+        if cnt["0"] == cnt["1"]:
+            bit = default
+        values = [value for value in values if value[index] == bit]
+        index += 1
+
+    return values[0]
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        # part 1
+        most_and_least_common = [
+            tuple(
+                Counter(line[col] for line in lines).most_common(2)[m][0]
+                for m in range(2)
+            )
+            for col in range(len(lines[0]))
+        ]
+        gamma_rate = int("".join(most for most, _ in most_and_least_common), base=2)
+        epsilon_rate = int("".join(least for _, least in most_and_least_common), base=2)
+        yield gamma_rate * epsilon_rate
+
+        # part 2
+        oxygen_generator_rating = int(generator_rating(lines, True, "1"), base=2)
+        co2_scrubber_rating = int(generator_rating(lines, False, "0"), base=2)
+        yield oxygen_generator_rating * co2_scrubber_rating

src/holt59/aoc/2021/day4.py

@@ -0,0 +1,52 @@
+from typing import Any, Iterator
+
+import numpy as np
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        numbers = [int(c) for c in lines[0].split(",")]
+
+        boards = np.asarray(
+            [
+                [[int(c) for c in line.split()] for line in lines[start : start + 5]]
+                for start in range(2, len(lines), 6)
+            ]
+        )
+
+        # (round, score) for each board (-1 when not found)
+        winning_rounds: list[tuple[int, int]] = [(-1, -1) for _ in range(len(boards))]
+        marked = np.zeros_like(boards, dtype=bool)
+
+        for round, number in enumerate(numbers):
+            # mark boards
+            marked[boards == number] = True
+
+            # check each board for winning
+            for index in range(len(boards)):
+                if winning_rounds[index][0] > 0:
+                    continue
+
+                if np.any(
+                    np.all(marked[index], axis=0) | np.all(marked[index], axis=1)
+                ):
+                    winning_rounds[index] = (
+                        round,
+                        number * int(np.sum(boards[index][~marked[index]])),
+                    )
+
+            # all boards are winning - break
+            if np.all(marked.all(axis=1) | marked.all(axis=2)):
+                break
+
+        # part 1
+        (_, score) = min(winning_rounds, key=lambda w: w[0])
+        yield score
+
+        # part 2
+        (_, score) = max(winning_rounds, key=lambda w: w[0])
+        yield score

src/holt59/aoc/2021/day5.py

@@ -0,0 +1,48 @@
+from typing import Any, Iterator
+
+import numpy as np
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        sections: list[tuple[tuple[int, int], tuple[int, int]]] = [
+            (
+                (
+                    int(line.split(" -> ")[0].split(",")[0]),
+                    int(line.split(" -> ")[0].split(",")[1]),
+                ),
+                (
+                    int(line.split(" -> ")[1].split(",")[0]),
+                    int(line.split(" -> ")[1].split(",")[1]),
+                ),
+            )
+            for line in lines
+        ]
+
+        np_sections = np.array(sections).reshape(-1, 4)
+
+        x_max, y_max = (
+            max(np_sections[:, 0].max(), np_sections[:, 2].max()),
+            max(np_sections[:, 1].max(), np_sections[:, 3].max()),
+        )
+
+        counts_1 = np.zeros((y_max + 1, x_max + 1), dtype=int)
+        counts_2 = counts_1.copy()
+
+        for (x1, y1), (x2, y2) in sections:
+            x_rng = range(x1, x2 + 1, 1) if x2 >= x1 else range(x1, x2 - 1, -1)
+            y_rng = range(y1, y2 + 1, 1) if y2 >= y1 else range(y1, y2 - 1, -1)
+
+            if x1 == x2 or y1 == y2:
+                counts_1[list(y_rng), list(x_rng)] += 1
+                counts_2[list(y_rng), list(x_rng)] += 1
+            elif abs(x2 - x1) == abs(y2 - y1):
+                for i, j in zip(y_rng, x_rng):
+                    counts_2[i, j] += 1
+
+        yield (counts_1 >= 2).sum()
+        yield (counts_2 >= 2).sum()

src/holt59/aoc/2021/day6.py

@@ -0,0 +1,21 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        values = [int(c) for c in input.split(",")]
+
+        days = 256
+        lanterns = {day: 0 for day in range(days)}
+        for value in values:
+            for day in range(value, days, 7):
+                lanterns[day] += 1
+
+        for day in range(days):
+            for day2 in range(day + 9, days, 7):
+                lanterns[day2] += lanterns[day]
+
+        yield sum(v for k, v in lanterns.items() if k < 80) + len(values)
+        yield sum(lanterns.values()) + len(values)

src/holt59/aoc/2021/day7.py

@@ -0,0 +1,22 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        positions = [int(c) for c in input.split(",")]
+
+        min_position, max_position = min(positions), max(positions)
+
+        # part 1
+        yield min(
+            sum(abs(p - position) for p in positions)
+            for position in range(min_position, max_position + 1)
+        )
+
+        # part 2
+        yield min(
+            sum(abs(p - position) * (abs(p - position) + 1) // 2 for p in positions)
+            for position in range(min_position, max_position + 1)
+        )

src/holt59/aoc/2021/day8.py

@@ -0,0 +1,89 @@
+import itertools
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+digits = {
+    "abcefg": 0,
+    "cf": 1,
+    "acdeg": 2,
+    "acdfg": 3,
+    "bcdf": 4,
+    "abdfg": 5,
+    "abdefg": 6,
+    "acf": 7,
+    "abcdefg": 8,
+    "abcdfg": 9,
+}
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        # part 1
+        lengths = {len(k) for k, v in digits.items() if v in (1, 4, 7, 8)}
+        yield sum(
+            len(p) in lengths
+            for line in lines
+            for p in line.split("|")[1].strip().split()
+        )
+
+        # part 2
+        values: list[int] = []
+
+        for line in lines:
+            parts = line.split("|")
+            broken_digits = sorted(parts[0].strip().split(), key=len)
+
+            per_length = {
+                k: list(v)
+                for k, v in itertools.groupby(sorted(broken_digits, key=len), key=len)
+            }
+
+            # a can be found immediately
+            a = next(u for u in per_length[3][0] if u not in per_length[2][0])
+
+            # c and f have only two possible values corresponding to the single entry of
+            # length 2
+            cf = list(per_length[2][0])
+
+            # the only digit of length 4 contains bcdf, so we can deduce bd by removing cf
+            bd = [u for u in per_length[4][0] if u not in cf]
+
+            # the 3 digits of length 5 have a, d and g in common
+            adg = [
+                u for u in per_length[5][0] if all(u in pe for pe in per_length[5][1:])
+            ]
+
+            # we can remove a
+            dg = [u for u in adg if u != a]
+
+            # we can deduce d and g
+            d = next(u for u in dg if u in bd)
+            g = next(u for u in dg if u != d)
+
+            # then b
+            b = next(u for u in bd if u != d)
+
+            # f is in the three 6-length digits, while c is only in 2
+            f = next(u for u in cf if all(u in p for p in per_length[6]))
+
+            # c is not f
+            c = next(u for u in cf if u != f)
+
+            # e is the last one
+            e = next(u for u in "abcdefg" if u not in {a, b, c, d, f, g})
+
+            mapping = dict(zip((a, b, c, d, e, f, g), "abcdefg"))
+
+            value = 0
+            for number in parts[1].strip().split():
+                digit = "".join(sorted(mapping[c] for c in number))
+                value = 10 * value + digits[digit]
+
+            self.logger.info(f"value for '{line}' is {value}")
+
+            values.append(value)
+
+        yield sum(values)

src/holt59/aoc/2021/day9.py

@@ -0,0 +1,47 @@
+from math import prod
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def neighbors(point: tuple[int, int], n_rows: int, n_cols: int):
+    i, j = point
+    for di, dj in ((-1, 0), (+1, 0), (0, -1), (0, +1)):
+        if 0 <= i + di < n_rows and 0 <= j + dj < n_cols:
+            yield (i + di, j + dj)
+
+
+def basin(values: list[list[int]], start: tuple[int, int]) -> set[tuple[int, int]]:
+    n_rows, n_cols = len(values), len(values[0])
+    visited: set[tuple[int, int]] = set()
+    queue = [start]
+
+    while queue:
+        i, j = queue.pop()
+
+        if (i, j) in visited or values[i][j] == 9:
+            continue
+
+        visited.add((i, j))
+        queue.extend(neighbors((i, j), n_rows, n_cols))
+
+    return visited
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        values = [[int(c) for c in row] for row in input.splitlines()]
+        n_rows, n_cols = len(values), len(values[0])
+
+        low_points = [
+            (i, j)
+            for i in range(n_rows)
+            for j in range(n_cols)
+            if all(
+                values[ti][tj] > values[i][j]
+                for ti, tj in neighbors((i, j), n_rows, n_cols)
+            )
+        ]
+
+        yield sum(values[i][j] + 1 for i, j in low_points)
+        yield prod(sorted(len(basin(values, point)) for point in low_points)[-3:])

src/holt59/aoc/2022/day1.py

@@ -0,0 +1,12 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        blocks = input.split("\n\n")
+        values = sorted(sum(map(int, block.split())) for block in blocks)
+
+        yield values[-1]
+        yield sum(values[-3:])

src/holt59/aoc/2022/day10.py

@@ -0,0 +1,43 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        cycle, x = 1, 1
+        values = {cycle: x}
+
+        for line in lines:
+            cycle += 1
+
+            if line == "noop":
+                pass
+            else:
+                r = int(line.split()[1])
+
+                values[cycle] = x
+
+                cycle += 1
+                x += r
+
+            values[cycle] = x
+
+        answer_1 = sum(c * values[c] for c in range(20, max(values.keys()) + 1, 40))
+        yield answer_1
+
+        yield (
+            "\n"
+            + "\n".join(
+                "".join(
+                    "#"
+                    if j >= (v := values[1 + i * 40 + j]) - 1 and j <= v + 1
+                    else "."
+                    for j in range(40)
+                )
+                for i in range(6)
+            )
+            + "\n"
+        )

src/holt59/aoc/2022/day11.py

@@ -0,0 +1,147 @@
+import copy
+from functools import reduce
+from typing import Any, Callable, Final, Iterator, Mapping, Sequence
+
+from ..base import BaseSolver
+
+
+class Monkey:
+    id: Final[int]
+    items: Final[Sequence[int]]
+    worry_fn: Final[Callable[[int], int]]
+    test_value: Final[int]
+    throw_targets: Final[Mapping[bool, int]]
+
+    def __init__(
+        self,
+        id: int,
+        items: list[int],
+        worry_fn: Callable[[int], int],
+        test_value: int,
+        throw_targets: dict[bool, int],
+    ):
+        self.id = id
+        self.items = items
+        self.worry_fn = worry_fn
+        self.test_value = test_value
+        self.throw_targets = throw_targets
+
+    def __eq__(self, o: object) -> bool:
+        if not isinstance(o, Monkey):
+            return False
+        return self.id == o.id
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+
+def parse_monkey(lines: list[str]) -> Monkey:
+    assert lines[0].startswith("Monkey")
+
+    monkey_id = int(lines[0].split()[-1][:-1])
+
+    # parse items
+    items = [int(r.strip()) for r in lines[1].split(":")[1].split(",")]
+
+    # parse worry
+    worry_fn: Callable[[int], int]
+    worry_s = lines[2].split("new =")[1].strip()
+    operand = worry_s.split()[2].strip()
+
+    if worry_s.startswith("old *"):
+        if operand == "old":
+            worry_fn = lambda w: w * w  # noqa: E731
+        else:
+            worry_fn = lambda w: w * int(operand)  # noqa: E731
+    elif worry_s.startswith("old +"):
+        if operand == "old":
+            worry_fn = lambda w: w + w  # noqa: E731
+        else:
+            worry_fn = lambda w: w + int(operand)  # noqa: E731
+    else:
+        assert False, worry_s
+
+    # parse test
+    assert lines[3].split(":")[1].strip().startswith("divisible by")
+    test_value = int(lines[3].split()[-1])
+
+    assert lines[4].strip().startswith("If true")
+    assert lines[5].strip().startswith("If false")
+    throw_targets = {True: int(lines[4].split()[-1]), False: int(lines[5].split()[-1])}
+
+    assert monkey_id not in throw_targets.values()
+
+    return Monkey(monkey_id, items, worry_fn, test_value, throw_targets)
+
+
+def run(
+    monkeys: list[Monkey], n_rounds: int, me_worry_fn: Callable[[int], int]
+) -> dict[Monkey, int]:
+    """
+    Perform a full run.
+
+    Args:
+        monkeys: Initial list of monkeys. The Monkey are not modified.
+        n_rounds: Number of rounds to run.
+        me_worry_fn: Worry function to apply after the Monkey operation (e.g., divide
+            by 3 for round 1).
+
+    Returns:
+        A mapping containing, for each monkey, the number of items inspected.
+    """
+    # copy of the items
+    items = {monkey: list(monkey.items) for monkey in monkeys}
+
+    # number of inspects
+    inspects = {monkey: 0 for monkey in monkeys}
+
+    for _ in range(n_rounds):
+        for monkey in monkeys:
+            for item in items[monkey]:
+                inspects[monkey] += 1
+
+                # compute the new worry level
+                item = me_worry_fn(monkey.worry_fn(item))
+
+                # find the target
+                target = monkey.throw_targets[item % monkey.test_value == 0]
+                assert target != monkey.id
+
+                items[monkeys[target]].append(item)
+
+            # clear after the loop
+            items[monkey].clear()
+
+    return inspects
+
+
+def monkey_business(inspects: dict[Monkey, int]) -> int:
+    sorted_levels = sorted(inspects.values())
+    return sorted_levels[-2] * sorted_levels[-1]
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        monkeys = [parse_monkey(block.splitlines()) for block in input.split("\n\n")]
+
+        # case 1: we simply divide the worry by 3 after applying the monkey worry operation
+        yield monkey_business(
+            run(copy.deepcopy(monkeys), 20, me_worry_fn=lambda w: w // 3)
+        )
+
+        # case 2: to keep reasonable level values, we can use a modulo operation, we need to
+        # use the product of all "divisible by" test so that the test remains valid
+        #
+        # (a + b) % c == ((a % c) + (b % c)) % c --- this would work for a single test value
+        #
+        # (a + b) % c == ((a % d) + (b % d)) % c --- if d is a multiple of c, which is why here
+        # we use the product of all test value
+        #
+        total_test_value = reduce(lambda w, m: w * m.test_value, monkeys, 1)
+        yield monkey_business(
+            run(
+                copy.deepcopy(monkeys),
+                10_000,
+                me_worry_fn=lambda w: w % total_test_value,
+            )
+        )

src/holt59/aoc/2022/day12.py

@@ -0,0 +1,168 @@
+import heapq
+from typing import Any, Callable, Iterator, TypeVar
+
+from ..base import BaseSolver
+
+Node = TypeVar("Node")
+
+
+def dijkstra(
+    start: Node,
+    neighbors: Callable[[Node], Iterator[Node]],
+    cost: Callable[[Node, Node], float],
+) -> tuple[dict[Node, float], dict[Node, Node]]:
+    """
+    Compute shortest paths from one node to all reachable ones.
+
+    Args:
+        start: Starting node.
+        neighbors: Function returning the neighbors of a node.
+        cost: Function to compute the cost of an edge.
+
+    Returns:
+        A tuple (lengths, parents) where lengths is a mapping from Node to distance
+        (from the starting node) and parents a mapping from parents Node (in the
+        shortest path). If keyset of lengths and parents is the same. If a Node is not
+        in the mapping, it cannot be reached from the starting node.
+    """
+
+    queue: list[tuple[float, Node]] = []
+
+    visited: set[Node] = set()
+    lengths: dict[Node, float] = {start: 0}
+    parents: dict[Node, Node] = {}
+
+    heapq.heappush(queue, (0, start))
+
+    while queue:
+        length, current = heapq.heappop(queue)
+
+        if current in visited:
+            continue
+
+        visited.add(current)
+
+        for neighbor in neighbors(current):
+            if neighbor in visited:
+                continue
+
+            neighbor_cost = length + cost(current, neighbor)
+
+            if neighbor_cost < lengths.get(neighbor, float("inf")):
+                lengths[neighbor] = neighbor_cost
+                parents[neighbor] = current
+
+                heapq.heappush(queue, (neighbor_cost, neighbor))
+
+    return lengths, parents
+
+
+def make_path(parents: dict[Node, Node], start: Node, end: Node) -> list[Node] | None:
+    if end not in parents:
+        return None
+
+    path: list[Node] = [end]
+
+    while path[-1] is not start:
+        path.append(parents[path[-1]])
+
+    return list(reversed(path))
+
+
+def neighbors(
+    grid: list[list[int]], node: tuple[int, int], up: bool
+) -> Iterator[tuple[int, int]]:
+    n_rows = len(grid)
+    n_cols = len(grid[0])
+
+    c_row, c_col = node
+    for n_row, n_col in (
+        (c_row - 1, c_col),
+        (c_row + 1, c_col),
+        (c_row, c_col - 1),
+        (c_row, c_col + 1),
+    ):
+        if not (n_row >= 0 and n_row < n_rows and n_col >= 0 and n_col < n_cols):
+            continue
+
+        if up and grid[n_row][n_col] > grid[c_row][c_col] + 1:
+            continue
+        elif not up and grid[n_row][n_col] < grid[c_row][c_col] - 1:
+            continue
+
+        yield n_row, n_col
+
+
+# === main code ===
+
+
+class Solver(BaseSolver):
+    def print_path(self, path: list[tuple[int, int]], n_rows: int, n_cols: int) -> None:
+        end = path[-1]
+
+        graph = [["." for _c in range(n_cols)] for _r in range(n_rows)]
+        graph[end[0]][end[1]] = "E"
+
+        for i in range(0, len(path) - 1):
+            cr, cc = path[i]
+            nr, nc = path[i + 1]
+
+            if cr == nr and nc == cc - 1:
+                graph[cr][cc] = "<"
+            elif cr == nr and nc == cc + 1:
+                graph[cr][cc] = ">"
+            elif cr == nr - 1 and nc == cc:
+                graph[cr][cc] = "v"
+            elif cr == nr + 1 and nc == cc:
+                graph[cr][cc] = "^"
+            else:
+                assert False, "{} -> {} infeasible".format(path[i], path[i + 1])
+
+        for row in graph:
+            self.logger.info("".join(row))
+
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        grid = [[ord(cell) - ord("a") for cell in line] for line in lines]
+
+        start: tuple[int, int] | None = None
+        end: tuple[int, int] | None = None
+
+        # for part 2
+        start_s: list[tuple[int, int]] = []
+
+        for i_row, row in enumerate(grid):
+            for i_col, col in enumerate(row):
+                if chr(col + ord("a")) == "S":
+                    start = (i_row, i_col)
+                    start_s.append(start)
+                elif chr(col + ord("a")) == "E":
+                    end = (i_row, i_col)
+                elif col == 0:
+                    start_s.append((i_row, i_col))
+
+        assert start is not None
+        assert end is not None
+
+        # fix values
+        grid[start[0]][start[1]] = 0
+        grid[end[0]][end[1]] = ord("z") - ord("a")
+
+        lengths_1, parents_1 = dijkstra(
+            start=start,
+            neighbors=lambda n: neighbors(grid, n, True),
+            cost=lambda lhs, rhs: 1,
+        )
+        path_1 = make_path(parents_1, start, end)
+        assert path_1 is not None
+
+        self.print_path(path_1, n_rows=len(grid), n_cols=len(grid[0]))
+        yield lengths_1[end] - 1
+
+        lengths_2, _ = dijkstra(
+            start=end,
+            neighbors=lambda n: neighbors(grid, n, False),
+            cost=lambda lhs, rhs: 1,
+        )
+        yield min(lengths_2.get(start, float("inf")) for start in start_s)

src/holt59/aoc/2022/day13.py

@@ -0,0 +1,42 @@
+import json
+from functools import cmp_to_key
+from typing import Any, Iterator, TypeAlias, cast
+
+from ..base import BaseSolver
+
+Packet: TypeAlias = list[int | list["Packet"]]
+
+
+def compare(lhs: Packet, rhs: Packet) -> int:
+    for lhs_a, rhs_a in zip(lhs, rhs):
+        if isinstance(lhs_a, int) and isinstance(rhs_a, int):
+            if lhs_a != rhs_a:
+                return rhs_a - lhs_a
+        else:
+            if not isinstance(lhs_a, list):
+                lhs_a = [lhs_a]  # type: ignore
+            elif not isinstance(rhs_a, list):
+                rhs_a = [rhs_a]  # type: ignore
+            assert isinstance(rhs_a, list) and isinstance(lhs_a, list)
+            r = compare(cast(Packet, lhs_a), cast(Packet, rhs_a))
+            if r != 0:
+                return r
+
+    return len(rhs) - len(lhs)
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        blocks = input.split("\n\n")
+        pairs = [tuple(json.loads(p) for p in block.split("\n")) for block in blocks]
+
+        yield sum(i + 1 for i, (lhs, rhs) in enumerate(pairs) if compare(lhs, rhs) > 0)
+
+        dividers = [[[2]], [[6]]]
+
+        packets = [packet for packets in pairs for packet in packets]
+        packets.extend(dividers)
+        packets = list(reversed(sorted(packets, key=cmp_to_key(compare))))
+
+        d_index = [packets.index(d) + 1 for d in dividers]
+        yield d_index[0] * d_index[1]

src/holt59/aoc/2022/day14.py

@@ -0,0 +1,139 @@
+from enum import Enum, auto
+from typing import Any, Callable, Iterator, cast
+
+from ..base import BaseSolver
+
+
+class Cell(Enum):
+    AIR = auto()
+    ROCK = auto()
+    SAND = auto()
+
+    def __str__(self) -> str:
+        return {Cell.AIR: ".", Cell.ROCK: "#", Cell.SAND: "O"}[self]
+
+
+def flow(
+    blocks: dict[tuple[int, int], Cell],
+    stop_fn: Callable[[int, int], bool],
+    fill_fn: Callable[[int, int], Cell],
+) -> dict[tuple[int, int], Cell]:
+    """
+    Flow sands onto the given set of blocks
+
+    Args:
+        blocks: Blocks containing ROCK position. Modified in-place.
+        stop_fn: Function called with the last (assumed) position of a grain of
+            sand BEFORE adding it to blocks. If the function returns True, the grain
+            is added and a new one is flowed, otherwise, the whole procedure stops
+            and the function returns (without adding the final grain).
+        fill_fn: Function called when the target position of a grain (during the
+            flowing process) is missing from blocks.
+
+    Returns:
+        The input blocks.
+    """
+
+    y_max = max(y for _, y in blocks)
+
+    while True:
+        x, y = 500, 0
+
+        while y <= y_max:
+            moved = False
+            for cx, cy in ((x, y + 1), (x - 1, y + 1), (x + 1, y + 1)):
+                if (cx, cy) not in blocks and fill_fn(cx, cy) == Cell.AIR:
+                    x, y = cx, cy
+                    moved = True
+                elif blocks[cx, cy] == Cell.AIR:
+                    x, y = cx, cy
+                    moved = True
+
+                if moved:
+                    break
+
+            if not moved:
+                break
+
+        if stop_fn(x, y):
+            break
+
+        blocks[x, y] = Cell.SAND
+
+    return blocks
+
+
+# === inputs ===
+
+
+class Solver(BaseSolver):
+    def print_blocks(self, blocks: dict[tuple[int, int], Cell]):
+        """
+        Print the given set of blocks on a grid.
+
+        Args:
+            blocks: Set of blocks to print.
+        """
+        x_min, y_min, x_max, y_max = (
+            min(x for x, _ in blocks),
+            0,
+            max(x for x, _ in blocks),
+            max(y for _, y in blocks),
+        )
+
+        for y in range(y_min, y_max + 1):
+            self.logger.info(
+                "".join(
+                    str(blocks.get((x, y), Cell.AIR)) for x in range(x_min, x_max + 1)
+                )
+            )
+
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        paths: list[list[tuple[int, int]]] = []
+        for line in lines:
+            parts = line.split(" -> ")
+            paths.append(
+                [
+                    cast(
+                        tuple[int, int], tuple(int(c.strip()) for c in part.split(","))
+                    )
+                    for part in parts
+                ]
+            )
+
+        blocks: dict[tuple[int, int], Cell] = {}
+        for path in paths:
+            for start, end in zip(path[:-1], path[1:]):
+                x_start = min(start[0], end[0])
+                x_end = max(start[0], end[0]) + 1
+                y_start = min(start[1], end[1])
+                y_end = max(start[1], end[1]) + 1
+
+                for x in range(x_start, x_end):
+                    for y in range(y_start, y_end):
+                        blocks[x, y] = Cell.ROCK
+
+        self.print_blocks(blocks)
+
+        y_max = max(y for _, y in blocks)
+
+        # === part 1 ===
+
+        blocks_1 = flow(
+            blocks.copy(), stop_fn=lambda x, y: y > y_max, fill_fn=lambda x, y: Cell.AIR
+        )
+        self.print_blocks(blocks_1)
+        yield sum(v == Cell.SAND for v in blocks_1.values())
+
+        # === part 2 ===
+
+        blocks_2 = flow(
+            blocks.copy(),
+            stop_fn=lambda x, y: x == 500 and y == 0,
+            fill_fn=lambda x, y: Cell.AIR if y < y_max + 2 else Cell.ROCK,
+        )
+        blocks_2[500, 0] = Cell.SAND
+        self.print_blocks(blocks_2)
+        yield sum(v == Cell.SAND for v in blocks_2.values())

src/holt59/aoc/2022/day15.py

@@ -0,0 +1,95 @@
+import itertools as it
+from typing import Any, Iterator
+
+import numpy as np
+import parse  # type: ignore
+from numpy.typing import NDArray
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def part1(
+        self, sensor_to_beacon: dict[tuple[int, int], tuple[int, int]], row: int
+    ) -> int:
+        no_beacons_row_l: list[NDArray[np.floating[Any]]] = []
+
+        for (sx, sy), (bx, by) in sensor_to_beacon.items():
+            d = abs(sx - bx) + abs(sy - by)  # closest
+
+            no_beacons_row_l.append(sx - np.arange(0, d - abs(sy - row) + 1))  # type: ignore
+            no_beacons_row_l.append(sx + np.arange(0, d - abs(sy - row) + 1))  # type: ignore
+
+        beacons_at_row = set(bx for (bx, by) in sensor_to_beacon.values() if by == row)
+        no_beacons_row = set(it.chain(*no_beacons_row_l)).difference(beacons_at_row)  # type: ignore
+
+        return len(no_beacons_row)
+
+    def part2_intervals(
+        self, sensor_to_beacon: dict[tuple[int, int], tuple[int, int]], xy_max: int
+    ) -> tuple[int, int, int]:
+        for y in self.progress.wrap(range(xy_max + 1)):
+            its: list[tuple[int, int]] = []
+            for (sx, sy), (bx, by) in sensor_to_beacon.items():
+                d = abs(sx - bx) + abs(sy - by)
+                dx = d - abs(sy - y)
+
+                if dx >= 0:
+                    its.append((max(0, sx - dx), min(sx + dx, xy_max)))
+
+            its = sorted(its)
+            _, e = its[0]
+
+            for si, ei in its[1:]:
+                if si > e + 1:
+                    return si - 1, y, 4_000_000 * (si - 1) + y
+                if ei > e:
+                    e = ei
+
+        return (0, 0, 0)
+
+    def part2_cplex(
+        self, sensor_to_beacon: dict[tuple[int, int], tuple[int, int]], xy_max: int
+    ) -> tuple[int, int, int]:
+        from docplex.mp.model import Model
+
+        m = Model()
+
+        x, y = m.continuous_var_list(2, ub=xy_max, name=["x", "y"])
+
+        for (sx, sy), (bx, by) in sensor_to_beacon.items():
+            d = abs(sx - bx) + abs(sy - by)
+            m.add_constraint(
+                m.abs(x - sx) + m.abs(y - sy) >= d + 1,  # type: ignore
+                ctname=f"ct_{sx}_{sy}",
+            )
+
+        m.set_objective("min", x + y)
+
+        s = m.solve()
+        assert s is not None
+
+        vx = int(s.get_value(x))
+        vy = int(s.get_value(y))
+        return vx, vy, 4_000_000 * vx + vy
+
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        sensor_to_beacon: dict[tuple[int, int], tuple[int, int]] = {}
+
+        for line in lines:
+            r: dict[str, str] = parse.parse(  # type: ignore
+                "Sensor at x={sx}, y={sy}: closest beacon is at x={bx}, y={by}", line
+            )
+            sensor_to_beacon[int(r["sx"]), int(r["sy"])] = (int(r["bx"]), int(r["by"]))
+
+        xy_max = 4_000_000 if max(sensor_to_beacon) > (1_000, 0) else 20
+        row = 2_000_000 if max(sensor_to_beacon) > (1_000, 0) else 10
+
+        yield self.part1(sensor_to_beacon, row)
+
+        # x, y, a2 = part2_cplex(sensor_to_beacon, xy_max)
+        x, y, a2 = self.part2_intervals(sensor_to_beacon, xy_max)
+        self.logger.info(f"answer 2 is {a2} (x={x}, y={y})")
+        yield a2

src/holt59/aoc/2022/day16.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import heapq
+import itertools
+import re
+from collections import defaultdict
+from typing import Any, FrozenSet, Iterator, NamedTuple
+
+from tqdm import tqdm
+
+from ..base import BaseSolver
+
+
+class Pipe(NamedTuple):
+    name: str
+    flow: int
+    tunnels: list[str]
+
+    def __lt__(self, other: object) -> bool:
+        return isinstance(other, Pipe) and other.name < self.name
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Pipe) and other.name == self.name
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return self.name
+
+
+def breadth_first_search(pipes: dict[str, Pipe], pipe: Pipe) -> dict[Pipe, int]:
+    """
+    Runs a BFS from the given pipe and return the shortest distance (in term of hops)
+    to all other pipes.
+    """
+    queue = [(0, pipe)]
+    visited: set[Pipe] = set()
+    distances: dict[Pipe, int] = {}
+
+    while len(distances) < len(pipes):
+        distance, current = heapq.heappop(queue)
+
+        if current in visited:
+            continue
+
+        visited.add(current)
+        distances[current] = distance
+
+        for tunnel in current.tunnels:
+            heapq.heappush(queue, (distance + 1, pipes[tunnel]))
+
+    return distances
+
+
+def update_with_better(
+    node_at_times: dict[FrozenSet[Pipe], int], flow: int, flowing: FrozenSet[Pipe]
+) -> None:
+    node_at_times[flowing] = max(node_at_times[flowing], flow)
+
+
+def part_1(
+    start_pipe: Pipe,
+    max_time: int,
+    distances: dict[tuple[Pipe, Pipe], int],
+    relevant_pipes: FrozenSet[Pipe],
+):
+    node_at_times: dict[int, dict[Pipe, dict[FrozenSet[Pipe], int]]] = defaultdict(
+        lambda: defaultdict(lambda: defaultdict(lambda: 0))
+    )
+    node_at_times[0] = {start_pipe: {frozenset(): 0}}
+
+    for time in range(max_time):
+        for c_pipe, nodes in node_at_times[time].items():
+            for flowing, flow in nodes.items():
+                for target in relevant_pipes:
+                    distance = distances[c_pipe, target] + 1
+                    if time + distance >= max_time or target in flowing:
+                        continue
+
+                    update_with_better(
+                        node_at_times[time + distance][target],
+                        flow + sum(pipe.flow for pipe in flowing) * distance,
+                        flowing | {target},
+                    )
+
+                update_with_better(
+                    node_at_times[max_time][c_pipe],
+                    flow + sum(pipe.flow for pipe in flowing) * (max_time - time),
+                    flowing,
+                )
+
+    return max(
+        flow
+        for nodes_of_pipe in node_at_times[max_time].values()
+        for flow in nodes_of_pipe.values()
+    )
+
+
+def part_2(
+    start_pipe: Pipe,
+    max_time: int,
+    distances: dict[tuple[Pipe, Pipe], int],
+    relevant_pipes: FrozenSet[Pipe],
+):
+    def compute(pipes_for_me: FrozenSet[Pipe]) -> int:
+        return part_1(start_pipe, max_time, distances, pipes_for_me) + part_1(
+            start_pipe, max_time, distances, relevant_pipes - pipes_for_me
+        )
+
+    combs = [
+        frozenset(relevant_pipes_1)
+        for r in range(2, len(relevant_pipes) // 2 + 1)
+        for relevant_pipes_1 in itertools.combinations(relevant_pipes, r)
+    ]
+
+    return max(compute(comb) for comb in tqdm(combs))
+
+
+# === MAIN ===
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        pipes: dict[str, Pipe] = {}
+        for line in lines:
+            r = re.match(
+                R"Valve ([A-Z]+) has flow rate=([0-9]+); tunnels? leads? to valves? (.+)",
+                line,
+            )
+            assert r
+
+            g = r.groups()
+
+            pipes[g[0]] = Pipe(g[0], int(g[1]), g[2].split(", "))
+
+        # compute distances from one valve to any other
+        distances: dict[tuple[Pipe, Pipe], int] = {}
+        for pipe_1 in pipes.values():
+            distances.update(
+                {
+                    (pipe_1, pipe_2): distance
+                    for pipe_2, distance in breadth_first_search(pipes, pipe_1).items()
+                }
+            )
+
+        # valves with flow
+        relevant_pipes = frozenset(pipe for pipe in pipes.values() if pipe.flow > 0)
+
+        # 1651, 1653
+        yield part_1(pipes["AA"], 30, distances, relevant_pipes)
+
+        # 1707, 2223
+        yield part_2(pipes["AA"], 26, distances, relevant_pipes)

src/holt59/aoc/2022/day17.py

@@ -0,0 +1,122 @@
+from typing import Any, Iterator, Sequence, TypeAlias, TypeVar
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ..base import BaseSolver
+
+T = TypeVar("T")
+
+Tower: TypeAlias = NDArray[np.bool]
+
+
+def print_tower(tower: Tower, out: str = "#"):
+    print("-" * (tower.shape[1] + 2))
+    non_empty = False
+    for row in reversed(range(1, tower.shape[0])):
+        if not non_empty and not tower[row, :].any():
+            continue
+        non_empty = True
+        print("|" + "".join(out if c else "." for c in tower[row, :]) + "|")
+    print("+" + "-" * tower.shape[1] + "+")
+
+
+def tower_height(tower: Tower) -> int:
+    return int(tower.shape[0] - tower[::-1, :].argmax(axis=0).min() - 1)
+
+
+def next_cycle(sequence: Sequence[T], index: int) -> tuple[T, int]:
+    t = sequence[index]
+    index = (index + 1) % len(sequence)
+    return t, index
+
+
+ROCKS = [
+    np.array([(0, 0), (0, 1), (0, 2), (0, 3)]),
+    np.array([(0, 1), (1, 0), (1, 1), (1, 2), (2, 1)]),
+    np.array([(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]),
+    np.array([(0, 0), (1, 0), (2, 0), (3, 0)]),
+    np.array([(0, 0), (0, 1), (1, 0), (1, 1)]),
+]
+
+WIDTH = 7
+START_X = 2
+
+EMPTY_BLOCKS = np.zeros((10, WIDTH), dtype=bool)
+
+
+def build_tower(
+    n_rocks: int,
+    jets: str,
+    early_stop: bool = False,
+    init: Tower = np.ones(WIDTH, dtype=bool),
+) -> tuple[Tower, int, int, dict[int, int]]:
+    tower = EMPTY_BLOCKS.copy()
+    tower[0, :] = init
+
+    done_at: dict[tuple[int, int], int] = {}
+    heights: dict[int, int] = {}
+    i_jet, i_rock = 0, 0
+    rock_count = 0
+
+    for rock_count in range(n_rocks):
+        if early_stop:
+            if i_rock == 0 and (i_rock, i_jet) in done_at:
+                break
+            done_at[i_rock, i_jet] = rock_count
+
+        y_start = tower.shape[0] - tower[::-1, :].argmax(axis=0).min() + 3
+        rock, i_rock = next_cycle(ROCKS, i_rock)
+
+        rock_y = rock[:, 0] + y_start
+        rock_x = rock[:, 1] + START_X
+
+        if rock_y.max() >= tower.shape[0]:
+            tower = np.concatenate([tower, EMPTY_BLOCKS], axis=0)
+
+        while True:
+            jet, i_jet = next_cycle(jets, i_jet)
+
+            dx = 0
+            if jet == ">" and rock_x.max() < WIDTH - 1:
+                dx = 1
+            elif jet == "<" and rock_x.min() > 0:
+                dx = -1
+
+            if dx != 0 and not tower[rock_y, rock_x + dx].any():
+                rock_x = rock_x + dx
+
+            # move down
+            rock_y -= 1
+
+            if tower[rock_y, rock_x].any():
+                rock_y += 1
+                break
+
+        heights[rock_count] = tower_height(tower)
+        tower[rock_y, rock_x] = True
+
+    return tower, rock_count, done_at.get((i_rock, i_jet), -1), heights
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        tower, *_ = build_tower(2022, input)
+        yield tower_height(tower)
+
+        TOTAL_ROCKS = 1_000_000_000_000
+        _tower_1, n_rocks_1, prev_1, heights_1 = build_tower(TOTAL_ROCKS, input, True)
+        assert prev_1 > 0
+
+        # 2767 1513
+        remaining_rocks = TOTAL_ROCKS - n_rocks_1
+        n_repeat_rocks = n_rocks_1 - prev_1
+        n_repeat_towers = remaining_rocks // n_repeat_rocks
+
+        base_height = heights_1[prev_1]
+        repeat_height = heights_1[prev_1 + n_repeat_rocks - 1] - heights_1[prev_1]
+        remaining_height = (
+            heights_1[prev_1 + remaining_rocks % n_repeat_rocks] - heights_1[prev_1]
+        )
+
+        yield base_height + (n_repeat_towers + 1) * repeat_height + remaining_height

src/holt59/aoc/2022/day18.py

@@ -0,0 +1,58 @@
+from typing import Any, Iterator
+
+import numpy as np
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        xyz = np.asarray(
+            [
+                tuple(int(x) for x in row.split(","))  # type: ignore
+                for row in input.splitlines()
+            ]
+        )
+
+        xyz = xyz - xyz.min(axis=0) + 1
+
+        cubes = np.zeros(xyz.max(axis=0) + 3, dtype=bool)
+        cubes[xyz[:, 0], xyz[:, 1], xyz[:, 2]] = True
+
+        faces = [(-1, 0, 0), (1, 0, 0), (0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1)]
+
+        yield sum(
+            1
+            for x, y, z in xyz
+            for dx, dy, dz in faces
+            if not cubes[x + dx, y + dy, z + dz]
+        )
+
+        visited = np.zeros_like(cubes, dtype=bool)
+        queue = [(0, 0, 0)]
+
+        n_faces = 0
+        while queue:
+            x, y, z = queue.pop(0)
+
+            if visited[x, y, z]:
+                continue
+
+            visited[x, y, z] = True
+
+            for dx, dy, dz in faces:
+                nx, ny, nz = x + dx, y + dy, z + dz
+                if not all(
+                    n >= 0 and n < cubes.shape[i] for i, n in enumerate((nx, ny, nz))
+                ):
+                    continue
+
+                if visited[nx, ny, nz]:
+                    continue
+
+                if cubes[nx, ny, nz]:
+                    n_faces += 1
+                else:
+                    queue.append((nx, ny, nz))
+
+        yield n_faces

src/holt59/aoc/2022/day19.py

@@ -0,0 +1,181 @@
+from typing import Any, Iterator, Literal
+
+import numpy as np
+import parse  # pyright: ignore[reportMissingTypeStubs]
+from numpy.typing import NDArray
+
+from ..base import BaseSolver
+
+Reagent = Literal["ore", "clay", "obsidian", "geode"]
+REAGENTS: tuple[Reagent, ...] = (
+    "ore",
+    "clay",
+    "obsidian",
+    "geode",
+)
+
+IntOfReagent = dict[Reagent, int]
+
+
+class State:
+    robots: IntOfReagent
+    reagents: IntOfReagent
+
+    def __init__(
+        self,
+        robots: IntOfReagent | None = None,
+        reagents: IntOfReagent | None = None,
+    ):
+        if robots is None:
+            assert reagents is None
+            self.reagents = {reagent: 0 for reagent in REAGENTS}
+            self.robots = {reagent: 0 for reagent in REAGENTS}
+            self.robots["ore"] = 1
+        else:
+            assert robots is not None and reagents is not None
+            self.robots = robots
+            self.reagents = reagents
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, State)
+            and self.robots == other.robots
+            and self.reagents == other.reagents
+        )
+
+    def __hash__(self) -> int:
+        return hash(tuple((self.robots[r], self.reagents[r]) for r in REAGENTS))
+
+    def __str__(self) -> str:
+        return "State({}, {})".format(
+            "/".join(str(self.robots[k]) for k in REAGENTS),
+            "/".join(str(self.reagents[k]) for k in REAGENTS),
+        )
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+def dominates(lhs: State, rhs: State):
+    return all(
+        lhs.robots[r] >= rhs.robots[r] and lhs.reagents[r] >= rhs.reagents[r]
+        for r in REAGENTS
+    )
+
+
+def run(blueprint: dict[Reagent, dict[Reagent, int]], max_time: int) -> int:
+    # since we can only build one robot per time, we do not need more than X robots
+    # of type K where X is the maximum number of K required among all robots, e.g.,
+    # in the first toy blueprint, we need at most 4 ore robots, 14 clay ones and 7
+    # obsidian ones
+    maximums = {
+        name: max(blueprint[r].get(name, 0) for r in REAGENTS) for name in REAGENTS
+    }
+
+    state_after_t: dict[int, set[State]] = {0: {State()}}
+
+    for t in range(1, max_time + 1):
+        # list of new states at the end of step t that we are going to prune later
+        states_for_t: set[State] = set()
+        robots_that_can_be_built: list[Reagent]
+
+        for state in state_after_t[t - 1]:
+            robots_that_can_be_built = [
+                robot
+                for robot in REAGENTS
+                if all(
+                    state.reagents[reagent] >= blueprint[robot].get(reagent, 0)
+                    for reagent in REAGENTS
+                )
+            ]
+
+            states_for_t.add(
+                State(
+                    robots=state.robots,
+                    reagents={
+                        reagent: state.reagents[reagent] + state.robots[reagent]
+                        for reagent in REAGENTS
+                    },
+                )
+            )
+
+            if "geode" in robots_that_can_be_built:
+                robots_that_can_be_built = ["geode"]
+            else:
+                robots_that_can_be_built = [
+                    robot
+                    for robot in robots_that_can_be_built
+                    if state.robots[robot] < maximums[robot]
+                ]
+
+            for robot in robots_that_can_be_built:
+                robots = state.robots.copy()
+                robots[robot] += 1
+                reagents: IntOfReagent = {
+                    reagent: state.reagents[reagent]
+                    + state.robots[reagent]
+                    - blueprint[robot].get(reagent, 0)
+                    for reagent in REAGENTS
+                }
+                states_for_t.add(State(robots=robots, reagents=reagents))
+
+        # use numpy to switch computation of dominated states -> store each state
+        # as a 8 array and use numpy broadcasting to find dominated states
+        states_after = np.asarray(list(states_for_t))
+        np_states = np.array(
+            [
+                [state.robots[r] for r in REAGENTS]
+                + [state.reagents[r] for r in REAGENTS]
+                for state in states_after
+            ]
+        )
+
+        to_keep: list[NDArray[np.integer[Any]]] = []
+        while len(np_states) > 0:
+            first_dom = (np_states[1:] >= np_states[0]).all(axis=1).any()
+
+            if first_dom:
+                np_states = np_states[1:]
+            else:
+                to_keep.append(np_states[0])
+                np_states = np_states[1:][~(np_states[1:] <= np_states[0]).all(axis=1)]
+
+        state_after_t[t] = {
+            State(
+                robots=dict(zip(REAGENTS, row[:4])),
+                reagents=dict(zip(REAGENTS, row[4:])),
+            )
+            for row in to_keep
+        }
+
+    return max(state.reagents["geode"] for state in state_after_t[max_time])
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        blueprints: list[dict[Reagent, IntOfReagent]] = []
+        for line in input.splitlines():
+            r: list[int] = parse.parse(  # type: ignore
+                "Blueprint {}: "
+                "Each ore robot costs {:d} ore. "
+                "Each clay robot costs {:d} ore. "
+                "Each obsidian robot costs {:d} ore and {:d} clay. "
+                "Each geode robot costs {:d} ore and {:d} obsidian.",
+                line,
+            )
+
+            blueprints.append(
+                {
+                    "ore": {"ore": r[1]},
+                    "clay": {"ore": r[2]},
+                    "obsidian": {"ore": r[3], "clay": r[4]},
+                    "geode": {"ore": r[5], "obsidian": r[6]},
+                }
+            )
+
+        yield sum(
+            (i_blueprint + 1) * run(blueprint, 24)
+            for i_blueprint, blueprint in enumerate(blueprints)
+        )
+
+        yield (run(blueprints[0], 32) * run(blueprints[1], 32) * run(blueprints[2], 32))

src/holt59/aoc/2022/day2.py

@@ -0,0 +1,57 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def score_1(ux: int, vx: int) -> int:
+    # here ux and vx are both moves: 0 = rock, 1 = paper, 2 = scissor
+    #
+
+    # 1. to get the score of the move/shape, we simply add 1 -> vx + 1
+    # 2. to get the score of the outcome (loss/draw/win), we use the fact that the
+    #    winning hand is always the opponent hand (ux) + 1 in modulo-3 arithmetic:
+    #    - (ux - vx) % 3 gives us 0 for a draw, 1 for a loss and 2 for a win
+    #    - 1 - ((ux - vx) % 3) gives us -1 for a win, 0 for a loss and 1 for a draw
+    #    - (1 - ((ux - vx) % 3)) gives us 0 / 1 / 2 for loss / draw / win
+    #    - the above can be rewritten as ((1 - (ux - vx)) % 3)
+    #    we can then simply multiply this by 3 to get the outcome score
+    #
+    return (vx + 1) + ((1 - (ux - vx)) % 3) * 3
+
+
+def score_2(ux: int, vx: int) -> int:
+    # here ux is the opponent move (0 = rock, 1 = paper, 2 = scissor) and vx is the
+    # outcome (0 = loss, 1 = draw, 2 = win)
+    #
+
+    # 1. to get the score to the move/shape, we need to find it (as 0, 1 or 2) and then
+    #    add 1 to it
+    #    - (vx - 1) gives the offset from the opponent shape (-1 for a loss, 0 for a
+    #      draw and 1 for a win)
+    #    - from the offset, we can retrieve the shape by adding the opponent shape and
+    #      using modulo-3 arithmetic -> (ux + vx - 1) % 3
+    #    - we then add 1 to get the final shape score
+    # 2. to get the score of the outcome, we can simply multiply vx by 3 -> vx * 3
+    return (ux + vx - 1) % 3 + 1 + vx * 3
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        # the solution relies on replacing rock / paper / scissor by values 0 / 1 / 2 and using
+        # modulo-3 arithmetic
+        #
+        # in modulo-3 arithmetic, the winning move is 1 + the opponent move (e.g., winning move
+        # if opponent plays 0 is 1, or 0 if opponent plays 2 (0 = (2 + 1 % 3)))
+        #
+
+        # we read the lines in a Nx2 in array with value 0/1/2 instead of A/B/C or X/Y/Z for
+        # easier manipulation
+        values = [(ord(row[0]) - ord("A"), ord(row[2]) - ord("X")) for row in lines]
+
+        # part 1 - 13526
+        yield sum(score_1(*v) for v in values)
+
+        # part 2 - 14204
+        yield sum(score_2(*v) for v in values)

src/holt59/aoc/2022/day20.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Number:
+    current: int
+    value: int
+
+    def __init__(self, value: int):
+        self.current = 0
+        self.value = value
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return str(self)
+
+
+def decrypt(numbers: list[Number], key: int, rounds: int) -> int:
+    numbers = numbers.copy()
+    original = numbers.copy()
+
+    for index, number in enumerate(numbers):
+        number.current = index
+
+    for _ in range(rounds):
+        for number in original:
+            index = number.current
+            offset = (number.value * key) % (len(numbers) - 1)
+            target = index + offset
+
+            # need to wrap
+            if target >= len(numbers):
+                target = offset - (len(numbers) - index) + 1
+
+                for number_2 in numbers[target:index]:
+                    number_2.current += 1
+
+                numbers = (
+                    numbers[:target]
+                    + [number]
+                    + numbers[target:index]
+                    + numbers[index + 1 :]
+                )
+            else:
+                for number_2 in numbers[index : target + 1]:
+                    number_2.current -= 1
+
+                numbers = (
+                    numbers[:index]
+                    + numbers[index + 1 : target + 1]
+                    + [number]
+                    + numbers[target + 1 :]
+                )
+            number.current = target
+
+    index_of_0 = next(
+        filter(lambda index: numbers[index].value == 0, range(len(numbers)))
+    )
+    return sum(
+        numbers[(index_of_0 + offset) % len(numbers)].value * key
+        for offset in (1000, 2000, 3000)
+    )
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        numbers = [Number(int(x)) for x in input.splitlines()]
+
+        yield decrypt(numbers, 1, 1)
+        yield decrypt(numbers, 811589153, 10)

src/holt59/aoc/2022/day21.py

@@ -0,0 +1,108 @@
+import operator
+from typing import Any, Callable, Iterator
+
+from ..base import BaseSolver
+
+
+def compute(monkeys: dict[str, int | tuple[str, str, str]], monkey: str) -> int:
+    value = monkeys[monkey]
+    if isinstance(value, int):
+        return value
+    else:
+        op: dict[str, Callable[[int, int], int]] = {
+            "+": operator.add,
+            "-": operator.sub,
+            "*": operator.mul,
+            "/": operator.floordiv,
+        }
+        value = op[value[1]](compute(monkeys, value[0]), compute(monkeys, value[2]))
+        monkeys[monkey] = value
+        return value
+
+
+def invert(
+    monkeys: dict[str, int | tuple[str, str, str]], monkey: str, target: int
+) -> dict[str, int | tuple[str, str, str]]:
+    """
+    Revert the given mapping from monkey name to value or operation such that
+    the value from 'monkey' is computable by inverting operation until the root is
+    found.
+
+    Args:
+        monkeys: Dictionary of monkeys, that will be updated and returned.
+        monkey: Name of the monkey to start from.
+        target: Target value to set for the monkey that depends on root.
+
+    Returns:
+        The given dictionary of monkeys.
+    """
+
+    monkeys = monkeys.copy()
+
+    depends: dict[str, str] = {}
+    for m, v in monkeys.items():
+        if isinstance(v, int):
+            continue
+
+        op1, _, op2 = v
+
+        assert op1 not in depends
+        assert op2 not in depends
+        depends[op1] = m
+        depends[op2] = m
+
+    invert_op = {"+": "-", "-": "+", "*": "/", "/": "*"}
+
+    current = monkey
+    while True:
+        dep = depends[current]
+
+        if dep == "root":
+            monkeys[current] = target
+            break
+
+        val = monkeys[dep]
+        assert not isinstance(val, int)
+
+        op1, ope, op2 = val
+
+        if op1 == current:
+            monkeys[current] = (dep, invert_op[ope], op2)
+        elif ope in ("+", "*"):
+            monkeys[current] = (dep, invert_op[ope], op1)
+        else:
+            monkeys[current] = (op1, ope, dep)
+
+        current = dep
+
+    return monkeys
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        monkeys: dict[str, int | tuple[str, str, str]] = {}
+
+        op_monkeys: set[str] = set()
+
+        for line in lines:
+            parts = line.split(":")
+            name = parts[0].strip()
+
+            try:
+                value = int(parts[1].strip())
+                monkeys[name] = value
+            except ValueError:
+                op1, ope, op2 = parts[1].strip().split()
+                monkeys[name] = (op1, ope, op2)
+
+                op_monkeys.add(name)
+
+        yield compute(monkeys.copy(), "root")
+
+        # assume the second operand of 'root' can be computed, and the first one depends on
+        # humn, which is the case is my input and the test input
+        assert isinstance(monkeys["root"], tuple)
+        p1, _, p2 = monkeys["root"]  # type: ignore
+        yield compute(invert(monkeys, "humn", compute(monkeys.copy(), p2)), "humn")

src/holt59/aoc/2022/day22.py

@@ -0,0 +1,243 @@
+import re
+from typing import Any, Callable, Iterator
+
+import numpy as np
+
+from ..base import BaseSolver
+
+VOID, EMPTY, WALL = 0, 1, 2
+TILE_FROM_CHAR = {" ": VOID, ".": EMPTY, "#": WALL}
+
+SCORES = {"E": 0, "S": 1, "W": 2, "N": 3}
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        board_map_s, direction_s = input.split("\n\n")
+
+        # board
+        board_lines = board_map_s.splitlines()
+        max_line = max(len(line) for line in board_lines)
+        board = np.array(
+            [
+                [TILE_FROM_CHAR[c] for c in row] + [VOID] * (max_line - len(row))
+                for row in board_map_s.splitlines()
+            ]
+        )
+
+        directions = [
+            int(p1) if p2 else p1
+            for p1, p2 in re.findall(R"(([0-9])+|L|R)", direction_s)
+        ]
+
+        # find on each row and column the first and last non-void
+        row_first_non_void = np.argmax(board != VOID, axis=1)
+        row_last_non_void = (
+            board.shape[1] - np.argmax(board[:, ::-1] != VOID, axis=1) - 1
+        )
+        col_first_non_void = np.argmax(board != VOID, axis=0)
+        col_last_non_void = (
+            board.shape[0] - np.argmax(board[::-1, :] != VOID, axis=0) - 1
+        )
+
+        faces = np.zeros_like(board)
+        size = np.gcd(board.shape[0], board.shape[1])
+        for row in range(0, board.shape[0], size):
+            for col in range(row_first_non_void[row], row_last_non_void[row], size):
+                faces[row : row + size, col : col + size] = faces.max() + 1
+
+        SIZE = np.gcd(*board.shape)
+
+        # TODO: deduce this from the actual cube...
+        faces_wrap: dict[int, dict[str, Callable[[int, int], tuple[int, int, str]]]]
+
+        if board.shape == (12, 16):  # example
+            faces_wrap = {
+                1: {
+                    "W": lambda y, x: (4, 4 + y, "S"),  # 3N
+                    "N": lambda y, x: (4, 11 - x, "S"),  # 2N
+                    "E": lambda y, x: (11 - y, 15, "W"),  # 6E
+                },
+                2: {
+                    "W": lambda y, x: (11, 19 - y, "N"),  # 6S
+                    "N": lambda y, x: (0, 11 - y, "S"),  # 1N
+                    "S": lambda y, x: (11, 11 - x, "N"),  # 5S
+                },
+                3: {
+                    "N": lambda y, x: (x - 4, 8, "E"),  # 1W
+                    "S": lambda y, x: (15 - x, 8, "E"),  # 5W
+                },
+                4: {"E": lambda y, x: (8, 19 - y, "S")},  # 6N
+                5: {
+                    "W": lambda y, x: (7, 15 - y, "N"),  # 3S
+                    "S": lambda y, x: (7, 11 - x, "N"),  # 2S
+                },
+                6: {
+                    "N": lambda y, x: (19 - x, 11, "W"),  # 4E
+                    "E": lambda y, x: (11 - y, 11, "W"),  # 1E
+                    "S": lambda y, x: (19 - x, 0, "E"),  # 2W
+                },
+            }
+
+        else:
+            faces_wrap = {
+                1: {
+                    "W": lambda y, x: (3 * SIZE - y - 1, 0, "E"),  # 4W
+                    "N": lambda y, x: (2 * SIZE + x, 0, "E"),  # 6W
+                },
+                2: {
+                    "N": lambda y, x: (4 * SIZE - 1, x - 2 * SIZE, "N"),  # 6S
+                    "E": lambda y, x: (3 * SIZE - y - 1, 2 * SIZE - 1, "W"),  # 5E
+                    "S": lambda y, x: (x - SIZE, 2 * SIZE - 1, "W"),  # 3E
+                },
+                3: {
+                    "W": lambda y, x: (2 * SIZE, y - SIZE, "S"),  # 4N
+                    "E": lambda y, x: (SIZE - 1, SIZE + y, "N"),  # 2S
+                },
+                4: {
+                    "W": lambda y, x: (3 * SIZE - y - 1, SIZE, "E"),  # 1W
+                    "N": lambda y, x: (SIZE + x, SIZE, "E"),  # 3W
+                },
+                5: {
+                    "E": lambda y, x: (3 * SIZE - y - 1, 3 * SIZE - 1, "W"),  # 2E
+                    "S": lambda y, x: (2 * SIZE + x, SIZE - 1, "W"),  # 6E
+                },
+                6: {
+                    "W": lambda y, x: (0, y - 2 * SIZE, "S"),  # 1N
+                    "E": lambda y, x: (3 * SIZE - 1, y - 2 * SIZE, "N"),  # 5S
+                    "S": lambda y, x: (0, x + 2 * SIZE, "S"),  # 2N
+                },
+            }
+
+        def wrap_part_1(y0: int, x0: int, r0: str) -> tuple[int, int, str]:
+            if r0 == "E":
+                return y0, row_first_non_void[y0], r0
+            elif r0 == "S":
+                return col_first_non_void[x0], x0, r0
+            elif r0 == "W":
+                return y0, row_last_non_void[y0], r0
+            elif r0 == "N":
+                return col_last_non_void[x0], x0, r0
+
+            assert False
+
+        def wrap_part_2(y0: int, x0: int, r0: str) -> tuple[int, int, str]:
+            cube = faces[y0, x0]
+            assert r0 in faces_wrap[cube]
+            return faces_wrap[cube][r0](y0, x0)
+
+        def run(
+            wrap: Callable[[int, int, str], tuple[int, int, str]],
+        ) -> tuple[int, int, str]:
+            y0 = 0
+            x0 = np.where(board[0] == EMPTY)[0][0]
+            r0 = "E"
+
+            for direction in directions:
+                if isinstance(direction, int):
+                    while direction > 0:
+                        if r0 == "E":
+                            xi = np.where(
+                                board[y0, x0 + 1 : x0 + direction + 1] == WALL
+                            )[0]
+                            if len(xi):
+                                x0 = x0 + xi[0]
+                                direction = 0
+                            elif (
+                                x0 + direction < board.shape[1]
+                                and board[y0, x0 + direction] == EMPTY
+                            ):
+                                x0 = x0 + direction
+                                direction = 0
+                            else:
+                                y0_t, x0_t, r0_t = wrap(y0, x0, r0)
+                                if board[y0_t, x0_t] == WALL:
+                                    x0 = row_last_non_void[y0]
+                                    direction = 0
+                                else:
+                                    direction = (
+                                        direction - (row_last_non_void[y0] - x0) - 1
+                                    )
+                                    y0, x0, r0 = y0_t, x0_t, r0_t
+                        elif r0 == "S":
+                            yi = np.where(
+                                board[y0 + 1 : y0 + direction + 1, x0] == WALL
+                            )[0]
+                            if len(yi):
+                                y0 = y0 + yi[0]
+                                direction = 0
+                            elif (
+                                y0 + direction < board.shape[0]
+                                and board[y0 + direction, x0] == EMPTY
+                            ):
+                                y0 = y0 + direction
+                                direction = 0
+                            else:
+                                y0_t, x0_t, r0_t = wrap(y0, x0, r0)
+                                if board[y0_t, x0_t] == WALL:
+                                    y0 = col_last_non_void[x0]
+                                    direction = 0
+                                else:
+                                    direction = (
+                                        direction - (col_last_non_void[x0] - y0) - 1
+                                    )
+                                    y0, x0, r0 = y0_t, x0_t, r0_t
+                        elif r0 == "W":
+                            left = max(x0 - direction - 1, 0)
+                            xi = np.where(board[y0, left:x0] == WALL)[0]
+                            if len(xi):
+                                x0 = left + xi[-1] + 1
+                                direction = 0
+                            elif (
+                                x0 - direction >= 0
+                                and board[y0, x0 - direction] == EMPTY
+                            ):
+                                x0 = x0 - direction
+                                direction = 0
+                            else:
+                                y0_t, x0_t, r0_t = wrap(y0, x0, r0)
+                                if board[y0_t, x0_t] == WALL:
+                                    x0 = row_first_non_void[y0]
+                                    direction = 0
+                                else:
+                                    direction = (
+                                        direction - (x0 - row_first_non_void[y0]) - 1
+                                    )
+                                    y0, x0, r0 = y0_t, x0_t, r0_t
+                        elif r0 == "N":
+                            top = max(y0 - direction - 1, 0)
+                            yi = np.where(board[top:y0, x0] == WALL)[0]
+                            if len(yi):
+                                y0 = top + yi[-1] + 1
+                                direction = 0
+                            elif (
+                                y0 - direction >= 0
+                                and board[y0 - direction, x0] == EMPTY
+                            ):
+                                y0 = y0 - direction
+                                direction = 0
+                            else:
+                                y0_t, x0_t, r0_t = wrap(y0, x0, r0)
+                                if board[y0_t, x0_t] == WALL:
+                                    y0 = col_first_non_void[x0]
+                                    direction = 0
+                                else:
+                                    direction = (
+                                        direction - (y0 - col_first_non_void[x0]) - 1
+                                    )
+                                    y0, x0, r0 = y0_t, x0_t, r0_t
+                else:
+                    r0 = {
+                        "E": {"L": "N", "R": "S"},
+                        "N": {"L": "W", "R": "E"},
+                        "W": {"L": "S", "R": "N"},
+                        "S": {"L": "E", "R": "W"},
+                    }[r0][direction]
+
+            return y0, x0, r0
+
+        y1, x1, r1 = run(wrap_part_1)
+        yield 1000 * (1 + y1) + 4 * (1 + x1) + SCORES[r1]
+
+        y2, x2, r2 = run(wrap_part_2)
+        yield 1000 * (1 + y2) + 4 * (1 + x2) + SCORES[r2]

src/holt59/aoc/2022/day23.py

@@ -0,0 +1,108 @@
+import itertools
+from collections import defaultdict
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+Directions = list[
+    tuple[
+        str, tuple[int, int], tuple[tuple[int, int], tuple[int, int], tuple[int, int]]
+    ]
+]
+
+# (Y, X)
+DIRECTIONS: Directions = [
+    ("N", (-1, 0), ((-1, -1), (-1, 0), (-1, 1))),
+    ("S", (1, 0), ((1, -1), (1, 0), (1, 1))),
+    ("W", (0, -1), ((-1, -1), (0, -1), (1, -1))),
+    ("E", (0, 1), ((-1, 1), (0, 1), (1, 1))),
+]
+
+
+def min_max_yx(positions: set[tuple[int, int]]) -> tuple[int, int, int, int]:
+    ys, xs = {y for y, _x in positions}, {x for _y, x in positions}
+    return min(ys), min(xs), max(ys), max(xs)
+
+
+def print_positions(positions: set[tuple[int, int]]):
+    min_y, min_x, max_y, max_x = min_max_yx(positions)
+    print(
+        "\n".join(
+            "".join(
+                "#" if (y, x) in positions else "." for x in range(min_x - 1, max_x + 2)
+            )
+            for y in range(min_y - 1, max_y + 2)
+        )
+    )
+
+
+def round(
+    positions: set[tuple[int, int]],
+    directions: Directions,
+):
+    to_move: dict[tuple[int, int], list[tuple[int, int]]] = defaultdict(lambda: [])
+    for y, x in positions:
+        elves = {
+            (dy, dx): (y + dy, x + dx) in positions
+            for dy, dx in itertools.product((-1, 0, 1), (-1, 0, 1))
+            if (dy, dx) != (0, 0)
+        }
+
+        if not any(elves.values()):
+            to_move[y, x].append((y, x))
+            continue
+
+        found: str | None = None
+        for d, (dy, dx), d_yx_check in directions:
+            if not any(elves[dy, dx] for dy, dx in d_yx_check):
+                found = d
+                to_move[y + dy, x + dx].append((y, x))
+                break
+        if found is None:
+            to_move[y, x].append((y, x))
+
+    positions.clear()
+    for ty, tx in to_move:
+        if len(to_move[ty, tx]) > 1:
+            positions.update(to_move[ty, tx])
+        else:
+            positions.add((ty, tx))
+
+    directions.append(directions.pop(0))
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        POSITIONS = {
+            (i, j)
+            for i, row in enumerate(input.splitlines())
+            for j, col in enumerate(row)
+            if col == "#"
+        }
+
+        # === part 1 ===
+
+        p1, d1 = POSITIONS.copy(), DIRECTIONS.copy()
+        for _ in range(10):
+            round(p1, d1)
+
+        min_y, min_x, max_y, max_x = min_max_yx(p1)
+        yield sum(
+            (y, x) not in p1
+            for y in range(min_y, max_y + 1)
+            for x in range(min_x, max_x + 1)
+        )
+
+        # === part 2 ===
+
+        p2, d2 = POSITIONS.copy(), DIRECTIONS.copy()
+        answer_2 = 0
+        while True:
+            answer_2 += 1
+            backup = p2.copy()
+            round(p2, d2)
+
+            if backup == p2:
+                break
+
+        yield answer_2

src/holt59/aoc/2022/day24.py

@@ -0,0 +1,117 @@
+import heapq
+import math
+from collections import defaultdict
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        winds = {
+            (i - 1, j - 1, lines[i][j])
+            for i in range(1, len(lines) - 1)
+            for j in range(1, len(lines[i]) - 1)
+            if lines[i][j] != "."
+        }
+
+        n_rows, n_cols = len(lines) - 2, len(lines[0]) - 2
+        CYCLE = math.lcm(n_rows, n_cols)
+
+        east_winds = [
+            {j for j in range(n_cols) if (i, j, ">") in winds} for i in range(n_rows)
+        ]
+        west_winds = [
+            {j for j in range(n_cols) if (i, j, "<") in winds} for i in range(n_rows)
+        ]
+        north_winds = [
+            {i for i in range(n_rows) if (i, j, "^") in winds} for j in range(n_cols)
+        ]
+        south_winds = [
+            {i for i in range(n_rows) if (i, j, "v") in winds} for j in range(n_cols)
+        ]
+
+        def run(start: tuple[int, int], start_cycle: int, end: tuple[int, int]):
+            def heuristic(y: int, x: int) -> int:
+                return abs(end[0] - y) + abs(end[1] - x)
+
+            # (distance + heuristic, distance, (start_pos, cycle))
+            queue = [
+                (heuristic(start[0], start[1]), 0, ((start[0], start[1]), start_cycle))
+            ]
+            visited: set[tuple[tuple[int, int], int]] = set()
+            distances: dict[tuple[int, int], dict[int, int]] = defaultdict(lambda: {})
+
+            while queue:
+                _, distance, ((y, x), cycle) = heapq.heappop(queue)
+
+                if ((y, x), cycle) in visited:
+                    continue
+
+                distances[y, x][cycle] = distance
+
+                visited.add(((y, x), cycle))
+
+                if (y, x) == (end[0], end[1]):
+                    break
+
+                for dy, dx in (0, 0), (-1, 0), (1, 0), (0, -1), (0, 1):
+                    ty = y + dy
+                    tx = x + dx
+
+                    n_cycle = (cycle + 1) % CYCLE
+
+                    if (ty, tx) == end:
+                        heapq.heappush(
+                            queue, (distance + 1, distance + 1, ((ty, tx), n_cycle))
+                        )
+                        break
+
+                    if ((ty, tx), n_cycle) in visited:
+                        continue
+
+                    if (ty, tx) != start and (
+                        ty < 0 or tx < 0 or ty >= n_rows or tx >= n_cols
+                    ):
+                        continue
+
+                    if (ty, tx) != start:
+                        if (ty - n_cycle) % n_rows in south_winds[tx]:
+                            continue
+                        if (ty + n_cycle) % n_rows in north_winds[tx]:
+                            continue
+                        if (tx + n_cycle) % n_cols in west_winds[ty]:
+                            continue
+                        if (tx - n_cycle) % n_cols in east_winds[ty]:
+                            continue
+
+                    heapq.heappush(
+                        queue,
+                        (
+                            (
+                                heuristic(ty, tx) + distance + 1,
+                                distance + 1,
+                                ((ty, tx), n_cycle),
+                            )
+                        ),
+                    )
+
+            return distances, next(iter(distances[end].values()))
+
+        start = (
+            -1,
+            next(j for j in range(1, len(lines[0]) - 1) if lines[0][j] == ".") - 1,
+        )
+        end = (
+            n_rows,
+            next(j for j in range(1, len(lines[-1]) - 1) if lines[-1][j] == ".") - 1,
+        )
+
+        distances_1, forward_1 = run(start, 0, end)
+        yield forward_1
+
+        distances_2, return_1 = run(end, next(iter(distances_1[end].keys())), start)
+        _distances_3, forward_2 = run(start, next(iter(distances_2[start].keys())), end)
+        yield forward_1 + return_1 + forward_2

src/holt59/aoc/2022/day25.py

@@ -0,0 +1,28 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        coeffs = {"2": 2, "1": 1, "0": 0, "-": -1, "=": -2}
+
+        def snafu2number(number: str) -> int:
+            value = 0
+            for c in number:
+                value *= 5
+                value += coeffs[c]
+            return value
+
+        def number2snafu(number: int) -> str:
+            values = ["0", "1", "2", "=", "-"]
+            res = ""
+            while number > 0:
+                mod = number % 5
+                res = res + values[mod]
+                number = number // 5 + int(mod >= 3)
+            return "".join(reversed(res))
+
+        yield number2snafu(sum(map(snafu2number, lines)))

src/holt59/aoc/2022/day3.py

@@ -0,0 +1,28 @@
+import string
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        # extract content of each part
+        parts = [
+            (set(line[: len(line) // 2]), set(line[len(line) // 2 :])) for line in lines
+        ]
+
+        # priorities
+        priorities = {c: i + 1 for i, c in enumerate(string.ascii_letters)}
+
+        # part 1
+        yield sum(priorities[c] for p1, p2 in parts for c in p1.intersection(p2))
+
+        # part 2
+        n_per_group = 3
+        yield sum(
+            priorities[c]
+            for i in range(0, len(lines), n_per_group)
+            for c in set(lines[i]).intersection(*lines[i + 1 : i + n_per_group])
+        )

src/holt59/aoc/2022/day4.py

@@ -0,0 +1,20 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def make_range(value: str) -> set[int]:
+    parts = value.split("-")
+    return set(range(int(parts[0]), int(parts[1]) + 1))
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        sections = [
+            tuple(make_range(part) for part in line.split(",")) for line in lines
+        ]
+
+        yield sum(s1.issubset(s2) or s2.issubset(s1) for s1, s2 in sections)
+        yield sum(bool(s1.intersection(s2)) for s1, s2 in sections)

src/holt59/aoc/2022/day5.py

@@ -0,0 +1,43 @@
+import copy
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        blocks_s, moves_s = (part.splitlines() for part in input.split("\n\n"))
+
+        blocks: dict[str, list[str]] = {stack: [] for stack in blocks_s[-1].split()}
+
+        # this codes assumes that the lines are regular, i.e., 4 characters per "crate" in the
+        # form of '[X] ' (including the trailing space)
+        #
+        for block in blocks_s[-2::-1]:
+            for stack, index in zip(blocks, range(0, len(block), 4)):
+                crate = block[index + 1 : index + 2].strip()
+
+                if crate:
+                    blocks[stack].append(crate)
+
+        # part 1 - deep copy for part 2
+        blocks_1 = copy.deepcopy(blocks)
+
+        for move in moves_s:
+            _, count_s, _, from_, _, to_ = move.strip().split()
+
+            for _i in range(int(count_s)):
+                blocks_1[to_].append(blocks_1[from_].pop())
+
+        # part 2
+        blocks_2 = copy.deepcopy(blocks)
+
+        for move in moves_s:
+            _, count_s, _, from_, _, to_ = move.strip().split()
+            count = int(count_s)
+
+            blocks_2[to_].extend(blocks_2[from_][-count:])
+            del blocks_2[from_][-count:]
+
+        yield "".join(s[-1] for s in blocks_1.values())
+        yield "".join(s[-1] for s in blocks_2.values())

src/holt59/aoc/2022/day6.py

@@ -0,0 +1,16 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def index_of_first_n_differents(data: str, n: int) -> int:
+    for i in range(len(data)):
+        if len(set(data[i : i + n])) == n:
+            return i + n
+    return -1
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        yield index_of_first_n_differents(input, 4)
+        yield index_of_first_n_differents(input, 14)

src/holt59/aoc/2022/day7.py

@@ -0,0 +1,81 @@
+from pathlib import Path
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        # we are going to use Path to create path and go up/down in the file tree since it
+        # implements everything we need
+        #
+        # we can use .resolve() to get normalized path, although this will add C:\ to all paths
+        # on Windows but that is not an issue since only the sizes matter
+        #
+
+        # mapping from path to list of files or directories
+        trees: dict[Path, list[Path]] = {}
+
+        # mapping from paths to either size (for file) or -1 for directory
+        sizes: dict[Path, int] = {}
+
+        # first line must be a cd otherwise we have no idea where we are
+        assert lines[0].startswith("$ cd")
+        base_path = Path(lines[0].strip("$").split()[1]).resolve()
+        cur_path = base_path
+
+        trees[cur_path] = []
+        sizes[cur_path] = -1
+
+        for line in lines[1:]:
+            # command
+            if line.startswith("$"):
+                parts = line.strip("$").strip().split()
+                command = parts[0]
+
+                if command == "cd":
+                    cur_path = cur_path.joinpath(parts[1]).resolve()
+
+                    # just initialize the lis of files if not already done
+                    if cur_path not in trees:
+                        trees[cur_path] = []
+                else:
+                    # nothing to do here
+                    pass
+
+            # fill the current path
+            else:
+                parts = line.split()
+                name: str = parts[1]
+                if line.startswith("dir"):
+                    size = -1
+                else:
+                    size = int(parts[0])
+
+                path = cur_path.joinpath(name)
+                trees[cur_path].append(path)
+                sizes[path] = size
+
+        def compute_size(path: Path) -> int:
+            size = sizes[path]
+
+            if size >= 0:
+                return size
+
+            return sum(compute_size(sub) for sub in trees[path])
+
+        acc_sizes = {path: compute_size(path) for path in trees}
+
+        # part 1
+        yield sum(size for size in acc_sizes.values() if size <= 100_000)
+
+        # part 2
+        total_space = 70_000_000
+        update_space = 30_000_000
+        free_space = total_space - acc_sizes[base_path]
+
+        to_free_space = update_space - free_space
+
+        yield min(size for size in acc_sizes.values() if size >= to_free_space)

src/holt59/aoc/2022/day8.py

@@ -0,0 +1,54 @@
+from typing import Any, Iterator
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        trees = np.array([[int(x) for x in row] for row in lines])
+
+        # answer 1
+        highest_trees = np.ones(trees.shape + (4,), dtype=int) * -1
+        highest_trees[1:-1, 1:-1] = [
+            [
+                [
+                    trees[:i, j].max(),
+                    trees[i + 1 :, j].max(),
+                    trees[i, :j].max(),
+                    trees[i, j + 1 :].max(),
+                ]
+                for j in range(1, trees.shape[1] - 1)
+            ]
+            for i in range(1, trees.shape[0] - 1)
+        ]
+
+        yield (highest_trees.min(axis=2) < trees).sum()
+
+        def viewing_distance(row_of_trees: NDArray[np.int_], value: int) -> int:
+            w = np.where(row_of_trees >= value)[0]
+
+            if not w.size:
+                return len(row_of_trees)
+
+            return w[0] + 1
+
+        # answer 2
+        v_distances = np.zeros(trees.shape + (4,), dtype=int)
+        v_distances[1:-1, 1:-1, :] = [
+            [
+                [
+                    viewing_distance(trees[i - 1 :: -1, j], trees[i, j]),
+                    viewing_distance(trees[i, j - 1 :: -1], trees[i, j]),
+                    viewing_distance(trees[i, j + 1 :], trees[i, j]),
+                    viewing_distance(trees[i + 1 :, j], trees[i, j]),
+                ]
+                for j in range(1, trees.shape[1] - 1)
+            ]
+            for i in range(1, trees.shape[0] - 1)
+        ]
+        yield np.prod(v_distances, axis=2).max()

src/holt59/aoc/2022/day9.py

@@ -0,0 +1,59 @@
+import itertools as it
+from typing import Any, Iterator
+
+import numpy as np
+
+from ..base import BaseSolver
+
+
+def move(head: tuple[int, int], command: str) -> tuple[int, int]:
+    h_col, h_row = head
+
+    if command == "L":
+        head = (h_col - 1, h_row)
+    elif command == "R":
+        head = (h_col + 1, h_row)
+    elif command == "U":
+        head = (h_col, h_row + 1)
+    elif command == "D":
+        head = (h_col, h_row - 1)
+
+    return head
+
+
+def follow(head: tuple[int, int], tail: tuple[int, int]) -> tuple[int, int]:
+    h_col, h_row = head
+    t_col, t_row = tail
+
+    if abs(t_col - h_col) <= 1 and abs(t_row - h_row) <= 1:
+        return tail
+
+    return t_col + np.sign(h_col - t_col), t_row + np.sign(h_row - t_row)
+
+
+def run(commands: list[str], n_blocks: int) -> list[tuple[int, int]]:
+    blocks: list[tuple[int, int]] = [(0, 0) for _ in range(n_blocks)]
+    visited = [blocks[-1]]
+
+    for command in commands:
+        blocks[0] = move(blocks[0], command)
+
+        for i in range(0, n_blocks - 1):
+            blocks[i + 1] = follow(blocks[i], blocks[i + 1])
+
+        visited.append(blocks[-1])
+
+    return visited
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
+
+        # flatten the commands
+        commands = list(
+            it.chain(*(p[0] * int(p[1]) for line in lines if (p := line.split())))
+        )
+
+        yield len(set(run(commands, n_blocks=2)))
+        yield len(set(run(commands, n_blocks=10)))

src/holt59/aoc/2023/day1.py

@@ -0,0 +1,49 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def find_values(lines: list[str], lookups: dict[str, int]) -> list[int]:
+    values: list[int] = []
+
+    for line in filter(bool, lines):
+        first_digit = min(
+            lookups,
+            key=lambda lookup: index
+            if (index := line.find(lookup)) >= 0
+            else len(line),
+        )
+        last_digit = max(
+            lookups,
+            key=lambda lookup: index if (index := line.rfind(lookup)) >= 0 else -1,
+        )
+
+        values.append(10 * lookups[first_digit] + lookups[last_digit])
+
+    return values
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lookups_1 = {str(d): d for d in range(1, 10)}
+        lookups_2 = lookups_1 | {
+            d: i + 1
+            for i, d in enumerate(
+                (
+                    "one",
+                    "two",
+                    "three",
+                    "four",
+                    "five",
+                    "six",
+                    "seven",
+                    "eight",
+                    "nine",
+                )
+            )
+        }
+
+        lines = input.splitlines()
+
+        yield sum(find_values(lines, lookups_1))
+        yield sum(find_values(lines, lookups_2))

src/holt59/aoc/2023/day10.py

@@ -0,0 +1,100 @@
+from typing import Any, Iterator, Literal, cast
+
+from ..base import BaseSolver
+
+Symbol = Literal["|", "-", "L", "J", "7", "F", ".", "S"]
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines: list[list[Symbol]] = [
+            [cast(Symbol, symbol) for symbol in line] for line in input.splitlines()
+        ]
+
+        # find starting point
+        si, sj = next(
+            (i, j)
+            for i in range(len(lines))
+            for j in range(len(lines[0]))
+            if lines[i][j] == "S"
+        )
+
+        # find one of the two outputs
+        ni, nj = si, sj
+        for ni, nj, chars in (
+            (si - 1, sj, "|7F"),
+            (si + 1, sj, "|LJ"),
+            (si, sj - 1, "-LF"),
+            (si, sj + 1, "-J7"),
+        ):
+            if lines[ni][nj] in chars:
+                break
+
+        # part 1 - find the loop (re-used in part 2)
+        loop = [(si, sj), (ni, nj)]
+        while True:
+            pi, pj = loop[-2]
+            i, j = loop[-1]
+
+            sym = lines[i][j]
+
+            if sym == "|" and pi > i or sym in "JL" and pi == i:
+                i -= 1
+            elif sym == "|" and pi < i or sym in "7F" and pi == i:
+                i += 1
+            elif sym == "-" and pj > j or sym in "J7" and pj == j:
+                j -= 1
+            elif sym == "-" and pj < j or sym in "LF" and pj == j:
+                j += 1
+
+            if (i, j) == (si, sj):
+                break
+
+            loop.append((i, j))
+
+        yield len(loop) // 2
+
+        # part 2
+
+        # replace S by an appropriate character for the loop below
+        di1, dj1 = loop[1][0] - loop[0][0], loop[1][1] - loop[0][1]
+        di2, dj2 = loop[0][0] - loop[-1][0], loop[0][1] - loop[-1][1]
+        mapping: dict[tuple[int, int], dict[tuple[int, int], Symbol]] = {
+            (0, 1): {(0, 1): "-", (-1, 0): "F", (1, 0): "L"},
+            (0, -1): {(0, -1): "-", (-1, 0): "7", (1, 0): "J"},
+            (1, 0): {(1, 0): "|", (0, 1): "7", (0, -1): "F"},
+            (-1, 0): {(-1, 0): "|", (0, -1): "L", (0, 1): "J"},
+        }
+        lines[si][sj] = mapping[di1, dj1][di2, dj2]
+
+        # find the points inside the loop using an adaptation of ray casting for a discrete
+        # grid (https://stackoverflow.com/a/218081/2666289)
+        #
+        # use a set for faster '... in loop' check
+        #
+        loop_s = set(loop)
+        inside: set[tuple[int, int]] = set()
+        for i in range(len(lines)):
+            cnt = 0
+            for j in range(len(lines[0])):
+                if (i, j) not in loop_s and cnt % 2 == 1:
+                    inside.add((i, j))
+
+                if (i, j) in loop_s and lines[i][j] in "|LJ":
+                    cnt += 1
+
+        if self.verbose:
+            for i in range(len(lines)):
+                s = ""
+                for j in range(len(lines[0])):
+                    if (i, j) == (si, sj):
+                        s += "\033[91mS\033[0m"
+                    elif (i, j) in loop:
+                        s += lines[i][j]
+                    elif (i, j) in inside:
+                        s += "\033[92mI\033[0m"
+                    else:
+                        s += "."
+                self.logger.info(s)
+
+        yield len(inside)

src/holt59/aoc/2023/day11.py

@@ -0,0 +1,42 @@
+from typing import Any, Iterator
+
+import numpy as np
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        data = np.array([[c == "#" for c in line] for line in lines])
+
+        rows = {c for c in range(data.shape[0]) if not data[c, :].any()}
+        columns = {c for c in range(data.shape[1]) if not data[:, c].any()}
+
+        galaxies_y, galaxies_x = np.where(data)  # type: ignore
+
+        def compute_total_distance(expansion: int) -> int:
+            distances: list[int] = []
+            for g1 in range(len(galaxies_y)):
+                x1, y1 = int(galaxies_x[g1]), int(galaxies_y[g1])
+                for g2 in range(g1 + 1, len(galaxies_y)):
+                    x2, y2 = int(galaxies_x[g2]), int(galaxies_y[g2])
+
+                    dx = sum(
+                        1 + (expansion - 1) * (x in columns)
+                        for x in range(min(x1, x2), max(x1, x2))
+                    )
+                    dy = sum(
+                        1 + (expansion - 1) * (y in rows)
+                        for y in range(min(y1, y2), max(y1, y2))
+                    )
+
+                    distances.append(dx + dy)
+            return sum(distances)
+
+        # part 1
+        yield compute_total_distance(2)
+
+        # part 2
+        yield compute_total_distance(1000000)

src/holt59/aoc/2023/day12.py

@@ -0,0 +1,103 @@
+from functools import lru_cache
+from typing import Any, Iterable, Iterator
+
+from ..base import BaseSolver
+
+
+@lru_cache
+def compute_fitting_arrangements(pattern: str, counts: tuple[int, ...]) -> int:
+    """
+    fn3p tries to fit ALL values in counts() inside the pattern.
+    """
+    # no pattern -> ok if nothing to fit, otherwise ko
+    if not pattern:
+        count = 1 if not counts else 0
+
+    # no count -> ok if pattern has no mandatory entry, else ko
+    elif not counts:
+        count = 1 if pattern.find("#") == -1 else 0
+
+    # cannot fit all values -> ko
+    elif len(pattern) < sum(counts) + len(counts) - 1:
+        count = 0
+
+    elif len(pattern) < counts[0]:
+        count = 0
+
+    else:
+        count = 0
+
+        if pattern[0] == "?":
+            count += compute_fitting_arrangements(pattern[1:], counts)
+
+        if len(pattern) == counts[0]:
+            count += 1
+
+        elif pattern[counts[0]] != "#":
+            count += compute_fitting_arrangements(pattern[counts[0] + 1 :], counts[1:])
+
+    return count
+
+
+@lru_cache
+def compute_possible_arrangements(
+    patterns: tuple[str, ...], counts: tuple[int, ...]
+) -> int:
+    if not patterns:
+        return 1 if not counts else 0
+
+    with_hash = sum(1 for p in patterns[1:] if p.find("#") >= 0)
+
+    if with_hash > len(counts):
+        return 0
+
+    to_fit = counts if with_hash == 0 else counts[:-with_hash]
+    remaining = () if with_hash == 0 else counts[-with_hash:]
+
+    if not to_fit:
+        if patterns[0].find("#") != -1:
+            return 0
+        return compute_possible_arrangements(patterns[1:], remaining)
+
+    elif patterns[0].find("#") != -1 and len(patterns[0]) < to_fit[0]:
+        return 0
+
+    elif patterns[0].find("?") == -1:
+        if len(patterns[0]) != to_fit[0]:
+            return 0
+        return compute_possible_arrangements(patterns[1:], counts[1:])
+
+    else:
+        return sum(
+            fp * compute_possible_arrangements(patterns[1:], to_fit[i:] + remaining)
+            for i in range(len(to_fit) + 1)
+            if (fp := compute_fitting_arrangements(patterns[0], to_fit[:i])) > 0
+        )
+
+
+class Solver(BaseSolver):
+    def compute_all_possible_arrangements(
+        self, lines: Iterable[str], repeat: int
+    ) -> int:
+        count = 0
+
+        for i_line, line in enumerate(lines):
+            self.logger.info(f"processing line {i_line}: {line}...")
+            parts = line.split(" ")
+            count += compute_possible_arrangements(
+                tuple(
+                    filter(len, "?".join(parts[0] for _ in range(repeat)).split("."))
+                ),
+                tuple(int(c) for c in parts[1].split(",")) * repeat,
+            )
+
+        return count
+
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        # part 1
+        yield self.compute_all_possible_arrangements(lines, 1)
+
+        # part 2
+        yield self.compute_all_possible_arrangements(lines, 5)

src/holt59/aoc/2023/day13.py

@@ -0,0 +1,43 @@
+from typing import Any, Callable, Iterator, Literal
+
+from ..base import BaseSolver
+
+
+def split(block: list[str], axis: Literal[0, 1], count: int) -> int:
+    n_iter = len(block) if axis == 0 else len(block[0])
+    n_check = len(block) if axis == 1 else len(block[0])
+
+    at: Callable[[int, int], str] = (
+        (lambda i, j: block[i][j]) if axis == 0 else (lambda i, j: block[j][i])
+    )
+
+    for i in range(n_iter - 1):
+        size = min(i + 1, n_iter - i - 1)
+        if (
+            sum(
+                at(i - s, j) != at(i + 1 + s, j)
+                for s in range(0, size)
+                for j in range(n_check)
+            )
+            == count
+        ):
+            return i + 1
+
+    return 0
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        blocks = [block.splitlines() for block in input.split("\n\n")]
+
+        # part 1
+        yield sum(
+            split(block, axis=1, count=0) + 100 * split(block, axis=0, count=0)
+            for block in blocks
+        )
+
+        # part 2
+        yield sum(
+            split(block, axis=1, count=1) + 100 * split(block, axis=0, count=1)
+            for block in blocks
+        )

src/holt59/aoc/2023/day14.py

@@ -0,0 +1,70 @@
+from typing import Any, Iterator, TypeAlias
+
+from ..base import BaseSolver
+
+RockGrid: TypeAlias = list[list[str]]
+
+
+def slide_rocks_top(rocks: RockGrid) -> RockGrid:
+    top = [0 if c == "." else 1 for c in rocks[0]]
+    for row in range(1, len(rocks)):
+        for col in range(len(rocks[0])):
+            match rocks[row][col]:
+                case "O":
+                    if top[col] != row:
+                        rocks[top[col]][col] = "O"
+                        rocks[row][col] = "."
+                    top[col] = top[col] + 1
+                case "#":
+                    top[col] = row + 1
+                case _:
+                    pass
+    return rocks
+
+
+def cycle(rocks: RockGrid) -> RockGrid:
+    for _ in range(4):
+        rocks = slide_rocks_top(rocks)
+        rocks = [
+            [rocks[len(rocks) - j - 1][i] for j in range(len(rocks))]
+            for i in range(len(rocks[0]))
+        ]
+
+    return rocks
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        rocks0 = [list(line) for line in input.splitlines()]
+
+        rocks = slide_rocks_top([[c for c in r] for r in rocks0])
+
+        # part 1
+        yield sum(
+            (len(rocks) - i) * sum(1 for c in row if c == "O")
+            for i, row in enumerate(rocks)
+        )
+
+        # part 2
+        rocks = rocks0
+
+        N = 1000000000
+        cycles: list[RockGrid] = []
+        i_cycle: int = -1
+        for i_cycle in range(N):
+            rocks = cycle(rocks)
+
+            if any(rocks == c for c in cycles):
+                break
+
+            cycles.append([[c for c in r] for r in rocks])
+
+        cycle_start = next(i for i in range(len(cycles)) if (rocks == cycles[i]))
+        cycle_length = i_cycle - cycle_start
+
+        ci = cycle_start + (N - cycle_start) % cycle_length - 1
+
+        yield sum(
+            (len(rocks) - i) * sum(1 for c in row if c == "O")
+            for i, row in enumerate(cycles[ci])
+        )

src/holt59/aoc/2023/day15.py

@@ -0,0 +1,33 @@
+from functools import reduce
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def _hash(s: str) -> int:
+    return reduce(lambda v, u: ((v + ord(u)) * 17) % 256, s, 0)
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        steps = input.split(",")
+
+        # part 1
+        yield sum(map(_hash, steps))
+
+        # part 2
+        boxes: list[dict[str, int]] = [{} for _ in range(256)]
+
+        for step in steps:
+            if (i := step.find("=")) >= 0:
+                label, length = step[:i], int(step[i + 1 :])
+                boxes[_hash(label)][label] = length
+            else:
+                label = step[:-1]
+                boxes[_hash(label)].pop(label, None)
+
+        yield sum(
+            i_box * i_lens * length
+            for i_box, box in enumerate(boxes, start=1)
+            for i_lens, length in enumerate(box.values(), start=1)
+        )

src/holt59/aoc/2023/day16.py

@@ -0,0 +1,108 @@
+from typing import Any, Iterator, Literal, TypeAlias, cast
+
+from ..base import BaseSolver
+
+CellType: TypeAlias = Literal[".", "|", "-", "\\", "/"]
+Direction: TypeAlias = Literal["R", "L", "U", "D"]
+
+Mappings: dict[
+    CellType,
+    dict[
+        Direction,
+        tuple[tuple[tuple[int, int, Direction], ...], tuple[Direction, ...]],
+    ],
+] = {
+    ".": {
+        "R": (((0, +1, "R"),), ("R", "L")),
+        "L": (((0, -1, "L"),), ("R", "L")),
+        "U": (((-1, 0, "U"),), ("U", "D")),
+        "D": (((+1, 0, "D"),), ("U", "D")),
+    },
+    "-": {
+        "R": (((0, +1, "R"),), ("R", "L")),
+        "L": (((0, -1, "L"),), ("R", "L")),
+        "U": (((0, +1, "R"), (0, -1, "L")), ("U", "D")),
+        "D": (((0, +1, "R"), (0, -1, "L")), ("U", "D")),
+    },
+    "|": {
+        "U": (((-1, 0, "U"),), ("U", "D")),
+        "D": (((+1, 0, "D"),), ("U", "D")),
+        "R": (((-1, 0, "U"), (+1, 0, "D")), ("R", "L")),
+        "L": (((-1, 0, "U"), (+1, 0, "D")), ("R", "L")),
+    },
+    "/": {
+        "R": (((-1, 0, "U"),), ("R", "D")),
+        "L": (((+1, 0, "D"),), ("L", "U")),
+        "U": (((0, +1, "R"),), ("U", "L")),
+        "D": (((0, -1, "L"),), ("R", "D")),
+    },
+    "\\": {
+        "R": (((+1, 0, "D"),), ("R", "U")),
+        "L": (((-1, 0, "U"),), ("L", "D")),
+        "U": (((0, -1, "L"),), ("U", "R")),
+        "D": (((0, +1, "R"),), ("L", "D")),
+    },
+}
+
+
+def propagate(
+    layout: list[list[CellType]], start: tuple[int, int], direction: Direction
+) -> list[list[tuple[Direction, ...]]]:
+    n_rows, n_cols = len(layout), len(layout[0])
+
+    beams: list[list[tuple[Direction, ...]]] = [
+        [() for _ in range(len(layout[0]))] for _ in range(len(layout))
+    ]
+
+    queue: list[tuple[tuple[int, int], Direction]] = [(start, direction)]
+
+    while queue:
+        (row, col), direction = queue.pop()
+
+        if (
+            row not in range(0, n_rows)
+            or col not in range(0, n_cols)
+            or direction in beams[row][col]
+        ):
+            continue
+
+        moves, update = Mappings[layout[row][col]][direction]
+
+        beams[row][col] += update
+
+        for move in moves:
+            queue.append(((row + move[0], col + move[1]), move[2]))
+
+    return beams
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        layout: list[list[CellType]] = [
+            [cast(CellType, col) for col in row] for row in input.splitlines()
+        ]
+
+        beams = propagate(layout, (0, 0), "R")
+
+        if self.verbose:
+            for row in beams:
+                self.logger.info("".join("#" if col else "." for col in row))
+
+        # part 1
+        yield sum(sum(map(bool, row)) for row in beams)
+
+        # part 2
+        n_rows, n_cols = len(layout), len(layout[0])
+        cases: list[tuple[tuple[int, int], Direction]] = []
+
+        for row in range(n_rows):
+            cases.append(((row, 0), "R"))
+            cases.append(((row, n_cols - 1), "L"))
+        for col in range(n_cols):
+            cases.append(((0, col), "D"))
+            cases.append(((n_rows - 1, col), "U"))
+
+        yield max(
+            sum(sum(map(bool, row)) for row in propagate(layout, start, direction))
+            for start, direction in cases
+        )

src/holt59/aoc/2023/day17.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import heapq
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any, Iterator, Literal, TypeAlias
+
+from ..base import BaseSolver
+
+Direction: TypeAlias = Literal[">", "<", "^", "v"]
+
+
+@dataclass(frozen=True, order=True)
+class Label:
+    row: int
+    col: int
+
+    direction: Direction
+    count: int
+
+    parent: Label | None = None
+
+
+# mappings from direction to row shift / col shift / opposite direction
+MAPPINGS: dict[Direction, tuple[int, int, Direction]] = {
+    ">": (0, +1, "<"),
+    "<": (0, -1, ">"),
+    "v": (+1, 0, "^"),
+    "^": (-1, 0, "v"),
+}
+
+
+class Solver(BaseSolver):
+    def print_shortest_path(
+        self,
+        grid: list[list[int]],
+        target: tuple[int, int],
+        per_cell: dict[tuple[int, int], list[tuple[Label, int]]],
+    ):
+        assert len(per_cell[target]) == 1
+        label = per_cell[target][0][0]
+
+        path: list[Label] = []
+        while True:
+            path.insert(0, label)
+            if label.parent is None:
+                break
+            label = label.parent
+
+        p_grid = [[str(c) for c in r] for r in grid]
+
+        for i in range(len(grid)):
+            for j in range(len(grid[0])):
+                if per_cell[i, j]:
+                    p_grid[i][j] = f"\033[94m{grid[i][j]}\033[0m"
+
+        prev_label = path[0]
+        for label in path[1:]:
+            for r in range(
+                min(prev_label.row, label.row), max(prev_label.row, label.row) + 1
+            ):
+                for c in range(
+                    min(prev_label.col, label.col),
+                    max(prev_label.col, label.col) + 1,
+                ):
+                    if (r, c) != (prev_label.row, prev_label.col):
+                        p_grid[r][c] = f"\033[93m{grid[r][c]}\033[0m"
+
+            p_grid[label.row][label.col] = (
+                f"\033[91m{grid[label.row][label.col]}\033[0m"
+            )
+
+            prev_label = label
+
+        p_grid[0][0] = f"\033[92m{grid[0][0]}\033[0m"
+
+        for row in p_grid:
+            self.logger.info("".join(row))
+
+    def shortest_many_paths(self, grid: list[list[int]]) -> dict[tuple[int, int], int]:
+        n_rows, n_cols = len(grid), len(grid[0])
+
+        visited: dict[tuple[int, int], tuple[Label, int]] = {}
+
+        queue: list[tuple[int, Label]] = [
+            (0, Label(row=n_rows - 1, col=n_cols - 1, direction="^", count=0))
+        ]
+
+        while queue and len(visited) != n_rows * n_cols:
+            distance, label = heapq.heappop(queue)
+
+            if (label.row, label.col) in visited:
+                continue
+
+            visited[label.row, label.col] = (label, distance)
+
+            for direction, (c_row, c_col, i_direction) in MAPPINGS.items():
+                if label.direction == i_direction:
+                    continue
+                else:
+                    row, col = (label.row + c_row, label.col + c_col)
+
+                # exclude labels outside the grid or with too many moves in the same
+                # direction
+                if row not in range(0, n_rows) or col not in range(0, n_cols):
+                    continue
+
+                heapq.heappush(
+                    queue,
+                    (
+                        distance
+                        + sum(
+                            grid[r][c]
+                            for r in range(min(row, label.row), max(row, label.row) + 1)
+                            for c in range(min(col, label.col), max(col, label.col) + 1)
+                        )
+                        - grid[row][col],
+                        Label(
+                            row=row,
+                            col=col,
+                            direction=direction,
+                            count=0,
+                            parent=label,
+                        ),
+                    ),
+                )
+
+        return {(r, c): visited[r, c][1] for r in range(n_rows) for c in range(n_cols)}
+
+    def shortest_path(
+        self,
+        grid: list[list[int]],
+        min_straight: int,
+        max_straight: int,
+        lower_bounds: dict[tuple[int, int], int],
+    ) -> int:
+        n_rows, n_cols = len(grid), len(grid[0])
+
+        target = (len(grid) - 1, len(grid[0]) - 1)
+
+        # for each tuple (row, col, direction, count), the associated label when visited
+        visited: dict[tuple[int, int, str, int], Label] = {}
+
+        # list of all visited labels for a cell (with associated distance)
+        per_cell: dict[tuple[int, int], list[tuple[Label, int]]] = defaultdict(list)
+
+        # need to add two start labels, otherwise one of the two possible direction will
+        # not be possible
+        queue: list[tuple[int, int, Label]] = [
+            (lower_bounds[0, 0], 0, Label(row=0, col=0, direction="^", count=0)),
+            (lower_bounds[0, 0], 0, Label(row=0, col=0, direction="<", count=0)),
+        ]
+
+        while queue:
+            _, distance, label = heapq.heappop(queue)
+
+            if (label.row, label.col, label.direction, label.count) in visited:
+                continue
+
+            visited[label.row, label.col, label.direction, label.count] = label
+            per_cell[label.row, label.col].append((label, distance))
+
+            if (label.row, label.col) == target:
+                break
+
+            for direction, (c_row, c_col, i_direction) in MAPPINGS.items():
+                # cannot move in the opposite direction
+                if label.direction == i_direction:
+                    continue
+
+                # other direction, move 'min_straight' in the new direction
+                elif label.direction != direction:
+                    row, col, count = (
+                        label.row + min_straight * c_row,
+                        label.col + min_straight * c_col,
+                        min_straight,
+                    )
+
+                # same direction, too many count
+                elif label.count == max_straight:
+                    continue
+
+                # same direction, keep going and increment count
+                else:
+                    row, col, count = (
+                        label.row + c_row,
+                        label.col + c_col,
+                        label.count + 1,
+                    )
+                # exclude labels outside the grid or with too many moves in the same
+                # direction
+                if row not in range(0, n_rows) or col not in range(0, n_cols):
+                    continue
+
+                distance_to = (
+                    distance
+                    + sum(
+                        grid[r][c]
+                        for r in range(min(row, label.row), max(row, label.row) + 1)
+                        for c in range(min(col, label.col), max(col, label.col) + 1)
+                    )
+                    - grid[label.row][label.col]
+                )
+
+                heapq.heappush(
+                    queue,
+                    (
+                        distance_to + lower_bounds[row, col],
+                        distance_to,
+                        Label(
+                            row=row,
+                            col=col,
+                            direction=direction,
+                            count=count,
+                            parent=label,
+                        ),
+                    ),
+                )
+
+        if self.verbose:
+            self.print_shortest_path(grid, target, per_cell)
+
+        return per_cell[target][0][1]
+
+    def solve(self, input: str) -> Iterator[Any]:
+        data = [[int(c) for c in r] for r in input.splitlines()]
+        estimates = self.shortest_many_paths(data)
+
+        # part 1
+        yield self.shortest_path(data, 1, 3, lower_bounds=estimates)
+
+        # part 2
+        yield self.shortest_path(data, 4, 10, lower_bounds=estimates)

src/holt59/aoc/2023/day18.py

@@ -0,0 +1,56 @@
+from typing import Any, Iterator, Literal, TypeAlias, cast
+
+from ..base import BaseSolver
+
+Direction: TypeAlias = Literal["R", "L", "U", "D"]
+
+DIRECTIONS: list[Direction] = ["R", "D", "L", "U"]
+MOVES: dict[Direction, tuple[int, int]] = {
+    "R": (0, +1),
+    "L": (0, -1),
+    "U": (-1, 0),
+    "D": (+1, 0),
+}
+
+
+def area(corners: list[tuple[int, int]], perimeter: int) -> int:
+    area = abs(
+        sum(c0[0] * c1[1] - c0[1] * c1[0] for c0, c1 in zip(corners, corners[1::])) // 2
+    )
+    return 1 + area - perimeter // 2 + perimeter
+
+
+def polygon(values: list[tuple[Direction, int]]) -> tuple[list[tuple[int, int]], int]:
+    perimeter = 0
+    corners: list[tuple[int, int]] = [(0, 0)]
+    for direction, amount in values:
+        perimeter += amount
+        corners.append(
+            (
+                corners[-1][0] + amount * MOVES[direction][0],
+                corners[-1][1] + amount * MOVES[direction][1],
+            )
+        )
+    return corners, perimeter
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        # part 1
+        yield area(
+            *polygon(
+                [(cast(Direction, (p := line.split())[0]), int(p[1])) for line in lines]
+            )
+        )
+
+        # part 2
+        yield area(
+            *polygon(
+                [
+                    (DIRECTIONS[int((h := line.split()[-1])[-2])], int(h[2:-2], 16))
+                    for line in lines
+                ]
+            )
+        )

src/holt59/aoc/2023/day19.py

@@ -0,0 +1,134 @@
+import operator
+from math import prod
+from typing import Any, Iterator, Literal, TypeAlias, cast
+
+from ..base import BaseSolver
+
+Category: TypeAlias = Literal["x", "m", "a", "s"]
+Part: TypeAlias = dict[Category, int]
+PartWithBounds: TypeAlias = dict[Category, tuple[int, int]]
+
+OPERATORS = {"<": operator.lt, ">": operator.gt}
+
+# None if there is no check (last entry), otherwise (category, sense, value)
+Check: TypeAlias = tuple[Category, Literal["<", ">"], int] | None
+
+# workflow as a list of check, in specified order, with target
+Workflow: TypeAlias = list[tuple[Check, str]]
+
+
+class Solver(BaseSolver):
+    def accept(self, workflows: dict[str, Workflow], part: Part) -> bool:
+        workflow = "in"
+        decision: bool | None = None
+
+        while decision is None:
+            for check, target in workflows[workflow]:
+                passed = check is None
+                if check is not None:
+                    category, sense, value = check
+                    passed = OPERATORS[sense](part[category], value)
+
+                if passed:
+                    if target in workflows:
+                        workflow = target
+                    else:
+                        decision = target == "A"
+                    break
+
+        return decision
+
+    def propagate(self, workflows: dict[str, Workflow], start: PartWithBounds) -> int:
+        def _fmt(meta: PartWithBounds) -> str:
+            return "{" + ", ".join(f"{k}={v}" for k, v in meta.items()) + "}"
+
+        def transfer_or_accept(
+            target: str, meta: PartWithBounds, queue: list[tuple[PartWithBounds, str]]
+        ) -> int:
+            count = 0
+            if target in workflows:
+                self.logger.info(f"    transfer to {target}")
+                queue.append((meta, target))
+            elif target == "A":
+                count = prod((high - low + 1) for low, high in meta.values())
+                self.logger.info(f"    accepted ({count})")
+            else:
+                self.logger.info("    rejected")
+            return count
+
+        accepted = 0
+        queue: list[tuple[PartWithBounds, str]] = [(start, "in")]
+
+        n_iterations = 0
+
+        while queue:
+            n_iterations += 1
+            meta, workflow = queue.pop()
+            self.logger.info(f"{workflow}: {_fmt(meta)}")
+            for check, target in workflows[workflow]:
+                if check is None:
+                    self.logger.info("  end-of-workflow")
+                    accepted += transfer_or_accept(target, meta, queue)
+                    continue
+
+                category, sense, value = check
+                bounds, op = meta[category], OPERATORS[sense]
+
+                self.logger.info(
+                    f"  checking {_fmt(meta)} against {category} {sense} {value}"
+                )
+
+                if not op(bounds[0], value) and not op(bounds[1], value):
+                    self.logger.info("    reject, always false")
+                    continue
+
+                if op(meta[category][0], value) and op(meta[category][1], value):
+                    self.logger.info("    accept, always true")
+                    accepted += transfer_or_accept(target, meta, queue)
+                    break
+
+                meta2 = meta.copy()
+                low, high = meta[category]
+                if sense == "<":
+                    meta[category], meta2[category] = (value, high), (low, value - 1)
+                else:
+                    meta[category], meta2[category] = (low, value), (value + 1, high)
+                self.logger.info(f"    split {_fmt(meta2)} ({target}), {_fmt(meta)}")
+
+                accepted += transfer_or_accept(target, meta2, queue)
+
+        self.logger.info(f"run took {n_iterations} iterations")
+        return accepted
+
+    def solve(self, input: str) -> Iterator[Any]:
+        workflows_s, parts_s = input.split("\n\n")
+
+        workflows: dict[str, Workflow] = {}
+        for workflow_s in workflows_s.split("\n"):
+            name, block_s = workflow_s.split("{")
+            workflows[name] = []
+
+            for block in block_s[:-1].split(","):
+                check: Check
+                if (i := block.find(":")) >= 0:
+                    check = (
+                        cast(Category, block[0]),
+                        cast(Literal["<", ">"], block[1]),
+                        int(block[2:i]),
+                    )
+                    target = block[i + 1 :]
+                else:
+                    check, target = None, block
+                workflows[name].append((check, target))
+
+        # part 1
+        parts: list[Part] = [
+            {cast(Category, s[0]): int(s[2:]) for s in part_s[1:-1].split(",")}
+            for part_s in parts_s.split("\n")
+        ]
+        yield sum(sum(part.values()) for part in parts if self.accept(workflows, part))
+
+        # part 2
+        yield self.propagate(
+            workflows, {cast(Category, c): (1, 4000) for c in ["x", "m", "a", "s"]}
+        )

src/holt59/aoc/2023/day2.py

@@ -0,0 +1,43 @@
+import math
+from typing import Any, Iterator, Literal, TypeAlias, cast
+
+from ..base import BaseSolver
+
+CubeType: TypeAlias = Literal["red", "blue", "green"]
+
+MAX_CUBES: dict[CubeType, int] = {"red": 12, "green": 13, "blue": 14}
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+        games: dict[int, list[dict[CubeType, int]]] = {}
+        for line in filter(bool, lines):
+            id_part, sets_part = line.split(":")
+
+            games[int(id_part.split(" ")[-1])] = [
+                {
+                    cast(CubeType, s[1]): int(s[0])
+                    for cube_draw in cube_set_s.strip().split(", ")
+                    if (s := cube_draw.split(" "))
+                }
+                for cube_set_s in sets_part.strip().split(";")
+            ]
+
+        yield sum(
+            id
+            for id, set_of_cubes in games.items()
+            if all(
+                n_cubes <= MAX_CUBES[cube]
+                for cube_set in set_of_cubes
+                for cube, n_cubes in cube_set.items()
+            )
+        )
+
+        yield sum(
+            math.prod(
+                max(cube_set.get(cube, 0) for cube_set in set_of_cubes)
+                for cube in MAX_CUBES
+            )
+            for set_of_cubes in games.values()
+        )

src/holt59/aoc/2023/day20.py

@@ -0,0 +1,172 @@
+import sys
+from collections import defaultdict
+from math import lcm
+from typing import Any, Iterator, Literal, TypeAlias
+
+from ..base import BaseSolver
+
+ModuleType: TypeAlias = Literal["broadcaster", "conjunction", "flip-flop"]
+PulseType: TypeAlias = Literal["high", "low"]
+
+
+class Solver(BaseSolver):
+    _modules: dict[str, tuple[ModuleType, list[str]]]
+
+    def _process(
+        self,
+        start: tuple[str, str, PulseType],
+        flip_flop_states: dict[str, Literal["on", "off"]],
+        conjunction_states: dict[str, dict[str, PulseType]],
+    ) -> tuple[dict[PulseType, int], dict[str, dict[PulseType, int]]]:
+        pulses: list[tuple[str, str, PulseType]] = [start]
+        counts: dict[PulseType, int] = {"low": 0, "high": 0}
+        inputs: dict[str, dict[PulseType, int]] = defaultdict(
+            lambda: {"low": 0, "high": 0}
+        )
+
+        self.logger.info("starting process... ")
+
+        while pulses:
+            input, name, pulse = pulses.pop(0)
+            self.logger.info(f"{input} -{pulse}-> {name}")
+            counts[pulse] += 1
+
+            inputs[name][pulse] += 1
+
+            if name not in self._modules:
+                continue
+
+            type, outputs = self._modules[name]
+
+            if type == "broadcaster":
+                ...
+
+            elif type == "flip-flop":
+                if pulse == "high":
+                    continue
+
+                if flip_flop_states[name] == "off":
+                    flip_flop_states[name] = "on"
+                    pulse = "high"
+                else:
+                    flip_flop_states[name] = "off"
+                    pulse = "low"
+
+            else:
+                conjunction_states[name][input] = pulse
+
+                if all(state == "high" for state in conjunction_states[name].values()):
+                    pulse = "low"
+                else:
+                    pulse = "high"
+
+            pulses.extend((name, output, pulse) for output in outputs)
+
+        return counts, inputs
+
+    def solve(self, input: str) -> Iterator[Any]:
+        self._modules = {}
+
+        lines = sys.stdin.read().splitlines()
+
+        for line in lines:
+            name, outputs_s = line.split(" -> ")
+            outputs = outputs_s.split(", ")
+            if name == "broadcaster":
+                self._modules["broadcaster"] = ("broadcaster", outputs)
+            else:
+                self._modules[name[1:]] = (
+                    "conjunction" if name.startswith("&") else "flip-flop",
+                    outputs,
+                )
+
+        if self.outputs:
+            with open("./day20.dot", "w") as fp:
+                fp.write("digraph G {\n")
+                fp.write("rx [shape=circle, color=red, style=filled];\n")
+                for name, (type, outputs) in self._modules.items():
+                    if type == "conjunction":
+                        shape = "diamond"
+                    elif type == "flip-flop":
+                        shape = "box"
+                    else:
+                        shape = "circle"
+                    fp.write(f"{name} [shape={shape}];\n")
+                for name, (type, outputs) in self._modules.items():
+                    for output in outputs:
+                        fp.write(f"{name} -> {output};\n")
+                fp.write("}\n")
+
+        # part 1
+        flip_flop_states: dict[str, Literal["on", "off"]] = {
+            name: "off"
+            for name, (type, _) in self._modules.items()
+            if type == "flip-flop"
+        }
+        conjunction_states: dict[str, dict[str, PulseType]] = {
+            name: {
+                input: "low"
+                for input, (_, outputs) in self._modules.items()
+                if name in outputs
+            }
+            for name, (type, _) in self._modules.items()
+            if type == "conjunction"
+        }
+        counts: dict[PulseType, int] = {"low": 0, "high": 0}
+        for _ in range(1000):
+            result, _ = self._process(
+                ("button", "broadcaster", "low"), flip_flop_states, conjunction_states
+            )
+            for pulse in ("low", "high"):
+                counts[pulse] += result[pulse]
+        yield counts["low"] * counts["high"]
+
+        # part 2
+
+        # reset states
+        for name in flip_flop_states:
+            flip_flop_states[name] = "off"
+
+        for name in conjunction_states:
+            for input in conjunction_states[name]:
+                conjunction_states[name][input] = "low"
+
+        # find the conjunction connected to rx
+        to_rx = [
+            name for name, (_, outputs) in self._modules.items() if "rx" in outputs
+        ]
+        assert len(to_rx) == 1, "cannot handle multiple module inputs for rx"
+        assert (
+            self._modules[to_rx[0]][0] == "conjunction"
+        ), "can only handle conjunction as input to rx"
+
+        to_rx_inputs = [
+            name for name, (_, outputs) in self._modules.items() if to_rx[0] in outputs
+        ]
+        assert all(
+            self._modules[i][0] == "conjunction" and len(self._modules[i][1]) == 1
+            for i in to_rx_inputs
+        ), "can only handle inversion as second-order inputs to rx"
+
+        count = 1
+        cycles: dict[str, int] = {}
+        second: dict[str, int] = {}
+        while len(second) != len(to_rx_inputs):
+            _, inputs = self._process(
+                ("button", "broadcaster", "low"), flip_flop_states, conjunction_states
+            )
+
+            for node in to_rx_inputs:
+                if inputs[node]["low"] == 1:
+                    if node not in cycles:
+                        cycles[node] = count
+                    elif node not in second:
+                        second[node] = count
+
+            count += 1
+
+        assert all(
+            second[k] == cycles[k] * 2 for k in to_rx_inputs
+        ), "cannot only handle cycles starting at the beginning"
+
+        yield lcm(*cycles.values())

src/holt59/aoc/2023/day21.py

@@ -0,0 +1,150 @@
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+def reachable(
+    map: list[str], tiles: set[tuple[int, int]], steps: int
+) -> set[tuple[int, int]]:
+    n_rows, n_cols = len(map), len(map[0])
+
+    for _ in range(steps):
+        tiles = {
+            (i + di, j + dj)
+            for i, j in tiles
+            for di, dj in ((-1, 0), (+1, 0), (0, -1), (0, +1))
+            if map[(i + di) % n_rows][(j + dj) % n_cols] != "#"
+        }
+    return tiles
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        map = input.splitlines()
+        start = next(
+            (i, j)
+            for i in range(len(map))
+            for j in range(len(map[i]))
+            if map[i][j] == "S"
+        )
+
+        # part 1
+        yield len(reachable(map, {start}, 6 if len(map) < 20 else 64))
+
+        # part 2
+
+        # the initial map is a square and contains an empty rhombus whose diameter is
+        # the size of the map, and has only empty cells around the middle row and column
+        #
+        # after ~n/2 steps, the first map is filled with a rhombus, after that we get a
+        # bigger rhombus every n steps
+        #
+        # we are going to find the number of cells reached for the initial rhombus, n
+        # steps after and n * 2 steps after
+        #
+        cycle = len(map)
+        rhombus = (len(map) - 3) // 2 + 1
+
+        values: list[int] = []
+        values.append(len(tiles := reachable(map, {start}, rhombus)))
+        values.append(len(tiles := reachable(map, tiles, cycle)))
+        values.append(len(tiles := reachable(map, tiles, cycle)))
+
+        if self.verbose:
+            n_rows, n_cols = len(map), len(map[0])
+
+            rows = [
+                [
+                    map[i % n_rows][j % n_cols] if (i, j) not in tiles else "O"
+                    for j in range(-2 * cycle, 3 * cycle)
+                ]
+                for i in range(-2 * cycle, 3 * cycle)
+            ]
+
+            for i in range(len(rows)):
+                for j in range(len(rows[i])):
+                    if (i // cycle) % 2 == (j // cycle) % 2:
+                        rows[i][j] = f"\033[91m{rows[i][j]}\033[0m"
+
+            for row in rows:
+                self.logger.info("".join(row))
+
+        self.logger.info(f"values to fit: {values}")
+
+        # version 1:
+        #
+        # after 3 cycles, the figure looks like the following:
+        #
+        #   I M D
+        # I J A K D
+        # H A F A L
+        # C E A K B
+        #   C G B
+        #
+        # after 4 cycles, the figure looks like the following:
+        #
+        #     I M D
+        #   I J A K D
+        # I J A B A K D
+        # H A B A B A L
+        # C E A B A N F
+        #   C E A N F
+        #     C G F
+        #
+        # the 'radius' of the rhombus is the number of cycles minus 1
+        #
+        # the 4 'corner' (M, H, L, G) are counted once, the blocks with a corner triangle (D, I,
+        # C, B) are each counted radius times, the blocks with everything but one corner (J, K,
+        # E, N) are each counted radius - 1 times
+        #
+        # there are two versions of the whole block, A and B in the above (or odd and even),
+        # depending on the number of cycles, either A or B will be in the center
+        #
+
+        counts = [
+            [
+                sum(
+                    (i, j) in tiles
+                    for i in range(ci * cycle, (ci + 1) * cycle)
+                    for j in range(cj * cycle, (cj + 1) * cycle)
+                )
+                for cj in range(-2, 3)
+            ]
+            for ci in range(-2, 3)
+        ]
+
+        radius = (26501365 - rhombus) // cycle - 1
+        A = counts[2][2] if radius % 2 == 0 else counts[2][1]
+        B = counts[2][2] if radius % 2 == 1 else counts[2][1]
+        answer_2 = (
+            (radius + 1) * A
+            + radius * B
+            + 2 * radius * (radius + 1) // 2 * A
+            + 2 * radius * (radius - 1) // 2 * B
+            + sum(counts[i][j] for i, j in ((0, 2), (-1, 2), (2, 0), (2, -1)))
+            + sum(counts[i][j] for i, j in ((0, 1), (0, 3), (-1, 1), (-1, 3)))
+            * (radius + 1)
+            + sum(counts[i][j] for i, j in ((1, 1), (1, 3), (-2, 1), (-2, 3))) * radius
+        )
+        print(f"answer 2 (v1) is {answer_2}")
+
+        # version 2: fitting a polynomial
+        #
+        # the value we are interested in (26501365) can be written as R + K * C where R is the
+        # step at which we find the first rhombus, and K the repeat step, so instead of fitting
+        # for X values (R, R + K, R + 2 K), we are going to fit for (0, 1, 2), giving us much
+        # simpler equation for the a, b and c coefficient
+        #
+        # we get:
+        #   - (a * 0² + b * 0 + c) = y1  =>  c = y1
+        #   - (a * 1² + b * 1 + c) = y2  =>  a + b = y2 - y1
+        #                                =>  b = y2 - y1 - a
+        #   - (a * 2² + b * 2 + c) = y3  =>  4a + 2b = y3 - y1
+        #                                =>  4a + 2(y2 - y1 - a) = y3 - y1
+        #                                =>  a = (y1 + y3) / 2 - y2
+        #
+        y1, y2, y3 = values
+        a, b, c = (y1 + y3) // 2 - y2, 2 * y2 - (3 * y1 + y3) // 2, y1
+
+        n = (26501365 - rhombus) // cycle
+        yield a * n * n + b * n + c

src/holt59/aoc/2023/day22.py

@@ -0,0 +1,109 @@
+import itertools
+import string
+from collections import defaultdict
+from typing import Any, Iterator
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        def _name(i: int) -> str:
+            if len(lines) < 26:
+                return string.ascii_uppercase[i]
+            return f"B{i:04d}"
+
+        def build_supports(
+            bricks: list[tuple[tuple[int, int, int], tuple[int, int, int]]],
+        ) -> tuple[dict[int, set[int]], dict[int, set[int]]]:
+            # 1. compute locations where a brick of sand will land after falling by processing
+            # them in sorted order of bottom z location
+            levels: dict[tuple[int, int, int], int] = defaultdict(lambda: -1)
+            for i_brick, ((sx, sy, sz), (ex, ey, ez)) in enumerate(bricks):
+                assert sx <= ex and sy <= ey and sz <= ez
+
+                xs, ys = range(sx, ex + 1), range(sy, ey + 1)
+
+                for z in range(sz - 1, 0, -1):
+                    if any(levels[x, y, z] >= 0 for x, y in itertools.product(xs, ys)):
+                        break
+                    sz, ez = sz - 1, ez - 1
+
+                bricks[i_brick] = ((sx, sy, sz), (ex, ey, ez))
+                zs = range(sz, ez + 1)
+
+                for x, y, z in itertools.product(xs, ys, zs):
+                    levels[x, y, z] = i_brick
+
+            # 2. compute the bricks that supports any brick
+            supported_by: dict[int, set[int]] = {}
+            supports: dict[int, set[int]] = {
+                i_brick: set() for i_brick in range(len(bricks))
+            }
+            for i_brick, ((sx, sy, sz), (ex, ey, ez)) in enumerate(bricks):
+                name = _name(i_brick)
+
+                supported_by[i_brick] = {
+                    v
+                    for x, y in itertools.product(range(sx, ex + 1), range(sy, ey + 1))
+                    if (v := levels[x, y, sz - 1]) != -1
+                }
+                self.logger.info(
+                    f"{name} supported by {', '.join(map(_name, supported_by[i_brick]))}"
+                )
+
+                for support in supported_by[i_brick]:
+                    supports[support].add(i_brick)
+
+            return supported_by, supports
+
+        bricks: list[tuple[tuple[int, int, int], tuple[int, int, int]]] = []
+        for line in lines:
+            bricks.append(
+                (
+                    tuple(int(c) for c in line.split("~")[0].split(",")),  # type: ignore
+                    tuple(int(c) for c in line.split("~")[1].split(",")),  # type: ignore
+                )
+            )
+
+        # sort bricks by bottom z position to compute supports
+        bricks = sorted(bricks, key=lambda b: b[0][-1])
+        supported_by, supports = build_supports(bricks)
+
+        # part 1
+        yield len(bricks) - sum(
+            any(len(supported_by[supported]) == 1 for supported in supports_to)
+            for supports_to in supports.values()
+        )
+
+        # part 2
+        falling_in_chain: dict[int, set[int]] = {}
+        for i_brick in range(len(bricks)):
+            to_disintegrate: set[int] = {
+                supported
+                for supported in supports[i_brick]
+                if len(supported_by[supported]) == 1
+            }
+
+            supported_by_copy = dict(supported_by)
+
+            falling_in_chain[i_brick] = set()
+            while to_disintegrate:
+                falling_in_chain[i_brick].update(to_disintegrate)
+
+                to_disintegrate_v: set[int] = set()
+
+                for d_brick in to_disintegrate:
+                    for supported in supports[d_brick]:
+                        supported_by_copy[supported] = supported_by_copy[supported] - {
+                            d_brick
+                        }
+
+                        if not supported_by_copy[supported]:
+                            to_disintegrate_v.add(supported)
+
+                to_disintegrate = to_disintegrate_v
+
+        yield sum(len(falling) for falling in falling_in_chain.values())

src/holt59/aoc/2023/day23.py

@@ -0,0 +1,165 @@
+from collections import defaultdict
+from typing import Any, Iterator, Literal, Sequence, TypeAlias, cast
+
+from ..base import BaseSolver
+
+DirectionType: TypeAlias = Literal[">", "<", "^", "v", ".", "#"]
+
+Direction: dict[DirectionType, tuple[int, int]] = {
+    ">": (0, +1),
+    "<": (0, -1),
+    "^": (-1, 0),
+    "v": (+1, 0),
+}
+
+Neighbors = cast(
+    "dict[DirectionType, tuple[tuple[int, int], ...]]",
+    {
+        ".": ((+1, 0), (-1, 0), (0, +1), (0, -1)),
+        "#": (),
+    }
+    | {k: (v,) for k, v in Direction.items()},
+)
+
+
+def neighbors(
+    grid: list[Sequence[DirectionType]],
+    node: tuple[int, int],
+    ignore: set[tuple[int, int]] = set(),
+):
+    """
+    Compute neighbors of the given node, ignoring the given set of nodes and considering
+    that you can go uphill on slopes.
+    """
+    n_rows, n_cols = len(grid), len(grid[0])
+    i, j = node
+
+    for di, dj in Neighbors[grid[i][j]]:
+        ti, tj = di + i, dj + j
+
+        if ti < 0 or ti >= n_rows or tj < 0 or tj >= n_cols:
+            continue
+
+        if (ti, tj) in ignore:
+            continue
+
+        v = grid[ti][tj]
+
+        if (
+            v == "#"
+            or (v == "v" and di == -1)
+            or (v == "^" and di == 1)
+            or (v == ">" and dj == -1)
+            or (v == "<" and dj == 1)
+        ):
+            continue
+
+        yield ti, tj
+
+
+def reachable(
+    grid: list[Sequence[DirectionType]], start: tuple[int, int], target: tuple[int, int]
+) -> tuple[tuple[int, int], int]:
+    """
+    Compute the next 'reachable' node in the grid, starting at the given node.
+
+    The next 'reachable' node is the first node after a slope in the path starting from
+    the given node (not going uphill).
+    """
+    distance, path = 0, {start}
+    while True:
+        i, j = start
+
+        if (i, j) == target:
+            return (target, distance)
+
+        if grid[i][j] != ".":
+            di, dj = Direction[grid[i][j]]
+            return ((i + di, j + dj), distance + 1)
+
+        start = next(neighbors(grid, start, path := path | {(i, j)}))
+        distance += 1
+
+
+def compute_direct_links(
+    grid: list[Sequence[DirectionType]], start: tuple[int, int], target: tuple[int, int]
+) -> dict[tuple[int, int], list[tuple[tuple[int, int], int]]]:
+    if start == target:
+        return {}
+
+    direct: dict[tuple[int, int], list[tuple[tuple[int, int], int]]] = {start: []}
+    for neighbor in neighbors(grid, start):
+        i, j = neighbor
+        di, dj = Direction[grid[i][j]]
+
+        reach, distance = reachable(grid, (i + di, j + dj), target)
+        direct[start].append((reach, distance + 2))
+
+        direct.update(compute_direct_links(grid, reach, target))
+
+    return direct
+
+
+class Solver(BaseSolver):
+    def longest_path_length(
+        self,
+        links: dict[tuple[int, int], list[tuple[tuple[int, int], int]]],
+        start: tuple[int, int],
+        target: tuple[int, int],
+    ) -> int:
+        max_distance: int = -1
+        queue: list[tuple[tuple[int, int], int, frozenset[tuple[int, int]]]] = [
+            (start, 0, frozenset({start}))
+        ]
+
+        nodes = 0
+        while queue:
+            node, distance, path = queue.pop()
+
+            nodes += 1
+
+            if node == target:
+                max_distance = max(distance, max_distance)
+                continue
+
+            queue.extend(
+                (reach, distance + length, path | {reach})
+                for reach, length in links.get(node, [])
+                if reach not in path
+            )
+
+        self.logger.info(f"processed {nodes} nodes")
+
+        return max_distance
+
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = cast(list[Sequence[DirectionType]], input.splitlines())
+
+        start = (0, 1)
+        target = (len(lines) - 1, len(lines[0]) - 2)
+
+        direct_links: dict[tuple[int, int], list[tuple[tuple[int, int], int]]] = {
+            start: [reachable(lines, start, target)]
+        }
+        direct_links.update(
+            compute_direct_links(lines, direct_links[start][0][0], target)
+        )
+
+        # part 1
+        yield self.longest_path_length(direct_links, start, target)
+
+        # part 2
+        reverse_links: dict[tuple[int, int], list[tuple[tuple[int, int], int]]] = (
+            defaultdict(list)
+        )
+        for origin, links in direct_links.items():
+            for destination, distance in links:
+                if origin != start:
+                    reverse_links[destination].append((origin, distance))
+
+        links = {
+            k: direct_links.get(k, []) + reverse_links.get(k, [])
+            for k in direct_links.keys() | reverse_links.keys()
+        }
+
+        yield self.longest_path_length(links, start, target)

src/holt59/aoc/2023/day24.py

@@ -0,0 +1,68 @@
+from typing import Any, Iterator
+
+import numpy as np
+from sympy import solve, symbols
+
+from ..base import BaseSolver
+
+
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = input.splitlines()
+
+        positions = np.array(
+            [[int(c) for c in line.split("@")[0].strip().split(", ")] for line in lines]
+        )
+        velocities = np.array(
+            [[int(c) for c in line.split("@")[1].strip().split(", ")] for line in lines]
+        )
+
+        # part 1
+        low, high = (
+            [7, 27] if len(positions) <= 10 else [200000000000000, 400000000000000]
+        )
+
+        count = 0
+        for i1, (p1, v1) in enumerate(zip(positions, velocities)):
+            p, r = p1[:2], v1[:2]
+
+            q, s = positions[i1 + 1 :, :2], velocities[i1 + 1 :, :2]
+
+            rs = np.cross(r, s)
+
+            q, s, rs = q[m := (rs != 0)], s[m], rs[m]
+            t = np.cross((q - p), s) / rs
+            u = np.cross((q - p), r) / rs
+
+            t, u = t[m := ((t >= 0) & (u >= 0))], u[m]
+            c = p + np.expand_dims(t, 1) * r
+            count += np.all((low <= c) & (c <= high), axis=1).sum()
+
+        yield count
+
+        # part 2
+        # equation
+        #   p1 + t1 * v1 == p0 + t1 * v0
+        #   p2 + t2 * v2 == p0 + t2 * v0
+        #   p3 + t3 * v3 == p0 + t3 * v0
+        #      ...
+        #   pn + tn * vn == p0 + tn * v0
+        #
+
+        # we can solve with only 3 lines since each lines contains 3
+        # equations (x / y / z), so 3 lines give 9 equations and 9
+        # variables: position (3), velocities (3) and times (3).
+        n = 3
+
+        x, y, z, vx, vy, vz, *ts = symbols(
+            "x y z vx vy vz " + " ".join(f"t{i}" for i in range(n + 1))
+        )
+        equations = []
+        for i1, ti in zip(range(n), ts):
+            for p, d, pi, di in zip(
+                (x, y, z), (vx, vy, vz), positions[i1], velocities[i1]
+            ):
+                equations.append(p + ti * d - pi - ti * di)
+
+        r = solve(equations, [x, y, z, vx, vy, vz] + list(ts), dict=True)[0]
+        yield r[x] + r[y] + r[z]