Added days 2019-01 and 2019-02

Piratmac · Piratmac · commit 3c83d1f6139f · 2020-08-09T19:11:46.000+02:00
diff --git a/2019/01-The Tyranny of the Rocket Equation.py b/2019/01-The Tyranny of the Rocket Equation.py
@@ -0,0 +1,64 @@
+# -------------------------------- Input data ---------------------------------------- #
+import os, pathfinding
+
+from complex_utils import *
+
+test_data = {}
+
+test = 1
+test_data[test] = {
+    "input": """1969""",
+    "expected": ["2", "966"],
+}
+
+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": ["3360301", "5037595"],
+}
+
+# -------------------------------- 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 ----------------------------- #
+
+if part_to_test == 1:
+    total = 0
+    for string in puzzle_input.split("\n"):
+        val = int(string)
+        val = val // 3 - 2
+        total += val
+
+    puzzle_actual_result = total
+
+
+else:
+    total = 0
+    for string in puzzle_input.split("\n"):
+        val = int(string)
+        val = val // 3 - 2
+        while val > 0:
+            total += val
+            val = val // 3 - 2
+
+    puzzle_actual_result = total
+
+
+# -------------------------------- Outputs / results --------------------------------- #
+
+print("Expected result : " + str(puzzle_expected_result))
+print("Actual result   : " + str(puzzle_actual_result))
diff --git a/2019/02-1202 Program Alarm.py b/2019/02-1202 Program Alarm.py
@@ -0,0 +1,130 @@
+# -------------------------------- Input data ---------------------------------------- #
+import os, pathfinding
+
+from complex_utils import *
+
+test_data = {}
+
+test = 1
+test_data[test] = {
+    "input": """1,9,10,3,2,3,11,0,99,30,40,50""",
+    "expected": ["3500,9,10,70,2,3,11,0,99,30,40,50", "Unknown"],
+}
+
+test += 1
+test_data[test] = {
+    "input": """1,0,0,0,99""",
+    "expected": ["2,0,0,0,99", "Unknown"],
+}
+
+test += 1
+test_data[test] = {
+    "input": """2,4,4,5,99,0""",
+    "expected": ["2,4,4,5,99,9801", "Unknown"],
+}
+
+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": ["6327510", "4112"],
+}
+
+# -------------------------------- Control program execution ------------------------- #
+
+case_to_test = "real"
+part_to_test = 2
+verbose_level = 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 ----------------------------- #
+
+
+class IntCode:
+    instructions = []
+    pointer = 0
+    state = "Running"
+
+    def __init__(self, instructions):
+        self.instructions = list(map(int, instructions.split(",")))
+
+    def reset(self, instructions):
+        self.instructions = list(map(int, instructions.split(",")))
+        self.pointer = 0
+        self.state = "Running"
+
+    def get_instruction(self):
+        if self.instructions[self.pointer] in [1, 2]:
+            return self.instructions[self.pointer : self.pointer + 4]
+        else:
+            return [self.instructions[self.pointer]]
+
+    def op_1(self, instr):
+        self.instructions[instr[3]] = (
+            self.instructions[instr[1]] + self.instructions[instr[2]]
+        )
+        self.pointer += 4
+        self.state = "Running"
+
+    def op_2(self, instr):
+        self.instructions[instr[3]] = (
+            self.instructions[instr[1]] * self.instructions[instr[2]]
+        )
+        self.pointer += 4
+        self.state = "Running"
+
+    def op_99(self, instr):
+        self.pointer += 1
+        self.state = "Stopped"
+
+    def run(self):
+        while self.state == "Running":
+            current_instruction = self.get_instruction()
+            getattr(self, "op_" + str(current_instruction[0]))(current_instruction)
+            if verbose_level >= 3:
+                print("Pointer after execution:", self.pointer)
+                print("Instructions:", self.export())
+
+    def export(self):
+        return ",".join(map(str, self.instructions))
+
+
+if part_to_test == 1:
+    computer = IntCode(puzzle_input)
+    if case_to_test == "real":
+        computer.instructions[1] = 12
+        computer.instructions[2] = 2
+    computer.run()
+    puzzle_actual_result = computer.instructions[0]
+
+
+else:
+    computer = IntCode(puzzle_input)
+    for noon in range(100):
+        for verb in range(100):
+            computer.reset(puzzle_input)
+            computer.instructions[1] = noon
+            computer.instructions[2] = verb
+            computer.run()
+            if computer.instructions[0] == 19690720:
+                puzzle_actual_result = 100 * noon + verb
+                break
+
+        if puzzle_actual_result != "Unknown":
+            break
+
+
+# -------------------------------- Outputs / results --------------------------------- #
+
+print("Expected result : " + str(puzzle_expected_result))
+print("Actual result   : " + str(puzzle_actual_result))
diff --git a/2019/complex_utils.py b/2019/complex_utils.py
@@ -0,0 +1,121 @@
+"""
+Small library for complex numbers
+"""
+from math import sqrt
+
+
+class ReturnTypeWrapper(type):
+    def __new__(mcs, name, bases, dct):
+        cls = type.__new__(mcs, name, bases, dct)
+        for attr, obj in cls.wrapped_base.__dict__.items():
+            # skip 'member descriptor's and overridden methods
+            if type(obj) == type(complex.real) or attr in dct:
+                continue
+            if getattr(obj, "__objclass__", None) is cls.wrapped_base:
+                setattr(cls, attr, cls.return_wrapper(obj))
+        return cls
+
+    def return_wrapper(cls, obj):
+        def convert(value):
+            return cls(value) if type(value) is cls.wrapped_base else value
+
+        def wrapper(*args, **kwargs):
+            return convert(obj(*args, **kwargs))
+
+        wrapper.__name__ = obj.__name__
+        return wrapper
+
+
+class SuperComplex(complex):
+    __metaclass__ = ReturnTypeWrapper
+    wrapped_base = complex
+
+    def __lt__(self, other):
+        return abs(other - self) < 0
+
+    def __le__(self, other):
+        return abs(other - self) <= 0
+
+    def __gt__(self, other):
+        return abs(other - self) > 0
+
+    def __ge__(self, other):
+        return abs(other - self) >= 0
+
+    def __str__(self):
+        return "(" + str(self.real) + "," + str(self.imag) + ")"
+
+    def __add__(self, no):
+        return SuperComplex(self.real + no.real, self.imag + no.imag)
+
+    def __sub__(self, no):
+        return SuperComplex(self.real - no.real, self.imag - no.imag)
+
+
+j = SuperComplex(1j)
+
+# Cardinal directions
+north = j
+south = -j
+west = -1
+east = 1
+northeast = 1 + j
+northwest = -1 + j
+southeast = 1 - j
+southwest = -1 - j
+
+directions_straight = [north, south, west, east]
+directions_diagonals = directions_straight + [
+    northeast,
+    northwest,
+    southeast,
+    southwest,
+]
+
+# To be multiplied by the current cartinal direction
+relative_directions = {
+    "left": j,
+    "right": -j,
+    "ahead": 1,
+    "back": -1,
+}
+
+
+def min_real(complexes):
+    real_values = [x.real for x in complexes]
+    return min(real_values)
+
+
+def min_imag(complexes):
+    real_values = [x.imag for x in complexes]
+    return min(real_values)
+
+
+def max_real(complexes):
+    real_values = [x.real for x in complexes]
+    return max(real_values)
+
+
+def max_imag(complexes):
+    real_values = [x.imag for x in complexes]
+    return max(real_values)
+
+
+def manhattan_distance(a, b):
+    return abs(b.imag - a.imag) + abs(b.real - a.real)
+
+
+def complex_sort(complexes, mode=""):
+    # Sorts by real, then by imaginary component (x then y)
+    if mode == "xy":
+        complexes.sort(key=lambda a: (a.real, a.imag))
+    # Sorts by imaginary, then by real component (y then x)
+    elif mode == "yx":
+        complexes.sort(key=lambda a: (a.imag, a.real))
+    # Sorts by negative imaginary, then by real component (-y then x) - 'Reading" order
+    elif mode == "reading":
+        complexes.sort(key=lambda a: (-a.imag, a.real))
+    # Sorts by distance from 0,0 (kind of polar coordinates)
+    else:
+        complexes.sort(key=lambda a: sqrt(a.imag ** 2 + a.real ** 2))
+    return complexes
diff --git a/2019/pathfinding.py b/2019/pathfinding.py
