Lightnews — Scholar-powered news

Fridtjof Siebert

@fridis.bsky.social

The small cherry tree in our garden has started blossoming this week.

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

April 5, 2025 at 9:58 AM

Fridtjof Siebert

@fridis.bsky.social

Hanami in Karlsruhe!

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

March 29, 2025 at 1:36 PM

Fridtjof Siebert

@fridis.bsky.social

Big thanks to all the helpers and supporters of @fosdem.bsky.social for this great event and great infrastructure!
Those responsible for the sunshine deserve special thanks, that made a big difference!

February 10, 2025 at 9:29 AM

Fridtjof Siebert

@fridis.bsky.social

Hab schon seit ein Paar Wochen mit dem Gedanken gespielt, das @wirtschaftswoche.bsky.social-Abo abzuschließen. Jetzt gab es einen Anlass! Wenig als drei Wochen bleiben uns, Merz als Kanzler zu verhindern.

WirschaftsWoche: Friedrich Merz kann es nicht.

February 2, 2025 at 10:19 PM

Fridtjof Siebert

@fridis.bsky.social

Free Java devroom @fosdem is packed already 15min before talks start!

February 1, 2025 at 10:07 AM

Fridtjof Siebert

@fridis.bsky.social

Awful rain today, but just a few days ago, there was this delightful frosty weather.

January 2, 2025 at 2:39 PM

Fridtjof Siebert

@fridis.bsky.social

Cold air and high humidity created a magic scenery yesterday.

December 30, 2024 at 10:04 AM

Fridtjof Siebert

@fridis.bsky.social

The Christmas Day's #AdventOfCode puzzle's solution took only three lines of logic using combine, zip, ∀ and count in @fuzionlang.bsky.social.

src: github.com/fridis/fuzio...

I am happy to have solved all 25 puzzles in Fuzion this year. The main goal was to improve Fuzion.

1/4

$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"$

December 26, 2024 at 1:28 PM

Fridtjof Siebert

@fridis.bsky.social

Late with yesterday's #AdventOfCode in @fuzionlang.bsky.social: A mixture of o-o and fp code: A parent `Wire` with abstract inner feature `state` and children `inpt` and `gate` that implement `state`.
Sneaked in monadic bind operators >>=, just for option.and_then.
srcs: github.com/fridis/fuzio...

$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$

December 25, 2024 at 10:33 PM

Fridtjof Siebert

@fridis.bsky.social

Dec 23 #AdventOfCode was a fun graph problem of finding cliques in graphs. My @fuzionlang.bsky.social defines types for vertices, edges and cliques to work with. To find the largest clique, it helped to start with smaller ones and add vertices one by one.
Sources: github.com/fridis/fuzio...

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])

December 23, 2024 at 11:53 PM

Fridtjof Siebert

@fridis.bsky.social

After almost giving up, #AdventOfCode today was easier, but not trivial. Using memoization and arrays to speed up the code in @fuzionlang.bsky.social.
The sources on github: github.com/fridis/fuzio...

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"

December 22, 2024 at 8:55 PM

Fridtjof Siebert

@fridis.bsky.social

Almost gave up on yesterday's #AdventOfCode: First, I did not want to believe that taking different paths on the small keypads really would make a difference, got convinced after peeking into other's solutions.

Concise solution using effect-based memoziation APIs.

Src: github.com/fridis/fuzio...

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"

December 22, 2024 at 2:03 PM

Fridtjof Siebert

@fridis.bsky.social

Dec 20 #AdventOfCode reading comprehension exercise: A feature point with many inner helper features, including infix + and - operators helped to create a clean solution in @fuzionlang.bsky.social .
The sources: github.com/fridis/fuzio...

$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"$

December 21, 2024 at 9:48 AM

Fridtjof Siebert

@fridis.bsky.social

Happy about a clean @fuzionlang.bsky.social solution for today's #AdventOfCode challenge: arranging towels to match designs. Caches did the trick.

A nice gimmick: Added a new feature `suffix` to be called on `String`, just to make the code a little cleaner.

The source: github.com/fridis/fuzio...

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"

December 19, 2024 at 8:56 PM

Fridtjof Siebert

@fridis.bsky.social

Dec 18 #AdventOfCode started with a path search in a maze. In part 2, the maze gradually becomes denser until unsolvable. In my solution in @fuzionlang.bsky.social, instead of re-solving each maze, I track walls from bottom/left and top/right until they connect.
src: github.com/fridis/fuzio...

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"

December 19, 2024 at 9:51 AM

Fridtjof Siebert

@fridis.bsky.social

Had fun with today's #AdventOfCode in @fuzionlang.bsky.social:

Part1 An interpreter for machine code, managed to use only pure functions.

Part2 is hacky, basically guessing input 3 bits at a time. Almost tried to change the dir of time in the part 1 interperter.

src github.com/fridis/fuzio...

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"

December 17, 2024 at 9:18 PM

Fridtjof Siebert

@fridis.bsky.social

Today's #AdventOfCode was a fairly standard shortest path finding in a 2D grid, but it turned out to actually be 3D since turning has a hefty extra cost.
Here my solution in @fuzionlang.bsky.social on github: github.com/fridis/fuzio...

$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$

December 16, 2024 at 9:58 PM

Fridtjof Siebert

@fridis.bsky.social

Today's #AdventOfCode has 2 input sources: input file & bathroom dimensions. In the @fuzionlang.bsky.social solution, I use command line args for the latter, which is, of course, another effect envir.args. Simple image detection for part2 detects the frame only.
Sources: github.com/fridis/fuzio...

$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"$

December 14, 2024 at 9:52 PM

Fridtjof Siebert

@fridis.bsky.social

Today's #AdventOfCode was easy with a little algebra. @fuzionlang.bsky.social supports exponents like 1E13 also for integer literals, which was helpful here. Part2 only needs to adjust prize locations.
The sources: github.com/fridis/fuzio...

$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"$

December 13, 2024 at 12:23 PM

Fridtjof Siebert

@fridis.bsky.social

Insight for today's #AdventOfCount: # of sides in polygon is # of corners, which are easier to count, but still tedious: 8 cases: in/out-side x 4 (NE, SE, SW, NW).
@fuzionlang.bsky.social solution uses locally mutable arrays and an int for total cost.

The sources: github.com/fridis/fuzio...

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"

December 12, 2024 at 8:27 PM

Fridtjof Siebert

@fridis.bsky.social

Today's #AdventOfCode in @fuzionlang.bsky.social requires memoization / caching of results. Since caching a value performs a state change, we need a mutate effect. We use a local mutate `M` in our `blink` function that itself remains pure.
The sources on github: github.com/fridis/fuzio...

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"

December 11, 2024 at 4:13 PM

Fridtjof Siebert

@fridis.bsky.social

Today's #AdventOfCode solution in @fuzionlang.bsky.social is compact and fully functional. Part2 is simpler than part 1. The solution starts backwards: From the highest points creating an array of distances in a recursive function down to the starts.
The source on github: github.com/fridis/fuzio...

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"

December 10, 2024 at 9:32 PM

Fridtjof Siebert

@fridis.bsky.social

Today's #AdventOfCode in @fuzionlang.bsky.social using mutable arrays created using a local mutate effect. Some type casts since Fuzion is not yet consistent in the index variable type for arrays (i64 vs. i32).
The sources on github: github.com/fridis/fuzio...

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"

December 8, 2024 at 5:29 PM

Fridtjof Siebert

@fridis.bsky.social

User defined operators and type parameters in @fuzionlang.bsky.social enable a nice #AdventOfCode solution today: Adding an infix ++ op too all integer types made part 2 a one line change. Small optimization: t >= v to stop once v is too big.
Sources: github.com/fridis/fuzio...

$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$

December 7, 2024 at 10:48 AM

Fridtjof Siebert

@fridis.bsky.social

#AdvenOfCode today requires mutable two-dimensional arrays, so I enclosed the @fuzionlang.bsky.social code with a local mutate instance. The ||> operator came in handy today to destructure tuples.
The sources on github: github.com/fridis/fuzio...

$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 !=…$

December 6, 2024 at 7:56 PM

Add to Home Screen

Light up
your news

Add to Home Screen

Light upyour news

Sign in to Lightnews

Sign up to start reading

Connect Bluesky

Connect with Bluesky

Light up
your news