Refactor to SolutionBase

Author: pareronia

src/main/python/AoC2022_02.py

@@ -4,7 +4,7 @@
 #
 
 import sys
-from typing import Callable
+from collections.abc import Callable
 
 from aoc.common import InputData
 from aoc.common import SolutionBase

src/main/python/AoC2022_03.py

@@ -4,37 +4,11 @@
 #
 
 
-from aoc.common import aoc_main
-
-
-def _priority(ch: str) -> int:
-    if "a" <= ch <= "z":
-        return ord(ch) - ord("a") + 1
-    else:
-        return ord(ch) - ord("A") + 27
-
-
-def part_1(inputs: tuple[str, ...]) -> int:
-    ans = 0
-    for input_ in inputs:
-        ln = len(input_) // 2
-        s1 = {_ for _ in input_[:ln]}
-        s2 = {_ for _ in input_[ln:]}
-        ch = (s1 & s2).pop()
-        ans += _priority(ch)
-    return ans
-
-
-def part_2(inputs: tuple[str, ...]) -> int:
-    ans = 0
-    for i in range(0, len(inputs), 3):
-        s1 = {_ for _ in inputs[i]}
-        s2 = {_ for _ in inputs[i + 1]}
-        s3 = {_ for _ in inputs[i + 2]}
-        ch = (s1 & s2 & s3).pop()
-        ans += _priority(ch)
-    return ans
+import sys
 
+from aoc.common import InputData
+from aoc.common import SolutionBase
+from aoc.common import aoc_samples
 
 TEST = """\
 vJrwpWtwJgWrhcsFMMfFFhFp
@@ -43,13 +17,58 @@ def part_2(inputs: tuple[str, ...]) -> int:
 wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
 ttgJtRGJQctTZtZT
 CrZsJsPPZsGzwwsLwLmpwMDw
-""".splitlines()
+"""
+
+
+Input = tuple[str, ...]
+Output1 = int
+Output2 = int
+
+
+class Solution(SolutionBase[Input, Output1, Output2]):
+    def parse_input(self, input_data: InputData) -> Input:
+        return tuple(input_data)
+
+    def priority(self, ch: str) -> int:
+        if "a" <= ch <= "z":
+            return ord(ch) - ord("a") + 1
+        return ord(ch) - ord("A") + 27
+
+    def part_1(self, inputs: Input) -> Output1:
+        ans = 0
+        for input_ in inputs:
+            ln = len(input_) // 2
+            s1 = set(input_[:ln])
+            s2 = set(input_[ln:])
+            ch = (s1 & s2).pop()
+            ans += self.priority(ch)
+        return ans
+
+    def part_2(self, inputs: Input) -> Output2:
+        ans = 0
+        for i in range(0, len(inputs), 3):
+            s1 = set(inputs[i])
+            s2 = set(inputs[i + 1])
+            s3 = set(inputs[i + 2])
+            ch = (s1 & s2 & s3).pop()
+            ans += self.priority(ch)
+        return ans
+
+    @aoc_samples(
+        (
+            ("part_1", TEST, 157),
+            ("part_2", TEST, 70),
+        )
+    )
+    def samples(self) -> None:
+        pass
+
+
+solution = Solution(2022, 3)
 
 
-@aoc_main(2022, 3, part_1, part_2)
 def main() -> None:
-    assert part_1(TEST) == 157  # type:ignore[arg-type]
-    assert part_2(TEST) == 70  # type:ignore[arg-type]
+    solution.run(sys.argv)
 
 
 if __name__ == "__main__":

src/main/python/AoC2022_04.py

@@ -7,32 +7,16 @@
 from __future__ import annotations
 
 import re
-from typing import Callable
+from typing import TYPE_CHECKING
 
-from aoc.common import aoc_main
+if TYPE_CHECKING:
+    from collections.abc import Callable
 
+import sys
 
-def _solve(
-    inputs: tuple[str, ...], f: Callable[[set[int], set[int]], bool]
-) -> int:
-    return sum(
-        f(
-            set(range(n1, n2 + 1)),
-            set(range(n3, n4 + 1)),
-        )
-        for n1, n2, n3, n4 in (
-            (int(n) for n in re.findall(r"[0-9]+", line)) for line in inputs
-        )
-    )
-
-
-def part_1(inputs: tuple[str, ...]) -> int:
-    return _solve(inputs, lambda s1, s2: s1.issubset(s2) or s2.issubset(s1))
-
-
-def part_2(inputs: tuple[str, ...]) -> int:
-    return _solve(inputs, lambda s1, s2: not s1.isdisjoint(s2))
-
+from aoc.common import InputData
+from aoc.common import SolutionBase
+from aoc.common import aoc_samples
 
 TEST = """\
 2-4,6-8
@@ -41,13 +25,55 @@ def part_2(inputs: tuple[str, ...]) -> int:
 2-8,3-7
 6-6,4-6
 2-6,4-8
-""".splitlines()
+"""
+
+
+Input = tuple[str, ...]
+Output1 = int
+Output2 = int
+RE = re.compile(r"[0-9]+")
+
+
+class Solution(SolutionBase[Input, Output1, Output2]):
+    def parse_input(self, input_data: InputData) -> Input:
+        return tuple(input_data)
+
+    def solve(
+        self, inputs: tuple[str, ...], f: Callable[[set[int], set[int]], bool]
+    ) -> int:
+        return sum(
+            f(
+                set(range(n1, n2 + 1)),
+                set(range(n3, n4 + 1)),
+            )
+            for n1, n2, n3, n4 in (
+                (int(n) for n in RE.findall(line)) for line in inputs
+            )
+        )
+
+    def part_1(self, inputs: Input) -> Output1:
+        return self.solve(
+            inputs, lambda s1, s2: s1.issubset(s2) or s2.issubset(s1)
+        )
+
+    def part_2(self, inputs: Input) -> Output2:
+        return self.solve(inputs, lambda s1, s2: not s1.isdisjoint(s2))
+
+    @aoc_samples(
+        (
+            ("part_1", TEST, 2),
+            ("part_2", TEST, 4),
+        )
+    )
+    def samples(self) -> None:
+        pass
+
+
+solution = Solution(2022, 4)
 
 
-@aoc_main(2022, 4, part_1, part_2)
 def main() -> None:
-    assert part_1(TEST) == 2  # type:ignore[arg-type]
-    assert part_2(TEST) == 4  # type:ignore[arg-type]
+    solution.run(sys.argv)
 
 
 if __name__ == "__main__":

src/main/python/AoC2022_05.py

@@ -5,80 +5,94 @@
 
 
 import re
+import sys
 
 from aoc import my_aocd
-from aoc.common import aoc_main
+from aoc.common import InputData
+from aoc.common import SolutionBase
+from aoc.common import aoc_samples
+
+TEST = """\
+    [D]    \n\
+[N] [C]    \n\
+[Z] [M] [P]\n\
+ 1   2   3 \n\
+
+move 1 from 2 to 1
+move 3 from 1 to 3
+move 2 from 2 to 1
+move 1 from 1 to 2
+"""
 
-Move = tuple[int, int, int]
 
+Move = tuple[int, int, int]
+Stack = tuple[str, ...]
+Input = tuple[tuple[Stack, ...], tuple[Move, ...]]
+Output1 = str
+Output2 = str
+RE = re.compile(r"[0-9]+")
 CM_9000 = "CrateMover 9000"
 CM_9001 = "CrateMover 9001"
 
 
-def _parse(inputs: tuple[str, ...]) -> tuple[list[list[str]], list[Move]]:
-    blocks = my_aocd.to_blocks(inputs)
-    size = int(blocks[0][-1].replace(" ", "")[-1])
-    stacks: list[list[str]] = [[] for _ in range(size)]
-    for i in range(len(blocks[0]) - 2, -1, -1):
-        line = blocks[0][i]
-        for j in range(len(line)):
-            if j % 4 == 1 and line[j] != " ":
-                stacks[j // 4].append(line[j])
-    moves = [
-        (n1, n2 - 1, n3 - 1)
-        for n1, n2, n3 in (
-            (int(n) for n in re.findall(r"[0-9]+", line)) for line in blocks[1]
+class Solution(SolutionBase[Input, Output1, Output2]):
+    def parse_input(self, input_data: InputData) -> Input:
+        blocks = my_aocd.to_blocks(list(input_data))
+        size = int(blocks[0][-1].replace(" ", "")[-1])
+        stacks: list[list[str]] = [[] for _ in range(size)]
+        for i in range(len(blocks[0]) - 2, -1, -1):
+            line = blocks[0][i]
+            for j in range(len(line)):
+                if j % 4 == 1 and line[j] != " ":
+                    stacks[j // 4].append(line[j])
+        moves = tuple(
+            (n1, n2 - 1, n3 - 1)
+            for n1, n2, n3 in (
+                (int(n) for n in RE.findall(line)) for line in blocks[1]
+            )
+        )
+        return tuple(tuple(stack) for stack in stacks), moves
+
+    def simulate_for(
+        self,
+        stacks: tuple[Stack, ...],
+        moves: tuple[Move, ...],
+        crate_mover: str,
+    ) -> str:
+        new_stacks = [list(stack) for stack in stacks]
+        for amount, _from, to in moves:
+            tmp = []
+            for _ in range(amount):
+                tmp.append(new_stacks[_from][-1])
+                new_stacks[_from] = new_stacks[_from][:-1]
+            new_stacks[to].extend(
+                tmp if crate_mover == CM_9000 else reversed(tmp)
+            )
+        return "".join(stack[-1] for stack in new_stacks)
+
+    def part_1(self, inputs: Input) -> Output1:
+        stacks, moves = inputs
+        return self.simulate_for(stacks, moves, crate_mover=CM_9000)
+
+    def part_2(self, inputs: Input) -> Output2:
+        stacks, moves = inputs
+        return self.simulate_for(stacks, moves, crate_mover=CM_9001)
+
+    @aoc_samples(
+        (
+            ("part_1", TEST, "CMZ"),
+            ("part_2", TEST, "MCD"),
         )
-    ]
-    return stacks, moves
-
-
-def _simulate_for(
-    stacks: list[list[str]], moves: list[Move], crate_mover: str
-) -> str:
-    for amount, _from, to in moves:
-        tmp = []
-        for _ in range(amount):
-            crate = stacks[_from][-1]
-            stacks[_from] = stacks[_from][:-1]
-            if crate_mover == CM_9000:
-                tmp.append(crate)
-            else:
-                tmp.insert(0, crate)
-        for c in tmp:
-            stacks[to].append(c)
-    return "".join(stack[-1] for stack in stacks)
-
-
-def part_1(inputs: tuple[str, ...]) -> str:
-    stacks, moves = _parse(inputs)
-    return _simulate_for(stacks, moves, CM_9000)
-
-
-def part_2(inputs: tuple[str, ...]) -> str:
-    stacks, moves = _parse(inputs)
-    return _simulate_for(stacks, moves, CM_9001)
-
-
-TEST = tuple(
-    [
-        "    [D]    ",
-        "[N] [C]    ",
-        "[Z] [M] [P]",
-        " 1   2   3 ",
-        "",
-        "move 1 from 2 to 1",
-        "move 3 from 1 to 3",
-        "move 2 from 2 to 1",
-        "move 1 from 1 to 2",
-    ]
-)
-
-
-@aoc_main(2022, 5, part_1, part_2)
+    )
+    def samples(self) -> None:
+        pass
+
+
+solution = Solution(2022, 5)
+
+
 def main() -> None:
-    assert part_1(TEST) == "CMZ"
-    assert part_2(TEST) == "MCD"
+    solution.run(sys.argv)
 
 
 if __name__ == "__main__":