day17: just count active neighbours when there is actually an active neighbour

day17.py

@@ -7,102 +7,59 @@ TEST_SOLUTION_PART1 = 112
 TEST_SOLUTION_PART2 = 848
 
 
-def getEdgeCoords(grid, quad=False):
+def simulate(active_cubes, fourD=False):
-    x_list = [x[0] for x in grid.keys()]
+    active_neighbours = defaultdict(int)
-    y_list = [x[1] for x in grid.keys()]
+    for active_cube in active_cubes:
-    z_list = [x[2] for x in grid.keys()]
+        if fourD:
-    if not quad:
+            x, y, z, w = active_cube
-        return min(x_list), min(y_list), min(z_list), max(x_list), max(y_list), max(z_list)
+        else:
-    else:
+            x, y, z = active_cube
-        w_list = [x[3] for x in grid.keys()]
-        return min(x_list), min(y_list), min(z_list), min(w_list), max(x_list), max(y_list), max(z_list), max(w_list)
 
-
+        for cx in [x - 1, x, x + 1]:
-def simulate(grid):
+            for cy in [y - 1, y, y + 1]:
-    minX, minY, minZ, maxX, maxY, maxZ = getEdgeCoords(grid)
+                for cz in [z - 1, z, z + 1]:
-
+                    if not fourD:
-    new_grid = defaultdict(int)
+                        if not (x == cx and y == cy and z == cz):
-
+                            active_neighbours[(cx, cy, cz)] += 1
-    for x in range(minX - 1, maxX + 2):
-        for y in range(minY - 1, maxY + 2):
-            for z in range(minZ - 1, maxZ + 2):
-                cube_state = grid[(x, y, z)]
-
-                sum_neighbours = 0
-                for cx in [x - 1, x, x + 1]:
-                    for cy in [y - 1, y, y + 1]:
-                        for cz in [z - 1, z, z + 1]:
-                            sum_neighbours += grid[(cx, cy, cz)]
-
-                sum_neighbours -= cube_state
-
-                if not cube_state and sum_neighbours == 3:
-                    new_grid[(x, y, z)] = 1
-                elif cube_state:
-                    if sum_neighbours not in [2, 3]:
-                        new_grid[(x, y, z)] = 0
                     else:
-                        new_grid[(x, y, z)] = 1
+                        for cw in [active_cube[3] - 1, active_cube[3], active_cube[3] + 1]:
+                            if not (x == cx and y == cy and z == cz and w == cw):
+                                active_neighbours[(cx, cy, cz, cw)] += 1
 
-    return new_grid
+    new_active_cubes = set()
+    for coord, neighbour_count in active_neighbours.items():
+        if coord in active_cubes and neighbour_count in (2, 3):
+            new_active_cubes.add(coord)
+        elif neighbour_count == 3:
+            new_active_cubes.add(coord)
+
+    return new_active_cubes
 
 
-def simulate4D(grid):
+def get_active_cubes_from_input(grid_input, dimensions=3):
-    minX, minY, minZ, minW, maxX, maxY, maxZ, maxW = getEdgeCoords(grid, True)
+    active_cubes = set()
+    for x, line in enumerate(grid_input):
+        for y, char in enumerate(line):
+            if char == '#':
+                active_cubes.add((x, y) + tuple(0 for _ in range(dimensions - 2)))
 
-    new_grid = defaultdict(int)
+    return active_cubes
-
-    for x in range(minX - 1, maxX + 2):
-        for y in range(minY - 1, maxY + 2):
-            for z in range(minZ - 1, maxZ + 2):
-                for w in range(minW - 1, maxW + 2):
-                    cube_state = grid[(x, y, z, w)]
-
-                    sum_neighbours = 0
-                    for cx in [x - 1, x, x + 1]:
-                        for cy in [y - 1, y, y + 1]:
-                            for cz in [z - 1, z, z + 1]:
-                                for cw in [w - 1, w, w + 1]:
-                                    sum_neighbours += grid[(cx, cy, cz, cw)]
-
-                    sum_neighbours -= cube_state
-
-                    if not cube_state and sum_neighbours == 3:
-                        new_grid[(x, y, z, w)] = 1
-                    elif cube_state:
-                        if sum_neighbours not in [2, 3]:
-                            new_grid[(x, y, z, w)] = 0
-                        else:
-                            new_grid[(x, y, z, w)] = 1
-
-    return new_grid
 
 
 def part1(test_mode=False):
     my_input = aoclib.getInputAsArray(day=DAY, test=test_mode)
+    active_cubes = get_active_cubes_from_input(my_input)
 
-    grid = defaultdict(int)
+    for _ in range(6):
+        active_cubes = simulate(active_cubes)
 
-    for y, line in enumerate(my_input):
+    return len(active_cubes)
-        for x, char in enumerate(line):
-            grid[(x, y, 0)] = 1 if char == '#' else 0
-
-    for i in range(6):
-        grid = simulate(grid)
-
-    return sum(grid.values())
 
 
 def part2(test_mode=False):
     my_input = aoclib.getInputAsArray(day=DAY, test=test_mode)
+    active_cubes = get_active_cubes_from_input(my_input, 4)
+    for _ in range(6):
+        active_cubes = simulate(active_cubes, True)
 
-    grid = defaultdict(int)
+    return len(active_cubes)
-
-    for y, line in enumerate(my_input):
-        for x, char in enumerate(line):
-            grid[(x, y, 0, 0)] = 1 if char == '#' else 0
-
-    for i in range(6):
-        grid = simulate4D(grid)
-
-    return sum(grid.values())