Improved performance for days 2018-10 and 2018-22

Author: Piratmac

2018/10-The Stars Align.py

@@ -71,25 +71,31 @@
     stars.append(list(map(int, r)))
 
 star_map = pathfinding.Graph()
+stars_init = [star.copy() for star in stars]
+min_galaxy_size = 10 ** 15
+min_i_galaxy_size = 0
 for i in range(2 * 10 ** 4):
-    stars = [(x + vx, y + vy, vx, vy) for x, y, vx, vy in stars]
-    vertices = [x - y * 1j for x, y, vx, vy in stars]
-
-    # This was solved a bit manually
-    # I noticed all coordinates would converge around 0 at some point
-    # That point was around 10300 seconds
-    # Then made a limit: all coordinates should be within 300 from zero
-    # (my first test was actually 200, but that was gave no result)
-    # This gave ~ 20 seconds of interesting time
-    # At the end it was trial and error to find 10 240
-    coords = [v.real in range(-300, 300) for v in vertices] + [
-        v.imag in range(-300, 300) for v in vertices
-    ]
-
-    if all(coords) and i == 10239:
+    stars = [(x + i * vx, y + i * vy, vx, i * vy) for x, y, vx, vy in stars_init]
+
+    # This gives a very rough idea of the galaxy's size
+    coords = list(zip(*stars))
+    galaxy_size = max(coords[0]) - min(coords[0]) + max(coords[1]) - max(coords[1])
+
+    if i == 0:
+        min_galaxy_size = galaxy_size
+
+    if galaxy_size < min_galaxy_size:
+        min_i_galaxy_size = i
+        min_galaxy_size = galaxy_size
+    elif galaxy_size > min_galaxy_size:
+        vertices = [
+            x + vx * min_i_galaxy_size - (y + vy * min_i_galaxy_size) * 1j
+            for x, y, vx, vy in stars_init
+        ]
         star_map.vertices = vertices
-        print(i + 1)
+        puzzle_actual_result = min_i_galaxy_size
         print(star_map.vertices_to_grid(wall=" "))
+        break
 
 
 # -------------------------------- Outputs / results -------------------------------- #

2018/10-The Stars Align.v1.py

@@ -0,0 +1,98 @@
+# -------------------------------- Input data -------------------------------- #
+import os, parse, pathfinding
+
+test_data = {}
+
+test = 1
+test_data[test] = {
+    "input": """position=< 9,  1> velocity=< 0,  2>
+position=< 7,  0> velocity=<-1,  0>
+position=< 3, -2> velocity=<-1,  1>
+position=< 6, 10> velocity=<-2, -1>
+position=< 2, -4> velocity=< 2,  2>
+position=<-6, 10> velocity=< 2, -2>
+position=< 1,  8> velocity=< 1, -1>
+position=< 1,  7> velocity=< 1,  0>
+position=<-3, 11> velocity=< 1, -2>
+position=< 7,  6> velocity=<-1, -1>
+position=<-2,  3> velocity=< 1,  0>
+position=<-4,  3> velocity=< 2,  0>
+position=<10, -3> velocity=<-1,  1>
+position=< 5, 11> velocity=< 1, -2>
+position=< 4,  7> velocity=< 0, -1>
+position=< 8, -2> velocity=< 0,  1>
+position=<15,  0> velocity=<-2,  0>
+position=< 1,  6> velocity=< 1,  0>
+position=< 8,  9> velocity=< 0, -1>
+position=< 3,  3> velocity=<-1,  1>
+position=< 0,  5> velocity=< 0, -1>
+position=<-2,  2> velocity=< 2,  0>
+position=< 5, -2> velocity=< 1,  2>
+position=< 1,  4> velocity=< 2,  1>
+position=<-2,  7> velocity=< 2, -2>
+position=< 3,  6> velocity=<-1, -1>
+position=< 5,  0> velocity=< 1,  0>
+position=<-6,  0> velocity=< 2,  0>
+position=< 5,  9> velocity=< 1, -2>
+position=<14,  7> velocity=<-2,  0>
+position=<-3,  6> velocity=< 2, -1>""",
+    "expected": ["Unknown", "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": ["RLEZNRAN", "10240"],
+}
+
+# -------------------------------- Control program execution -------------------------------- #
+
+case_to_test = "real"
+part_to_test = 1
+
+# -------------------------------- 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 -------------------------------- #
+stars = []
+for string in puzzle_input.split("\n"):
+    if string == "":
+        continue
+    r = parse.parse("position=<{:>d},{:>d}> velocity=<{:>d},{:>d}>", string)
+    stars.append(list(map(int, r)))
+
+star_map = pathfinding.Graph()
+for i in range(2 * 10 ** 4):
+    stars = [(x + vx, y + vy, vx, vy) for x, y, vx, vy in stars]
+    vertices = [x - y * 1j for x, y, vx, vy in stars]
+
+    # This was solved a bit manually
+    # I noticed all coordinates would converge around 0 at some point
+    # That point was around 10300 seconds
+    # Then made a limit: all coordinates should be within 300 from zero
+    # (my first test was actually 200, but that was gave no result)
+    # This gave ~ 20 seconds of interesting time
+    # At the end it was trial and error to find 10 240
+    coords = [v.real in range(-300, 300) for v in vertices] + [
+        v.imag in range(-300, 300) for v in vertices
+    ]
+
+    if all(coords) and i == 10239:
+        star_map.vertices = vertices
+        print(i + 1)
+        print(star_map.vertices_to_grid(wall=" "))
+
+
+# -------------------------------- Outputs / results -------------------------------- #
+
+print("Expected result : " + str(puzzle_expected_result))
+print("Actual result   : " + str(puzzle_actual_result))

2018/22-Mode Maze.py

@@ -1,6 +1,12 @@
 # -------------------------------- Input data ---------------------------------------- #
 import os, pathfinding
 
+from complex_utils import *
+
+
+j = SuperComplex(1j)
+
+
 test_data = {}
 
 test = 1
@@ -18,7 +24,7 @@
 )
 test_data[test] = {
     "input": open(input_file, "r+").read().strip(),
-    "expected": ["6256", "Unknown"],
+    "expected": ["6256", "973"],
 }
 
 # -------------------------------- Control program execution ------------------------- #
@@ -40,23 +46,23 @@
 
 depth = int(depth)
 max_x, max_y = map(int, target.split(","))
-target = max_x - 1j * max_y
+target = max_x - j * max_y
 
 geological = {0: 0}
 erosion = {0: 0}
 for x in range(max_x + 1):
     geological[x] = x * 16807
     erosion[x] = (geological[x] + depth) % 20183
 for y in range(max_y + 1):
-    geological[-1j * y] = y * 48271
-    erosion[-1j * y] = (geological[-1j * y] + depth) % 20183
+    geological[-j * y] = y * 48271
+    erosion[-j * y] = (geological[-j * y] + depth) % 20183
 
 for x in range(1, max_x + 1):
     for y in range(1, max_y + 1):
-        geological[x - 1j * y] = (
-            erosion[x - 1 - 1j * y] * erosion[x - 1j * (y - 1)]
+        geological[x - j * y] = (
+            erosion[x - 1 - j * y] * erosion[x - j * (y - 1)]
         ) % 20183
-        erosion[x - 1j * y] = (geological[x - 1j * y] + depth) % 20183
+        erosion[x - j * y] = (geological[x - j * y] + depth) % 20183
 
 geological[target] = 0
 erosion[target] = 0
@@ -70,65 +76,86 @@
     neither, climbing, torch = 0, 1, 2
     rocky, wet, narrow = 0, 1, 2
 
-    # Override the neighbors function
-    def neighbors(self, vertex):
-        north = (0, 1)
-        south = (0, -1)
-        west = (-1, 0)
-        east = (1, 0)
-        directions_straight = [north, south, west, east]
-
-        neighbors = {}
-        for dir in directions_straight:
-            target = (vertex[0] + dir[0], vertex[1] + dir[1], vertex[2])
-            if target in self.vertices:
-                neighbors[target] = 1
-        for tool in (neither, climbing, torch):
-            target = (vertex[0], vertex[1], tool)
-            if target in self.vertices and tool != vertex[1]:
-                neighbors[target] = 7
-
-        return neighbors
+    allowed = {
+        rocky: [torch, climbing],
+        wet: [neither, climbing],
+        narrow: [torch, neither],
+    }
 
     # Add some coordinates around the target
     padding = 10 if case_to_test == 1 else 50
     for x in range(max_x, max_x + padding):
         geological[x] = x * 16807
         erosion[x] = (geological[x] + depth) % 20183
     for y in range(max_y, max_y + padding):
-        geological[-1j * y] = y * 48271
-        erosion[-1j * y] = (geological[-1j * y] + depth) % 20183
+        geological[-j * y] = y * 48271
+        erosion[-j * y] = (geological[-j * y] + depth) % 20183
     for x in range(1, max_x + padding):
         for y in range(1, max_y + padding):
-            if x - 1j * y in geological:
+            if x - j * y in geological:
                 continue
-            geological[x - 1j * y] = (
-                erosion[x - 1 - 1j * y] * erosion[x - 1j * (y - 1)]
+            geological[x - j * y] = (
+                erosion[x - 1 - j * y] * erosion[x - j * (y - 1)]
             ) % 20183
-            erosion[x - 1j * y] = (geological[x - 1j * y] + depth) % 20183
+            erosion[x - j * y] = (geological[x - j * y] + depth) % 20183
 
     terrain = {x: erosion[x] % 3 for x in erosion}
+
     del erosion
     del geological
 
-    # Then run pathfinding algo
+    # Prepare pathfinding algorithm
+
+    # Override the neighbors function
+    def neighbors(self, vertex):
+        north = j
+        south = -j
+        west = -1
+        east = 1
+        directions_straight = [north, south, west, east]
+
+        neighbors = {}
+        for dir in directions_straight:
+            target = (vertex[0] + dir, vertex[1])
+            if self.is_valid(target):
+                neighbors[target] = 1
+        for tool in (neither, climbing, torch):
+            target = (vertex[0], tool)
+            if self.is_valid(target):
+                neighbors[target] = 7
+
+        return neighbors
+
+    # Define what is a valid spot
+    def is_valid(self, vertex):
+        if vertex[0].real < 0 or vertex[0].imag > 0:
+            return False
+        if vertex[0].real >= max_x + padding or vertex[0].imag <= -(max_y + padding):
+            return False
+        if vertex[1] in allowed[terrain[vertex[0]]]:
+            return True
+        return False
+
+    # Heuristics function for A* search
+    def estimate_to_complete(self, start, target):
+        distance = 0
+        for i in range(len(start) - 1):
+            distance += abs(start[i] - target[i])
+        distance += 7 if start[-1] != target[-1] else 0
+        return distance
+
+    # Run pathfinding algorithm
     pathfinding.WeightedGraph.neighbors = neighbors
-    vertices = [
-        (x.real, x.imag, neither) for x in terrain if terrain[x] in (wet, narrow)
-    ]
-    vertices += [
-        (x.real, x.imag, climbing) for x in terrain if terrain[x] in (rocky, wet)
-    ]
-    vertices += [
-        (x.real, x.imag, torch) for x in terrain if terrain[x] in (rocky, narrow)
-    ]
-    graph = pathfinding.WeightedGraph(vertices)
-
-    graph.dijkstra((0, 0, torch), (max_x, -max_y, torch))
-
-    puzzle_actual_result = graph.distance_from_start[(max_x, -max_y, torch)]
-
-# 979 is too high
+    pathfinding.WeightedGraph.is_valid = is_valid
+    pathfinding.Graph.estimate_to_complete = estimate_to_complete
+
+    graph = pathfinding.WeightedGraph()
+
+    graph.a_star_search(
+        (SuperComplex(0), torch), (SuperComplex(max_x - j * max_y), torch)
+    )
+
+    puzzle_actual_result = graph.distance_from_start[(max_x - j * max_y, torch)]
 
 
 # -------------------------------- Outputs / results --------------------------------- #