AoC 2022 Day 15 - faster

pareronia · pareronia · commit dc10273b0d7f · 2025-01-12T12:12:26.000+01:00
diff --git a/src/main/python/AoC2022_15.py b/src/main/python/AoC2022_15.py
@@ -3,16 +3,17 @@
 # Advent of Code 2022 Day 15
 #
 
+import itertools
 import re
 import sys
-from collections import defaultdict
 
 from aoc.common import InputData
 from aoc.common import SolutionBase
+from aoc.geometry import Position
+from aoc.range import RangeInclusive
 
-Sensors = list[tuple[int, int, int]]
-Beacons = dict[int, set[int]]
-Range = tuple[int, int]
+Sensors = dict[Position, int]
+Beacons = set[Position]
 Input = tuple[Sensors, Beacons]
 Output1 = int
 Output2 = int
@@ -37,61 +38,58 @@
 
 class Solution(SolutionBase[Input, Output1, Output2]):
     def parse_input(self, input_data: InputData) -> Input:
-        sensors = Sensors()
-        beacons = defaultdict[int, set[int]](set)
+        sensors, beacons = Sensors(), Beacons()
         for line in input_data:
             sx, sy, bx, by = map(int, re.findall(r"-?[0-9]+", line))
-            sensors.append((sx, sy, abs(sx - bx) + abs(sy - by)))
-            beacons[by].add(bx)
+            s, b = Position.of(sx, sy), Position.of(bx, by)
+            sensors[s] = s.manhattan_distance(b)
+            beacons.add(b)
         return sensors, beacons
 
-    def _get_ranges(self, sensors: Sensors, y: int) -> list[Range]:
-        ranges = list[Range]()
-        for sx, sy, d in sensors:
-            dy = abs(sy - y)
-            if dy > d:
-                continue
-            ranges.append((sx - d + dy, sx + d - dy))
-        merged = list[Range]()
-        for s_min, s_max in sorted(ranges):
-            if len(merged) == 0:
-                merged.append((s_min, s_max))
-                continue
-            last_min, last_max = merged[-1]
-            if s_min <= last_max:
-                merged[-1] = (last_min, max(last_max, s_max))
-                continue
-            merged.append((s_min, s_max))
-        return merged
-
-    def solve_1(self, input: Input, y: int) -> int:
+    def solve_1(self, input: Input, y: int) -> Output1:
         sensors, beacons = input
+
+        def get_ranges(y: int) -> list[RangeInclusive]:
+            ranges = list[RangeInclusive]()
+            for s, md in sensors.items():
+                dy = abs(s.y - y)
+                if dy > md:
+                    continue
+                ranges.append(
+                    RangeInclusive.between(s.x - md + dy, s.x + md - dy)
+                )
+            return RangeInclusive.merge(ranges)
+
         return sum(
-            (
-                r_max
-                - r_min
-                + 1
-                - sum(1 for bx in beacons[y] if r_min <= bx <= r_max)
-            )
-            for r_min, r_max in self._get_ranges(sensors, y)
+            r.len - len({b for b in beacons if b.y == y and r.contains(b.x)})
+            for r in get_ranges(y)
         )
 
-    def solve_2(self, input: Input, the_max: int) -> int:
+    def solve_2(self, input: Input, the_max: int) -> Output2:
+        """https://old.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0b90nr/"""  # noqa E501
         sensors, _ = input
-        for y in range(the_max, 0, -1):
-            ranges = self._get_ranges(sensors, y)
-            x = 0
-            while x <= the_max:
-                for r_min, r_max in ranges:
-                    if x < r_min:
-                        return x * 4_000_000 + y
-                    x = r_max + 1
-        raise RuntimeError()
-
-    def part_1(self, input: Input) -> int:
+        a_coeffs, b_coeffs = set(), set()
+        for s, md in sensors.items():
+            a_coeffs.add(s.y - s.x + md + 1)
+            a_coeffs.add(s.y - s.x - md - 1)
+            b_coeffs.add(s.x + s.y + md + 1)
+            b_coeffs.add(s.x + s.y - md - 1)
+        return next(
+            4_000_000 * p.x + p.y
+            for p in (
+                Position.of((ab[1] - ab[0]) // 2, (ab[0] + ab[1]) // 2)
+                for ab in itertools.product(a_coeffs, b_coeffs)
+                if ab[0] < ab[1] and (ab[1] - ab[0]) % 2 == 0
+            )
+            if 0 < p.x < the_max
+            and 0 < p.y < the_max
+            and all(p.manhattan_distance(s) > sensors[s] for s in sensors)
+        )
+
+    def part_1(self, input: Input) -> Output1:
         return self.solve_1(input, 2_000_000)
 
-    def part_2(self, input: Input) -> int:
+    def part_2(self, input: Input) -> Output2:
         return self.solve_2(input, 4_000_000)
 
     def samples(self) -> None:
diff --git a/src/main/python/aoc/range.py b/src/main/python/aoc/range.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from typing import Iterable
 from typing import Iterator
 from typing import NamedTuple
 
@@ -32,6 +33,26 @@ class RangeInclusive(NamedTuple):
     def between(cls, minimum: int, maximum: int) -> RangeInclusive:
         return RangeInclusive(minimum, maximum)
 
+    @classmethod
+    def merge(cls, ranges: Iterable[RangeInclusive]) -> list[RangeInclusive]:
+        merged = list[RangeInclusive]()
+        for rng in sorted(ranges):
+            if len(merged) == 0:
+                merged.append(rng)
+                continue
+            last = merged[-1]
+            if last.is_overlapped_by(rng):
+                merged[-1] = RangeInclusive.between(
+                    last.minimum, max(last.maximum, rng.maximum)
+                )
+            else:
+                merged.append(rng)
+        return merged
+
+    @property
+    def len(self) -> int:
+        return self.maximum - self.minimum + 1
+
     def contains(self, element: int) -> bool:
         return self.minimum <= element <= self.maximum
 
