Homogenize input and output handling

Author: pareronia

src/main/python/AoC2015_01.py

@@ -7,10 +7,12 @@
 
 
 def part_1(inputs: tuple[str]) -> int:
+    assert len(inputs) == 1
     return len(inputs[0]) - 2 * inputs[0].count(")")
 
 
 def part_2(inputs: tuple[str]) -> int:
+    assert len(inputs) == 1
     sum_ = int()
     for i, c in enumerate(inputs[0]):
         if c == "(":
@@ -24,35 +26,35 @@ def part_2(inputs: tuple[str]) -> int:
     raise RuntimeError("Unreachable")
 
 
-test1 = "(())".splitlines()
-test2 = "()()".splitlines()
-test3 = "(((".splitlines()
-test4 = "(()(()(".splitlines()
-test5 = "))(((((".splitlines()
-test6 = "())".splitlines()
-test7 = "))(".splitlines()
-test8 = ")))".splitlines()
-test9 = ")())())".splitlines()
-test10 = ")".splitlines()
-test11 = "()())".splitlines()
+TEST1 = "(())".splitlines()
+TEST2 = "()()".splitlines()
+TEST3 = "(((".splitlines()
+TEST4 = "(()(()(".splitlines()
+TEST5 = "))(((((".splitlines()
+TEST6 = "())".splitlines()
+TEST7 = "))(".splitlines()
+TEST8 = ")))".splitlines()
+TEST9 = ")())())".splitlines()
+TEST10 = ")".splitlines()
+TEST11 = "()())".splitlines()
 
 
 def main() -> None:
     my_aocd.print_header(2015, 1)
 
-    assert part_1(test1) == 0
-    assert part_1(test2) == 0
-    assert part_1(test3) == 3
-    assert part_1(test4) == 3
-    assert part_1(test5) == 3
-    assert part_1(test6) == -1
-    assert part_1(test7) == -1
-    assert part_1(test8) == -3
-    assert part_1(test9) == -3
-    assert part_2(test10) == 1
-    assert part_2(test11) == 5
-
-    inputs = my_aocd.get_input_as_tuple(2015, 1, 1)
+    assert part_1(TEST1) == 0
+    assert part_1(TEST2) == 0
+    assert part_1(TEST3) == 3
+    assert part_1(TEST4) == 3
+    assert part_1(TEST5) == 3
+    assert part_1(TEST6) == -1
+    assert part_1(TEST7) == -1
+    assert part_1(TEST8) == -3
+    assert part_1(TEST9) == -3
+    assert part_2(TEST10) == 1
+    assert part_2(TEST11) == 5
+
+    inputs = my_aocd.get_input(2015, 1, 1)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_02.py

@@ -47,19 +47,19 @@ def part_2(inputs: tuple[str]) -> int:
     return sum([_calculate_required_length(p) for p in presents])
 
 
-test1 = "2x3x4".splitlines()
-test2 = "1x1x10".splitlines()
+TEST1 = "2x3x4".splitlines()
+TEST2 = "1x1x10".splitlines()
 
 
 def main() -> None:
     my_aocd.print_header(2015, 2)
 
-    assert part_1(test1) == 58
-    assert part_1(test2) == 43
-    assert part_2(test1) == 34
-    assert part_2(test2) == 14
+    assert part_1(TEST1) == 58
+    assert part_1(TEST2) == 43
+    assert part_2(TEST1) == 34
+    assert part_2(TEST2) == 14
 
-    inputs = my_aocd.get_input_as_tuple(2015, 2, 1000)
+    inputs = my_aocd.get_input(2015, 2, 1000)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_03.py

@@ -70,7 +70,7 @@ def main() -> None:
     assert part_2(TEST2) == 3
     assert part_2(TEST3) == 11
 
-    inputs = my_aocd.get_input_as_tuple(2015, 3, 1)
+    inputs = my_aocd.get_input(2015, 3, 1)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_04.py

@@ -20,16 +20,18 @@ def _find_md5_starting_with_zeroes(input_: str, zeroes: int) -> int:
     return i
 
 
-def part_1(input_: str) -> int:
-    return _find_md5_starting_with_zeroes(input_, 5)
+def part_1(inputs: tuple[str]) -> int:
+    assert len(inputs) == 1
+    return _find_md5_starting_with_zeroes(inputs[0], 5)
 
 
-def part_2(input_: str) -> int:
-    return _find_md5_starting_with_zeroes(input_, 6)
+def part_2(inputs: tuple[str]) -> int:
+    assert len(inputs) == 1
+    return _find_md5_starting_with_zeroes(inputs[0], 6)
 
 
-TEST1 = "abcdef"
-TEST2 = "pqrstuv"
+TEST1 = "abcdef".splitlines()
+TEST2 = "pqrstuv".splitlines()
 
 
 def main() -> None:
@@ -38,9 +40,10 @@ def main() -> None:
     assert part_1(TEST1) == 609043
     assert part_1(TEST2) == 1048970
 
-    result1 = part_1("iwrupvqb")
+    inputs = my_aocd.get_input(2015, 4, 1)
+    result1 = part_1(inputs)
     print(f"Part 1: {result1}")
-    result2 = part_2("iwrupvqb")
+    result2 = part_2(inputs)
     print(f"Part 2: {result2}")
 
 

src/main/python/AoC2015_05.py

@@ -52,7 +52,7 @@ def main() -> None:
     assert part_2(TEST9) == 0
     assert part_2(TEST10) == 1
 
-    inputs = my_aocd.get_input_as_tuple(2015, 5, 1000)
+    inputs = my_aocd.get_input(2015, 5, 1000)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_06.py

@@ -116,7 +116,7 @@ def main() -> None:
     assert part_2(TEST4) == 1
     assert part_2(TEST5) == 2_000_000
 
-    inputs = my_aocd.get_input_as_tuple(2015, 6, 300)
+    inputs = my_aocd.get_input(2015, 6, 300)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_08.py

@@ -43,7 +43,7 @@ def main() -> None:
     assert part_1(TEST) == 12
     assert part_2(TEST) == 19
 
-    inputs = my_aocd.get_input_as_tuple(2015, 8, 300)
+    inputs = my_aocd.get_input(2015, 8, 300)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_10.py

@@ -37,17 +37,15 @@ def part_2(inputs: tuple[str]) -> int:
     return len(_look_and_say_iterations(inputs[0], 50))
 
 
-TEST = """\
-1
-""".splitlines()
+TEST = "1".splitlines()
 
 
 def main() -> None:
     my_aocd.print_header(2015, 10)
 
     assert _look_and_say_iterations(TEST, 5) == "312211"
 
-    inputs = my_aocd.get_input_as_tuple(2015, 10, 1)
+    inputs = my_aocd.get_input(2015, 10, 1)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_12.py

@@ -61,7 +61,7 @@ def main() -> None:
     assert part_2(TEST10) == 0
     assert part_2(TEST11) == 6
 
-    inputs = my_aocd.get_input_as_tuple(2015, 12, 1)
+    inputs = my_aocd.get_input(2015, 12, 1)
     result1 = part_1(inputs)
     print(f"Part 1: {result1}")
     result2 = part_2(inputs)

src/main/python/AoC2015_14.py

@@ -41,11 +41,15 @@ def _distance_reached(reindeer: Reindeer, time: int) -> int:
         return periods * period_distance + reindeer.speed * left
 
 
-def part_1(inputs: tuple[str], time: int) -> int:
+def _do_part_1(inputs: tuple[str], time: int) -> int:
     return max([_distance_reached(r, time) for r in _parse(inputs)])
 
 
-def part_2(inputs: tuple[str], time: int) -> int:
+def part_1(inputs: tuple[str]) -> int:
+    return _do_part_1(inputs, 2503)
+
+
+def _do_part_2(inputs: tuple[str], time: int) -> int:
     reindeer = _parse(inputs)
     points = defaultdict(int)
     for i in range(time):
@@ -54,6 +58,10 @@ def part_2(inputs: tuple[str], time: int) -> int:
     return max(points.values())
 
 
+def part_2(inputs: tuple[str]) -> int:
+    return _do_part_2(inputs, 2503)
+
+
 TEST = """\
 Comet can fly 14 km/s for 10 seconds, but then must rest for 127 seconds.
 Dancer can fly 16 km/s for 11 seconds, but then must rest for 162 seconds.
@@ -63,13 +71,13 @@ def part_2(inputs: tuple[str], time: int) -> int:
 def main() -> None:
     my_aocd.print_header(2015, 14)
 
-    assert part_1(TEST, 1000) == 1120
-    assert part_2(TEST, 1000) == 689
+    assert _do_part_1(TEST, 1000) == 1120
+    assert _do_part_2(TEST, 1000) == 689
 
-    inputs = my_aocd.get_input_as_tuple(2015, 14, 9)
-    result1 = part_1(inputs, 2503)
+    inputs = my_aocd.get_input(2015, 14, 9)
+    result1 = part_1(inputs)
     print(f"Part 1: {result1}")
-    result2 = part_2(inputs, 2503)
+    result2 = part_2(inputs)
     print(f"Part 2: {result2}")
 
 

src/main/python/AoC2020_01.py

@@ -19,10 +19,11 @@ def _print_part_2(prefix: str, first: int, second: int, third: int,
     print(f"{prefix} Threesome: {first} * {second} * {third} = {result}")
 
 
-def part_1_primeagen(inputs: tuple[int]) -> int:
+def part_1_primeagen(inputs: tuple[str]) -> int:
     others = set[int]()
     start = time.perf_counter()
-    for n1 in inputs:
+    for i in range(len(inputs)):
+        n1 = int(inputs[i])
         others.add(n1)
         check = 2020 - n1
         if check in others:
@@ -33,13 +34,14 @@ def part_1_primeagen(inputs: tuple[int]) -> int:
             return result
 
 
-def part_2_primeagen(inputs: tuple[int]) -> int:
+def part_2_primeagen(inputs: tuple[str]) -> int:
     others = set[int]()
     start = time.perf_counter()
     for i in range(len(inputs)):
-        n1 = inputs[i]
+        n1 = int(inputs[i])
         others.add(n1)
-        for n2 in inputs[i:]:
+        for j in range(i, len(inputs)):
+            n2 = int(inputs[j])
             check = 2020 - n1 - n2
             if check in others:
                 result = n1*n2*check
@@ -49,15 +51,16 @@ def part_2_primeagen(inputs: tuple[int]) -> int:
                 return result
 
 
-def _squared(inputs: tuple[int], target: int) -> tuple[int]:
+def _squared(inputs: tuple[str], target: int) -> tuple[int]:
     for i in range(len(inputs)):
-        n1 = inputs[i]
-        for n2 in inputs[i:]:
+        n1 = int(inputs[i])
+        for j in range(i, len(inputs)):
+            n2 = int(inputs[j])
             if n1 + n2 == target:
                 return (n1, n2)
 
 
-def part_1_squared(inputs: tuple[int]) -> int:
+def part_1_squared(inputs: tuple[str]) -> int:
     start = time.perf_counter()
     twosome = _squared(inputs, 2020)
     result = twosome[0]*twosome[1]
@@ -67,10 +70,10 @@ def part_1_squared(inputs: tuple[int]) -> int:
     return result
 
 
-def part_2_cubed(inputs: tuple[int]) -> int:
+def part_2_cubed(inputs: tuple[str]) -> int:
     start = time.perf_counter()
     for i in range(len(inputs)):
-        n1 = inputs[i]
+        n1 = int(inputs[i])
         twosome = _squared(inputs[i:], 2020-n1)
         if twosome is not None:
             threesome = (twosome[0], twosome[1], n1)
@@ -83,24 +86,25 @@ def part_2_cubed(inputs: tuple[int]) -> int:
     return result
 
 
-test = (1721,
-        979,
-        366,
-        299,
-        675,
-        1456,
-        )
+TEST = """\
+1721
+979
+366
+299
+675
+1456
+""".splitlines()
 
 
 def main() -> None:
     my_aocd.print_header(2020, 1)
 
-    assert part_1_squared(test) == 514579
-    assert part_2_cubed(test) == 241861950
-    assert part_1_primeagen(test) == 514579
-    assert part_2_primeagen(test) == 241861950
+    assert part_1_squared(TEST) == 514579
+    assert part_2_cubed(TEST) == 241861950
+    assert part_1_primeagen(TEST) == 514579
+    assert part_2_primeagen(TEST) == 241861950
 
-    inputs = my_aocd.get_input_as_ints_tuple(2020, 1, 200)
+    inputs = my_aocd.get_input(2020, 1, 200)
     part_1_squared(inputs)
     part_1_primeagen(inputs)
     part_2_cubed(inputs)