Advent of Code: improve parser-guesser and apply to another 22 solutions

IsaacG · IsaacG · commit 9120baaf714f · 2025-12-04T23:30:41.000-08:00
diff --git a/advent_of_code/2015/d02.py b/advent_of_code/2015/d02.py
@@ -19,7 +19,6 @@ class Day02(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE[0], part=2, want=34),
         aoc.TestCase(inputs=SAMPLE[1], part=2, want=14),
     ]
-    INPUT_PARSER = aoc.parse_ints
 
     def part1(self, puzzle_input: InputType) -> int:
         """Return the amount of wrapping paper needed."""
diff --git a/advent_of_code/2015/d19.py b/advent_of_code/2015/d19.py
@@ -48,8 +48,6 @@ class Day19(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE[0], part=2, want=aoc.TEST_SKIP),
     ]
 
-    INPUT_PARSER = aoc.ParseBlocks([aoc.parse_multi_str_per_line, aoc.parse_one_str])
-
     def part1(self, puzzle_input: InputType) -> int:
         mappings, start = puzzle_input
         found = set()
diff --git a/advent_of_code/2017/d20.py b/advent_of_code/2017/d20.py
@@ -24,7 +24,6 @@ class Day20(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE[0], want=0),
         aoc.TestCase(part=2, inputs=SAMPLE[1], want=1),
     ]
-    INPUT_PARSER = aoc.parse_ints
 
     @staticmethod
     def distance(vals: tuple[int, ...]) -> int:
diff --git a/advent_of_code/2018/d06.py b/advent_of_code/2018/d06.py
@@ -20,7 +20,6 @@ class Day06(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=17),
         aoc.TestCase(part=2, inputs=SAMPLE, want=16),
     ]
-    INPUT_PARSER = aoc.parse_ints
 
     def minmax(self, puzzle_input: list[list[int]]) -> tuple[int, int, int, int]:
         """Return the boundaries of the puzzle."""
diff --git a/advent_of_code/2018/d14.py b/advent_of_code/2018/d14.py
@@ -7,7 +7,6 @@
 class Day14(aoc.Challenge):
     """Day 14: Chocolate Charts. Mix recipes until a pattern is found."""
 
-    INPUT_PARSER = aoc.parse_one_str
     TESTS = [
         aoc.TestCase(inputs="9", part=1, want="5158916779"),
         aoc.TestCase(inputs="5", part=1, want="0124515891"),
@@ -18,6 +17,7 @@ class Day14(aoc.Challenge):
         aoc.TestCase(inputs="92510", part=2, want=18),
         aoc.TestCase(inputs="59414", part=2, want=2018),
     ]
+    INPUT_PARSER = aoc.parse_one_str
 
     def solver(self, puzzle_input: str, part_one: bool) -> int | str:
         """Solve for the target recipes."""
diff --git a/advent_of_code/2018/d18.py b/advent_of_code/2018/d18.py
@@ -27,7 +27,7 @@ class Day18(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=1147),
         aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.CoordinatesParserC(chars=None, origin_top_left=True)
+    INPUT_PARSER = aoc.CoordinatesParserC()
 
     def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:
         area = typing.cast(frozendict.frozendict[complex, str], frozendict.frozendict(puzzle_input.chars))
diff --git a/advent_of_code/2018/d19.py b/advent_of_code/2018/d19.py
@@ -22,7 +22,6 @@ class Day19(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=6),
         aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.parse_multi_mixed_per_line
 
     def compute(self, puzzle_input: list[list[str | int]], initial: int) -> int:
         """Run a CPU simulator."""
diff --git a/advent_of_code/2018/d20.py b/advent_of_code/2018/d20.py
@@ -18,7 +18,6 @@ class Day20(aoc.Challenge):
         aoc.TestCase(part=1, inputs="^WSSEESWWWNW(S|NENNEEEENN(ESSSSW(NWSW|SSEN)|WSWWN(E|WWS(E|SS))))$", want=31),
         aoc.TestCase(part=2, inputs="", want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.parse_one_str
 
     def solver(self, puzzle_input: str, part_one: bool) -> int:
         """Walk a regex to explore a map."""
diff --git a/advent_of_code/2018/d21.py b/advent_of_code/2018/d21.py
@@ -58,7 +58,6 @@ class Day21(aoc.Challenge):
         aoc.TestCase(part=1, inputs="", want=aoc.TEST_SKIP),
         aoc.TestCase(part=2, inputs="", want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.parse_multi_mixed_per_line
 
     def part1(self, puzzle_input: list[list[str | int]]) -> int:
         """Return the r0 value needed to make the program terminate."""
diff --git a/advent_of_code/2019/d02.py b/advent_of_code/2019/d02.py
@@ -16,7 +16,6 @@ class Day02(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE[0], part=1, want=3500),
         aoc.TestCase(inputs=SAMPLE[0], part=2, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.parse_one_str
 
     def run_with_inputs(self, program: str, noun: int, verb: int) -> int:
         computer = intcode.Computer(program)
diff --git a/advent_of_code/2019/d16.py b/advent_of_code/2019/d16.py
@@ -27,7 +27,6 @@ class Day16(aoc.Challenge):
         aoc.TestCase(inputs="", part=2, want=0),
         # aoc.TestCase(inputs=SAMPLE[0], part=2, want=aoc.TEST_SKIP),
     ]
-
     INPUT_PARSER = aoc.parse_one_str
 
     @functools.cache
diff --git a/advent_of_code/2019/d19.py b/advent_of_code/2019/d19.py
@@ -14,7 +14,6 @@ class Day19(aoc.Challenge):
         aoc.TestCase(part=1, inputs="", want=aoc.TEST_SKIP),
         aoc.TestCase(part=2, inputs="", want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.parse_one_str
 
     def is_on(self, computer, x: int, y: int) -> bool:
         """Return if a given coordinate is on."""
diff --git a/advent_of_code/2021/d02.py b/advent_of_code/2021/d02.py
@@ -23,7 +23,6 @@ class Day02(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE, part=1, want=150),
         aoc.TestCase(inputs=SAMPLE, part=2, want=900),
     )
-    INPUT_PARSER = aoc.parse_multi_mixed_per_line
 
     def part1(self, puzzle_input: list[tuple[str, int]]) -> int:
         """Compute the submarine's horizontal position and depth."""
diff --git a/advent_of_code/2022/d01.py b/advent_of_code/2022/d01.py
@@ -28,7 +28,6 @@ class Day01(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE, part=1, want=24000),
         aoc.TestCase(inputs=SAMPLE, part=2, want=45000),
     ]
-    INPUT_PARSER = aoc.ParseBlocks([aoc.parse_one_int_per_line])
 
     def part1(self, puzzle_input: InputType) -> int:
         """Return the sum calories held by the elf with the most calories."""
diff --git a/advent_of_code/2022/d02.py b/advent_of_code/2022/d02.py
@@ -22,7 +22,6 @@ class Day02(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE, part=1, want=15),
         aoc.TestCase(inputs=SAMPLE, part=2, want=12),
     ]
-    INPUT_PARSER = aoc.parse_multi_str_per_line
 
     def part1(self, puzzle_input: InputType) -> int:
         """Score a tournament with the columns representing the choices."""
diff --git a/advent_of_code/2022/d09.py b/advent_of_code/2022/d09.py
@@ -35,7 +35,6 @@ class Day09(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE[0], part=1, want=13),
         aoc.TestCase(inputs=SAMPLE[1], part=2, want=36),
     ]
-    INPUT_PARSER = aoc.parse_multi_mixed_per_line
 
     def solver(self, lines: list[tuple[str, int]], part_one: bool) -> int:
         """Track the movement of knots on a rope. Return the number of positions the tail visits."""
@@ -48,8 +47,8 @@ def solver(self, lines: list[tuple[str, int]], part_one: bool) -> int:
                 for i, (a, b) in enumerate(zip(knots, knots[1:])):
                     if a - b in aoc.EIGHT_DIRECTIONS:
                         continue
-                    x = self.cmp(a.real, b.real)
-                    y = self.cmp(a.imag, b.imag)
+                    x = aoc.cmp(a.real, b.real)
+                    y = aoc.cmp(a.imag, b.imag)
                     knots[i + 1] += complex(x, y)
                 points.add(knots[-1])
         return len(points)
diff --git a/advent_of_code/2022/d10.py b/advent_of_code/2022/d10.py
@@ -164,7 +164,6 @@ class Day10(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE, part=1, want=13140),
         aoc.TestCase(inputs=SAMPLE, part=2, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.parse_multi_mixed_per_line
 
     def run_program(self, lines: InputType) -> list[int]:
         """Run the program and store the `X` register value for each cycle."""
diff --git a/advent_of_code/2023/d13.py b/advent_of_code/2023/d13.py
@@ -20,7 +20,7 @@
 ..##..###
 #....#..#"""
 
-InputType = list[set[complex]]
+InputType = list[set[tuple[int, int]]]
 
 
 class Day13(aoc.Challenge):
@@ -30,39 +30,44 @@ class Day13(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE, part=1, want=405),
         aoc.TestCase(inputs=SAMPLE, part=2, want=400),
     ]
-    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParserC()])
 
-    def find_mirror(self, points: set[complex], point: complex | None) -> int | None:
+    def find_mirror(self, points: set[tuple[int, int]], point: tuple[int, int] | None) -> int | None:
         """Find the row/column around which the data is mirrored.
 
         Optionally take a point which must be reflected.
         """
-        min_x, min_y, max_x, max_y = aoc.bounding_coords(points)
+        min_x = min(x for x, _ in points)
+        min_y = min(y for _, y in points)
+        max_x = max(x for x, _ in points)
+        max_y = max(y for _, y in points)
 
         for x in range(min_x, max_x):
             shift = 2 * x + 1
-            if point is not None and not min_x <= shift - point.real <= max_x:
+            if point is not None and not min_x <= shift - point[0] <= max_x:
                 continue
-            if all(complex(shift - p.real, p.imag) in points for p in points if min_x <= shift - p.real <= max_x):
+            if all((shift - p[0], p[1]) in points for p in points if min_x <= shift - p[0] <= max_x):
                 return x + 1
 
         for y in range(min_y, max_y):
             shift = 2 * y + 1
-            if point is not None and not min_y <= shift - point.imag <= max_y:
+            if point is not None and not min_y <= shift - point[1] <= max_y:
                 continue
-            if all(complex(p.real, shift - p.imag) in points for p in points if min_y <= shift - p.imag <= max_y):
+            if all((p[0], shift - p[1]) in points for p in points if min_y <= shift - p[1] <= max_y):
                 return 100 * (y + 1)
 
         return None
 
-    def find_with_change(self, points: set[complex]) -> int:
+    def find_with_change(self, points: set[tuple[int, int]]) -> int:
         """Try finding the mirror with a point toggled."""
         points = points.copy()
-        min_x, min_y, max_x, max_y = aoc.bounding_coords(points)
+        min_x = min(x for x, _ in points)
+        min_y = min(y for _, y in points)
+        max_x = max(x for x, _ in points)
+        max_y = max(y for _, y in points)
         ops = {True: [points.remove, points.add], False: [points.add, points.remove]}
         for x in range(min_x, max_x + 1):
             for y in range(min_y, max_y + 1):
-                point = complex(x, y)
+                point = (x, y)
                 op_a, op_b = ops[point in points]
                 # Add/compute/remove or remove/compute/add.
                 op_a(point)
diff --git a/advent_of_code/2024/d08.py b/advent_of_code/2024/d08.py
@@ -33,7 +33,7 @@ def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:
         all_locations = puzzle_input.all_coords
         antinodes = set()
         for freq in puzzle_input.non_blank_chars:
-            for a, b in itertools.combinations(puzzle_input[freq], 2):
+            for a, b in itertools.combinations(puzzle_input.coords[freq], 2):
                 sequences: tuple[collections.abc.Iterable[int], collections.abc.Iterable[int]]
                 if part_one:
                     sequences = ([2], [-1])
diff --git a/advent_of_code/2024/d10.py b/advent_of_code/2024/d10.py
@@ -21,7 +21,6 @@ class Day10(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=36),
         aoc.TestCase(part=2, inputs=SAMPLE, want=81),
     ]
-    INPUT_PARSER = aoc.CoordinatesParserC()
 
     def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:
         """Score and rate trails by computing how to walk the trail to a 9."""
@@ -33,8 +32,8 @@ def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:
                 new_trails = set()
                 for last_pos, path in trails:
                     coords = maps[elevation]
-                    for neighbor in aoc.FOUR_DIRECTIONS:
-                        if (new_pos := last_pos + neighbor) in coords:
+                    for dx, dy in aoc.FOUR_DIRECTIONS_T:
+                        if (new_pos := (last_pos[0] + dx, last_pos[1] + dy)) in coords:
                             new_trails.add((new_pos, path + (new_pos,)))
                 trails = new_trails
             total += len({trail[0 if part_one else 1] for trail in trails})
diff --git a/advent_of_code/2024/d14.py b/advent_of_code/2024/d14.py
@@ -47,7 +47,6 @@ class Day14(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=12),
         aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.parse_ints
 
     def part1(self, puzzle_input: list[list[int]]) -> int:
         """Simulate robots for 100 steps."""
diff --git a/advent_of_code/2024/d25.py b/advent_of_code/2024/d25.py
@@ -53,7 +53,6 @@ class Day25(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=3),
         aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParserC()])
 
     def part1(self, puzzle_input: list[aoc.Map]) -> int:
         """Count how many keys (loosely) fit inside a locks."""
diff --git a/advent_of_code/2025/d05.py b/advent_of_code/2025/d05.py
@@ -23,13 +23,12 @@ class Day05(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=3),
         aoc.TestCase(part=2, inputs=SAMPLE, want=14),
     ]
-    INPUT_PARSER = aoc.ParseBlocks([aoc.parse_re_findall_int(r"\d+")])
 
-    def part1(self, puzzle_input: list[list[list[int]]]) -> int:
+    def part1(self, puzzle_input: list[list[int] | list[list[int]]]) -> int:
         """Return how many available ingredients are fresh."""
         fresh, available = puzzle_input
         return sum(
-            any(x <= ingredient[0] <= y for x, y in fresh)
+            any(x <= ingredient <= y for x, y in fresh)
             for ingredient in available
         )
 
diff --git a/pylib/aoc.py b/pylib/aoc.py
@@ -614,11 +614,25 @@ def _parser(self) -> parsers.BaseParser:
             return self.INPUT_PARSER
         # Use heuristics to guess at an input parser.
         data = self.raw_data(None)
+        got = self._guess_parser(data)
+        # print("Guessing at parser", got)
+        return got
+
+    def _guess_parser(self, data: str) -> parsers.BaseParser:
+        for i in range(5, 1, -1):
+            sep = "\n" * i
+            if sep in data:
+                parsers = [self._guess_parser(chunk) for chunk in data.split(sep)]
+                if len(parsers) > 5 and all(type(parser) == type(parsers[0]) for parser in parsers):
+                    parsers = parsers[:1]
+                return ParseBlocks(separator=sep, parsers=parsers)
+
         lines = data.splitlines()
         multi_line = len(lines) > 1
         one_line = lines[0]
 
-        if len(lines) > 5 and len(lines[0]) > 5 and len(lines) == len(lines[0]):
+        check_lines = lines if len(lines) < 10 else lines[:-1]
+        if len(lines) >= 5 and len(lines[0]) >= 5 and all(len(line) == len(lines[0]) for line in check_lines):
             return CoordinatesParser()
         pi = ParseIntergers(multi_line=multi_line)
         if pi.matches(data):
@@ -640,7 +654,7 @@ def _parser(self) -> parsers.BaseParser:
         word_count = max(len(line.split()) for line in data.splitlines())
         if word_count == 1:
             return parse_one_str_per_line if multi_line else parse_one_str
-        return parse_multi_str_per_line if multi_line else parse_one_str
+        return parse_multi_mixed_per_line if multi_line else parse_one_str
 
     def input_parser(self, puzzle_input: str) -> Any:
         """Parse input data. Block of text -> output."""
diff --git a/pylib/helpers.py b/pylib/helpers.py
@@ -25,7 +25,8 @@
 LETTER_DIRECTIONS = {"U": UP, "D": DOWN, "R": RIGHT, "L": LEFT}
 COMPASS_DIRECTIONS = {"S": -1j, "N": 1j, "E": 1, "W": -1}
 STRAIGHT_NEIGHBORS = FOUR_DIRECTIONS
-STRAIGHT_NEIGHBORS_T = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+FOUR_DIRECTIONS_T = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+STRAIGHT_NEIGHBORS_T = FOUR_DIRECTIONS_T
 DIAGONALS = [((1 + 1j) * -1j ** i) for i in range(4)]
 EIGHT_DIRECTIONS = FOUR_DIRECTIONS + DIAGONALS
 ALL_NEIGHBORS = EIGHT_DIRECTIONS
diff --git a/pylib/parsers.py b/pylib/parsers.py
@@ -18,6 +18,8 @@
 
 RE_INT = re.compile(r"[+-]?\d{1,1000}")
 RE_BOUNDED_INT = re.compile(r"[+-]?\b\d+\b")
+RE_BOUNDED_INT_UNSIGNED = re.compile(r"\b\d+\b")
+RE_INT_RANGES = re.compile(r"\d+(-\d+)+")
 RE_POINT = re.compile(r"[+-]?\d+,[+-]?\d+")
 
 
@@ -68,16 +70,24 @@ class ParseIntergers(BaseParser):
     """Get integers from input."""
 
     multi_line: bool | None = None
-    NUMBER_LINE = re.compile(r"^[+-]?\d{1,1000}( +[+-]?\d{1,1000})*$")
 
     def matches(self, puzzle_input) -> bool:
         """Check if the input is all numbers."""
-        return all(self.NUMBER_LINE.fullmatch(line) for line in puzzle_input.splitlines())
+        patterns = [
+            re.compile(r"[+-]?\d{1,1000}( *[+-]?\d{1,1000})*"),
+        ]
+        return any(
+            all(pattern.fullmatch(line) for line in puzzle_input.splitlines())
+            for pattern in patterns
+        )
 
     def parse(self, puzzle_input: str) -> int | list[int] | list[list[int]]:
         """Parse a puzzle input."""
         lines = puzzle_input.splitlines()
-        numbers = [[int(num) for num in RE_BOUNDED_INT.findall(line)] for line in lines]
+        regex = RE_BOUNDED_INT
+        if all(RE_INT_RANGES.fullmatch(line) for line in lines):
+            regex = RE_BOUNDED_INT_UNSIGNED
+        numbers = [[int(num) for num in regex.findall(line)] for line in lines]
         numbers = [n for n in numbers if n]
         multi_line = len(numbers) > 1 if self.multi_line is None else self.multi_line
         multi_word = any(len(line) > 1 for line in numbers)

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,6 @@ class Day02(aoc.Challenge):`
`19`	`19`	`aoc.TestCase(inputs=SAMPLE[0], part=2, want=34),`
`20`	`20`	`aoc.TestCase(inputs=SAMPLE[1], part=2, want=14),`
`21`	`21`	`]`
`22`		`- INPUT_PARSER = aoc.parse_ints`
`23`	`22`
`24`	`23`	`def part1(self, puzzle_input: InputType) -> int:`
`25`	`24`	`"""Return the amount of wrapping paper needed."""`
Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,6 @@ class Day19(aoc.Challenge):`
`48`	`48`	`aoc.TestCase(inputs=SAMPLE[0], part=2, want=aoc.TEST_SKIP),`
`49`	`49`	`]`
`50`	`50`
`51`		`- INPUT_PARSER = aoc.ParseBlocks([aoc.parse_multi_str_per_line, aoc.parse_one_str])`
`52`		`-`
`53`	`51`	`def part1(self, puzzle_input: InputType) -> int:`
`54`	`52`	`mappings, start = puzzle_input`
`55`	`53`	`found = set()`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,6 @@ class Day20(aoc.Challenge):`
`24`	`24`	`aoc.TestCase(part=1, inputs=SAMPLE[0], want=0),`
`25`	`25`	`aoc.TestCase(part=2, inputs=SAMPLE[1], want=1),`
`26`	`26`	`]`
`27`		`- INPUT_PARSER = aoc.parse_ints`
`28`	`27`
`29`	`28`	`@staticmethod`
`30`	`29`	`def distance(vals: tuple[int, ...]) -> int:`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@ class Day06(aoc.Challenge):`
`20`	`20`	`aoc.TestCase(part=1, inputs=SAMPLE, want=17),`
`21`	`21`	`aoc.TestCase(part=2, inputs=SAMPLE, want=16),`
`22`	`22`	`]`
`23`		`- INPUT_PARSER = aoc.parse_ints`
`24`	`23`
`25`	`24`	`def minmax(self, puzzle_input: list[list[int]]) -> tuple[int, int, int, int]:`
`26`	`25`	`"""Return the boundaries of the puzzle."""`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ class Day18(aoc.Challenge):`
`27`	`27`	`aoc.TestCase(part=1, inputs=SAMPLE, want=1147),`
`28`	`28`	`aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),`
`29`	`29`	`]`
`30`		`- INPUT_PARSER = aoc.CoordinatesParserC(chars=None, origin_top_left=True)`
	`30`	`+ INPUT_PARSER = aoc.CoordinatesParserC()`
`31`	`31`
`32`	`32`	`def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:`
`33`	`33`	`area = typing.cast(frozendict.frozendict[complex, str], frozendict.frozendict(puzzle_input.chars))`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ class Day19(aoc.Challenge):`
`22`	`22`	`aoc.TestCase(part=1, inputs=SAMPLE, want=6),`
`23`	`23`	`aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),`
`24`	`24`	`]`
`25`		`- INPUT_PARSER = aoc.parse_multi_mixed_per_line`
`26`	`25`
`27`	`26`	`def compute(self, puzzle_input: list[list[str \| int]], initial: int) -> int:`
`28`	`27`	`"""Run a CPU simulator."""`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,6 @@ class Day20(aoc.Challenge):`
`18`	`18`	`aoc.TestCase(part=1, inputs="^WSSEESWWWNW(S\|NENNEEEENN(ESSSSW(NWSW\|SSEN)\|WSWWN(E\|WWS(E\|SS))))$", want=31),`
`19`	`19`	`aoc.TestCase(part=2, inputs="", want=aoc.TEST_SKIP),`
`20`	`20`	`]`
`21`		`- INPUT_PARSER = aoc.parse_one_str`
`22`	`21`
`23`	`22`	`def solver(self, puzzle_input: str, part_one: bool) -> int:`
`24`	`23`	`"""Walk a regex to explore a map."""`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,6 @@ class Day21(aoc.Challenge):`
`58`	`58`	`aoc.TestCase(part=1, inputs="", want=aoc.TEST_SKIP),`
`59`	`59`	`aoc.TestCase(part=2, inputs="", want=aoc.TEST_SKIP),`
`60`	`60`	`]`
`61`		`- INPUT_PARSER = aoc.parse_multi_mixed_per_line`
`62`	`61`
`63`	`62`	`def part1(self, puzzle_input: list[list[str \| int]]) -> int:`
`64`	`63`	`"""Return the r0 value needed to make the program terminate."""`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,6 @@ class Day02(aoc.Challenge):`
`16`	`16`	`aoc.TestCase(inputs=SAMPLE[0], part=1, want=3500),`
`17`	`17`	`aoc.TestCase(inputs=SAMPLE[0], part=2, want=aoc.TEST_SKIP),`
`18`	`18`	`]`
`19`		`- INPUT_PARSER = aoc.parse_one_str`
`20`	`19`
`21`	`20`	`def run_with_inputs(self, program: str, noun: int, verb: int) -> int:`
`22`	`21`	`computer = intcode.Computer(program)`