Add day 22

Author: nthistle

2022/day22/aoc_tools.py

@@ -0,0 +1,95 @@
+from collections import deque, defaultdict, Counter
+import itertools
+import re
+from typing import TypeVar, Generator, Iterable, Tuple, List
+
+_T = TypeVar("T")
+
+def adjacent_pairs(elements: Iterable[_T]) -> Generator[Tuple[_T, _T], None, None]:
+ elements_iter = iter(elements)
+ last_element = next(elements_iter)
+ for element in elements_iter:
+ yield (last_element, element)
+ last_element = element
+
+def all_pairs(elements: Iterable[_T]) -> Generator[Tuple[_T, _T], None, None]:
+ elements_list = list(elements)
+ for i in range(len(elements_list)):
+ for j in range(i + 1, len(elements_list)):
+ yield (elements_list[i], elements_list[j])
+
+def all_tuples(elements: Iterable[_T]) -> Generator[Tuple[_T, _T], None, None]:
+ elements_list = list(elements)
+ for i in range(len(elements_list)):
+ for j in range(len(elements_list)):
+ if j == i: continue
+ yield (elements_list[i], elements_list[j])
+
+
+# yes, everyone else calls this "cumsum" but ohwell
+def rolling_sum(elements: Iterable[_T], start: _T = None) -> List[_T]:
+ rsum = []
+ elements_iter = iter(elements)
+ 
+ if start is None:
+ rsum.append(next(elements_iter))
+ else:
+ rsum.append(start)
+ 
+ for element in elements_iter:
+ rsum.append(rsum[-1] + element)
+ return rsum
+
+
+# I did some rough experiments with this version vs. a version that uses a deque, which
+# has efficient popleft, and it seems like this version actually wins because of how slow
+# iterating over a deque is (which you have to do if you want to use the results)
+def rolling_window(
+ elements: Iterable[_T],
+ window_size: int,
+) -> Generator[Tuple[_T, ...], None, None]:
+ current_window = []
+ for element in elements:
+ current_window.append(element)
+ if len(current_window) > window_size:
+ del current_window[0]
+ if len(current_window) == window_size:
+ yield current_window
+
+
+
+# this is like slightly borked because it doesn't get negative numbers
+# oh well i guess
+#nums_regex = regex.compile("([^\\d]*)((?P<nums>\\d+)([^\\d]*))*")
+
+def nums(s):
+ m = nums_regex.match(s)
+ vals = m.capturesdict()["nums"]
+ return [int(x) for x in vals]
+
+def nums(s):
+ m = re.findall("-?\d+", s)
+ return [int(x) for x in m]
+
+def numsp(s):
+ m = re.findall("-?\d+", s)
+ return [int(x) for x in m]
+
+def sign(x):
+ if x < 0:
+ return -1
+ elif x == 0:
+ return 0
+ else:
+ return 1
+
+
+# underscored names are in case functions get shadowed by accident
+adjp = _adjp = adjacent_pairs
+ap = _ap = all_pairs
+at = _at = all_tuples
+rw = _rw = rolling_window
+rsum = _rsum = rolling_sum
+
+dd = _dd = defaultdict
+ctr = _ctr = Counter

2022/day22/day22.py

@@ -0,0 +1,195 @@
+import string
+from collections import defaultdict
+from aoc_tools import *
+import functools
+import sys
+#sys.setrecursionlimit(10000000)
+# RIGHT0 DOWN1 LEFT2 UP3
+dirs = ((0,1),(1,0),(0,-1),(-1,0))
+dirs3 = ((1,0,0),(-1,0,0),(0,1,0),(0,-1,0),(0,0,1),(0,0,-1))
+
+with open(r"input.txt") as f:
+ s = f.read()[:-1]#.strip()
+print("\n".join(x[:60] for x in s.split("\n")[:6]))
+
+g = defaultdict(lambda : "")
+
+gs, ins = s.split("\n\n")
+
+for i, r in enumerate(gs.split("\n")):
+ for j in range(len(r)):
+ if r[j] != " ":
+ g[i,j] = r[j]
+
+path = ["".join(v) for k, v in itertools.groupby(ins, str.isdigit)]
+
+initx,inity = 0,0
+while g[initx,inity] != ".":
+ inity += 1
+
+
+cx,cy,mdir = initx,inity,0
+
+
+
+for z,p in enumerate(path):
+ #print(z)
+ if p == "R":
+ mdir = (mdir + 1) % 4
+ elif p == "L":
+ mdir = (mdir - 1) % 4
+ else:
+ steps = int(p)
+ dx,dy = dirs[mdir]
+ for _ in range(steps):
+ cx += dx
+ cy += dy
+ # check if off the board or blocked
+ if g[cx,cy] == "#":
+ cx -= dx
+ cy -= dy
+ break
+ if g[cx,cy] == "":
+ # SLOW!
+ nx,ny = cx - dx, cy - dy
+ while g[nx,ny] != "":
+ nx -= dx
+ ny -= dy
+ nx += dx
+ ny += dy
+ if g[nx,ny] == "#":
+ cx -= dx
+ cy -= dy
+ break
+ cx = nx
+ cy = ny
+
+print(1000 * (cx + 1) + 4 * (cy + 1) + mdir)
+ 
+ 
+
+# right = +dir
+
+# 5 6 .
+# 4 /|\
+# 2 3 |
+# 1
+# 50x50 cells
+
+cx,cy,mdir = initx,inity,0
+
+def region(cx,cy):
+ rx = cx//50
+ ry = cy//50
+ if (rx,ry) == (0,1): return 5
+ if (rx,ry) == (0,2): return 6
+ if (rx,ry) == (1,1): return 4
+ if (rx,ry) == (2,1): return 3
+ if (rx,ry) == (2,0): return 2
+ if (rx,ry) == (3,0): return 1
+
+def nxt(cx,cy,mdir):
+ dx,dy = dirs[mdir]
+ r = region(cx,cy)
+ invalid = (g[cx + dx, cy + dy] == "")
+ if mdir == 0:
+ if r == 1 and invalid:
+ # bottom of 3
+ d = cx - 150
+ return (149, 50 + d), 3, 3
+ elif r == 3 and invalid:
+ # right edge of 6
+ d = cx - 100
+ return (49 - d, 149), 2, 6
+ elif r == 4 and invalid:
+ # bottom of 6
+ d = cx - 50
+ return (49, 100 + d), 3, 6
+ elif r == 6 and invalid:
+ # right edge of 3
+ d = cx
+ return (149 - d, 99), 2, 3
+ else:
+ return (cx+dx, cy+dy), mdir, None
+ elif mdir == 1:
+ if r == 1 and invalid:
+ # top of 6
+ d = cy
+ return (0, 100 + d), 1, 6
+ elif r == 3 and invalid:
+ # right of 1
+ d = cy - 50
+ return (150 + d, 49), 2, 1
+ elif r == 6 and invalid:
+ # right of 4
+ d = cy - 100
+ return (50 + d, 99), 2, 4
+ else:
+ return (cx+dx, cy+dy), mdir, None
+ elif mdir == 2:
+ if r == 1 and invalid:
+ # top of 5
+ d = cx - 150
+ return (0, 50 + d), 1, 5
+ elif r == 2 and invalid:
+ # left of 5
+ d = cx - 100
+ return (49 - d, 50), 0, 5
+ elif r == 4 and invalid:
+ # top of 2
+ d = cx - 50
+ return (100, d), 1, 2
+ elif r == 5 and invalid:
+ # left of 2
+ d = cx
+ return (149 - d, 0), 0, 2
+ else:
+ return (cx+dx, cy+dy), mdir, None
+ elif mdir == 3: # theory: 0,3
+ if r == 2 and invalid:
+ # left of 4
+ d = cy
+ return (50 + d, 50), 0, 4
+ elif r == 5 and invalid:
+ # left of 1
+ d = cy - 50
+ return (150 + d, 0), 0, 1
+ elif r == 6 and invalid:
+ # bottom of 1
+ d = cy - 100
+ return (199, d), 3, 1
+ else:
+ return (cx+dx, cy+dy), mdir, None
+
+## 
+### correctness test ish
+##for (x,y),v in list(g.items()):
+## if v == "": continue
+## for mdir in range(3):
+## (nx,ny),ndir,_ = nxt(x,y,mdir)
+## (nnx,nny),nndir,_ = nxt(nx,ny,(ndir + 2) % 4)
+## assert nnx == x and nny == y and (nndir + 2) % 4 == mdir
+
+ 
+cx,cy,mdir = initx,inity,0
+
+for z,p in enumerate(path):
+ if p == "R":
+ mdir = (mdir + 1) % 4
+ elif p == "L":
+ mdir = (mdir - 1) % 4
+ else:
+ steps = int(p)
+ for _ in range(steps):
+ (nx,ny),nmd,nr = nxt(cx,cy,mdir)
+ if nr is not None:
+ assert region(nx,ny) == nr, "new region chk"
+ if g[nx,ny] == "#":
+ break
+ assert g[nx,ny] == "."
+ cx = nx
+ cy = ny
+ mdir = nmd
+
+print(1000 * (cx + 1) + 4 * (cy + 1) + mdir)
+