def a():
groups = data.split("\n\n")
criteria, ticket, nearby = [l.split("\n") for l in groups]
rules = {}
for c in criteria:
k, vs = c.split(":")
rs = u.lmap(tuple, u.chunks(u.ints(vs.replace("-", " to ")), 2))
rules[k] = rs
def valid(val):
for ruleset in rules.values():
for a, b in ruleset:
if a <= val <= b:
return True
return False
s = 0
for ticket in nearby[1:]:
t = u.ints(ticket)
for v in t:
if not valid(v):
s += v
return s
def b():
d = inp * 10_000
offs = int("".join(str(c) for c in inp[:7]))
d = d[offs:]
for _ in range(100):
partials = list(itertools.accumulate(d)):[-1]
d = u.lmap(lambda p: (partials[-1] - p) % 10, partials)
return "".join(str(x) for x in d[:8])
def b():
positions = u.lmap(u.ints, lines)
px, vx = [p[0] for p in positions], [0] * len(positions)
py, vy = [p[1] for p in positions], [0] * len(positions)
pz, vz = [p[2] for p in positions], [0] * len(positions)
sx = simulate(px, vx)
sy = simulate(py, vy)
sz = simulate(pz, vz)
return lcms((sx, sy, sz))
def b():
groups = data.split("\n\n")
criteria, my_ticket, nearby = [g.split("\n") for g in groups]
my_ticket = u.ints(my_ticket[1])
rules = {}
for c in criteria:
k, vs = c.split(":")
rs = u.lmap(tuple, u.chunks(u.ints(vs.replace("-", " ")), 2))
rules[k] = rs
def valid_for_field(v, field):
return any(a <= v <= b for a, b in rules[field])
def valid(val):
return any(valid_for_field(val, field) for field in rules)
valid_nearby = []
for ticket in nearby[1:]:
t = u.ints(ticket)
if all(valid(v) for v in t):
valid_nearby.append(t)
possible = []
for _ in range(len(my_ticket)):
possible.append(set(rules.keys()))
for ticket in valid_nearby:
for i, v in enumerate(ticket):
pl = list(possible[i])
for field in pl:
if not valid_for_field(v, field):
possible[i].remove(field)
mapping = {}
allocated = set()
for i, p in sorted(enumerate(possible), key=lambda x: x[1]):
field = (p - allocated).pop()
mapping[i] = field
allocated.add(field)
s = functools.reduce(
operator.mul,
(my_ticket[i] for i in mapping if mapping[i].startswith("departure")),
1,
)
return s
def a():
positions = u.lmap(u.ints, lines)
px, vx = [p[0] for p in positions], [0] * len(positions)
py, vy = [p[1] for p in positions], [0] * len(positions)
pz, vz = [p[2] for p in positions], [0] * len(positions)
simulate(px, vx, 1000)
simulate(py, vy, 1000)
simulate(pz, vz, 1000)
return sum(
(abs(px[i]) + abs(py[i]) + abs(pz[i])) * (abs(vx[i]) + abs(vy[i]) + abs(vz[i]))
for i in range(len(positions))
)
def position_scanners():
scanners = [set(u.chunks(u.ints(scanner)[1:], 3)) for scanner in data.split('\n\n')]
fingerprints = u.lmap(fingerprint, scanners)
positions = {0: (0,0,0)}
relative_sensors = {0: scanners[0]}
solvable = deque([0])
while len(solvable) > 0:
i = solvable.popleft()
rscanner1 = relative_sensors[i]
for j, scanner2 in enumerate(scanners):
if j == i or j in positions or len(fingerprints[i] & fingerprints[j]) < threshold:
continue
aligned, position, rscanner2 = align_scanners(rscanner1, scanner2)
if aligned:
solvable.append(j)
positions[j] = position
relative_sensors[j] = rscanner2
sensors = {pt for v in relative_sensors.values() for pt in v}
return positions, sensors
#4,1
#0,13
#10,12
#3,4
#3,0
#8,4
#1,10
#2,14
#8,10
#9,0
#
#fold along y=7
#fold along x=5"""
ints = u.ints(data)
intlines = u.lmap(u.ints, lines)
toklines = [line.split(' ') for line in lines]
def a():
dots, insns = data.split('\n\n')
dots = [u.ints(d) for d in dots.splitlines()]
insns = insns.splitlines()
grid = set(tuple(p) for p in dots)
for insn in insns:
axis, val = u.fixparse('fold along {}={:d}', insn)
newgrid = set()
for pos in grid:
x, y = newx, newy = pos
if axis == 'y' and y > val:
newx = x
import itertools
import numpy as np
from math import ceil
import functools
from collections import defaultdict, namedtuple
import u
from aocd import data
inp = u.lmap(int, data)
ln = len(inp)
def pattern(i, ln):
j = i + 1
a = [0] * j
b = [1] * j
c = [0] * j
d = [-1] * j
v = a + b + c + d
v1 = v[1:]
return list(itertools.islice(itertools.chain(v1, itertools.cycle(v)), ln))
def mat(ln):
return np.array([pattern(i, ln) for i in range(ln)])
def phase(mt, v):
return np.mod(np.absolute(np.matmul(mt, v)), 10)
