feat: 2023 days 21 and 22

Author: Programator2

2023/21.txt

@@ -0,0 +1 @@
+16

2023/21_expa.txt

@@ -0,0 +1,11 @@
+...........
+.....###.#.
+.###.##..#.
+..#.#...#..
+....#.#....
+.##..S####.
+.##..#...#.
+.......##..
+.##.#.####.
+.##..##.##.
+...........

2023/21_expb.txt

@@ -0,0 +1,36 @@
+from aoc import *
+from functools import cache
+
+
+S = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+
+def main(input_file: str):
+    m = load_map_dd(input_file)
+
+    @cache
+    def step(x, y):
+        return {(x + dx, y + dy) for dx, dy in S if m[(x + dx, y + dy)] in ['.', 'S']}
+
+    places = {(x, y) for (x, y), c in m.items() if c == 'S'}
+    for i in range(64):
+        new_places = set()
+        for x, y in places:
+            new_places.update(step(x, y))
+        places = new_places
+
+    # maxx = max(x for x, y in m)
+    # maxy = max(y for x, y in m)
+    # for ri in range(maxx + 1):
+    #     for ci in range(maxy + 1):
+    #         if (ri, ci) in places:
+    #             print('O', end='')
+    #         else:
+    #             print(m[(ri, ci)], end='')
+    #     print()
+
+    return len(places)
+
+DAY = 21
+FILE = f"{DAY}.txt"
+print(main(FILE))

2023/21_test.txt

@@ -1,103 +1,236 @@
 from aoc import *
-from statistics import median, mode
-from more_itertools import windowed, take, peekable, chunked, first_true, split_when, first_true
-from heapq import *
-# from functools import reduce, cache, cmp_to_key
 from functools import cache
-from math import ceil
-import re
-from blessed import BlessedList
-from copy import deepcopy
-import operator
-from string import ascii_letters, ascii_lowercase, ascii_uppercase, digits, hexdigits, whitespace
-from pprint import pprint as pp
-import bisect
-import math
-from itertools import pairwise, combinations
-import sys
-from collections import defaultdict, OrderedDict, deque, Counter
-# from ordered_set import OrderedSet
+from collections import Counter
+
 
 S = [(-1, 0), (1, 0), (0, -1), (0, 1)]
 
 
 def main(input_file: str):
     m = load_map_dd(input_file)
     maxx = max(x for x, y in m)
-    sizex = maxx + 1
-    sizey = maxy + 1
+    sizex = maxx + 1  # 131
     maxy = max(y for x, y in m)
-    # pp(m)
+    sizey = maxy + 1  # 131
+
     @cache
     def step(x, y):
-        return {((x + dx),
-                 (y + dy)) for dx, dy in S
-                if m[((x + dx) % (maxx + 1),
-                      (y + dy) % (maxy + 1))] in ['.', 'S']}
+        return {
+            ((x + dx), (y + dy))
+            for dx, dy in S
+            if m[((x + dx) % (maxx + 1), (y + dy) % (maxy + 1))] in ['.', 'S']
+        }
 
     places = {(x, y) for (x, y), c in m.items() if c == 'S'}
     c = Counter()
     c[next(iter(places))] = 1
+    start = next(iter(places))
+    m[start] = '.'
     steps = 26501365
-    size = steps * 2 + 1
     suma = 0
-    for i in range(size):
-        if i <= size // 2:
-            # we are above or in the middle of the rhombus, the width is
-            # increasing
-            row = i % sizex
-            width = i * 2 + 1
-            if width <= sizey:
-                # take inner size of the rhomboid
-                for col in range(sizey // 2 - i, width, 2):
-                    if m[i, col] == '.':
-                        suma += 1
-            else:
-                # take outer size of the rhomboid
-                full_widths = width // sizey
-                remainder = width % sizey
-                if remainder <= sizey // 2:
-                    # Count the edges
-                    # XXX.........XXX
-                    pass
-
-                else:
-                    # Count the inside
-                    # XXXXXX...
-                    # ...XXXXXX
-                    #    ^^^......counting just these
-                    pass
-                pass
-        else:
-            # we are below rhombus, the width is decreasing
-            pass
-    for i in range(50):
-        new_places = set()
-        new_counter = Counter()
-        for x, y in places:
-            # steps_number = c[x, y]
-            # c[x, y] = 0
-            new_steps = step(x, y)
-            new_places.update(new_steps)
-            # for nx, ny in new_steps:
-                # new_counter[nx, ny] = steps_number
-        places = new_places
-        c = new_counter
-    # pp(m)
-    # for ri in range(maxx + 1):
-    #     for ci in range(maxy + 1):
-    #         if (ri, ci) in places:
-    #             print('O', end='')
-    #         else:
-    #             print(m[(ri, ci)], end='')
-    #     print()
-    # pp(c)
-    return sum(c.values())
+
+    # The best solution is finding the quadratic recurence. Since I can't find
+    # it on my own, I have painstakingly split the whole farm into 14 types of
+    # squares (each square represents visited places in one map):
+    #
+    # ^ - UP pentagon
+    # V - DOWN pentagon
+    # < - LEFT pentagon
+    # > - RIGHT pentagon
+    # / - RIGHT-DOWN pentagon
+    # \ - LEFT-DOWN pentagon
+    # ( - LEFT-UP pentagon
+    # ) - RIGHT-UP pentagon
+    # , - RIGHT-DOWN triangle
+    # . - LEFT-DOWN triangle
+    # ` - RIGHT-UP triangle
+    # ' - LEFT-UP triangle
+    # e - even parity square
+    # o - odd parity square
+    # S - starting square (the same as even parity square)
+    #
+    #     ,^.
+    #    ,/e\.
+    #   ,/eoe\.
+    #  ,/eoeoe\.
+    # ,/eoeoeoe\.
+    # <eoeoSoeoe>
+    # `(eoeoeoe)'
+    #  `(eoeoe)'
+    #   `(eoe)'
+    #    `(e)'
+    #     `V'
+    #
+    # Pentagons have odd parity an triangles have even parity.
+    #
+    # Parity can be computed by adding two coordinates together and computing
+    # modulo two. (0, 0) has even parity, (1, 2) has odd parity.
+    #
+    # The input is constructed so that the walking stops right at the edges of
+    # squares (0, 65) for the up pentagon, (130, 65) for the down pentagon, (65,
+    # 0) for the left pentagon, (65, 130) for the right pentagon. It's because
+    # the middle row and middle columns are garden plots. There's also garden
+    # plots inside the square creating a 45-degree rotated square of garden
+    # plots. Since there are no rocks, this creates a perfect sharp line of
+    # visited garden plots in pentagons and triangles, not requiring to manually
+    # do flood fill or search.
+    #
+    # Thus the problem reduces to just counting the number of each square in the
+    # whole farm and then counting the garden plots with the correct parity.
+    #
+    # And one special thing with this approach -- there are some garden plots
+    # not visitable by moving in four directions. I have manually detected these
+    # using my eyes and a bucket tool in Gimp. The adjusted input file is
+    # attached in the repository.
+
+    # Compute all types of squares
+    up_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i, sizey // 2 + i + 1):
+            if (i + col) % 2 and m[i, col] == '.':
+                up_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (i + col) % 2 and m[i, col] == '.':
+                up_pentagon += 1
+
+    down_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i, sizey // 2 + i + 1):
+            if (maxx - i + col) % 2 and m[maxx - i, col] == '.':
+                down_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (maxx - i + col) % 2 and m[maxx - i, col] == '.':
+                down_pentagon += 1
+
+    right_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i, sizey // 2 + i + 1):
+            if (maxx - i + col) % 2 and m[col, maxx - i] == '.':
+                right_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (maxx - i + col) % 2 and m[col, maxx - i] == '.':
+                right_pentagon += 1
+
+    left_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i, sizey // 2 + i + 1):
+            if (i + col) % 2 and m[col, i] == '.':
+                left_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (i + col) % 2 and m[col, i] == '.':
+                left_pentagon += 1
+
+    right_down_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i, sizex):
+            if (i + col) % 2 and m[i, col] == '.':
+                right_down_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (i + col) % 2 and m[i, col] == '.':
+                right_down_pentagon += 1
+
+    left_down_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 + i + 1):
+            if (i + col) % 2 and m[i, col] == '.':
+                left_down_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (i + col) % 2 and m[i, col] == '.':
+                left_down_pentagon += 1
+
+    right_up_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i, sizex):
+            if (maxx - i + col) % 2 and m[maxx - i, col] == '.':
+                right_up_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (maxx - i + col) % 2 and m[maxx - i, col] == '.':
+                right_up_pentagon += 1
+
+    left_up_pentagon = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 + i + 1):
+            if (maxx - i + col) % 2 and m[maxx - i, col] == '.':
+                left_up_pentagon += 1
+    for i in range(sizex // 2, sizex):
+        for col in range(sizey):
+            if (maxx - i + col) % 2 and m[maxx - i, col] == '.':
+                left_up_pentagon += 1
+
+    left_up_triangle = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i):
+            # The last one should be (64, 0)
+            if (i + col) % 2 == 0 and m[i, col] == '.':
+                left_up_triangle += 1
+
+    left_down_triangle = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 - i):
+            if (maxx - i + col) % 2 == 0 and m[maxx - i, col] == '.':
+                left_down_triangle += 1
+
+    right_up_triangle = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 + 1 + i, sizey):
+            # The last one should be (64, 0)
+            if (i + col) % 2 == 0 and m[i, col] == '.':
+                right_up_triangle += 1
+
+    right_down_triangle = 0
+    for i in range(sizex // 2):
+        for col in range(sizey // 2 + 1 + i, sizey):
+            if (maxx - i + col) % 2 == 0 and m[maxx - i, col] == '.':
+                right_down_triangle += 1
+
+    even_square = 0
+    for i in range(sizex):
+        for col in range(sizey):
+            if (i + col) % 2 == 0 and m[i, col] == '.':
+                even_square += 1
+
+    odd_square = 0
+    for i in range(sizex):
+        for col in range(sizey):
+            if (i + col) % 2 and m[i, col] == '.':
+                odd_square += 1
+
+    steps = (steps - sizex // 2) // sizex
+    suma += (
+        up_pentagon
+        + down_pentagon
+        + left_pentagon
+        + right_pentagon
+        + (steps - 1)
+        * (
+            right_down_pentagon
+            + right_up_pentagon
+            + left_down_pentagon
+            + left_up_pentagon
+            + right_down_triangle
+            + right_up_triangle
+            + left_down_triangle
+            + left_up_triangle
+        )
+        + right_down_triangle
+        + right_up_triangle
+        + left_down_triangle
+        + left_up_triangle
+        + steps * (steps + 1) // 2 * even_square
+        + steps * (steps - 1) // 2 * odd_square
+        + steps * (steps - 1) // 2 * even_square
+        + (steps - 1) * (steps - 2) // 2 * odd_square
+    )
+    return suma
+
 
 DAY = 21
-FILE_TEST = f"{DAY}_test.txt"
-FILE_EXP = f"{DAY}_expa.txt"
-FILE = f"{DAY}.txt"
-# test_and_submit(main, FILE_TEST, FILE_EXP, FILE, DAY)
-print(main(FILE_TEST))
-# print(main(FILE))
+FILE = f"{DAY}mod.txt"
+print(main(FILE))