Day 14

.gitignore

@@ -1 +1,2 @@
 .idea
+__pycache__

10.py

@@ -1,40 +1,9 @@
-import functools
-import itertools
-import operator
-
-
-def reverse_slice(input, start, length):
-    output = list(input)
-    for i, pos in enumerate(range(start, start + length)):
-        output[pos % len(output)] = input[(start + length - i - 1) % len(output)]
-    return output
-
-
-def do_rounds(lengths, count=1):
-    position, skip, data = 0, 0, list(range(256))
-    for _ in range(count):
-        for length in lengths:
-            data = reverse_slice(data, position, length)
-            position += length + skip
-            skip += 1
-    return data
-
-
-def group(n, iterable):
-    # https://docs.python.org/3.1/library/itertools.html#recipes
-    args = [iter(iterable)] * n
-    return itertools.zip_longest(*args)
-
+from shared import knot_hash, knot_hash_rounds
 
 with open('data/10.txt', 'r') as file:
     lengths = list(map(int, file.readline().strip().split(',')))
-    data = do_rounds(lengths)
+    data = knot_hash_rounds(lengths)
     print(f'Part one: {data[0]*data[1]}')
 
-
 with open('data/10.txt', 'r') as file:
-    lengths = list(map(ord, file.readline().strip())) + [17, 31, 73, 47, 23]
-    sparse_hash = do_rounds(lengths, 64)
-    dense_hash = [functools.reduce(operator.xor, g) for g in group(16, sparse_hash)]
-    # Yo dawg, I heard you like f-strings, so we put an f-string in your f-string.
-    print(f'Part two: {"".join(f"{c:02x}" for c in dense_hash)}')
+    print(f'Part two: {knot_hash(file.readline().strip())}')

12.py

@@ -1,13 +1,10 @@
-import functools
+from shared import add_connected_components
 
 with open('data/12.txt', 'r') as file:
     sets = []
     pipes = list(map(lambda l: l.strip().replace(' <-> ', ', ').split(', '), file.readlines()))
     for pipe in pipes:
-        overlapping = [s for s in sets if any(program in s for program in pipe)]
-        for overlap in overlapping:
-            sets.remove(overlap)
-        sets.append(functools.reduce(set.union, overlapping, set(pipe)))
+        add_connected_components(sets, pipe)
 
     print(f'Part one: {len(next(s for s in sets if "0" in s))}')
     print(f'Part two: {len(sets)}')

14.py

@@ -0,0 +1,15 @@
+import functools
+
+from shared import knot_hash, add_connected_components
+
+with open('data/14.txt', 'r') as file:
+    seed = file.readline().strip()
+    grid = [bin(int(knot_hash(f'{seed}-{i}'), 16))[2:].zfill(128) for i in range(128)]
+    print(f'Part one: {sum(row.count("1") for row in grid)}')
+
+    regions = []
+    for y, row in enumerate(grid):
+        for x, cell in enumerate(row):
+            if cell == '1':
+                add_connected_components(regions, [(x-1, y), (x, y-1), (x+1, y), (x, y+1)], {(x, y)})
+    print(f'Part two: {len(regions)}')

data/14.txt

@@ -0,0 +1 @@
+vbqugkhl

shared.py

@@ -0,0 +1,50 @@
+import functools
+import itertools
+import operator
+
+
+def reverse_slice(input, start, length):
+    """Reverses a slice of the input list, wrapping around if necessary."""
+    output = list(input)
+    for i, pos in enumerate(range(start, start + length)):
+        output[pos % len(output)] = input[(start + length - i - 1) % len(output)]
+    return output
+
+
+def knot_hash_rounds(lengths, count=1):
+    """Applies a number of rounds of the knot hash algorithm (see day 10)."""
+    position, skip, data = 0, 0, list(range(256))
+    for _ in range(count):
+        for length in lengths:
+            data = reverse_slice(data, position, length)
+            position += length + skip
+            skip += 1
+    return data
+
+
+def group(n, iterable):
+    """Collates the iterable into groups n items long."""
+    # https://docs.python.org/3.1/library/itertools.html#recipes
+    args = [iter(iterable)] * n
+    return itertools.zip_longest(*args)
+
+
+def knot_hash(seed):
+    """The knot has algorithm (day 10). Output is a hex string."""
+    lengths = list(map(ord, seed.strip())) + [17, 31, 73, 47, 23]
+    sparse_hash = knot_hash_rounds(lengths, 64)
+    dense_hash = [functools.reduce(operator.xor, g) for g in group(16, sparse_hash)]
+    return "".join(f"{c:02x}" for c in dense_hash)
+
+
+def add_connected_components(sets, links, to_add=None):
+    """
+    Updates the given collection of sets to include a new group of connected components.
+
+    Existing sets that overlap with the given `links` are removed and conjoined into a new superset along with the
+    `to_add` items specified. If `to_add` is not specified then the `links` are added in their place.
+    """
+    overlapping = [s for s in sets if any(link in s for link in links)]
+    for overlap in overlapping:
+        sets.remove(overlap)
+    sets.append(functools.reduce(set.union, overlapping, set(to_add if to_add is not None else links)))