AoC 2025 Day 5 - cleanup

Author: pareronia

src/main/python/AoC2019_04.py

@@ -5,7 +5,7 @@
 
 import sys
 from collections import Counter
-from typing import Callable
+from collections.abc import Callable
 
 from aoc.common import InputData
 from aoc.common import SolutionBase
@@ -18,7 +18,7 @@
 
 class Solution(SolutionBase[Input, Output1, Output2]):
     def parse_input(self, input_data: InputData) -> Input:
-        a, b = list(input_data)[0].split("-")
+        a, b = next(iter(input_data)).split("-")
         return RangeInclusive.between(int(a), int(b))
 
     def does_not_decrease(self, passw: str) -> bool:
@@ -30,14 +30,14 @@ def is_valid_1(self, passw: str) -> bool:
     def is_valid_2(self, passw: str) -> bool:
         return self.does_not_decrease(passw) and 2 in Counter(passw).values()
 
-    def count_valid(self, range: Input, check: Callable[[str], bool]) -> int:
-        return sum(check(str(i)) for i in range.iterator())
+    def count_valid(self, rng: Input, check: Callable[[str], bool]) -> int:
+        return sum(check(str(i)) for i in rng.iterator())
 
-    def part_1(self, range: Input) -> int:
-        return self.count_valid(range, self.is_valid_1)
+    def part_1(self, rng: Input) -> int:
+        return self.count_valid(rng, self.is_valid_1)
 
-    def part_2(self, range: Input) -> int:
-        return self.count_valid(range, self.is_valid_2)
+    def part_2(self, rng: Input) -> int:
+        return self.count_valid(rng, self.is_valid_2)
 
     def samples(self) -> None:
         assert self.is_valid_1("122345")

src/main/python/AoC2025_05.py

@@ -4,18 +4,15 @@
 #
 
 import sys
+from dataclasses import dataclass
+from typing import Self
 
 from aoc import my_aocd
 from aoc.common import InputData
 from aoc.common import SolutionBase
 from aoc.common import aoc_samples
 from aoc.range import RangeInclusive
 
-Input = InputData
-Output1 = int
-Output2 = int
-
-
 TEST = """\
 3-5
 10-14
@@ -31,33 +28,39 @@
 """
 
 
-class Solution(SolutionBase[Input, Output1, Output2]):
-    def parse_input(self, input_data: InputData) -> Input:
-        return input_data
+@dataclass(frozen=True)
+class Database:
+    id_ranges: set[RangeInclusive]
+    available_ids: list[int]
 
-    def part_1(self, inputs: Input) -> Output1:
-        blocks = my_aocd.to_blocks(list(inputs))
-        ranges = set[range]()
-        for line in blocks[0]:
-            lo, hi = map(int, line.split("-"))
-            ranges.add(range(lo, hi + 1))
-        ans = 0
-        for line in blocks[1]:
-            if any(int(line) in rng for rng in ranges):
-                ans += 1
-        return ans
-
-    def part_2(self, inputs: Input) -> Output2:
-        blocks = my_aocd.to_blocks(list(inputs))
+    @classmethod
+    def from_input(cls, input_data: InputData) -> Self:
+        blocks = my_aocd.to_blocks(input_data)
         ranges = set[RangeInclusive]()
         for line in blocks[0]:
             lo, hi = map(int, line.split("-"))
             ranges.add(RangeInclusive.between(lo, hi))
-        merged = RangeInclusive.merge(ranges)
-        ans = 0
-        for rng in merged:
-            ans += rng.len
-        return ans
+        pids = [int(line) for line in blocks[1]]
+        return cls(ranges, pids)
+
+
+Input = Database
+Output1 = int
+Output2 = int
+
+
+class Solution(SolutionBase[Input, Output1, Output2]):
+    def parse_input(self, input_data: InputData) -> Input:
+        return Database.from_input(input_data)
+
+    def part_1(self, database: Input) -> Output1:
+        return sum(
+            any(rng.contains(pid) for rng in database.id_ranges)
+            for pid in database.available_ids
+        )
+
+    def part_2(self, database: Input) -> Output2:
+        return sum(rng.len for rng in RangeInclusive.merge(database.id_ranges))
 
     @aoc_samples(
         (

src/main/python/aoc/range.py

@@ -1,8 +1,7 @@
-from __future__ import annotations
-
-from typing import Iterable
-from typing import Iterator
+from collections.abc import Iterable
+from collections.abc import Iterator
 from typing import NamedTuple
+from typing import Self
 
 
 class Range:
@@ -30,19 +29,19 @@ class RangeInclusive(NamedTuple):
     maximum: int
 
     @classmethod
-    def between(cls, minimum: int, maximum: int) -> RangeInclusive:
-        return RangeInclusive(minimum, maximum)
+    def between(cls, minimum: int, maximum: int) -> Self:
+        return cls(minimum, maximum)
 
     @classmethod
-    def merge(cls, ranges: Iterable[RangeInclusive]) -> list[RangeInclusive]:
-        merged = list[RangeInclusive]()
+    def merge(cls, ranges: Iterable[Self]) -> list[Self]:
+        merged = list[Self]()
         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(
+                merged[-1] = cls.between(
                     last.minimum, max(last.maximum, rng.maximum)
                 )
             else:
@@ -56,7 +55,7 @@ def len(self) -> int:
     def contains(self, element: int) -> bool:
         return self.minimum <= element <= self.maximum
 
-    def is_overlapped_by(self, other: RangeInclusive) -> bool:
+    def is_overlapped_by(self, other: Self) -> bool:
         return (
             other.contains(self.minimum)
             or other.contains(self.maximum)