Anders Englöf Ytterström
3a9a7d4994
Early versions of the code used Manhattan distance instead of BFS to find the movements. Turns out this was covering about 80% of all cases.
129 lines
2.7 KiB
Python
129 lines
2.7 KiB
Python
import re
|
|
from collections import deque, Counter, defaultdict
|
|
from heapq import heappop, heappush
|
|
from itertools import compress, combinations, chain, permutations
|
|
from functools import cache
|
|
|
|
from output import matrix, D, DD, DDa, ADJ, ints, mhd, mdbg, vdbg, cw, ccw
|
|
|
|
DKP = {
|
|
"^": (0, 1),
|
|
"A": (0, 2),
|
|
"<": (1, 0),
|
|
"v": (1, 1),
|
|
">": (1, 2),
|
|
}
|
|
|
|
NKP = {
|
|
"7": (0, 0),
|
|
"8": (0, 1),
|
|
"9": (0, 2),
|
|
"4": (1, 0),
|
|
"5": (1, 1),
|
|
"6": (1, 2),
|
|
"1": (2, 0),
|
|
"2": (2, 1),
|
|
"3": (2, 2),
|
|
"0": (3, 1),
|
|
"A": (3, 2),
|
|
}
|
|
|
|
|
|
def solve(data):
|
|
codes = data.split()
|
|
p1 = 0
|
|
for code in codes:
|
|
seqlen = unwrap(code)
|
|
num = int(code[:-1])
|
|
p1 += num * seqlen
|
|
p2 = None
|
|
return p1, p2
|
|
|
|
|
|
def unwrap(dests):
|
|
seqlen = float("inf")
|
|
for num_path in press(dests, NKP):
|
|
for d0_path in press(num_path, DKP):
|
|
for d1_path in press(d0_path, DKP):
|
|
seqlen = min(seqlen, len(d1_path))
|
|
return seqlen
|
|
|
|
|
|
def press(dests, pad):
|
|
s = "A"
|
|
P = [""]
|
|
for d in dests:
|
|
paths = bfs(tuple(pad.values()), pad[s], pad[d])
|
|
ml = len(sorted(paths, key=lambda x: len(x))[0])
|
|
sp = [p for p in paths if len(p) == ml]
|
|
nP = []
|
|
for a in P:
|
|
for b in sp:
|
|
nP.append(a + b)
|
|
P = nP
|
|
s = d
|
|
P = sorted(P, key=lambda x: len(x))
|
|
psl = len(P[0])
|
|
return [p for p in P if len(p) == psl]
|
|
|
|
|
|
@cache
|
|
def bfs(grid, S, E):
|
|
seen = set()
|
|
Q = deque([(S, "<", "")])
|
|
paths = []
|
|
while Q:
|
|
pos, dn, path = Q.popleft()
|
|
if (pos, dn) in seen:
|
|
continue
|
|
if pos == E:
|
|
paths.append(path + "A")
|
|
continue
|
|
seen.add((pos, dn))
|
|
y, x = pos
|
|
for dn, delta in DDa.items():
|
|
dy, dx = delta
|
|
if (y + dy, x + dx) in grid:
|
|
Q.append(((y + dy, x + dx), dn, path + dn))
|
|
return paths
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import os
|
|
|
|
# use dummy data
|
|
inp = """
|
|
029A
|
|
980A
|
|
179A
|
|
456A
|
|
379A
|
|
""".strip()
|
|
|
|
"""
|
|
68 * 29
|
|
60 * 980
|
|
68 * 179
|
|
64 * 456
|
|
64 * 379
|
|
"""
|
|
|
|
# uncomment to instead use stdin
|
|
# import sys; inp = sys.stdin.read().strip()
|
|
|
|
# uncomment to use AoC provided puzzle input
|
|
with open("./input/21.txt", "r") as f:
|
|
inp = f.read().strip()
|
|
|
|
# uncomment to do initial data processing shared by part 1-2
|
|
p1, p2 = solve(inp)
|
|
|
|
print(p1)
|
|
os.system(f"echo {p1} | wl-copy")
|
|
# print(p2)
|
|
# os.system(f"echo {p2} | wl-copy")
|
|
|
|
# uncomment and replace 0 with actual output to refactor code
|
|
# and ensure nonbreaking changes
|
|
# assert p1 == 0
|
|
# assert p2 == 0
|