Updated pathfinding to use complex numbers rather than coordinates

Author: Piratmac

2018/10-The Stars Align.py

@@ -4,7 +4,8 @@
 test_data = {}
 
 test = 1
-test_data[test]   = {"input": """position=< 9,  1> velocity=< 0,  2>
+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>
@@ -35,40 +36,44 @@
 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'],
-                    }
+    "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'
+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'
+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 == '':
+for string in puzzle_input.split("\n"):
+    if string == "":
         continue
-    r = parse.parse('position=<{:>d},{:>d}> velocity=<{:>d},{:>d}>', string)
+    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) for x, y, vx, vy in stars]
-
+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
@@ -77,21 +82,17 @@
     # (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[0] in range(-300, 300) for v in vertices] + [v[1] in range(-300, 300) for v in vertices]
+    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=' '))
-
-
+        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))
-
-
-
-
+print("Expected result : " + str(puzzle_expected_result))
+print("Actual result   : " + str(puzzle_actual_result))

2018/13-Mine Cart Madness.v1.py

@@ -1,126 +1,133 @@
-
-
 # This v1 works for part 1, not part 2
 # Since it's also quite slow, I've done a v2 that should be better
 
 
-
-
-
-
 # -------------------------------- Input data -------------------------------- #
 import os, pathfinding, re
 
 test_data = {}
 
 test = 1
-test_data[test]   = {"input": """/->-\\
+test_data[test] = {
+    "input": """/->-\\
 |   |  /----\\
 | /-+--+-\  |
 | | |  | v  |
 \-+-/  \-+--/
   \------/   """,
-                     "expected": ['Unknown', 'Unknown'],
-                    }
+    "expected": ["Unknown", "Unknown"],
+}
 
 test += 1
-test_data[test]   = {"input": r"""/>-<\
+test_data[test] = {
+    "input": r"""/>-<\
 |   |
 | /<+-\
 | | | v
 \>+</ |
   |   ^
   \<->/""",
-                     "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(),
-                     "expected": ['124,130', '99, 96'],
-                    }
+    "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(),
+    "expected": ["124,130", "99, 96"],
+}
 
 # -------------------------------- Control program execution -------------------------------- #
 
-case_to_test = 'real'
+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'
+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 -------------------------------- #
 
 
-def grid_to_vertices (self, grid, wall = '#'):
+def grid_to_vertices(self, grid, wall="#"):
     self.vertices = []
     track = {}
     y = 0
 
     for line in grid.splitlines():
-        line = line.replace('^', '|').replace('v', '|').replace('>', '-').replace('<', '-')
+        line = (
+            line.replace("^", "|").replace("v", "|").replace(">", "-").replace("<", "-")
+        )
         for x in range(len(line)):
             if line[x] != wall:
                 self.vertices.append((x, y))
                 track[(x, y)] = line[x]
 
         y += 1
 
-    directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
-    right, left, down, up = directions
+    north = 1j
+    south = -1j
+    west = -1
+    east = 1
+
+    directions = [north, south, west, east]
 
-    for coords in self.vertices:
+    for source in self.vertices:
         for direction in directions:
-            x, y = coords[0] + direction[0], coords[1] + direction[1]
+            target = source + direction
 
-            if track[coords] == '-' and direction in [up, down]:
+            if track[source] == "-" and direction in [north, south]:
                 continue
-            if track[coords] == '|' and direction in [left, right]:
+            if track[source] == "|" and direction in [west, east]:
                 continue
 
-            if (x, y) in self.vertices:
-                if track[coords] in ('\\', '/'):
-                    if track[(x, y)] in ('\\', '/'):
+            if target in self.vertices:
+                if track[source] in ("\\", "/"):
+                    if track[target] in ("\\", "/"):
                         continue
-                    if track[(x, y)] == '-' and direction in [up, down]:
+                    if track[target] == "-" and direction in [north, south]:
                         continue
-                    elif track[(x, y)] == '|' and direction in [left, right]:
+                    elif track[target] == "|" and direction in [west, east]:
                         continue
-                if coords in self.edges:
-                    self.edges[(coords)].append((x, y))
+                if source in self.edges:
+                    self.edges[(source)].append(target)
                 else:
-                    self.edges[(coords)] = [(x, y)]
+                    self.edges[(source)] = [target]
 
     return True
 
-pathfinding.Graph.grid_to_vertices = grid_to_vertices
 
-def turn_left (direction):
-    return (direction[1], -direction[0])
+pathfinding.Graph.grid_to_vertices = grid_to_vertices
 
-def turn_right (direction):
-    return (-direction[1], direction[0])
 
+def turn_left(direction):
+    return (direction[1], -direction[0])
 
 
+def turn_right(direction):
+    return (-direction[1], direction[0])
 
 
 # Analyze grid
 grid = puzzle_input
 graph = pathfinding.Graph()
-graph.grid_to_vertices(puzzle_input, ' ')
+graph.grid_to_vertices(puzzle_input, " ")
 
-intersections = graph.grid_search(grid, '+')['+']
+intersections = graph.grid_search(grid, "+")["+"]
 
-directions = {'^': (0, -1), '>': (1, 0), '<': (-1, 0), 'v': (0, 1)}
-dirs = {(0, -1): '^', (1, 0): '>', (-1, 0): '<', (0, 1): 'v'}
+directions = {"^": (0, -1), ">": (1, 0), "<": (-1, 0), "v": (0, 1)}
+dirs = {(0, -1): "^", (1, 0): ">", (-1, 0): "<", (0, 1): "v"}
 
 
 # Find carts
-list_carts = graph.grid_search(grid, ('^', '<', '>', 'v'))
+list_carts = graph.grid_search(grid, ("^", "<", ">", "v"))
 carts = []
 cart_positions = []
 for direction in list_carts:
@@ -143,15 +150,16 @@ def turn_right (direction):
     pos, dir, choice = cart
     new_pos = (pos[0] + dir[0], pos[1] + dir[1])
 
-    print (pos, choice, dirs[dir])
-
+    print(pos, choice, dirs[dir])
 
     # We need to turn
     if new_pos not in graph.edges[pos]:
-        options = [((pos[0] + x[0], pos[1] + x[1]), x)
-                  for x in directions.values()
-                  if x != (-dir[0], -dir[1])
-                  and (pos[0] + x[0], pos[1] + x[1]) in graph.edges[pos]]
+        options = [
+            ((pos[0] + x[0], pos[1] + x[1]), x)
+            for x in directions.values()
+            if x != (-dir[0], -dir[1])
+            and (pos[0] + x[0], pos[1] + x[1]) in graph.edges[pos]
+        ]
         new_pos, dir = options[0]
 
     # Intersection
@@ -165,25 +173,20 @@ def turn_right (direction):
 
     new_cart = (new_pos, dir, choice)
 
-
-
-
-
     # Check collisions
     if new_cart[0] in cart_positions:
         if part_to_test == 1:
             puzzle_actual_result = new_cart[0]
             break
         else:
-            print ('collision', new_cart[0])
+            print("collision", new_cart[0])
             collision += 1
             carts = [c for c in carts if c[0] != new_cart[0]]
             cart_positions = [c[0] for c in carts]
     else:
         carts.append(new_cart)
         cart_positions.append(new_cart[0])
 
-
     # Count ticks + sort carts
     subtick += 1
     if subtick == nb_carts - collision:
@@ -194,18 +197,14 @@ def turn_right (direction):
         carts = sorted(carts, key=lambda x: (x[0][1], x[0][0]))
         cart_positions = [c[0] for c in carts]
 
-        print ('End of tick', tick, ' - Remaining', len(carts))
+        print("End of tick", tick, " - Remaining", len(carts))
         if len(carts) == 1:
             break
 
 if part_to_test == 2:
     puzzle_actual_result = carts
-#99, 96
+# 99, 96
 # -------------------------------- Outputs / results -------------------------------- #
 
-print ('Expected result : ' + str(puzzle_expected_result))
-print ('Actual result   : '   + str(puzzle_actual_result))
-
-
-
-
+print("Expected result : " + str(puzzle_expected_result))
+print("Actual result   : " + str(puzzle_actual_result))