Refactor to SolutionBase

Author: pareronia

src/main/python/AoC2015_05.py

@@ -4,60 +4,77 @@
 #
 
 import re
-from aoc import my_aocd
+import sys
 
+from aoc.common import InputData
+from aoc.common import SolutionBase
+from aoc.common import aoc_samples
 
-def _count_matches(regexp: str, string: str) -> int:
-    return len(re.findall(regexp, string))
+Input = list[str]
+Output1 = int
+Output2 = int
 
 
-def part_1(inputs: tuple[str]) -> int:
-    return sum(1 for input_ in inputs
-               if _count_matches(r"(a|e|i|o|u)", input_) >= 3
-               and _count_matches(r"([a-z])\1", input_) >= 1
-               and _count_matches(r"(ab|cd|pq|xy)", input_) == 0
-               )
+TEST1 = "ugknbfddgicrmopn"
+TEST2 = "aaa"
+TEST3 = "jchzalrnumimnmhp"
+TEST4 = "haegwjzuvuyypxyu"
+TEST5 = "dvszwmarrgswjxmb"
+TEST6 = "qjhvhtzxzqqjkmpb"
+TEST7 = "xxyxx"
+TEST8 = "uurcxstgmygtbstg"
+TEST9 = "ieodomkazucvgmuy"
+TEST10 = "xyxy"
 
 
-def part_2(inputs: tuple[str]) -> int:
-    return sum(1 for input_ in inputs
-               if _count_matches(r"([a-z]{2})[a-z]*\1", input_) >= 1
-               and _count_matches(r"([a-z])[a-z]\1", input_) >= 1
-               )
+class Solution(SolutionBase[Input, Output1, Output2]):
+    def parse_input(self, input_data: InputData) -> Input:
+        return list(input_data)
 
+    def count_matches(self, regexp: str, string: str) -> int:
+        return len(re.findall(regexp, string))
 
-TEST1 = "ugknbfddgicrmopn".splitlines()
-TEST2 = "aaa".splitlines()
-TEST3 = "jchzalrnumimnmhp".splitlines()
-TEST4 = "haegwjzuvuyypxyu".splitlines()
-TEST5 = "dvszwmarrgswjxmb".splitlines()
-TEST6 = "qjhvhtzxzqqjkmpb".splitlines()
-TEST7 = "xxyxx".splitlines()
-TEST8 = "uurcxstgmygtbstg".splitlines()
-TEST9 = "ieodomkazucvgmuy".splitlines()
-TEST10 = "xyxy".splitlines()
+    def part_1(self, inputs: Input) -> Output1:
+        return sum(
+            1
+            for line in inputs
+            if self.count_matches(r"(a|e|i|o|u)", line) >= 3
+            and self.count_matches(r"([a-z])\1", line) >= 1
+            and self.count_matches(r"(ab|cd|pq|xy)", line) == 0
+        )
+
+    def part_2(self, inputs: Input) -> Output2:
+        return sum(
+            1
+            for line in inputs
+            if self.count_matches(r"([a-z]{2})[a-z]*\1", line) >= 1
+            and self.count_matches(r"([a-z])[a-z]\1", line) >= 1
+        )
+
+    @aoc_samples(
+        (
+            ("part_1", TEST1, 1),
+            ("part_1", TEST2, 1),
+            ("part_1", TEST3, 0),
+            ("part_1", TEST4, 0),
+            ("part_1", TEST5, 0),
+            ("part_2", TEST6, 1),
+            ("part_2", TEST7, 1),
+            ("part_2", TEST8, 0),
+            ("part_2", TEST9, 0),
+            ("part_2", TEST10, 1),
+        )
+    )
+    def samples(self) -> None:
+        pass
+
+
+solution = Solution(2015, 5)
 
 
 def main() -> None:
-    my_aocd.print_header(2015, 5)
-
-    assert part_1(TEST1) == 1
-    assert part_1(TEST2) == 1
-    assert part_1(TEST3) == 0
-    assert part_1(TEST4) == 0
-    assert part_1(TEST5) == 0
-    assert part_2(TEST6) == 1
-    assert part_2(TEST7) == 1
-    assert part_2(TEST8) == 0
-    assert part_2(TEST9) == 0
-    assert part_2(TEST10) == 1
-
-    inputs = my_aocd.get_input(2015, 5, 1000)
-    result1 = part_1(inputs)
-    print(f"Part 1: {result1}")
-    result2 = part_2(inputs)
-    print(f"Part 2: {result2}")
-
-
-if __name__ == '__main__':
+    solution.run(sys.argv)
+
+
+if __name__ == "__main__":
     main()

src/main/python/AoC2015_11.py

@@ -4,78 +4,81 @@
 #
 
 import re
+import sys
 
-import aocd
-
-from aoc import my_aocd
+from aoc.common import InputData
+from aoc.common import SolutionBase
+from aoc.common import aoc_samples
 
 ALPH = "abcdefghijklmnopqrstuvwxyz"
 NEXT = "bcdefghjjkmmnppqrstuvwxyza"
 CONFUSING_LETTERS = {"i", "o", "l"}
 RE = re.compile(r"([a-z])\1")
 
+Input = str
+Output1 = str
+Output2 = str
 
-def _is_ok(password: str) -> bool:
-    if len({p for p in RE.findall(password)}) < 2:
-        return False
-    trio = False
-    for i in range(len(password)):
-        if password[i] in CONFUSING_LETTERS:
-            return False
-        trio = (
-            trio
-            or i < len(password) - 3
-            and ord(password[i]) == ord(password[i + 1]) - 1
-            and ord(password[i + 1]) == ord(password[i + 2]) - 1
-        )
-    return trio
 
+class Solution(SolutionBase[Input, Output1, Output2]):
+    def parse_input(self, input_data: InputData) -> Input:
+        return next(iter(input_data))
 
-def _get_next(password: str) -> str:
-    def _increment(password: str, i: int) -> str:
-        password = (
-            password[:i]
-            + NEXT[ALPH.index(password[i])]
-            + password[i + 1 :]  # noqa E203
-        )
-        if password[i] == "a":
-            password = _increment(password, i - 1)
+    def is_ok(self, password: str) -> bool:
+        if len(set(RE.findall(password))) < 2:
+            return False
+        trio = False
+        for i in range(len(password)):
+            if password[i] in CONFUSING_LETTERS:
+                return False
+            trio = trio or (
+                i < len(password) - 3
+                and ord(password[i]) == ord(password[i + 1]) - 1
+                and ord(password[i + 1]) == ord(password[i + 2]) - 1
+            )
+        return trio
+
+    def get_next(self, password: str) -> str:
+        def increment(password: str, i: int) -> str:
+            password = (
+                password[:i]
+                + NEXT[ALPH.index(password[i])]
+                + password[i + 1 :]
+            )
+            if password[i] == "a":
+                password = increment(password, i - 1)
+            return password
+
+        while True:
+            password = increment(password, len(password) - 1)
+            if self.is_ok(password):
+                break
         return password
 
-    while True:
-        password = _increment(password, len(password) - 1)
-        if _is_ok(password):
-            break
-    return password
+    def part_1(self, password: Input) -> Output1:
+        return self.get_next(password)
 
+    def part_2(self, password: Input) -> Output2:
+        return self.get_next(self.get_next(password))
 
-def part_1(inputs: tuple[str]) -> str:
-    assert len(inputs) == 1
-    return _get_next(inputs[0])
+    @aoc_samples(
+        (
+            ("part_1", "abcdefgh", "abcdffaa"),
+            ("part_1", "ghijklmn", "ghjaabcc"),
+        )
+    )
+    def samples(self) -> None:
+        assert not self.is_ok("abci")
+        assert not self.is_ok("hijklmmn")
+        assert not self.is_ok("abbceffg")
+        assert not self.is_ok("abbcegjk")
 
 
-def part_2(inputs: tuple[str]) -> str:
-    assert len(inputs) == 1
-    return _get_next(_get_next(inputs[0]))
+solution = Solution(2015, 11)
 
 
 def main() -> None:
-    puzzle = aocd.models.Puzzle(2015, 11)
-    my_aocd.print_header(puzzle.year, puzzle.day)
-
-    assert not _is_ok("abci")
-    assert not _is_ok("hijklmmn")
-    assert not _is_ok("abbceffg")
-    assert not _is_ok("abbcegjk")
-    assert _get_next("abcdefgh") == "abcdffaa"
-    assert _get_next("ghijklmn") == "ghjaabcc"
-
-    inputs = my_aocd.get_input_data(puzzle, 1)
-    result1 = part_1(inputs)
-    print(f"Part 1: {result1}")
-    result2 = part_2(inputs)
-    print(f"Part 2: {result2}")
-    my_aocd.check_results(puzzle, result1, result2)
+    solution.run(sys.argv)
 
 
 if __name__ == "__main__":

src/main/python/AoC2015_12.py

@@ -4,69 +4,78 @@
 #
 
 import json
-from aoc import my_aocd
+import sys
+from typing import Any
+
+from aoc.common import InputData
+from aoc.common import SolutionBase
+from aoc.common import aoc_samples
+
+TEST1 = "[1,2,3]"
+TEST2 = '{"a":2,"b":4}'
+TEST3 = "[[[3]]]"
+TEST4 = '{"a":{"b":4},"c":-1}'
+TEST5 = '{"a":[-1,1]}'
+TEST6 = '[-1,{"a":1}]'
+TEST7 = "[]"
+TEST8 = "{}"
+TEST9 = '[1,{"c":"red","b":2},3]'
+TEST10 = '{"d":"red","e":[1,2,3,4],"f":5}'
+TEST11 = '[1,"red",5]'
+
+Input = str
+Output1 = int
+Output2 = int
+
+
+class Solution(SolutionBase[Input, Output1, Output2]):
+    def parse_input(self, input_data: InputData) -> Input:
+        return next(iter(input_data))
+
+    def add_all_numbers(self, string: str) -> int:
+        numbers = "".join(
+            c for c in string if c in {",", "-"} or c.isnumeric()
+        )
+        return sum(int(n) for n in numbers.split(",") if len(n) > 0)
+
+    def part_1(self, json_str: Input) -> Output1:
+        return self.add_all_numbers(json_str)
+
+    def part_2(self, json_str: Input) -> Output2:
+        def object_hook(obj: dict[Any, Any]) -> Any:  # noqa: ANN401
+            if "red" in obj.values():
+                return None
+            return obj
+
+        string = json.dumps(json.loads(json_str, object_hook=object_hook))
+        return self.add_all_numbers(string)
+
+    @aoc_samples(
+        (
+            ("part_1", TEST1, 6),
+            ("part_1", TEST2, 6),
+            ("part_1", TEST3, 3),
+            ("part_1", TEST4, 3),
+            ("part_1", TEST5, 0),
+            ("part_1", TEST6, 0),
+            ("part_1", TEST7, 0),
+            ("part_2", TEST8, 0),
+            ("part_2", TEST1, 6),
+            ("part_2", TEST9, 4),
+            ("part_2", TEST10, 0),
+            ("part_2", TEST11, 6),
+        )
+    )
+    def samples(self) -> None:
+        pass
+
+
+solution = Solution(2015, 12)
 
 
-def _add_all_numbers(string: str) -> int:
-    numbers = ""
-    for c in string:
-        if c in {',', '-'} or c.isnumeric():
-            numbers += c
-    return sum([int(_) for _ in numbers.split(',') if len(_) > 0])
-
-
-def part_1(inputs: tuple[str]) -> int:
-    assert len(inputs) == 1
-    return _add_all_numbers(inputs[0])
-
-
-def part_2(inputs: tuple[str]) -> int:
-    def object_hook(obj: dict) -> dict:
-        if "red" in obj.values():
-            return None
-        return obj
-
-    assert len(inputs) == 1
-    string = json.dumps(
-        json.loads(inputs[0], object_hook=object_hook))
-    return _add_all_numbers(string)
-
-
-TEST1 = "[1,2,3]".splitlines()
-TEST2 = "{\"a\":2,\"b\":4}".splitlines()
-TEST3 = "[[[3]]]".splitlines()
-TEST4 = "{\"a\":{\"b\":4},\"c\":-1}".splitlines()
-TEST5 = "{\"a\":[-1,1]}".splitlines()
-TEST6 = "[-1,{\"a\":1}]".splitlines()
-TEST7 = "[]".splitlines()
-TEST8 = "{}".splitlines()
-TEST9 = "[1,{\"c\":\"red\",\"b\":2},3]".splitlines()
-TEST10 = "{\"d\":\"red\",\"e\":[1,2,3,4],\"f\":5}".splitlines()
-TEST11 = "[1,\"red\",5]".splitlines()
+def main() -> None:
+    solution.run(sys.argv)
 
 
-def main() -> None:
-    my_aocd.print_header(2015, 12)
-
-    assert part_1(TEST1) == 6
-    assert part_1(TEST2) == 6
-    assert part_1(TEST3) == 3
-    assert part_1(TEST4) == 3
-    assert part_1(TEST5) == 0
-    assert part_1(TEST6) == 0
-    assert part_1(TEST7) == 0
-    assert part_1(TEST8) == 0
-    assert part_2(TEST1) == 6
-    assert part_2(TEST9) == 4
-    assert part_2(TEST10) == 0
-    assert part_2(TEST11) == 6
-
-    inputs = my_aocd.get_input(2015, 12, 1)
-    result1 = part_1(inputs)
-    print(f"Part 1: {result1}")
-    result2 = part_2(inputs)
-    print(f"Part 2: {result2}")
-
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()