Added days 2019-16 and 2019-17

Author: Piratmac

2019/16-Flawed Frequency Transmission.py

@@ -0,0 +1,102 @@
+# -------------------------------- Input data ---------------------------------------- #
+import os, pathfinding
+
+from complex_utils import *
+
+test_data = {}
+
+test = 1
+test_data[test] = {
+    "input": """12345678""",
+    "expected": ["01029498 after 4 phases", "Unknown"],
+}
+
+test += 1
+test_data[test] = {
+    "input": """80871224585914546619083218645595""",
+    "expected": ["24176176", "Unknown"],
+}
+
+test += 1
+test_data[test] = {
+    "input": """03036732577212944063491565474664""",
+    "expected": ["Unknown", "84462026"],
+}
+
+test = "real"
+input_file = os.path.join(
+    os.path.dirname(__file__),
+    "Inputs",
+    os.path.basename(__file__).replace(".py", ".txt"),
+)
+test_data[test] = {
+    "input": open(input_file, "r+").read().strip(),
+    "expected": ["27229269", "26857164"],
+}
+
+# -------------------------------- Control program execution ------------------------- #
+
+case_to_test = "real"
+part_to_test = 2
+
+# -------------------------------- Initialize some variables ------------------------- #
+
+puzzle_input = test_data[case_to_test]["input"]
+puzzle_expected_result = test_data[case_to_test]["expected"][part_to_test - 1]
+puzzle_actual_result = "Unknown"
+
+
+# -------------------------------- Actual code execution ----------------------------- #
+
+base_pattern = [0, 1, 0, -1]
+
+if part_to_test == 1:
+    signal = [int(x) for x in puzzle_input]
+
+    for phase in range(100):
+        output = [0] * len(signal)
+        for i in range(len(signal)):
+            pattern = []
+            for j in range(len(base_pattern)):
+                pattern += [base_pattern[j]] * (i + 1)
+
+            while len(pattern) < len(signal) + 1:
+                pattern += pattern
+            del pattern[0]
+
+            output[i] = sum([pattern[j] * signal[j] for j in range(len(signal))])
+            output[i] = abs(output[i]) % 10
+        signal = output[:]
+
+    puzzle_actual_result = "".join(map(str, output[:8]))
+
+
+else:
+    # The signal's length is 650 * 10000 = 6500000
+    # The first 7 digits of the input are 5978261
+    # Therefore, the first number to be calculated will ignore the first 5978261 of the input
+    # Also, since 5978261 < 6500000 < 5978261*2, the part with '0, -1' in the pattern is after the signal's length
+    # Therefore it can be ignored
+    signal = [int(x) for x in puzzle_input] * 10 ** 4
+    start = int(puzzle_input[:7])
+    signal = signal[start:]
+
+    sum_signal = sum([int(x) for x in puzzle_input]) % 10
+    len_signal = len(puzzle_input)
+
+    output = [0] * len(signal)
+
+    for phase in range(100):
+        output[-1] = signal[-1]
+        for i in range(1, len(signal)):
+            output[-i - 1] = output[-i] + signal[-i - 1]
+
+        signal = [x % 10 for x in output]
+
+    puzzle_actual_result = "".join(map(str, signal[:8]))
+
+
+# -------------------------------- Outputs / results --------------------------------- #
+
+print("Expected result : " + str(puzzle_expected_result))
+print("Actual result   : " + str(puzzle_actual_result))

2019/17-Set and Forget.py

@@ -0,0 +1,152 @@
+# -------------------------------- Input data ---------------------------------------- #
+import os, pathfinding, IntCode
+
+from complex_utils import *
+
+test_data = {}
+
+test = "real"
+input_file = os.path.join(
+    os.path.dirname(__file__),
+    "Inputs",
+    os.path.basename(__file__).replace(".py", ".txt"),
+)
+test_data[test] = {
+    "input": open(input_file, "r+").read().strip(),
+    "expected": ["5068", "1415975"],
+}
+
+# -------------------------------- Control program execution ------------------------- #
+
+case_to_test = "real"
+part_to_test = 2
+verbose_level = 0
+
+# -------------------------------- Initialize some variables ------------------------- #
+
+puzzle_input = test_data[case_to_test]["input"]
+puzzle_expected_result = test_data[case_to_test]["expected"][part_to_test - 1]
+puzzle_actual_result = "Unknown"
+
+
+# -------------------------------- Actual code execution ----------------------------- #
+
+position = 0
+
+droid = IntCode.IntCode(puzzle_input)
+droid.run()
+grid = []
+for output in droid.outputs:
+    if chr(output) == "#":
+        grid.append(position)
+    elif chr(output) in ["^", "v", ">", "<"]:
+        droid_pos = [position, accent_to_dir[chr(output)]]
+
+    if chr(output) == "\n":
+        position = j * (position.imag - 1)
+    else:
+        position += 1
+
+
+if part_to_test == 1:
+    alignment_parameter = 0
+    for x in range(1, int(max_real(grid))):
+        for y in range(int(min_imag(grid)), -1):
+            if x + y * j in grid:
+                if all([x + y * j + dir in grid for dir in directions_straight]):
+                    alignment_parameter += x * -y
+
+    puzzle_actual_result = alignment_parameter
+
+
+else:
+    steps = []
+    visited = []
+
+    # Find the path, in the long form (L,12,R,8,.....)
+    while True:
+        position, direction = droid_pos
+        visited.append(position)
+        if position + direction in grid:
+            steps[-1] += 1
+            droid_pos[0] += droid_pos[1]
+        else:
+            option = [
+                (turn[0].upper(), direction * relative_directions[turn])
+                for turn in relative_directions
+                if position + direction * relative_directions[turn] in grid
+                if position + direction * relative_directions[turn] not in visited
+            ]
+            if len(option) > 1:
+                print("error")
+                raise Exception(position, direction, option)
+
+            if option:
+                option = option[0]
+                steps += [option[0], 1]
+                droid_pos[1] = option[1]
+                droid_pos[0] += droid_pos[1]
+            else:
+                break
+
+    steps = list(map(str, steps))
+    steps_inline = ",".join(steps)
+
+    # Shorten the path
+    subprograms = []
+    nb_to_letter = {0: "A", 1: "B", 2: "C"}
+
+    offset = 0
+    for i in range(3):
+        while len(subprograms) == i:
+            nb_steps = min(20, len(steps) - offset)
+            subprogram = steps[offset : offset + nb_steps]
+            subprogram_inline = ",".join(subprogram)
+
+            # The limits of 3 is arbitrary
+            while (
+                steps_inline.count(subprogram_inline) < 3 or len(subprogram_inline) > 20
+            ):
+                # Shorten subprogram for test
+                if len(subprogram) <= 2:
+                    break
+                else:
+                    if subprogram[-1] in ("A", "B", "C"):
+                        del subprogram[-1]
+                    else:
+                        del subprogram[-2:]
+
+                subprogram_inline = ",".join(subprogram)
+
+            # Found one!
+            if steps_inline.count(subprogram_inline) >= 3 and len(subprogram) > 2:
+                subprograms.append(subprogram_inline)
+                steps_inline = steps_inline.replace(subprogram_inline, nb_to_letter[i])
+                steps = steps_inline.split(",")
+            else:
+                if steps[offset] in ["A", "B", "C"]:
+                    offset += 1
+                else:
+                    offset += 2
+        offset = 0
+
+    # Now send all that to the robot
+    droid.instructions[0] = 2
+    inputs = (
+        steps_inline + "\n" + "\n".join(subprograms) + "\nn\n"
+    )  # the last n is for the video
+    for letter in inputs:
+        droid.add_input(ord(letter))
+    droid.restart()
+    droid.run()
+
+    puzzle_actual_result = droid.outputs.pop()
+    if verbose_level:
+        for output in droid.outputs:
+            print(chr(output), end="")
+
+
+# -------------------------------- Outputs / results --------------------------------- #
+
+print("Expected result : " + str(puzzle_expected_result))
+print("Actual result   : " + str(puzzle_actual_result))