Solve Day 14

Change-Id: Id9b1522bee8e0c35e4231dd0b9d0e74555f2cbb5

Author: Björn Walter

10.py

@@ -1,6 +1,7 @@
 import numpy as np
 
-def traverse
+def traverse(grid, pos):
+    return
 
 def main():
     with open("inputs/10_test.txt", "r") as file:

13.py

@@ -1,34 +1,85 @@
 import numpy as np
+import math
 
 
 def find_symmetry(pattern):
     #horizontal
-    for i, row in enumerate(pattern):
-        top = pattern[:i]
-        bottom = np.flip(pattern[i:i*2], axis=0)
+    for i, _ in enumerate(pattern):
+        if i < len(pattern)/2:
+            top = pattern[:i]
+            bottom = np.flip(pattern[i:i*2], axis=0)
+        else:
+            bottom = np.flip(pattern[i:], axis=0)
+            top = pattern[i-len(bottom):i]
+        if np.array_equal(top, bottom) and i != 0:
+            return i*100
+    #vertical
+    hpattern = pattern.T
+
+    for i, _ in enumerate(hpattern):
+        if i < len(hpattern)/2:
+            top = hpattern[:i]
+            bottom = np.flip(hpattern[i:i*2], axis=0)
+        else:
+            bottom = np.flip(hpattern[i:], axis=0)
+            top = hpattern[i-len(bottom):i]
         if np.array_equal(top, bottom) and i != 0:
-            return i, "horizontal"
-    for j, _ in enumerate(pattern[0]):
-        left = pattern[:,:j]
-        right = np.flip(pattern[:, j:j*2], axis=0)
-        print(left, right)
-        if np.array_equal(left, right) and j != 0:
-            return j, "vertical"
+            return i
+        
+def all_versions(pattern):
+    versions = []
+
+    r, c = len(pattern), len(pattern[0])
+
+    for i in range(r):
+        for j in range(c):
+            smudged_pattern = [row.copy() for row in pattern]
+            smudged_pattern[i][j] = "#" if pattern[i][j] == "." else "."
+
+            versions.append(smudged_pattern)
+    return versions
 
 
 def main():
-    with open("inputs/13_test.txt", "r") as file:
+    with open("inputs/13.txt", "r") as file:
         lines = file.readlines()
     patterns = []
     pattern = []
     for i, line in enumerate(lines):
-        if line == "\n" or i == len(lines)-1:
-            patterns.append(np.array([list(map(str, row)) for row in pattern]))
+        if i == len(lines)-1:
+                pattern.append(line.strip("\n"))
+                patterns.append(np.array([list(map(str, row)) for row in pattern])) 
+        if line == "\n":
+            patterns.append(np.array([list(map(str, row)) for row in pattern]))    
             pattern = []
         else:
             pattern.append(line.strip("\n"))
-    find_symmetry(patterns[0])
+    scores = []
+    #find_symmetry(patterns[2])
+    for pattern in patterns:
+        score = find_symmetry(pattern)
+        if score:
+            scores.append(score)
+    print(len(scores))
+    print(sum(scores))
+
+    #part 2
+
+    extended_patterns = []
+    for pattern in patterns:
+        extended_pattern = all_versions(pattern)
+        
+        extended_patterns += extended_pattern
+        #print(extended_pattern)
+    
+    scores2 = []
+    for pattern in extended_patterns:
 
+        score = find_symmetry(pattern)
+        if score:
+            scores2.append(score)
+    print(len(scores2))
+    print(sum(scores2))
 
     #print(patterns)
 if __name__ == "__main__":

14.py

@@ -1,37 +1,72 @@
 import numpy as np
 
-def shift_stones(row):
-    for idx, _ in enumerate(row):
-        if row[-idx-1] == "O":
-            right = row[-idx:]
-            for i, _ in enumerate(right):
-                if right[i+1] == "#" or right[i+1] == "O":
-                    right[i] = "O"
-                    new_row = row[-idx-2] + "." + right
-                    row = new_row
-                    break
-                elif i == len(right):
-                    right[i] = "O"
-                    new_row = row[-idx-2] + "." + right
-                    row = new_row
-                    break
-                else:
-                    continue
-    return row
+def shift_stones(platform):
+    shifted_platform = []
+    for row in platform:
+        for i, _ in enumerate(row):
+            if row[-i-1] == "O":
+                right = row[-i-1:]
+                for j, _ in enumerate(right):
+                    if j == 0 and i == 0:
+                        continue
+                    elif j == len(right)-1:
+                        row[-i-1] = "."
+                        right[j] = "O"
+                        
+                        new_row = new_row = np.concatenate([row[:-i],right[-i:]])
+                        row = new_row
+                        break
+                    elif right[j+1] == "#" or right[j+1] == "O":
+                        row[-i-1] = "."
+                        right[j] = "O"
+                        
+                        new_row = np.concatenate([row[:-i],right[-i:]])
+                        row = new_row
+                        break
+                    else:
+                        continue
+        shifted_platform.append(list(row))
+    return shifted_platform
+
+def get_load(pl):
+    total_load = 0
+    for row in pl:
+        for i, pos in enumerate(row):
+            if pos == "O":
+                total_load += i+1
+    return total_load
+
+def perform_cycle(pl):
+    for i in range(4):
+        pl = np.rot90(pl, k=-1)
+        pl = shift_stones(pl)
+    return pl
+        
+
 
 
 def main():
-    with open("inputs/14_test.txt", "r") as file:
+    with open("inputs/14.txt", "r") as file:
         lines = file.readlines()
     platform = []
     for line in lines:
         row = line.strip("\n").split() 
         platform.append([*row[0]])
-    print(platform)
+    #print(platform)
     platform = np.array(platform)
+    shifted_platform = shift_stones(np.rot90(platform, k=-1))#platform[::-1].T)
 
-    for row in platform:
-        row = shift_stones(row)
+    for row in shifted_platform:
+        print(row)
+    print(get_load(shifted_platform))
+
+    # Part 2
+    for i in range(10000):
+        platform = perform_cycle(platform)
+        print(f"Load: {get_load(np.rot90(platform, k=-1))}, cycle: {i+1}")
+    # Write some code to detect the repeating pattern...
+    # I found that the pattern repeats every 17th cycle after about 100 loops.
+    # (1000000000-109)%17 = 0 so answer is same as after 109 cycles.
 
 
 if __name__ == "__main__":