Fridtjof Siebert

@fridis.bsky.social

࿋🚴🏃🐕‍🦺🐈🎏🥨🥐🥝🇪🇺 Designing the Fuzion programming language and implementing related tools (http://fuzion-lang.dev). SW safety&security, static code analysis, compilers, FP&OOP. Radical cyclist, distance runner, resisting car centric culture.

_ := concur.threads.env.spawn ()->
for limit := 1, 2*^c do
f, c := my_mutate.env
.exclusive ()->
my_mutate.env.wait ()->
cnt > limit || finish
if !finish then
say "$cnt multiples of 7 found so far..."
(finish.get, cnt.get)
until f

# an integer counter that is modified using mutate effect M
counter(M type : mutate) is

# the current value
private val := M.env.new 0

# increment the value by 1
increment =>
# exclusive to permit concurrent increments
M.env.exclusive ()->
val <- val+1

# read the current value
read =>
# exclusive to forbid reordering in case of concurrent increments
M.env.exclusive ()->
val.get

ch := concur.channel (interval i32) # jobs channel
res := concur.channel i32 # results channel

(1..nthreads)
.map t->
concur.threads.env.spawn ()->
res <- ch.as_list
.map count_sym
.sum
.for_each ignore # use result to ensure threads get spawned

$dec12 => input := io.stdin.read_string.trim.split "\n\n" .as_array grids := input[6].split "\n" .map (.split ": ") areas := grids.map (g->g[0].split "x" .map (.parse_i32.val)) pcnts := grids.map (g->g[1].split " " .map (.parse_i32.val)) part1 => # just stupidly count if the number of #s would fit, ignoreing the # actual shapes. Does not work in general, but for the given input: # present reduced to number of #s presents := array 6 (i->input[i].codepoints.count ="#") a2 := areas.map (.product) # areas reduced to size p2 := pcnts.map (.zip presents (*) .sum) # total count of #s # sum up presents * counts and check if fits into areas a2.zip p2 (>=) .count id part2 => "Merry Christmas" say "$part1:$part2"$

$dec11 => input := io.stdin.read_string.trim.split "\n" .map (.split ": " .as_tuple) nums := container.hash_map (input.map (.0)) 0..input.count-1 num(name) => nums[name].or_else -1 succs := input.map (.1.split " " .map dec11.this.num) .as_array dac := num "dac" fft := num "fft" cnts(n,d,f,b u64) is # counts (n)one, (d)ac, (f)ft, (b)oth count(n i32) cnts : memoize => keep n _-> if n < 0 then cnts 1 0 0 0 else r := succs[n].map count .fold1 a,b->(cnts a.n+b.n a.d+b.d a.f+b.f a.b+b.b) if n=dac then cnts 0 r.n+r.d 0 r.d+r.f+r.b else if n=fft then cnts 0 0 r.n+r.f r.d+r.f+r.b else r part1 => count (num "you") .n part2 => count (num "svr") .b say "$part1:$part2"$

$dec10 => input := io.stdin.read_string.trim.split "\n" .map (.split " ") .map data .as_array data(s) is lights := s[0].replace "[" "" .replace "]" "" .codepoints.foldf (0,1) e,c->(e.0|(c="#"?e.1:0),2*e.1) .0 buttons := (s.drop 1 .take s.count-2).map (.replace "(" "" .replace ")" "" .split "," .map c->1<<c.parse_i32.val .fold1 (|)) .as_array joltage := s.last.val.replace "\{" "" .replace "\}" "" .split "," .map (.parse_i32.val) try(l,n) => l=lights || n!=0 && (buttons ∃ b->try l^b n-1) p2 => # solution proposed by u/tenthmascot at # https://www.reddit.com/r/adventofcode/comments/1pk87hl/2025_day_10_part_2_bifurcate_your_way_to_victory/ solve(j) : memoize => keep "$s/$j" _-> if j ∀ =0 then 0 # all 0, nothing more to do else l := j.indexed.map ||>i,jo->jo%2<<i .fold1 (|) # desired lights = odd joltages (0..(2**buttons.length-1)).map m-> # for all button combinations pr := buttons.zip (m :: (/2)) b,mb->mb%2*b # pressed buttons if l = pr.fold1 (^) then # resulting lights ok? j2 := j.indexed.map ||>i,jo->(jo - (pr.map b->(b>>i)%2 .sum))/2 m.ones_count + 2 * solve j2 # recurse with halved joltage else 1000000 .min.val solve joltage part1 => input.map d->((0..).drop_while n->(!d.try 0 n))[0] .sum part2 => input.map (.p2) .sum say "$part1:$part2"$

$dec9 => input := io.stdin.read_string.trim.split "\n" .map (.split "," .map (.parse_i64.val) .as_tuple) .as_array # area or rectangle with corners a and b rect(a,b) => ((|a.0-b.0|)+1)*((|a.1-b.1|)+1) part1 => input.combine input rect .max part2 => xs := input.map (.0) .unique .sort # all used x coordinates ys := input.map (.1) .unique .sort # all used y coordinates x(v) => xs.find_key v .val.as_i64 # compress x to index in xs y(v) => ys.find_key v .val.as_i64 # compress y to index in ys m : mutate is m ! ()-> floor := m.env.new_array2 xs.length.as_i64 ys.length.as_i64 "." # put outline tiles (input ++ [input[0]]) .map_pairs p,q-> px := x p.0; py := y p.1 qx := x q.0; qy := y q.1 _ := for xi := px, xi+(qx-px).sign.as_i64 yi := py, yi+(qy-py).sign.as_i64 while xi!=qx || yi!=qy do if floor[xi,yi]="." then floor[xi,yi] := "X" .for_each ignore # enforce side-effect # clear outside area floor.indices1.for_each y-> clear(x) => if floor[x,y]="." then floor[x,y] := " "; true else false _ := floor.indices0 .take_while clear .count _ := floor.indices0.reverse.take_while clear .count # try all rectangles input.combine input a,b-> xr := [x a.0, x b.0].sort.as_tuple ||> (..) # range of x coord. yr := [y a.1, y b.1].sort.as_tuple ||> (..) # range of y coord. if xr.combine yr floor[] ∀ !=" " then rect a b else 0 .max say "$part1:$part2"$

$dec8 => input := io.stdin.read_string.trim.split "\n" .map (.split "," .map (.parse_i64.val) .as_array) .as_array n := input.length m := envir.args[1].parse_i32.val pairs := (0..n-1).flat_map (i -> (i+1..n-1).map (pair i)) .sort # get circuit id of junction box i # # cs[i] is >0 if i is identifying box, value is size of circuit, # <0 if identifiying box is at i+cs[i] circuit(cs, i) => if cs[i]<0 then circuit cs i+cs[i] else i # pair of junction box i and j, ordered by straight-line distance pair(i,j) : property.orderable is # straight-line distance between i and j dist := input[i].zip input[j] (-) .map **2 .sum # order public redef type.lteq(a,b pair.this) bool => a.dist <= b.dist # connect this pair for given circuit cs, return resulting circuit connect(cs) => ab := (circuit cs i, circuit cs j) a := ab ||> min b := ab ||> max if a=b then cs else array n x-> if x=a then cs[a] + cs[b] else if circuit cs x = b then a-x else cs[x] part1 => join(c,cs) i32 => if c = m then cs.sort.reverse.take 3 .product else join c+1 (pairs[c].connect cs) join 0 (array n _->1) part2 => join(c,cs) => p := pairs[c] cs0 := p.connect cs if cs0[0]=n then input[p.i][0]*input[p.j][0] else join c+1 cs0 join 0 (array n _->1) say "$part1:$part2"$

$dec7 => input := io.stdin.read_string.trim.split "\n" .map (.codepoints.as_array) .as_array w := input[0].count part1 => input.foldf (0,array w _->false) e,l->e||>c,a-> a2 := array w x-> (l[x]="S" || l[x]="." && a[x] || x>0 && l[x-1]="^" && a[x-1] || x<w-1 && l[x+1]="^" && a[x+1]) c2 := c + a.indices.count (x -> l[x]="^" && a[x]) (c2,a2) .0 part2 => input.foldf (array w _->(i64 0)) a,l-> array w x-> (if l[x]="." then a[x] else if l[x]="S" then 1 else 0 + if x>0 && l[x-1]="^" then a[x-1] else 0 + if x+1<w && l[x+1]="^" then a[x+1] else 0) .sum say "$part1:$part2"$

$dec6 => input := io.stdin.read_string.trim.split "\n" .as_array h := input.length-1 part1 => a := input.map (.split " " .filter !="" .as_array) .as_array a[0].indices.map x-> op := a[h][x] (0..h-1).map y->a[y][x].parse_i64.val .fold1 (if op="*" then * else +) .sum part2 => w := input.map (.trim.byte_length) .max.val i := input.map_to_array (.codepoints.as_array) next(c) => if c<w && (0..h ∃ y->i[y][c]!=" ") then next c+1 else c+1 (0 :: next).take_while <=w .map c-> op := i[h][c] (c..(next c)-2).map x-> (0..h-1).foldf "" e,y->e+i[y][x] .trim.parse_i64.val .fold1 (op="*" ? * : +) .sum say "$part1:$part2"$

$dec5 => fr,id := io.stdin.read_string.trim.split "\n\n" .as_tuples.first.val fresh := fr.split "\n" .map (.split "-" .map (.parse_i64.val) .as_tuple) ids := id.split "\n" .map (.parse_i64.val) none := fresh.take 0 part1 => ids.count i-> fresh ∃ ||> a,b -> a<=i<=b separate(a,b) => a.1+1 < b.0 || b.1+1 < a.0 join(a,b) => (min a.0 b.0, max a.1 b.1) part2 => fresh.foldf none l,n-> # create list of disjoint ranges, adding one range n at a time h, t := l.foldf (n, none) r,f-> # for each range f we found so far if separate r.0 f then (r.0, [f] ++ r.1) # r.0 and f separate, so keep both else (join r.0 f, r.1) # else join r.0 and f [h] ++ t .map (||> a,b -> b-a+1) .sum say "$part1:$part2"$

$dec4 => input := io.stdin.read_string.trim.split "\n" .map (l -> l.codepoints.map ="@" .as_array) .as_array w := input[0].length h := input.length a := array2 w+2 h+2 x,y-> 1 <= y <= h && 1 <= x <= w && input[y-1][x-1] # array2 of bool with directly inaccessible rolls in array2 `o` inaccessible1(o) => array2 w+2 h+2 x,y-> if o[x,y] then ((x-1 .. x+1).pairs (y-1 .. y+1) .count ||>xx,yy->o[xx,yy])>4 else false # count of recursively inaccessible rolls inaccessible(o) => i := inaccessible1 o co := o.count id ci := i.count id co = ci ? ci : inaccessible i part1 => i := inaccessible1 a a.index_pairs.count ||>x,y-> a[x,y] && !i[x,y] part2 => a.count id - inaccessible a say "$part1:$part2"$

$dec3 => input := io.stdin.read_string.trim.split "\n" .map (.codepoints.map (.parse_i64.val)) joltage(n,v,l) => if n=0 then v else d := l.take (l.count-n+1) .max.val joltage n-1 v*10+d (l.drop_while !=d .drop 1) part1 => input.map (joltage 2 (i64 0)) .sum part2 => input.map (joltage 12 (i64 0)) .sum say "$part1:$part2"$

$dec2 => input := io.stdin.read_string .split "\n" .first.val .split "," .flat_map (.split "-" .map (.parse_i64.val) .as_tuples) ten := i64 10 i64.strlen => ($val).byte_length.as_i64 part1 => input.flat_map ||>a,b-> sl := (a.strlen+1) / 2 f := ten**sl (max f/10 a/f .. min f-1 b/f ).map hi-> v := hi * (f+1) if a <= v <= b then v else 0 .sum part2 => input.flat_map ||>a,b-> (i64 2 .. b.strlen).flat_map sn-> # eg. 4 sl := (a.strlen+sn-1) / sn # 2 f0 := ten**sl # 100 f1 := f0**(sn-1) # 1000000 ff := (f1 :: (/f0)).take_while >0 .sum # 1010101 (max f0/10 a/f1 .. min f0-1 b/f1 ).map hi-> v := hi * ff # 34343434 if a <= v <= b then v else 0 .unique .sum say "$part1:$part2"$

$dec1 => input := io.stdin.read_string .replace "R" "+" .replace "L" "-" .split "\n" .filter !="" .map (.parse_i32.val) part1 => input.foldf (50,0) e,x-> n := (e.0 + x) % 100 c := e.1 + if n=0 then 1 else 0 (n,c) .1 part2 => input.foldf (50,0) e,x-> (1 .. (|x|)).foldf e r,_-> n := (r.0 + x.sign) % 100 c := r.1 + if n=0 then 1 else 0 (n,c) .1 say "$part1:$part2"$

Two small branches of a cherry tree in full blossom in front of a blue sky.

Blossoming cherry trees along a path through small private gardens in Karlsruhe, Germany.

WirschaftsWoche: Friedrich Merz kann es nicht.

$dec25 => input := io.stdin.read_string.split "\n\n" .map (.split "\n" .filter !="") counts(x) => (0..4).map (i -> x.map (.utf8[i]) .filter (="#".utf8[0]) .count) locks := input.filter (x -> x[0].starts_with "#") .map counts keys := input.filter (x -> x[0].starts_with ".") .map counts fits(l,k) => l.zip k (a,b -> a+b <= 6) ∀ id part1 => locks.combine keys fits .count id part2 => "Merry Christmas!" say "$part1:$part2"$

$dec24 => input := io.stdin.read_string.split "\n\n" .map (.split "\n" .filter !="") wires := (input[0].map (s -> s.split ": " |> (iw -> inpt iw[0] iw[1]="1")) .map Wire id ++ input[1].map (s -> s.split " " |> (ig -> gate ig[0] ig[1] ig[2] ig[4])) .map Wire id ) bits := wires.map (.name) .filter (.starts_with "z") .map (.replace "z" "" .parse_i64.val) .fold1 max device := container.ps_map String Wire .new (wires.map (.name)) wires # any wire coming from input or gate Wire(name String) ref is state(d,x,y i64, get (i64,i64,i64,String)->option bool) option bool => abstract fix := mut 0 fix(n i32) => fix <- n+fix unfixed Sequence Wire => [] # input wire with given initial state inpt(redef name String, state bool) : Wire name is fix <- 1 redef state(d,x,y i64, get (i64,i64,i64,String)->option bool) option bool => if x < 0 then state else b := name.substring 1 .parse_i64.val v := if name.starts_with "x" then x else if name.starts_with "y" then y else panic "x y expected $name" ((v >> b) & 1) != 0 # a logic gate gate(in1 String, op String, in2 String, redef name String) : Wire name is redef state(d,x,y i64, get (i64,i64,i64,String)->option bool) option bool => if d > 100 then nil // we got into a cycle else get d+1 x y in1 >>= a-> get d+1 x y in2 >>= b-> if op = "AND" then a && b else if op = "OR" then a || b else if op = "XOR" then a ^ b else panic "unkown $op" redef fix(n i32) => fix <- n+fix wire in1 .fix n wire in2 .fix n redef unfixed Sequence Wire => if fix.get > 0 then [] else (wire in1 .unfixed ++ wire in2 .unfixed ++ [gate.this]) i64.z => "z"+(val.as_string 2 10) wire(name) => device[name].val # check if state of wire `name` is defined. # swap gives wi$

dec23 is

# missing fuzion base lib functions:
redef property.orderable.type.equality(a,b property.orderable.this) =>
a <= b <= a

unique(sq Sequence (T : property.orderable)) =>
sq.reduce (id (container.Set T) (container.ps_set T).empty) (s,v -> s.add v)

# types for vertex, edge and clique
vertex(s) ref : property.orderable is
fixed redef type.lteq( a,b dec23.vertex) => a.s <= b.s
edges := lm.env.new (container.Set vertex) (container.ps_set vertex).empty

edge(v,w) : property.orderable is
v.edges <- v.edges.get.add w
w.edges <- w.edges.get.add v
fixed redef type.lteq(a,b dec23.edge) => !(b.v<=a.v) || a.v=b.v && a.w<=b.w

clique(vs Sequence vertex) : property.orderable is
fixed redef type.lteq(a,b dec23.clique) => a.as_string <= b.as_string

get_edge(v,w) => if v < w then edge v w
else edge w v

get_vertex(s) : memoize => keep s _->
vertex s

lm : mutate is
lm ! ()->
input := io.stdin.read_lines.filter !=""
.map s->(get_edge (get_vertex (s.substring 0 2))
(get_vertex (s.substring 3 5)))
edges := input |> unique

add_one(clique) =>
clique.vs.flat_map (e -> id (Sequence vertex) e.edges.get)
.filter (v -> !clique.vs.contains v) |> sq->(unique sq)
.filter (v -> clique.vs ∀ (.edges.get.contains v))
.map (v -> clique ([v] ++ clique.vs))

add_ones(cliques) =>
cliques.flat_map add_one
.map (.vs.sort)
.map clique |> unique

largest(cliques) =>
n := add_ones cliques
if n.is_empty then cliques else largest n

part1 =>
edges.map e->
e.v.edges.get.filter x->
(x > e.w && e.w.edges.get.contains x &&
(e.v.s.starts_with "t" ||
e.w.s.starts_with "t" ||
x .s.starts_with "t" ))
.count
.fold1 (+)

part2 =>
two_cliques := edges.map (e -> clique [e.v,e.w])

dec22 is

input := io.stdin.read_lines.filter !="" .map (.parse_i64.val) .as_array

next(s0 i64) =>
s2 := s0 ^ (s0 * 64)
s3 := s2 % 16777216
s6 := (s3 ^ (s3 / 32)) % 16777216
(s6 ^ (s6 * 2048)) % 16777216

secrets(x) => x :: next

prices(seed) : memoize => keep seed _->
secrets seed .map %10 .take 2001 .as_array
changes(seed) : memoize => keep seed _->
prices seed .map (-) .map_pairs (-) .as_array

part1 =>
input.map (seed -> secrets seed .drop 2000 .first.val) |> sum

part2 =>
range => i64 -9 .. 9
n := input.count
ns := 0..(n-1)
cs := array n (i -> changes input[i])

# create array of array of indices of sequences that match currently
# tested sequence up to index off. o is the previous array, v is the
# value expected at current offset.
#
arr(o,off,v) => array n (i -> o[i].filter j->cs[i][j+off]=v .as_array)

oa := array n _->(0..1996).as_array
(range .map (a -> arr oa 0 a) .flat_map aa->
range .map (b -> arr aa 1 b) .flat_map ba->
range .map (c -> arr ba 2 c) .flat_map ca->
range.map d->
(ns.flat_map i64 i->
ca[i].filter (j -> cs[i][j+3] = d)
.flat_map (j -> prices input[i] .drop j+4)
.first
) |> sum
).fold1 max

say "$part1:$part2"

dec21 is

input := io.stdin.read_lines.filter !=""

key(v codepoint) is

# overlapping two layouts, put ` ` at (0,0)
x => "741 <8520^v963AA>" .find v .val / 6
y => "789#456#123# 0^A<v>#".find v .val / 4 - 3

move_to(target key) =>
dx := target.x-x
dy := target.y-y
ve := ["^"," ","v"][dy.sign+1] * (|dy|)
ho := ["<"," ",">"][dx.sign+1] * (|dx|)

# I did not believe both paths make a difference for small keypad,
# convinced by (or stole from) https://aoc.csokavar.hu/2024/21/
p1 := (target.y != 0 || x != 0).as_option String ve+ho+"A"
p2 := (target.x != 0 || y != 0).as_option String ho+ve+"A"
p1 ++ p2

find_shortest(d, l) i64 : memoize => keep "$d$l" _->
if d < 0 then
l.byte_length.as_i64
else
for res := i64 0, res + s
prev := "A", cur
cur in l.as_codepoints
s := key prev .move_to (key cur)
.map (find_shortest d-1)
.fold1 min
else
res

shortest(n) =>
lens := input.map (find_shortest n)
numparts := input.map (.as_codepoints.filter (c -> "0" <= c <= "9")
.reduce "" (+) .parse_i64.val)
lens.zip numparts (*) |> sum

part1 => shortest 2
part2 => shortest 25

say "$part1:$part2"

$dec20 => minsaving := envir.args[1].parse_i32.val input := io.stdin.read_lines.filter !="" .map (.as_codepoints) w := input[0].count h := input.count area := array2 w h x,y->input[y][x] point(x,y) is xl => x.as_i64 yl => y.as_i64 neighbors => [up, dw, le, ri].filter (.valid) valid => 0 <= x < w && 0 <= y < h on_track => valid && area[x,y] != "#" inner_wall => 1 <= x < w-1 && 1 <= y < h-1 && !on_track abs => (|x|) + (|y|) infix + (o) => point x+o.x y+o.y infix - (o) => point x-o.x y-o.y up => { point x y-1}; dw => { point x y+1 } le => { point x-1 y}; ri => { point x+1 y } s := area.index_pairs.filter (||> y,x->area[y,x]="S") .first.val ||> point M : mutate is M ! ()-> track := (mutate.array point).type.new M picos := (mutate.array2 i32).type.new M w.as_i64 h.as_i64 -1 picos(p) => picos[p.xl,p.yl] for p := s, p.neighbors.filter (.on_track) .filter q->picos[q.xl,q.yl]<0 .first.val ps := 0, ps+1 do picos[p.xl,p.yl] := ps track.add p until area[p.x,p.y] = "E" unit part1 => saving(p) => t := picos p.up; b := picos p.dw l := picos p.le; r := picos p.ri if t>=0 && b>=0 then (|t-b|)-2 else if l>=0 && r>=0 then (|l-r|)-2 else 0 area.index_pairs.map ||>point .filter (.inner_wall) .map saving .filter >=minsaving .count part2 => range := -20 .. 20 track.as_array.flat_map pi-> range.combine range point .filter (p -> p.abs <= 20) .map (pi+) .filter (.on_track) .map (pj -> picos pj - picos pi - (pj-pi).abs) .filter >=minsaving .count say "$part1:$part2"$

dec19 =>

input := io.stdin.read_lines
towels := input[0].split ", " .as_array
designs := input.drop 2 .filter !=""

String.suffix(prfx) => substring prfx.byte_length

M : mutate is
M ! ()->
cachePos := (container.mutable_tree_map M String bool).empty
cacheCnt := (container.mutable_tree_map M String i64 ).empty

possible(s) =>
match cachePos.get s
v bool => v
nil => res := s="" || !towels.filter s.starts_with
.map s.suffix
.filter possible
.is_empty
cachePos.put s res
res

count(s) =>
match cacheCnt.get s
v i64 => v
nil => res := s="" ? 1 : towels.filter s.starts_with
.map s.suffix
.map count |> sum
cacheCnt.put s res
res

part1 => designs.filter possible .count
part2 => designs.map count |> sum

say "$part1:$part2"

dec18 =>

wi := envir.args[1].parse_i32.val
w := wi.as_i64
inside(x) => 0 <= x < w
l := envir.args[2].parse_i32.val
input2 := io.stdin.read_lines.filter !=""
.map (.split "," .map s->s.parse_i64.val) .map s->(s[0],s[1])
input1 := input2.map (||>x,y->(x.as_i32,y.as_i32)) .take l .as_array
lm : mutate is
lm ! ()->

part1 =>
area := array2 wi wi (x,y -> (input1 ∃ t -> t.0=x && t.1=y))
corrupt(x,y) => area[x.as_i32,y.as_i32]
mcost := (mutate.array2 i32).type.new lm w w i32.max
trace(x,y i64, cost i32) =>
if inside x && inside y && cost < mcost[x, y] && !corrupt x y
mcost[x, y] := cost
trace x+1 y cost+1; trace x y+1 cost+1
trace x-1 y cost+1; trace x y-1 cost+1
trace 0 0 0
mcost[w-1, w-1]

part2 =>
area := (mutate.array2 bool).type.new lm w w false
leftbot := (mutate.array2 bool).type.new lm w w false
toprite := (mutate.array2 bool).type.new lm w w false
for cor in input2 do
(x,y) := cor
area[x,y] := true
fill leftbot x y (x=0 || y=w-1)
fill toprite x y (y=0 || x=w-1)

get(a,xx,yy) => inside xx && inside yy && a[xx,yy]
get(a,xy) => xy ||> get a

box(xx,yy) => ((xx-1)..(xx+1)).combine (yy-1)..(yy+1) x0,y0->(x0,y0)

fill(a,xx,yy,touches) =>
if ((touches || (box x y ∃ get a)) &&
get area xx yy && !a[xx,yy])
a[xx,yy] := true
box xx yy .for_each (||> dx,dy -> fill a dx dy true)

until leftbot[x,y] && toprite[x,y] then "$x,$y"
else "never"

say "$part1:$part2"

dec17 =>

input := io.stdin.read_lines
get(prefx) => input.filter (.starts_with prefx) .first.val.replace prefx ""
initial_A := get "Register A: " .parse_i64.val
initial_B := get "Register B: " .parse_i64.val
initial_C := get "Register C: " .parse_i64.val
code := get "Program: " .split "," .map (.parse_i64.val) .as_array

regs(a,b,c,pc,out) is
ins => code[pc].as_i32
op => code[pc+1]
combo => if op < 4 then op
else if op = 4 then a
else if op = 5 then b
else if op = 6 then c
else panic "reserved op $op"
div => a >> combo

exec array regs->regs :=
[s -> regs s.div s.b s.c s.pc+2 s.out ,
s -> regs s.a s.b^s.op s.c s.pc+2 s.out ,
s -> regs s.a s.combo%8 s.c s.pc+2 s.out ,
s -> regs s.a s.b s.c s.a=0?s.pc+2:s.op.as_i32 s.out ,
s -> regs s.a s.b^s.c s.c s.pc+2 s.out ,
s -> regs s.a s.b s.c s.pc+2 s.out++[s.combo%8],
s -> regs s.a s.div s.c s.pc+2 s.out ,
s -> regs s.a s.b s.div s.pc+2 s.out ]

run(s) =>
if 0 <= s.pc < code.length then run (exec[s.ins].call s)
else s.out
runa(a) => run (regs a initial_B initial_C 0 (id (Sequence i64) []))

part1 => (runa initial_A).as_string ","
part2 =>
for i := 15, i-1
delta := i64 0o1000000000000000, delta / 8
a := i64 0, new_a
while delta > 0
new_a := for na := a, na + delta
until (runa na).drop i = code.drop i then na
else
a

say "$part1:$part2"

$dec16 => input := io.stdin.read_string.split "\n" .as_array .filter !="" .map (.as_codepoints) .as_array h := input.count w := input[0].count area := array2 codepoint h w y,x->input[y][x] point(y,x) is mov(d) => if d=0 then point y-1 x else if d=1 then point y x-1 else if d=2 then point y+1 x else point y x+1 e := area.index_pairs.filter (||> y,x->area[y,x]="E") .first.val ||> point s := area.index_pairs.filter (||> y,x->area[y,x]="S") .first.val ||> point cost_of_turns(d1,d2) => if (d1 = d2) then 0 else if (d1 = (d2+2)%4) then 2000 else 1000 lm : mutate is costs := lm ! ()-> mcosts := array2 4 h s,y-> (mutate.array i32).type.new lm w.as_i64 i32.max trace(d, p, cost) => if cost < mcosts[d,p.y][p.x.as_i64] then mcosts[d,p.y][p.x.as_i64] := cost # try to move p2 := p.mov (d+2)%4 if ("#" != area[p2.y,p2.x] && cost+1 < mcosts[d,p2.y][p2.x.as_i64] && cost+1 < mcosts[3,s .y][s .x.as_i64] ) then trace d p2 cost+1 # try to turn (1..3).for_each dd-> trace (d+dd)%4 p (cost + cost_of_turns 0 dd) # trace costs backwards starting at e (0..3).for_each (d -> trace d e 0) array2 4 h ss,yy->mcosts[ss,yy].as_array cost(d,p) => costs[d,p.y][p.x]; part1 => cost 3 s part2 => lm ! ()-> paths := (mutate.array2 bool).type.new lm h.as_i64 w.as_i64 false mark(d, p) => if !paths[p.y.as_i64, p.x.as_i64] then paths[ p.y.as_i64, p.x.as_i64] := true if cost 0 p != 0 min_cst(dd) => cost dd (p.mov dd) +^ cost_of_turns dd d cmin := (0..3).map min_cst .reduce i32.max min (0..3).for_each dd-> if min_cst dd = cmin then mark dd (p.mov dd) mark 3 s paths.as_array.filter id .count say "$part1$

$input := io.stdin.read_string .replace "," " " .replace "\n" " " .as_codepoints .filter c->"0"<=c<="9"||c=" "||c="-" .as_string "" .split " " .as_array .map (.parse_i32.val) .as_4tuples.map ||||>robot w := envir.args[1].parse_i32.val h := envir.args[2].parse_i32.val robot(x,y,vx,vy) is move(n) => robot (x+vx*n+w*1000000)%w (y+vy*n+h*1000000)%h vx vy quadrant => l := x <= w/2 t := y <= h/2 if x=w/2 || y=h/2 then 0 # middle else if t && l then 1 # top left else if t then 2 # top right else if l then 3 # bottom left else 4 # bottom right part1 => (1..4).map q->(input.map (.move 100) .filter r->r.quadrant=q .count) .fold i32.product part2 => for i := 0, i+1 a := input.as_array, array a.length (x->a[x].move 1) # xmas tree is boxed: find max num robots aligned hor'ly & vert'ly maxx := (0..(h-1)).map (y -> a.count r->r.y=y) .foldf max 0 maxy := (0..(w-1)).map (x -> a.count r->r.x=x) .foldf max 0 maxxy := maxx * maxy maxmaxxy := maxxy, max maxmaxxy maxxy until maxmaxxy > 900 i say "$part1,$part2"$

$dec12 => input := io.stdin .read_string.trim .replace "Button A: X+" "" .replace "Button B: X+" "" .replace ", Y+" " " .replace "Prize: X=" "" .replace ", Y=" " " .replace "\n" " " .split " " .map (.split " " .map (.parse_i64.val)) .map (x -> claw x[0] x[1] x[2] x[3] x[4] x[5]) claw(ax,ay,bx,by,px,py) is cost => # since px = ax*a + bx*b, py = ay*a + by*b, we get a := (py*bx - px*by) / (ay*bx - ax*by) b := (px-ax*a)/bx if ay*a+by*b = py a*3+b else 0 part1 => input.map (.cost) |> sum part2 => delta := i64 1E13 input.map (c -> claw c.ax c.ay c.bx c.by c.px+delta c.py+delta) .map (.cost) |> sum say "$part1,$part2"$

part2 =>
tot := lm.env.new 0
done := (mutate.array2 bool).new lm (w+2).as_i64 (h+2).as_i64 false
for xx in 1..w do
for yy in 1..h do
kind := data[xx,yy]
(a,s) := fill xx yy
tot <- a*s + tot

fill(x,y) =>
if kind != data[x,y] || done[x.as_i64,y.as_i64] then (0, 0)
else
done[x.as_i64,y.as_i64] := true
(a1,s1) := if kind = data[x,y] then fill x+1 y else (0,1)
(a2,s2) := if kind = data[x,y] then fill x y+1 else (0,1)
(a3,s3) := if kind = data[x,y] then fill x-1 y else (0,1)
(a4,s4) := if kind = data[x,y] then fill x y-1 else (0,1)
(1+a1+a2+a3+a4, s1+s2+s3+s4+ sides_started x y)

sides_started(x,y) =>
tl := data[x-1,y-1] = kind
ts := data[x ,y-1] = kind
tr := data[x+1,y-1] = kind
sl := data[x-1,y ] = kind
sr := data[x+1,y ] = kind
bl := data[x-1,y+1] = kind
bs := data[x ,y+1] = kind
[# a horizontal side starts in these configurations
#
# x|. . * . .
# +=== +===
# x X * .|X *
#
tl && sl && !ts, !ts && !sl,
sl && bl && !bs, !sl && !bs, # mirrored horizonally
tl && ts && !sl, !ts && !sl, # vert: point-reflection
ts && tr && !sr, !ts && !sr].count id
tot.get

say "$part1,$part2"

dec11 =>

input := io.stdin.read_string
data := input.trim.split " " .map (.parse_i64.val)

blink(b i64) =>
M : mutate is
M ! ()->
cache := (container.mutable_tree_map M i64 i64).empty

count(i, n) i64 ! M =>
k := i << 50 | n;
match cache[k]
nil => l := ($n).byte_length.as_i64
res := if i=0 then 1
else if n=0 then count i-1 1
else if l %% 2 then f := (i64 10)**(l/2);
count i-1 n/f + count i-1 n%f
else count i-1 n*2024
cache.put k res
res
r i64 => r

data.map (count b) |> sum

part1 => blink 25
part2 => blink 75

say "$part1,$part2"

dec10_part2 =>

LM : mutate is
arr := LM ! ()->
(io.stdin LM) ! ()->(io.buffered.read_lines LM)
.filter !="" .map (.as_codepoints.map (.parse_i32) .as_array) .as_array

h := arr.length + 2
w := arr[0].length + 2
area := array2 w+2 h+2 x,y->(1 <= x < w-1 && 1 <= y < h-1 ? arr[y-1][x-1] : 99)

join1(a,x,y) =>
container.set_of_ordered (a[x-1,y] ++ (a[x+1,y] ++ (a[x,y-1] ++ a[x,y+1])))
.as_array
join2(a,x,y) => a[x-1,y] + a[x+1,y] + a[x,y-1] + a[x,y+1]

f1(i,a) => i<0 ? a : f1 i-1 (array2 w h (x,y -> area[x,y] = i ? join1 a x y : []))
f2(i,a) => i<0 ? a : f2 i-1 (array2 w h (x,y -> area[x,y] = i ? join2 a x y : 0 ))

part1 => f1 8 (array2 w h (x,y -> area[x,y] = 9 ? [w*y+x] : [])) .map (.count) |> sum
part2 => f2 8 (array2 w h (x,y -> area[x,y] = 9 ? 1 : 0 )) |> sum

say "$part1,$part2"

dec8_part2 =>

LM : mutate is
LM ! ()->
arr := (io.stdin LM) ! ()->(io.buffered.read_lines LM)
.filter !="" .map (.as_codepoints.as_array) .as_array
h := arr.length .as_i64
w := arr[0].length.as_i64
area := (mutate.array2 i64).type.new LM w h x,y->arr[y.as_i32][x.as_i32].val.as_i64

location_count(antinode_pos Sequence i64) =>

# for each antenna kind, the list of antennas found so far
antennas := (mutate.array (list (i64,i64))).type.new LM 128 nil

# for each position: has an antinode been found here?
antinodes := (mutate.array2 bool).type.new LM w h _,_->false

area.indices0.for_each x->
area.indices1.for_each y->
if area[x,y] != ".".val.as_i64
v := area[x,y]
a := antennas[v]
a.for_each xy->
antinode_pos.for_each i->
(xx, yy) := (x+i*(xy.0-x), y+i*(xy.1-y))
if (0 <= xx < w &&
0 <= yy < h )
antinodes[xx,yy] := true
antennas[v] := (x,y) : a
antinodes.as_array.filter id .count

part1 => location_count [-1, 2]
part2 => location_count (max w h |> m -> -m..m)
say "$part1,$part2"

$dec7_part2 => LM : mutate is input := LM ! ()->((io.stdin LM) ! ()->(io.buffered.read_lines LM)).filter !="" total(s) => s.split ":" .first.val.parse_i64.val nums(s) => s.split " " .drop 1 .map (.parse_i64.val) num0(s) => nums s .first.val numr(s) => nums s .drop 1 test1(t, v, n) => match n.as_list nil => t = v c Cons => (test1 t v*c.head c.tail || test1 t v+c.head c.tail ) test2(t, v, n) => t >= v && match n.as_list nil => t = v c Cons => (test2 t (v * c.head) c.tail || test2 t (v + c.head) c.tail || test2 t (v ++ c.head) c.tail ) integer.infix ++ (o integer.this) => "{integer.this}$o".parse_integer (integer.this.from_u32 10) .val part1 => input.filter (s -> test1 (total s) (num0 s) (numr s)) .map total |> sum part2 => input.filter (s -> test2 (total s) (num0 s) (numr s)) .map total |> sum say part1 say part2$

$dec6_part2 => LM : mutate is LM ! ()-> input := io.stdin LM ! (() -> io.buffered.read_lines LM) # the relation defined by input as an array arr := input.filter !="" .map (.as_codepoints.as_array) .as_array h := arr.length.as_i64 w := arr[0].length.as_i64 data := array2 arr.length arr[0].length y,x->arr[y][x] area := (mutate.array2 codepoint).type.new LM h w y,x->data[y.as_i32, x.as_i32] start := data.index_pairs.filter (yx -> data[yx.0,yx.1] = "^") .first.val ||> y,x -> pos y.as_i64 x.as_i64 # direction, bit gives a unique bit 1, 2, 4, 8 dir(dy, dx i64) is turn => dir dx -dy bit => (dx = 0 ? (dy+3)*2 : (dx+3)/2).as_u8 # up is the only dir we need, the others are the result of calls to turn up => dir -1 0 # a position is our most important helper feature pos(y,x) is # move position in given direction infix +(d) => pos y+d.dy x+d.dx # is position inside our area ok => 0 <= y < h && 0 <= x < w # get or set value in given mutable array2 get(a container.Mutable_Array2 X LM) => a[y,x] put(a container.Mutable_Array2 X LM, v X) => a[y,x] := v # is this equal to o? infix =(o) => y=o.y && x=o.x # does given dir change at this position, return the new dir # # f checks if pos is blocked, i.e., we must turn # change_dir(d dir, f pos->bool) => for dd := d, dd.turn p := infix + dd while p.ok && f p else dd # candidate positions that should be checked in part2, filled in part1 cand := (mutate.array2 bool).type.new LM h w y,x->false # perform part1 and fill cand part1_res := LM.env.new 0 _ := for d := up, p.change_dir d q->{q.put cand true; q.get area = "#"} p := start, p + d while p.ok if p.get area !=…$