Start fixing 2022 for new API.

src/holt59/aoc/2021/day1.py

@@ -1,17 +1,14 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
-
-
-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:]))
+answer_1 = sum(v2 > v1 for v1, v2 in zip(values[:-1], values[1:]))
+print(f"answer 1 is {answer_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:]))
+answer_2 = sum(v2 > v1 for v1, v2 in zip(runnings[:-1], runnings[1:]))
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day10.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day11.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day12.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day13.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day14.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day15.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day16.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day17.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day18.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day19.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day2.py

@@ -1,19 +1,16 @@
+import sys
 from math import prod
-from typing import Any, Iterator, Literal, TypeAlias, cast
+from typing import Literal, TypeAlias, cast
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
 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:
@@ -34,5 +31,11 @@ class Solver(BaseSolver):
 
     return depth, pos
 
-        yield prod(depth_and_position(False))
+
-        yield prod(depth_and_position(True))
+# part 1
+answer_1 = prod(depth_and_position(False))
+print(f"answer 1 is {answer_1}")
+
+# part 2
+answer_2 = prod(depth_and_position(True))
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day20.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day21.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day22.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day23.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day24.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day25.py

@@ -1,7 +1,11 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
 
+# part 1
+answer_1 = ...
+print(f"answer 1 is {answer_1}")
 
-class Solver(BaseSolver):
+# part 2
-    def solve(self, input: str) -> Iterator[Any]: ...
+answer_2 = ...
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day3.py

@@ -1,7 +1,6 @@
+import sys
 from collections import Counter
-from typing import Any, Iterator, Literal
+from typing import Literal
-
-from ..base import BaseSolver
 
 
 def generator_rating(
@@ -21,23 +20,20 @@ def generator_rating(
     return values[0]
 
 
-class Solver(BaseSolver):
+lines = sys.stdin.read().splitlines()
-    def solve(self, input: str) -> Iterator[Any]:
+
-        lines = input.splitlines()
 
 # part 1
 most_and_least_common = [
-            tuple(
+    tuple(Counter(line[col] for line in lines).most_common(2)[m][0] for m in range(2))
-                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
+print(f"answer 1 is {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
+answer_2 = oxygen_generator_rating * co2_scrubber_rating
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day4.py

@@ -1,13 +1,8 @@
-from typing import Any, Iterator
+import sys
 
 import numpy as np
 
-from ..base import BaseSolver
+lines = sys.stdin.read().splitlines()
-
-
-class Solver(BaseSolver):
-    def solve(self, input: str) -> Iterator[Any]:
-        lines = input.splitlines()
 
 numbers = [int(c) for c in lines[0].split(",")]
 
@@ -31,9 +26,7 @@ class Solver(BaseSolver):
         if winning_rounds[index][0] > 0:
             continue
 
-                if np.any(
+        if np.any(np.all(marked[index], axis=0) | np.all(marked[index], axis=1)):
-                    np.all(marked[index], axis=0) | np.all(marked[index], axis=1)
-                ):
             winning_rounds[index] = (
                 round,
                 number * int(np.sum(boards[index][~marked[index]])),
@@ -45,8 +38,8 @@ class Solver(BaseSolver):
 
 # part 1
 (_, score) = min(winning_rounds, key=lambda w: w[0])
-        yield score
+print(f"answer 1 is {score}")
 
 # part 2
 (_, score) = max(winning_rounds, key=lambda w: w[0])
-        yield score
+print(f"answer 2 is {score}")

src/holt59/aoc/2021/day5.py

@@ -1,13 +1,8 @@
-from typing import Any, Iterator
+import sys
 
 import numpy as np
 
-from ..base import BaseSolver
+lines: list[str] = sys.stdin.read().splitlines()
-
-
-class Solver(BaseSolver):
-    def solve(self, input: str) -> Iterator[Any]:
-        lines = input.splitlines()
 
 sections: list[tuple[tuple[int, int], tuple[int, int]]] = [
     (
@@ -25,8 +20,10 @@ class Solver(BaseSolver):
 
 np_sections = np.array(sections).reshape(-1, 4)
 
-        x_max, y_max = (
+x_min, x_max, y_min, y_max = (
+    min(np_sections[:, 0].min(), np_sections[:, 2].min()),
     max(np_sections[:, 0].max(), np_sections[:, 2].max()),
+    min(np_sections[:, 1].min(), np_sections[:, 3].min()),
     max(np_sections[:, 1].max(), np_sections[:, 3].max()),
 )
 
@@ -44,5 +41,8 @@ class Solver(BaseSolver):
         for i, j in zip(y_rng, x_rng):
             counts_2[i, j] += 1
 
-        yield (counts_1 >= 2).sum()
+answer_1 = (counts_1 >= 2).sum()
-        yield (counts_2 >= 2).sum()
+print(f"answer 1 is {answer_1}")
+
+answer_2 = (counts_2 >= 2).sum()
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day6.py

@@ -1,11 +1,6 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+values = [int(c) for c in sys.stdin.read().strip().split(",")]
-
-
-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)}
@@ -17,5 +12,10 @@ class Solver(BaseSolver):
     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)
+# part 1
-        yield sum(lanterns.values()) + len(values)
+answer_1 = sum(v for k, v in lanterns.items() if k < 80) + len(values)
+print(f"answer 1 is {answer_1}")
+
+# part 2
+answer_2 = sum(lanterns.values()) + len(values)
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day7.py

@@ -1,22 +1,19 @@
-from typing import Any, Iterator
+import sys
 
-from ..base import BaseSolver
+positions = [int(c) for c in sys.stdin.read().strip().split(",")]
-
-
-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(
+answer_1 = min(
     sum(abs(p - position) for p in positions)
     for position in range(min_position, max_position + 1)
 )
+print(f"answer 1 is {answer_1}")
 
 # part 2
-        yield min(
+answer_2 = min(
     sum(abs(p - position) * (abs(p - position) + 1) // 2 for p in positions)
     for position in range(min_position, max_position + 1)
 )
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day8.py

@@ -1,7 +1,8 @@
 import itertools
-from typing import Any, Iterator
+import os
+import sys
 
-from ..base import BaseSolver
+VERBOSE = os.getenv("AOC_VERBOSE") == "True"
 
 digits = {
     "abcefg": 0,
@@ -16,18 +17,14 @@ digits = {
     "abcdfg": 9,
 }
 
-
+lines = sys.stdin.read().splitlines()
-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(
+answer_1 = sum(
-            len(p) in lengths
+    len(p) in lengths for line in lines for p in line.split("|")[1].strip().split()
-            for line in lines
-            for p in line.split("|")[1].strip().split()
 )
+print(f"answer 1 is {answer_1}")
 
 # part 2
 values: list[int] = []
@@ -52,9 +49,7 @@ class Solver(BaseSolver):
     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 = [
+    adg = [u for u in per_length[5][0] if all(u in pe for pe in per_length[5][1:])]
-                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]
@@ -82,8 +77,11 @@ class Solver(BaseSolver):
         digit = "".join(sorted(mapping[c] for c in number))
         value = 10 * value + digits[digit]
 
-            self.logger.info(f"value for '{line}' is {value}")
+    if VERBOSE:
+        print(value)
 
     values.append(value)
 
-        yield sum(values)
+
+answer_2 = sum(values)
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2021/day9.py

@@ -1,18 +1,18 @@
+import sys
 from math import prod
-from typing import Any, Iterator
 
-from ..base import BaseSolver
+values = [[int(c) for c in row] for row in sys.stdin.read().splitlines()]
+n_rows, n_cols = len(values), len(values[0])
 
 
-def neighbors(point: tuple[int, int], n_rows: int, n_cols: int):
+def neighbors(point: tuple[int, 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]]:
+def basin(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]
 
@@ -23,25 +23,22 @@ def basin(values: list[list[int]], start: tuple[int, int]) -> set[tuple[int, int
             continue
 
         visited.add((i, j))
-        queue.extend(neighbors((i, j), n_rows, n_cols))
+        queue.extend(neighbors((i, j)))
 
     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(
+    if all(values[ti][tj] > values[i][j] for ti, tj in neighbors((i, j)))
-                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)
+# part 1
-        yield prod(sorted(len(basin(values, point)) for point in low_points)[-3:])
+answer_1 = sum(values[i][j] + 1 for i, j in low_points)
+print(f"answer 1 is {answer_1}")
+
+# part 2
+answer_2 = prod(sorted(len(basin(point)) for point in low_points)[-3:])
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2022/day15.py

@@ -1,4 +1,3 @@
-import itertools as it
 from typing import Any, Iterator
 
 import numpy as np
@@ -21,7 +20,9 @@ class Solver(BaseSolver):
             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
+        no_beacons_row = set(np.concatenate(no_beacons_row_l)).difference(
+            beacons_at_row
+        )  # type: ignore
 
         return len(no_beacons_row)
 
@@ -91,5 +92,5 @@ class Solver(BaseSolver):
 
         # 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})")
+        self.logger.info("answer 2 is {at} (x={x}, y={y})")
         yield a2

src/holt59/aoc/2022/day16.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import heapq
 import itertools
 import re
+import sys
 from collections import defaultdict
 from typing import Any, FrozenSet, Iterator, NamedTuple
 
@@ -37,8 +38,8 @@ 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)]
+    queue = [(0, pipe_1)]
-    visited: set[Pipe] = set()
+    visited = set()
     distances: dict[Pipe, int] = {}
 
     while len(distances) < len(pipes):
@@ -123,9 +124,8 @@ def part_2(
 # === MAIN ===
 
 
-class Solver(BaseSolver):
+lines = sys.stdin.read().splitlines()
-    def solve(self, input: str) -> Iterator[Any]:
+
-        lines = [line.strip() for line in input.splitlines()]
 
 pipes: dict[str, Pipe] = {}
 for line in lines:
@@ -152,8 +152,9 @@ class Solver(BaseSolver):
 # 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)
+print(part_1(pipes["AA"], 30, distances, relevant_pipes))
 
 # 1707, 2223
-        yield part_2(pipes["AA"], 26, distances, relevant_pipes)
+print(part_2(pipes["AA"], 26, distances, relevant_pipes))

src/holt59/aoc/2022/day17.py

@@ -1,16 +1,14 @@
-from typing import Any, Iterator, Sequence, TypeAlias, TypeVar
+import sys
+from typing import Any, Iterator, Sequence, 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: np.ndarray, out: str = "#"):
-def print_tower(tower: Tower, out: str = "#"):
     print("-" * (tower.shape[1] + 2))
     non_empty = False
     for row in reversed(range(1, tower.shape[0])):
@@ -21,7 +19,7 @@ def print_tower(tower: Tower, out: str = "#"):
     print("+" + "-" * tower.shape[1] + "+")
 
 
-def tower_height(tower: Tower) -> int:
+def tower_height(tower: np.ndarray) -> int:
     return int(tower.shape[0] - tower[::-1, :].argmax(axis=0).min() - 1)
 
 
@@ -49,8 +47,8 @@ def build_tower(
     n_rocks: int,
     jets: str,
     early_stop: bool = False,
-    init: Tower = np.ones(WIDTH, dtype=bool),
+    init: np.ndarray = np.ones(WIDTH, dtype=bool),
-) -> tuple[Tower, int, int, dict[int, int]]:
+) -> tuple[np.ndarray, int, int, dict[int, int]]:
     tower = EMPTY_BLOCKS.copy()
     tower[0, :] = init
 
@@ -99,13 +97,14 @@ def build_tower(
     return tower, rock_count, done_at.get((i_rock, i_jet), -1), heights
 
 
-class Solver(BaseSolver):
+line = sys.stdin.read().strip()
-    def solve(self, input: str) -> Iterator[Any]:
+
-        tower, *_ = build_tower(2022, input)
+tower, *_ = build_tower(2022, line)
-        yield tower_height(tower)
+answer_1 = tower_height(tower)
+print(f"answer 1 is {answer_1}")
 
 TOTAL_ROCKS = 1_000_000_000_000
-        _tower_1, n_rocks_1, prev_1, heights_1 = build_tower(TOTAL_ROCKS, input, True)
+tower_1, n_rocks_1, prev_1, heights_1 = build_tower(TOTAL_ROCKS, line, True)
 assert prev_1 > 0
 
 # 2767 1513
@@ -119,4 +118,5 @@ class Solver(BaseSolver):
     heights_1[prev_1 + remaining_rocks % n_repeat_rocks] - heights_1[prev_1]
 )
 
-        yield base_height + (n_repeat_towers + 1) * repeat_height + remaining_height
+answer_2 = base_height + (n_repeat_towers + 1) * repeat_height + remaining_height
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2022/day18.py

@@ -1,16 +1,14 @@
+import sys
 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()
+        for row in sys.stdin.read().splitlines()
     ]
 )
 
@@ -19,14 +17,14 @@ class Solver(BaseSolver):
 cubes = np.zeros(xyz.max(axis=0) + 3, dtype=bool)
 cubes[xyz[:, 0], xyz[:, 1], xyz[:, 2]] = True
 
+n_dims = len(cubes.shape)
+
 faces = [(-1, 0, 0), (1, 0, 0), (0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1)]
 
-        yield sum(
+answer_1 = sum(
-            1
+    1 for x, y, z in xyz for dx, dy, dz in faces if not cubes[x + dx, y + dy, z + dz]
-            for x, y, z in xyz
-            for dx, dy, dz in faces
-            if not cubes[x + dx, y + dy, z + dz]
 )
+print(f"answer 1 is {answer_1}")
 
 visited = np.zeros_like(cubes, dtype=bool)
 queue = [(0, 0, 0)]
@@ -42,9 +40,7 @@ class Solver(BaseSolver):
 
     for dx, dy, dz in faces:
         nx, ny, nz = x + dx, y + dy, z + dz
-                if not all(
+        if not all(n >= 0 and n < cubes.shape[i] for i, n in enumerate((nx, ny, nz))):
-                    n >= 0 and n < cubes.shape[i] for i, n in enumerate((nx, ny, nz))
-                ):
             continue
 
         if visited[nx, ny, nz]:
@@ -54,5 +50,4 @@ class Solver(BaseSolver):
             n_faces += 1
         else:
             queue.append((nx, ny, nz))
-
+print(f"answer 2 is {n_faces}")
-        yield n_faces

src/holt59/aoc/2022/day19.py

@@ -1,3 +1,4 @@
+import sys
 from typing import Any, Iterator, Literal
 
 import numpy as np
@@ -63,6 +64,29 @@ def dominates(lhs: State, rhs: State):
     )
 
 
+lines = sys.stdin.read().splitlines()
+
+blueprints: list[dict[Reagent, IntOfReagent]] = []
+for line in lines:
+    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]},
+        }
+    )
+
+
 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.,
@@ -151,31 +175,11 @@ def run(blueprint: dict[Reagent, dict[Reagent, int]], max_time: int) -> int:
     return max(state.reagents["geode"] for state in state_after_t[max_time])
 
 
-class Solver(BaseSolver):
+answer_1 = sum(
-    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)
 )
+print(f"answer 1 is {answer_1}")
 
-        yield (run(blueprints[0], 32) * run(blueprints[1], 32) * run(blueprints[2], 32))
+answer_2 = run(blueprints[0], 32) * run(blueprints[1], 32) * run(blueprints[2], 32)
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2022/day20.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from typing import Any, Iterator
 
 from ..base import BaseSolver
@@ -67,9 +68,10 @@ def decrypt(numbers: list[Number], key: int, rounds: int) -> int:
     )
 
 
-class Solver(BaseSolver):
+numbers = [Number(int(x)) for i, x in enumerate(sys.stdin.readlines())]
-    def solve(self, input: str) -> Iterator[Any]:
-        numbers = [Number(int(x)) for x in input.splitlines()]
 
-        yield decrypt(numbers, 1, 1)
+answer_1 = decrypt(numbers, 1, 1)
-        yield decrypt(numbers, 811589153, 10)
+print(f"answer 1 is {answer_1}")
+
+answer_2 = decrypt(numbers, 811589153, 10)
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2022/day21.py

@@ -1,4 +1,5 @@
 import operator
+import sys
 from typing import Any, Callable, Iterator
 
 from ..base import BaseSolver
@@ -78,9 +79,7 @@ def invert(
     return monkeys
 
 
-class Solver(BaseSolver):
+lines = sys.stdin.read().splitlines()
-    def solve(self, input: str) -> Iterator[Any]:
-        lines = [line.strip() for line in input.splitlines()]
 
 monkeys: dict[str, int | tuple[str, str, str]] = {}
 
@@ -99,10 +98,12 @@ class Solver(BaseSolver):
 
         op_monkeys.add(name)
 
-        yield compute(monkeys.copy(), "root")
+
+answer_1 = compute(monkeys.copy(), "root")
+print(f"answer 1 is {answer_1}")
 
 # 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")
+answer_2 = compute(invert(monkeys, "humn", compute(monkeys.copy(), p2)), "humn")
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2022/day22.py

@@ -1,4 +1,5 @@
 import re
+import sys
 from typing import Any, Callable, Iterator
 
 import numpy as np
@@ -11,9 +12,7 @@ TILE_FROM_CHAR = {" ": VOID, ".": EMPTY, "#": WALL}
 SCORES = {"E": 0, "S": 1, "W": 2, "N": 3}
 
 
-class Solver(BaseSolver):
+board_map_s, direction_s = sys.stdin.read().split("\n\n")
-    def solve(self, input: str) -> Iterator[Any]:
-        board_map_s, direction_s = input.split("\n\n")
 
 # board
 board_lines = board_map_s.splitlines()
@@ -26,19 +25,16 @@ class Solver(BaseSolver):
 )
 
 directions = [
-            int(p1) if p2 else p1
+    int(p1) if p2 else p1 for p1, p2 in re.findall(R"(([0-9])+|L|R)", direction_s)
-            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 = (
+row_last_non_void = board.shape[1] - np.argmax(board[:, ::-1] != VOID, axis=1) - 1
-            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 = (
+col_last_non_void = board.shape[0] - np.argmax(board[::-1, :] != VOID, axis=0) - 1
-            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])
@@ -109,6 +105,7 @@ class Solver(BaseSolver):
         },
     }
 
+
 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
@@ -121,14 +118,14 @@ class Solver(BaseSolver):
 
     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]],
+def run(wrap: Callable[[int, int, str], tuple[int, int, str]]) -> tuple[int, int, str]:
-        ) -> tuple[int, int, str]:
     y0 = 0
     x0 = np.where(board[0] == EMPTY)[0][0]
     r0 = "E"
@@ -137,9 +134,7 @@ class Solver(BaseSolver):
         if isinstance(direction, int):
             while direction > 0:
                 if r0 == "E":
-                            xi = np.where(
+                    xi = np.where(board[y0, x0 + 1 : x0 + direction + 1] == WALL)[0]
-                                board[y0, x0 + 1 : x0 + direction + 1] == WALL
-                            )[0]
                     if len(xi):
                         x0 = x0 + xi[0]
                         direction = 0
@@ -155,14 +150,10 @@ class Solver(BaseSolver):
                             x0 = row_last_non_void[y0]
                             direction = 0
                         else:
-                                    direction = (
+                            direction = direction - (row_last_non_void[y0] - x0) - 1
-                                        direction - (row_last_non_void[y0] - x0) - 1
-                                    )
                             y0, x0, r0 = y0_t, x0_t, r0_t
                 elif r0 == "S":
-                            yi = np.where(
+                    yi = np.where(board[y0 + 1 : y0 + direction + 1, x0] == WALL)[0]
-                                board[y0 + 1 : y0 + direction + 1, x0] == WALL
-                            )[0]
                     if len(yi):
                         y0 = y0 + yi[0]
                         direction = 0
@@ -178,9 +169,7 @@ class Solver(BaseSolver):
                             y0 = col_last_non_void[x0]
                             direction = 0
                         else:
-                                    direction = (
+                            direction = direction - (col_last_non_void[x0] - y0) - 1
-                                        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)
@@ -188,10 +177,7 @@ class Solver(BaseSolver):
                     if len(xi):
                         x0 = left + xi[-1] + 1
                         direction = 0
-                            elif (
+                    elif x0 - direction >= 0 and board[y0, x0 - direction] == EMPTY:
-                                x0 - direction >= 0
-                                and board[y0, x0 - direction] == EMPTY
-                            ):
                         x0 = x0 - direction
                         direction = 0
                     else:
@@ -200,9 +186,7 @@ class Solver(BaseSolver):
                             x0 = row_first_non_void[y0]
                             direction = 0
                         else:
-                                    direction = (
+                            direction = direction - (x0 - row_first_non_void[y0]) - 1
-                                        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)
@@ -210,10 +194,7 @@ class Solver(BaseSolver):
                     if len(yi):
                         y0 = top + yi[-1] + 1
                         direction = 0
-                            elif (
+                    elif y0 - direction >= 0 and board[y0 - direction, x0] == EMPTY:
-                                y0 - direction >= 0
-                                and board[y0 - direction, x0] == EMPTY
-                            ):
                         y0 = y0 - direction
                         direction = 0
                     else:
@@ -222,9 +203,7 @@ class Solver(BaseSolver):
                             y0 = col_first_non_void[x0]
                             direction = 0
                         else:
-                                    direction = (
+                            direction = direction - (y0 - col_first_non_void[x0]) - 1
-                                        direction - (y0 - col_first_non_void[x0]) - 1
-                                    )
                             y0, x0, r0 = y0_t, x0_t, r0_t
         else:
             r0 = {
@@ -236,8 +215,11 @@ class Solver(BaseSolver):
 
     return y0, x0, r0
 
+
 y1, x1, r1 = run(wrap_part_1)
-        yield 1000 * (1 + y1) + 4 * (1 + x1) + SCORES[r1]
+answer_1 = 1000 * (1 + y1) + 4 * (1 + x1) + SCORES[r1]
+print(f"answer 1 is {answer_1}")
 
 y2, x2, r2 = run(wrap_part_2)
-        yield 1000 * (1 + y2) + 4 * (1 + x2) + SCORES[r2]
+answer_2 = 1000 * (1 + y2) + 4 * (1 + x2) + SCORES[r2]
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2022/day23.py

@@ -1,4 +1,5 @@
 import itertools
+import sys
 from collections import defaultdict
 from typing import Any, Iterator
 
@@ -20,7 +21,7 @@ DIRECTIONS: Directions = [
 
 
 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}
+    ys, xs = {y for y, x in positions}, {x for y, x in positions}
     return min(ys), min(xs), max(ys), max(xs)
 
 
@@ -71,11 +72,9 @@ def round(
     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 i, row in enumerate(sys.stdin.read().splitlines())
     for j, col in enumerate(row)
     if col == "#"
 }
@@ -83,15 +82,14 @@ class Solver(BaseSolver):
 # === part 1 ===
 
 p1, d1 = POSITIONS.copy(), DIRECTIONS.copy()
-        for _ in range(10):
+for r in range(10):
     round(p1, d1)
 
 min_y, min_x, max_y, max_x = min_max_yx(p1)
-        yield sum(
+answer_1 = sum(
-            (y, x) not in p1
+    (y, x) not in p1 for y in range(min_y, max_y + 1) for x in range(min_x, max_x + 1)
-            for y in range(min_y, max_y + 1)
-            for x in range(min_x, max_x + 1)
 )
+print(f"answer 1 is {answer_1}")
 
 # === part 2 ===
 
@@ -105,4 +103,4 @@ class Solver(BaseSolver):
     if backup == p2:
         break
 
-        yield answer_2
+print(f"answer 2 is {answer_2}")

src/holt59/aoc/2022/day24.py

@@ -1,14 +1,12 @@
 import heapq
 import math
+import sys
 from collections import defaultdict
 from typing import Any, Iterator
 
 from ..base import BaseSolver
 
-
+lines = sys.stdin.read().splitlines()
-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])
@@ -20,12 +18,8 @@ class Solver(BaseSolver):
 n_rows, n_cols = len(lines) - 2, len(lines[0]) - 2
 CYCLE = math.lcm(n_rows, n_cols)
 
-        east_winds = [
+east_winds = [{j for j in range(n_cols) if (i, j, ">") in winds} for i in range(n_rows)]
-            {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)]
-        ]
-        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)
 ]
@@ -33,14 +27,13 @@ class Solver(BaseSolver):
     {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 = [
+    queue = [(heuristic(start[0], start[1]), 0, ((start[0], start[1]), start_cycle))]
-                (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: {})
 
@@ -64,17 +57,13 @@ class Solver(BaseSolver):
             n_cycle = (cycle + 1) % CYCLE
 
             if (ty, tx) == end:
-                        heapq.heappush(
+                heapq.heappush(queue, (distance + 1, distance + 1, ((ty, tx), n_cycle)))
-                            queue, (distance + 1, distance + 1, ((ty, tx), n_cycle))
-                        )
                 break
 
             if ((ty, tx), n_cycle) in visited:
                 continue
 
-                    if (ty, tx) != start and (
+            if (ty, tx) != start and (ty < 0 or tx < 0 or ty >= n_rows or tx >= n_cols):
-                        ty < 0 or tx < 0 or ty >= n_rows or tx >= n_cols
-                    ):
                 continue
 
             if (ty, tx) != start:
@@ -89,17 +78,12 @@ class Solver(BaseSolver):
 
             heapq.heappush(
                 queue,
-                        (
+                ((heuristic(ty, tx) + distance + 1, distance + 1, ((ty, tx), n_cycle))),
-                            (
-                                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,
@@ -110,8 +94,8 @@ class Solver(BaseSolver):
 )
 
 distances_1, forward_1 = run(start, 0, end)
-        yield forward_1
+print(f"answer 1 is {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)
+distances_3, forward_2 = run(start, next(iter(distances_2[start].keys())), end)
-        yield forward_1 + return_1 + forward_2
+print(f"answer 2 is {forward_1 + return_1 + forward_2}")

src/holt59/aoc/2022/day25.py

@@ -1,14 +1,13 @@
+import sys
 from typing import Any, Iterator
 
 from ..base import BaseSolver
 
-
+lines = sys.stdin.read().splitlines()
-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:
@@ -16,6 +15,7 @@ class Solver(BaseSolver):
         value += coeffs[c]
     return value
 
+
 def number2snafu(number: int) -> str:
     values = ["0", "1", "2", "=", "-"]
     res = ""
@@ -25,4 +25,6 @@ class Solver(BaseSolver):
         number = number // 5 + int(mod >= 3)
     return "".join(reversed(res))
 
-        yield number2snafu(sum(map(snafu2number, lines)))
+
+answer_1 = number2snafu(sum(map(snafu2number, lines)))
+print(f"answer 1 is {answer_1}")

src/holt59/aoc/__main__.py

@@ -179,7 +179,7 @@ def main():
     start = datetime.now()
     last = start
 
-    it = solver.solve(data.rstrip())
+    it = solver.solve(data.strip())
 
     if it is None:
         solver.logger.error(f"no implementation for {year} day {day}")