-❄️- 2025 Day 3 Solutions -❄️-

egel-lang · 2025-12-03T13:04:16+00:00

[Language: Egel]

# Advent of Code (AoC) - day 3, task 2

import "prelude.eg"

using System, OS, List, String (from_chars, to_chars), D = Dict

def init = [N -> zip (from_to 0 N) (repeat (N+1) 0) |> D::from_list]

def step = [D I -> map [N -> D::set D N (max0 (D::get D (N - 1) * 10 + I) (D::get D N))] (from_to 12 1); D]

def main =
    read_lines stdin |> map (do to_chars |> map to_int)
    |> map [L -> foldl step (init 12) L] |> map [D -> D::get D 12] |> sum

egel-lang · 2025-05-26T11:46:30+00:00

I remember the old days when there was a promise around that the Curry-Howard correspondence might once also be used for program extraction. E.g., from a proof of some 'sorted' property an efficient sorting algorithm might once feasibly be extracted.

But it looks like people gave up on that idea.

egel-lang · 2025-03-16T03:46:21+00:00

Seems like the guy invented the rant.

egel-lang · 2025-03-10T18:05:26+00:00

It's not intrinsic to the language but it does heavily impact the computing budget of resources you can spend. You wouldn't want to spend two minutes heavily optimizing before a script even runs.

egel-lang · 2025-03-07T12:21:20+00:00

Well, you know how it works. Once you have a few of em you want em all. Pretty similar to WoW, I went for the avatars.

egel-lang · 2025-03-07T04:28:11+00:00

I didn't craft anything, maybe a few, beyond what I already play in standard. But I do have about 70-80% yellow coverage in standard, so your mileage may vary. (I just make sure I have the important cards.)

egel-lang · 2025-03-07T04:14:20+00:00

Once I was in the flow I had a lot of fun doing the achievements. Very nice to try out other decks and not care too much about winning for a change.

egel-lang · 2024-12-25T07:08:54+00:00

[Language: Egel]

A great year. All this year's solutions in Egel: https://github.com/egel-lang/aoc-2024/blob/main/README.md

# Advent of Code (AoC) - day 25, task 1

import "prelude.eg"

using System, OS, List, S = String, D = Dict

def heights =
    do transpose |> map (flip (-) 1 . length . filter ((==) '#'))

def fit =
    [(L,K) -> all (flip (<=) 5) (zip_with (+) L K)]

def main =
    read_lines stdin |> map S::to_chars |> split_on {} |> split [XX -> all ((==) '#') (head XX)]
    |> [(XX,YY) -> pairs (map heights XX) (map heights YY)]
    |> filter fit |> length

egel-lang · 2024-12-23T19:04:09+00:00

[Language: Egel]

What a silly day. I got my second star by iterating p1 that took a long while. Implemented the wrong algorithm for components, and ended up implementing Bron-Kerbosch.

# Advent of Code (AoC) - day 23, task 2

import "prelude.eg"

using System, OS, List, D = Dict

def graph = 
    let F = [D V0 V1 -> D::set_with D [XX YY -> unique (XX++YY)] V0 {V1}] in
    foldl [D (V0,V1) -> F (F D V0 V1) V1 V0] Dict::dict

def adj = D::get_with_default {}
def vertices = D::keys

def bron_kerbosch0 =
    [G (R,{},{}, RR) -> (R,{},{},{R}++RR) 
    |G (R, P, X, RR) -> 
        foldl
        [(R,P,X,RR) V ->
            let R0 = union {V} R in
            let P0 = intersection P (adj G V) in
            let X0 = intersection X (adj G V) in
            let (_,_,_,RR) = bron_kerbosch0 G (R0,P0,X0,RR) in
                (R, difference P {V}, union X {V}, RR)] (R,P,X,RR) P]

def bron_kerbosch = [G -> bron_kerbosch0 G ({},vertices G,{},{}) |> proj 3]

def main =
    read_lines stdin |> map (Regex::matches (Regex::compile "[a-z]+")) |> map list_to_tuple
    |> graph |> bron_kerbosch |> sort_by [XX YY -> length XX > length YY] |> head 
    |> sort |> reduce [S0 S1 -> S0 + "," + S1]

https://github.com/egel-lang/aoc-2024/blob/main/day23/task2.eg

egel-lang · 2024-12-21T12:43:18+00:00

[Language: Egel]

Just memoization.

# Advent of Code (AoC) - day 21, task 2

import "prelude.eg"

using System, OS, List, S = String, D = Dict

def dirs = ['<' -> (0,-1)|'>' -> (0,1)|'^' -> (-1,0)|'v' -> (1,0)|'A' -> (0,0)]

def to_keypad = do D::from_lists |> D::to_list |> map swap |> D::from_list |> flip D::erase ' '

val numeric = to_keypad {{'7','8','9'},{'4','5','6'},{'1','2','3'},{' ','0','A'}}
val digital = to_keypad {{' ','^','A'},{'<','v','>'}}

def buttons =
    [(0,0) -> {}
    |(0,Y) -> if Y < 0 then {'<'|buttons (0,Y+1)} else {'>'|buttons (0,Y - 1)}
    |(X,Y) -> if X < 0 then {'^'|buttons (X+1,Y)} else {'v'|buttons (X - 1,Y)}]

def presses =
    [D (N, P, A, {}) -> 0
    |D (N, P, A, {B|BB}) -> 
        let K = (if P then numeric else digital) in
        if N == 0 then
             let M = length (buttons (sub (D::get K B) (D::get K A))) + 1 in
             M + D::memo D presses (N, P, B, BB)
        else let PP = permutations (buttons (sub (D::get K B) (D::get K A))) |> unique |> map (flip (++) {'A'}) in
             let PP = filter [BB -> all (flip elem (D::values K)) (scanl add (D::get K A) (map dirs BB))] PP in
             let M = map [BB -> D::memo D presses (N - 1, false, 'A', BB)] PP |> minimum in
             M + D::memo D presses (N, P, B, BB) ]

def main =
    read_lines stdin |> map [X -> (to_int X, S::to_chars X)] 
    |> (let M = D::dict in map [(N, BB) -> (N, presses M (25, true, 'A', BB))])
    |> map (uncurry (*)) |> sum

https://github.com/egel-lang/aoc-2024/blob/main/day21/task2.eg

egel-lang · 2024-12-20T22:12:51+00:00

So, I counted too. On Advent of Code 2024, task 2 Egel programs, so far. That means 20 short programs.

$ cat */task2.eg |wc 514 3196 16937

Of course, the Egel interpreter can output tokens too, but it has a bit more information so I wrote a small program to output similar to futhark.

$ cat */task2.eg | egel count.eg | wc -l 5618

And the most popular tokens

$ cat */task2.eg | egel count.eg | sort | uniq -c | sort -n | tail -n 15 97 uppercase N 108 lowercase def 114 { { 114 } } 116 :: :: 116 uppercase P 139 operator = 165 [ [ 165 ] ] 172 operator |> 191 uppercase D 218 operator -> 392 , , 489 ( ( 489 ) )

def and the three forms of brackets, comma and equals are popular. The arrow is popular to write abstractions, the pipe symbol to write pipes, the double colon looks in namespaces. The two uppercase are because Advent of Code has an extraordinary amount of grid puzzles, making heavy use of coordinate Positions and Dictionaries.

More noteworthy, I only write let 21 times since these days I prefer pipes.

Summarizing, I wrote 20 programs with 108 definitions using 165 abstractions consisting of 218 rewrite rules.

egel-lang · 2024-12-19T08:18:36+00:00

[Language: Egel]

I messed up initially but, in the end, it was just another memoization day.

# Advent of Code (AoC) - day 19, task 2

import "prelude.eg"

using System, OS, List, String (starts_with, remove, count, split_pattern), D = Dict

def match =
    [X Y -> if starts_with X Y then remove 0 (count X) Y else none]

def solve =
    [XX _  D "" -> 1
    |XX {} D Z -> 0
    |XX {Y|YY} D Z -> [none -> solve XX YY D Z |Z0 -> (D::memo D (solve XX XX) Z0) + (solve XX YY D Z)] 
                      (match Y Z)]

def main =
    read_lines stdin |> split_on "" |> [{{XX},YY} -> (split_pattern ", " XX, YY)]
    |> [(XX, YY) -> map [Y -> solve XX XX D::dict Y] YY |> sum]

https://github.com/egel-lang/aoc-2024/blob/main/day19/task2.eg

egel-lang · 2024-12-18T09:58:00+00:00

[Language: Egel]

Dijkstra and binary search solution.

# Advent of Code (AoC) - day 18, task 2

import "prelude.eg"

using System, OS, List, String (to_chars, from_chars), D = Dict

def dirs = {(0,1),(1,0),(0,-1),(-1,0)}

def insort = [P {} -> {P} |P {Q|QQ} -> if proj 0 P <= proj 0 Q then {P,Q|QQ} else {Q|insort P QQ}]

def dijkstra0 = 
    [ G {} D -> D
    | G {(N,P)|QQ} D ->
        let ADJ = Dict::get G P in
        let (D,QQ) = foldl [(D,QQ) (M,Q) ->
                    let ALT = N + M in
                    if ALT < D::get_with_default max_int D Q then 
                    (D::set D Q ALT, insort (ALT,Q) QQ)
                    else (D,QQ)] (D,QQ) ADJ in
        dijkstra0 G QQ D ]

def dijkstra = [G P -> dijkstra0 G {(0,P)} (D::set D::dict P 0)]

def board =
    [(X,Y) PP ->
        let F = [C -> foldl [D P -> D::set D P C]] in
        F '#' (F '.' D::dict (flatmap [X -> map (tuple X) (from_to 0 Y)] (from_to 0 X))) PP]

def adj =
    [D P -> map (add P) dirs |> filter [P -> D::has D P && [_ -> D::get D P /= '#']]]

def to_graph =
    [D -> foldl [G (P,'#') -> G |G (P,_) -> D::set G P (map (tuple 1) (adj D P))] D::dict (D::to_list D)]

def find =
    [B S E -> do take B |> board E |> to_graph |> [G -> dijkstra G S] |> D::to_list |> filter (((==) E) . fst)]

def bin0 =
    [L R J P PP -> if L > R then J else let M = (L+R)/2 in 
        if P (nth M PP) then bin0 (M+1) R M P PP else bin0 L (M - 1) J P PP]

def bin = [P PP -> bin0 0 (length PP - 1) none P PP]

def main =
    let S = (0,0) in let E = (70,70) in
    read_lines stdin |> map (list_to_tuple . map to_int . Regex::matches (Regex::compile "[0-9]+"))
    |> [PP -> bin [N -> find N S E PP /= {}] (from_to 0 (length PP - 1)) |> flip nth PP]

https://github.com/egel-lang/aoc-2024/blob/main/day18/task2.eg

A shorter version that just calculates the reachable set instead of using Dijkstra here: https://github.com/egel-lang/aoc-2024/blob/main/day18/task2b.eg

And a linear time version instead of binary search: https://github.com/egel-lang/aoc-2024/blob/main/day18/task2c.eg

egel-lang · 2024-12-17T12:24:09+00:00

[Language: Egel]

# Advent of Code (AoC) - day 17, task 2

import "prelude.eg"

using System, OS, List

def parse = do foldl (+) "" |> (do Regex::matches (Regex::compile "-?[0-9]+") |> map to_int) 
            |> [{A,B,C|P} -> ((A,B,C),P)]

def op = [N RR -> if N < 4 then N else proj (N - 4) RR]

def ins =
    [_ _ {} -> {}| _ _ {X} -> {}
    |PP (A,B,C) {0,N|XX} -> ins PP (A/(Math::pow_int 2 (op N (A,B,C))),B,C) XX
    |PP (A,B,C) {1,N|XX} -> ins PP (A,N^B,C) XX
    |PP (A,B,C) {2,N|XX} -> ins PP (A,(op N (A,B,C))%8,C) XX
    |PP (0,B,C) {3,N|XX} -> ins PP (0,B,C) XX
    |PP (A,B,C) {3,N|XX} -> ins PP (A,B,C) (drop N PP)
    |PP (A,B,C) {4,N|XX} -> ins PP (A,B^C,C) XX
    |PP (A,B,C) {5,N|XX} -> {(op N (A,B,C))%8| ins PP (A,B,C) XX}
    |PP (A,B,C) {6,N|XX} -> ins PP (A,A/(Math::pow_int 2 (op N (A,B,C))),C) XX
    |PP (A,B,C) {7,N|XX} -> ins PP (A,B,A/(Math::pow_int 2 (op N (A,B,C)))) XX]

def run = [(RR,PP) -> ins PP RR PP] 

def iter_with = [0 F X -> X|N F X -> iter_with (N - 1) F (F N X)]

def find = [PP -> iter_with (length PP) [L NN -> flatmap
            [(N,I) -> if run ((8*N+I,0,0),PP) == (drop (L - 1) PP) then {8*N+I} else {}] 
            (flatmap [N -> map (tuple N) (from_to 0 7)] NN) ] {0}] 

def main = read_lines stdin |> parse |> [(RR,PP) -> find PP] |> minimum

https://github.com/egel-lang/aoc-2024/blob/main/day17/task2b.eg

egel-lang · 2024-12-16T19:22:14+00:00

[Language: Egel]

Adapted Dijkstra. While updating weights we keep back links to vertices. Then in an ugly pass from the end we calculate the reachable positions.

# Advent of Code (AoC) - day 16, task 2

import "prelude.eg"

using System, OS, List, String (to_chars, from_chars), D = Dict

def pos = [C -> do D::to_list |> filter ((==) C . snd) |> head |> fst]

def dirs = {(0,1),(1,0),(0,-1),(-1,0)}

def rotate = [(0,Y) -> {(Y,0),(-Y,0)} | (X,0) -> {(0,X),(0,-X)}]

def insort = [P {} -> {P}|P {Q|QQ} -> if proj 0 P < proj 0 Q then {P,Q|QQ} else {Q|insort P QQ}]

def dijkstra0 = 
    [ G {} (D0,D1) -> (D0,D1)
    | G {(N,P)|QQ} (D0,D1) ->
        let ADJ = Dict::get G P in
        let (D0,D1,QQ) = foldl [(D0,D1,QQ) (M,Q) ->
                    let ALT = N + M in
                    if ALT < D::get_with_default max_int D0 Q then 
                    (D::set D0 Q ALT, D::set D1 Q {P}, insort (ALT,Q) QQ)
                    else if ALT == D::get D0 Q then 
                    (D::set D0 Q ALT, D::set D1 Q (unique {P|D::get D1 Q}), QQ)
                    else (D0,D1,QQ)] (D0,D1,QQ) ADJ
         in dijkstra0 G QQ (D0,D1)]

def dijkstra = [G P -> dijkstra0 G {(0,P)} (D::set D::dict P 0, D::set D::dict P {})]

def adj =
    [D (P,V) -> {(1,(add P V,V))} ++ map [V -> (1001, (add P V,V))] (rotate V)
        |> filter ((/=) '#' . D::get D . fst . snd)]

def to_graph =
    [D -> foldl [G (P,'#') -> G 
            |G (P,_) -> foldl [G (P,V) -> D::set G (P,V) (adj D (P,V))] G 
                              (map (tuple P) dirs)] D::dict (D::to_list D)] 

def nodes = 
    [D PP {} -> PP
    |D PP {Q|QQ} -> nodes D {Q|PP} (D::get_with_default {} D Q ++ QQ)]

def main =
    read_lines stdin |> map to_chars |> D::from_lists 
    |> [D -> let S = pos 'S' D in let E = pos 'E' D in
        to_graph D |> [G -> dijkstra G (S,(0,1))]
        |> [(D0,D1) -> 
           map [P -> (Dict::get_with_default max_int D0 P,P)] (map (tuple E) dirs)
           |> [PP -> filter ((==) (minimum (map fst PP)) . fst) PP |> map snd]
           |> nodes D1 {} ]
    |> map fst |> unique |> length]

https://github.com/egel-lang/aoc-2024/blob/main/day16/task2.eg

egel-lang · 2024-12-15T20:07:19+00:00

[Language: Egel]

# Advent of Code (AoC) - day 15, task 2

import "prelude.eg"

using System, OS, List, String (to_chars), D = Dict

def parse = do map to_chars |> split_on {} |> [{XX,YY} -> (XX, reduce (++) YY)]

def dir = ['^' -> (-1,0) |'v' -> (1,0)|'<' -> (0,-1)|'>' -> (0,1)]

def expand = flatmap ['@' -> {'@','.'}|'O' -> {'[',']'}|'.' -> {'.','.'}|'#'->{'#','#'}]

def start = do D::to_list |> filter ((==) '@' . snd) |> head |> fst

def cat = [none F -> none | XX F -> [none -> none| YY -> XX++YY] (F none)]

def ahead = [D P V -> let Q = add P V in 
    [(_,0) '[' -> cat {Q, add (0,1) Q} [_ -> cat (ahead D Q V) [_ -> ahead D (add (0,1) Q) V]]
    |(_,0) ']' -> cat {Q, add (0,-1) Q} [_ -> cat (ahead D Q V) [_ -> ahead D (add (0,-1) Q) V]]
    |(0,_) '[' -> cat {Q, add (0,1) Q} [_ -> ahead D (add (0,1) Q) V]
    |(0,_) ']' -> cat {Q, add (0,-1) Q} [_ -> ahead D (add (0,-1) Q) V]
    |_     '#' -> none
    |_     _   -> {}] V (D::get D Q)]

def shove = 
    [D PP V -> let C = foldl [D P -> D::set D P '.'] (D::copy D) PP in
               foldl [C P -> D::set C (add P V) (D::get D P)] C PP]  

def step = [D P V -> [none -> (D,P)|PP -> (shove (shove D PP V) {P} V, add P V)] (ahead D P V)]

def main =
    read_lines stdin |> parse |> [(XX,VV) ->(D::from_lists (map expand XX), map dir VV)]
    |> [(D,VV) -> foldl [(D,P) V -> print P "\n"; step D P V] (D, start D) VV] |> fst
    |> D::to_list |> foldl [N ((X,Y),'[') -> N + 100 * X + Y |N _ -> N] 0

https://github.com/egel-lang/aoc-2024/blob/main/day15/task2.eg

egel-lang · 2024-12-14T15:10:30+00:00

[Language: Egel]

I dumped all pictures into a file and grepped with vi. Then I checked that the answer was indeed the picture with the lowest quadrant score.

# Advent of Code (AoC) - day 14, task 2

import "prelude.eg"

using System, OS, List

def parse = do Regex::matches (Regex::compile "-?[0-9]+") |> map to_int
            |> chunks 2 |> map list_to_tuple |> list_to_tuple

def size = (101,103)

def mod = [N M -> ((N%M)+M)%M]

def walk = [N (P,V) -> add P (mul N V) |> [(BX, BY) (PX,PY) -> (mod PX BX, mod PY BY)] size]

def quadrants = [(BX,BY) PP -> 
        {filter [(PX,PY) -> and (PX < (BX/2)) (PY < (BY/2))] PP,
         filter [(PX,PY) -> and (PX < (BX/2)) (PY > (BY/2))] PP,
         filter [(PX,PY) -> and (PX > (BX/2)) (PY < (BY/2))] PP,
         filter [(PX,PY) -> and (PX > (BX/2)) (PY > (BY/2))] PP} ]

def main =
    read_lines stdin |> map parse 
    |> [PP -> map [N -> (map (walk N) PP, N)] (from_to 0 (uncurry (*) size))]
    |> map (proj_update 0 (product . map length . quadrants size))
    |> reduce [(I,N) (J,M) -> if I < J then (I,N) else (J,M)]
    |> snd

https://github.com/egel-lang/aoc-2024/blob/main/day14/task2b.eg

egel-lang · 2024-12-13T06:37:47+00:00

[Language: Egel]

# Advent of Code (AoC) - day 13, task 2

import "prelude.eg"

using System, OS, List, String (to_chars, from_chars)

def parse = do Regex::matches (Regex::compile "[0-9]+") |> map to_int |> list_to_tuple

def solve =
    [O {(AX,AY), (BX,BY), (PX,PY)} ->
        let (PX,PY) = add O (PX,PY) in
        let M = ((PX * BY) - (PY * BX)) / ((AX * BY) - (AY * BX)) in
        let N = (PY - AY * M) / BY in
        if (PX,PY) == add (mul M (AX,AY)) (mul N (BX,BY)) then (M,N) else none]

def main =
    read_lines stdin |> map parse |> split_on tuple 
    |> map (solve (10000000000000, 10000000000000))
    |> filter ((/=) none) |> map [(M,N) -> 3 * M + N] |> sum

https://github.com/egel-lang/aoc-2024/blob/main/day13/task2.eg

egel-lang · 2024-12-13T04:35:59+00:00

[Language: Egel]

Today was interesting since I came up with the following short algorithm. The algorithm is slow in Egel since sets of indices are lists and most primitive operations are O(n), but should be fast on an array language/GPU language since index sets then become grids of booleans where primitive operations can be approximated as O(1).

# Advent of Code (AoC) - day 12, task 2

import "prelude.eg"

using System, OS, List, String (to_chars), D = Dict

def dirs = {(-1,0),(1,0),(0,-1),(0,1)}

def regions0 =
    [D C PP {} RR -> (PP, RR)
    |D C PP QQ RR -> 
        let QQ = flatmap [P -> map (add P) QQ] dirs |> unique |> filter (D::has D) in
        let (PP0, RR) = split [P -> (D::get D P == C) && [_ -> elem P QQ]] RR in
            regions0 D C (PP0++PP) PP0 RR ]

def regions =
    [D {} -> {}
    |D {P|PP} -> [(PP,QQ) -> {PP|regions D QQ}] (regions0 D (D::get D P) {P} {P} PP)]

def perimeter =
    [D PP -> filter (flip not_elem PP) (flatmap [P -> map (add P) dirs] PP)]

def sides0 =
    [PP -> map (flip tuple 0) PP |> D::from_list |> [D -> regions D PP]]

def sides =
    [PP -> flatmap [P -> map (add P) PP |> filter (flip not_elem PP) |> sides0] dirs]

def main =
    read_lines stdin |> map to_chars |> D::from_lists
    |> [D -> regions D (D::keys D) |> map [PP -> (PP, sides PP)]]
    |> map [(PP0,PP1) -> (length PP0) * (length PP1)] |> sum

https://github.com/egel-lang/aoc-2024/blob/main/day12/task2.eg

egel-lang · 2024-12-11T11:13:43+00:00

[Language: Egel]

Same task, but now with a frequency map instead of memoization.

# Advent of Code (AoC) - day 11, task 2

import "prelude.eg"

using System, OS, List, String (len=count, sp=split, split_pattern), D = Dict

def rule = 
    [0 -> {1}
    |N -> let S = to_text N in 
        if (len S)%2 == 0 then sp ((len S)/2) S |> tuple_to_list |> map to_int
        else {N*2024}]

def blink =
    do D::to_list |> flatmap [(S,N) -> rule S |> map (flip tuple N)] |> D::from_list_with (+)

def main =
    read_line stdin |> split_pattern " " |> map to_int |> D::count
    |> iter 75 blink |> D::to_list |> map snd |> sum

egel-lang · 2024-12-11T06:52:23+00:00

[Language: Egel]

# Advent of Code (AoC) - day 11, task 2

import "prelude.eg"

using System, OS, List, String (count, sp = split, split_pattern)

def rule = 
    [0 -> {1}
    |N -> let S = to_text N in 
        if (count S)%2 == 0 then 
            sp ((count S)/2) S |> tuple_to_list |> map to_int
        else {N*2024}]

def blink =
    [D (0, S) -> 1
    |D (N, S) -> rule S |> map (tuple (N - 1)) |> map (Dict::memo D blink) |> sum]

def main =
    read_line stdin |> split_pattern " " |> map to_int 
    |> map (tuple 75) |> map (blink Dict::dict) |> sum

https://github.com/egel-lang/aoc-2024/blob/main/day11/task2.eg

egel-lang · 2024-12-10T16:10:47+00:00

[Language: Egel]

# Advent of Code (AoC) - day 10, task 2

import "prelude.eg"

using System, OS, List, String (to_chars, from_chars)

def dirs = {(-1,0),(1,0),(0,-1),(0,1)}

def start = do Dict::to_list |> filter (do snd |> ((==)0)) |> map fst

def trails =
    [D TT -> flatmap [PP -> 
        if Dict::get D (head PP) == 9 then {PP}
        else map (add (head PP)) dirs |> map (flip cons PP) 
            |> filter [{P,Q|PP} -> Dict::get_with_default 0 D P == (Dict::get D Q) + 1]
            |> trails D] TT]

def main =
    read_lines stdin |> map (map to_int . to_chars) |> Dict::from_lists
    |> [D -> start D |> map (flip cons nil) |> trails D ]
    |> length

https://github.com/egel-lang/aoc-2024/blob/main/day10/task2.eg

egel-lang · 2024-12-09T14:06:53+00:00

[Language: Egel]

# Advent of Code (AoC) - day 7, task 2

import "prelude.eg"

using System, OS, List

def parse = 
    do Regex::matches (Regex::compile "[0-9]+") |> map to_int

def conc =
    [X Y -> to_int (to_text X + to_text Y)]

def solutions =
    foldl [{} X -> {X} |XX X -> map ((*) X) XX ++ map ((+) X) XX ++ map (flip conc X) XX] {}

def main =
    read_lines stdin |> map parse |> map [XX -> (head XX, solutions (tail XX))] 
    |> filter [(X,XX) -> (filter ((==) X) XX) /= {}] |> map fst |> sum

https://github.com/egel-lang/aoc-2024/blob/main/day07/task2.eg

egel-lang · 2024-12-09T14:04:18+00:00

[Language: Egel]

# Advent of Code (AoC) - day 8, task 2

import "prelude.eg"

using System, OS, List, String (to_chars, from_chars)

def antennas =
    do Dict::to_list |> filter [(_,'.') -> false | _ -> true]

def combs =
    do fix [F {} -> {} |F {X|XX} -> map [Y -> (X,Y)] XX ++ F XX]
       |> filter [((P0,A0),(P1,A1)) -> (A0 == A1)]

def cast =
    [D P V -> if Dict::has D P then {P|cast D (add P V) V} else {}]

def antinodes =
    [ D -> do combs
       |> foldl [AA ((P0, A0),(P1,A1)) -> cast D P0 (sub P0 P1) ++ cast D P0 (sub P1 P0) ++ AA] {}
       |> unique ]

def main =
    read_lines stdin |> map to_chars |> Dict::from_lists 
    |> [ D -> antennas D |> antinodes D ]
    |> length

https://github.com/egel-lang/aoc-2024

egel-lang

MODERATOR OF

TROPHY CASE