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)