Lightnews — Scholar-powered news

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion November news are out.

Our base library profits a lot from the work on the fuzion webserver fzweb: added functionilty, better usability and performance!

For the Fuzion language, type-safe variadic functions are an major addition.

All the details: fuzion-lang.dev/news/news_056

Fuzion Language Portal

Fuzion is a computer programming language with a focus on productivity, performance and correctness.

fuzion-lang.dev

November 13, 2025 at 4:16 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion October news are out.

We are making fast progress implementing the webserver behind fuzion-lang.dev to Fuzion.

On the Fuzion language, handling of lambdas and variadic type parameters and value argument is becoming more powerful.

All the details: fuzion-lang.dev/news/news_055

Fuzion Language Portal

Fuzion is a computer programming language with a focus on productivity, performance and correctness.

fuzion-lang.dev

October 10, 2025 at 4:49 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion September news:

An efficient and type-safe mechanism for variable argument lists for functions is one of the exciting things we are working on.

All the details:

fuzion-lang.dev/news/news_054

Fuzion Language Portal

Fuzion is a computer programming language with a focus on productivity, performance and correctness.

fuzion-lang.dev

September 9, 2025 at 1:06 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion August news:

Major news for the Fuzion language are support for loop correctness checking via loop invariants and faster static analysis.

Here are the details:

fuzion-lang.dev/news/news_053

Fuzion Language Portal

Fuzion is a computer programming language with a focus on productivity, performance and correctness.

fuzion-lang.dev

August 18, 2025 at 10:41 AM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion July news:

Last month brought some nice language improvements for destructuring, nullary functions and automatic unwrapping together with a number of enhancements in the base library, bug fixes and code cleanup in the tools.

Here are the details:

fuzion-lang.dev/news/news_052

Fuzion Language Portal

Fuzion is a computer programming language with a focus on productivity, performance and correctness.

fuzion-lang.dev

July 10, 2025 at 2:00 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion June news are out:

Progress on the foreign function interface is now demonstrated with an example calling the GTK toolkit.

Support for right associative operators make infix operation like piping to the left <| more natural.

Here are the details:

fuzion-lang.dev/news/news_051

Fuzion Language Portal

Fuzion is a computer programming language with a focus on productivity, performance and correctness.

fuzion-lang.dev

June 17, 2025 at 1:25 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion May news are out:

Last month saw a large number of minor fixes in the Fuzion language, compiler and base library combined with some larger progress towards native library interfacing via value types and callbacks.

Here are the details:

fuzion-lang.dev/news/news_050

Fuzion Language Portal

Fuzion is a computer programming language with a focus on productivity, performance and correctness.

fuzion-lang.dev

May 13, 2025 at 3:19 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion April news are out.

The focus shifted towards a Fuzion language improvements, generally turning experience we gain using Fuzion into language improvements. Meanwhile, important progress is happening on the native interface.

Here are the details:

fuzion-lang.dev/news/news_049

Fuzion Language Portal

Fuzion is a computer programming languange with a focus on productivity, performance and correctness.

fuzion-lang.dev

April 11, 2025 at 2:26 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion repository reached the milestone of 5000 issues / pull requests.

Fuzion is still in an experimental state, but it is moving ahead quickly!

Screenshot of github page showing three pull requests:

ast: Fix position of inheritance calls generated for cotype, fix #5003 bug front end
#5005 by fridis was merged Apr 3, 2025 • Approved

lib: fix argument order inconsistency in scan and fold in Sequence base library cleanup
#5004 by simonvonhackewitz was merged Apr 3, 2025 • Approved

Fix 4992: Type constraint using.this results in error bug front end
#5000 by fridis was merged Apr 3, 2025 • Approved

April 4, 2025 at 2:45 PM

The Fuzion Language

@fuzionlang.bsky.social

The Fuzion March news are out. Loads of minor cleanup and improvements are ongoing, while major work on improving the data flow analysis engine is on the way.

Here are the details:

fuzion-lang.dev/news/news_048

Fuzion Language Portal

Fuzion is a computer programming languange with a focus on productivity, performance and correctness.

fuzion-lang.dev

March 14, 2025 at 2:58 PM

The Fuzion Language

@fuzionlang.bsky.social

The February Fuzion news are out. A lot of work went into the stability of the Fuzion tools, in particular case of earlier errors and making the Fuzion intermediate representation more robuts.

Here are all the details:

fuzion-lang.dev/news/news_047

Fuzion Language Portal

Fuzion is a computer programming languange with a focus on productivity, performance and correctness.

fuzion-lang.dev

February 14, 2025 at 5:48 PM

Reposted by The Fuzion Language

Fridtjof Siebert

@fridis.bsky.social

A first version of the slides for my FOSDEM talk on effects for error handling in Fuzion are uploaded and I got onto my train just in time.

The examples can be modified and run interactively online:

fuzion-lang.dev/talks/fosdem...

Fuzion Language Portal

Fuzion is a computer programming languange with a focus on productivity, performance and correctness.

fuzion-lang.dev

January 31, 2025 at 2:12 PM

Reposted by The Fuzion Language

Fridtjof Siebert

@fridis.bsky.social

Just a week to go until @fosdem.bsky.social! Let me know if you are also there.
I will be in the Free Java dev room on Saturday.
Sunday, I will talk about effects for error handling in @fuzionlang.bsky.social in the Declarative and Minimalistic Languages devroom.
fosdem.org/2025/

FOSDEM 2025 - Home

fosdem.org

January 24, 2025 at 4:47 PM

The Fuzion Language

@fuzionlang.bsky.social

January Fuzion news are out. Progress on all fronts: From base lib work like easier meoization (one of many issues triggered by #AdventOfCode), fixes in the front end middle end down to native support for file io operations in all backends.

The details online:

fuzion-lang.dev/news/news_046

Fuzion Language Portal

Fuzion is a computer programming languange with a focus on productivity, performance and correctness.

fuzion-lang.dev

January 16, 2025 at 2:22 PM

The Fuzion Language

@fuzionlang.bsky.social

Very late with this month's Fuzion news, #AdventOfCode and the Holiday season kept us too busy.
Work focus was on performance of the fz tool, in particular DFA analysis, and loads of base library work applying effect handlers.
All the details:
fuzion-lang.dev/news/news_045

Fuzion Language Portal

Fuzion is a computer programming languange with a focus on productivity, performance and correctness.

fuzion-lang.dev

December 27, 2024 at 8:56 PM

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

Reposted by The Fuzion Language

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

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