Stream: advent of code

Topic: 2023 Day 4

timotree (Dec 04 2023 at 06:28):

My day 4 solution. I love how everything turns into a pipeline after I factor out helper functions

Johan Lindskogen (Dec 04 2023 at 07:39):

I am back on track with day 4! https://github.com/lindskogen/advent-of-code-2023/blob/main/day04/main.roc - Takes 11 seconds with --optimize so a lot of work still remains to make it fast

Luke Boswell (Dec 04 2023 at 08:17):

This is my solution for Day 4

Also timing comparison, It seems to hang or take a really long time to run with --optimize

$ roc dev src/cli.roc -- 2023 4
2023 Day 4: Scratchcards completed in 326 ms
Part 1 took 161 ms
Part 2 took 165 ms
$ roc run --optimize src/cli.roc -- 2023 4 <--- takes a long time or hangs???
$ roc build --optimize src/cli.roc <--- takes 2810 ms to build
2023 Day 4: Scratchcards completed in 4 ms
Part 1 took 2 ms
Part 2 took 1 ms

Luke Boswell (Dec 04 2023 at 08:22):

I'm wondering if there is something fishy going on with these optimized build times, is it possible that LLVM is calculating the function at compile time somehow??

Luke Boswell (Dec 04 2023 at 09:06):

@timotree that looks so simple. Nice use of Set

Fabian Schmalzried (Dec 04 2023 at 09:37):

Here is my solution
I think this was easier than yesterday. Using dbg is so nice now. I remember last year the output of dbg was just wrong sometimes.

joshi (Dec 04 2023 at 09:59):

That was short and sweet, and for once, I needed to make things actually go fast :sweat_smile:

https://gitlab.com/arkandos/aoc/-/blob/2023/solutions/day4.roc

I still think "dynamic programming" is such a dumb name

Oskar Hahn (Dec 04 2023 at 11:51):

Here is mine: https://github.com/ostcar/aoc2023/blob/main/days/day04.roc

I did not have the time yet to look at your solutions (which is always informative), but I did not have a performance problem. Without optimization, I get:

Part1 in 1.234s:
XXX

Part2 in 1.341s:
XXX

With --optimize, it does not compile

An internal compiler expectation was broken.
This is definitely a compiler bug.
Please file an issue here: https://github.com/roc-lang/roc/issues/new/choose
thread 'main' panicked at 'Undefined Symbol in relocation, (+9f90, Relocation { kind: PltRelative, encoding: Generic, size: +20, target: Symbol(SymbolIndex(+78)), addend: +fffffffffffffffc, implicit_addend: false }): Ok(Symbol { name: "memmove", address: +0, size: +0, kind: Label, section: Undefined, scope: Unknown, weak: false, flags: Elf { st_info: +10, st_other: +0 } })', crates/linker/src/elf.rs:1486:25
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Richard Feldman (Dec 04 2023 at 11:57):

ahh that bug looks like LLVM generating memmove instructions

Richard Feldman (Dec 04 2023 at 11:58):

(in the optimized build)

Richard Feldman (Dec 04 2023 at 11:58):

TIL it can generate not only memcpy but also memmove instructions!

Asbjørn Olling (Dec 04 2023 at 15:24):

Doing advent of code during work hours? Me?
I would never... :laughing:

https://gitlab.com/AsbjornOlling/aoc2023/-/blob/main/04/main.roc

Today was pretty harmless. No real struggles algorithmically or otherwise.
I have a suspicion that aoc puzzles are harder on weekend days. Today really confirms that theory.

I do have one pretty dumb |> Result.withDefault 9999 on a Dict.get lookup that I know always succeeds.
I want to have a look at getting rid of that later. I have a feeling I can do something smart if I use Dict.walk instead; or maybe I need to do my own recusion. Haven't really thought it through... Suggestions welcome.

Johan Lindskogen (Dec 04 2023 at 15:56):

Asbjørn Olling said:

Doing advent of code during work hours? Me?
I would never... :laughing:

https://gitlab.com/AsbjornOlling/aoc2023/-/blob/main/04/main.roc

Today was pretty harmless. No real struggles algorithmically or otherwise.
I have a suspicion that aoc puzzles are harder on weekend days. Today really confirms that theory.

I do have one pretty dumb |> Result.withDefault 9999 on a Dict.get lookup that I know always succeeds.
I want to have a look at getting rid of that later. I have a feeling I can do something smart if I use Dict.walk instead; or maybe I need to do my own recusion. Haven't really thought it through... Suggestions welcome.

@timotree here https://roc.zulipchat.com/#narrow/stream/358903-Advent-of-Code/topic/2023.20Day.204/near/405754608 made a orCrash helper :smiley:

Asbjørn Olling (Dec 04 2023 at 15:58):

hmm I don't love crashing.
Like, I can promise that it's always in there, but I think it'd be so much neater if I could convince the typechecker of it too.
rn it feels possible to do.

timotree (Dec 04 2023 at 16:06):

I only used orCrash for the parsing code. My data structure-manipulating code uses List.update which just does nothing silently if the indices are out of bounds

joshi (Dec 04 2023 at 16:06):

An idea I have that somewhat tries to keep the spirit of your solution:

But I also think a default of 0 is fine, from a mathematical standpoint. If a card that you never had wins, increment all copies of the next N card by 0. Makes sense to me! :big_smile:

Oskar Hahn (Dec 04 2023 at 16:25):

Luke Boswell said:

This is my solution for Day 4

Also timing comparison, It seems to hang or take a really long time to run with --optimize

$ roc dev src/cli.roc -- 2023 4
2023 Day 4: Scratchcards completed in 326 ms
Part 1 took 161 ms
Part 2 took 165 ms
$ roc run --optimize src/cli.roc -- 2023 4 <--- takes a long time or hangs???
$ roc build --optimize src/cli.roc <--- takes 2810 ms to build
2023 Day 4: Scratchcards completed in 4 ms
Part 1 took 2 ms
Part 2 took 1 ms

Every time I read your solutions, I learn something new. It's like the follow-up of the tutorial :smiling_face:

This time, it was the [_ ,..as rest] pattern when pattern matching.

Brendan Hansknecht (Dec 04 2023 at 17:28):

Day 4 felt smooth and quite easy:
https://github.com/bhansconnect/roc-aoc-2023/blob/main/day4.roc

Luke Boswell (Dec 04 2023 at 17:28):

Thats what I enjoy most about AoC, is reading other people's solutions and learning new tricks. I try to make my next one a little better to challenge myself.

Brendan Hansknecht (Dec 04 2023 at 17:32):

Also, I think my least favorite part of pipeline heavy solutions (which most AOC is for me) is that I prefer backpassing. They don't mix well though.

timotree (Dec 04 2023 at 17:50):

@Brendan Hansknecht wow our code is almost the exact same modulo function boundaries and integer sizes!

Brendan Hansknecht (Dec 04 2023 at 17:56):

Oh wow, yeah, really close

Brendan Hansknecht (Dec 04 2023 at 17:57):

I guess it is a very direct solution

Pearce Keesling (Dec 04 2023 at 18:51):

https://github.com/keeslinp/AoC2023/blob/main/day4.roc
Ended up going the dynamic programming route for Part 2, but I feel like there has to be a way to work backwards to make it a lot cleaner :thinking: . Under a second is plenty fast for me though.

Big thanks for pointing out formatting + highlighting yesterday, it made it a lot easier to parse for my brain.

Would it be possible to make crash behave like expect where it dumps out the variables in scope? I ended up just adding dbg in the crash branches to simulate that, but it would be super cool to have in debug builds.

Richard Feldman (Dec 04 2023 at 19:43):

whoa, I love that idea! :smiley:

Brendan Hansknecht (Dec 04 2023 at 19:52):

Makes me think that the real wanted feature is gradual typing with expect essentially.

So you could just write an expect of the Ok case and then if the expect fails it would dump everything. If the expect passes, suddenly, we would be safe to just unwrap without ever calling crash.

Of course, we don't have gradual typing, but it is a really nice use case.

Jason Hobbs (Dec 04 2023 at 20:47):

Brendan Hansknecht said:

Day 4 felt smooth and quite easy:
https://github.com/bhansconnect/roc-aoc-2023/blob/main/day4.roc

Wow, that does look simple. Nice to learn Set.intersection exists too!

Here's my novice take on it with Roc:

app "hello"
    packages
    {
        pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br",
        parser: "https://github.com/lukewilliamboswell/roc-parser/releases/download/0.3.0/-e3ebWWmlFPfe9fYrr2z1urfslzygbtQQsl69iH1qzQ.tar.br",
    }
    imports
    [
        pf.Stdout,
        pf.Task,
        "./day4-input.txt" as input : Str,
        parser.Core.{ Parser, const, keep, map, oneOrMore },
        parser.String.{ anyCodeunit, digits, oneOf, parseStr, string },
    ]
    provides [main] to pf

main =
    {} <- Stdout.line "The total sum is \(part1 input)" |> Task.await
    {} <- Stdout.line "The number of cards is \(part2 input)" |> Task.await
    Task.ok {}

part1 = \gamelist ->
    Str.split gamelist "\n"
    |> List.map correctPicksInGame
    |> mapScore
    |> List.sum
    |> Num.toStr

part2 = \gamelist ->
    correctPicksByGame =
        Str.split gamelist "\n"
        |> List.map correctPicksInGame

    emptyDict : Dict U32 U32
    emptyDict = Dict.empty {}

    numBonusCardsByGame =
        List.walkWithIndex
            correctPicksByGame
            emptyDict
            \numCardsByGame, item, index ->
                copies : Nat
                copies = Dict.get numCardsByGame (Num.toU32 index) |> Result.withDefault 0 |> Num.toNat
                # _ = debug index "index"
                # _ = debug item "item"
                # _ = debug copies "copies"

                if List.len item > 0 then
                    # Process normal cards
                    List.range { start: At (index + 1), end: At (index + (List.len item)) }
                    |> List.repeat (1 + copies)
                    |> List.join
                    |> List.map Num.toU32
                    |> incrementCards numCardsByGame
                else
                    numCardsByGame

    # dbg correctPicksByGame
    # dbg numBonusCardsByGame

    Num.add
        (List.len correctPicksByGame |> Num.toU32)
        (Dict.values numBonusCardsByGame |> List.sum)
    |> Num.toStr

incrementCards : List U32, Dict U32 U32 -> Dict U32 U32
incrementCards = \range, numCardsByGame ->
    if List.isEmpty range then
        numCardsByGame
    else
        key = List.first range |> Result.withDefault 0
        updatedDict = Dict.update numCardsByGame key incrementDict
        incrementCards (List.dropFirst range 1) updatedDict

incrementDict : [Missing, Present U32] -> [Present U32]
incrementDict = \possibleValue ->
    when possibleValue is
        Missing -> Present 1
        Present value -> Present (value + 1)

mapScore = \numCorrectByGame ->
    numCorrectByGame
    |> List.map List.len
    |> List.map \numCorrect ->
        when numCorrect is
            0 -> 0
            _ -> Num.powInt 2 (numCorrect - 1)

correctPicksInGame = \game ->
    numbers =
        Str.split game ":"
        |> List.get 1
        |> Result.withDefault ""
        |> Str.split "|"

    winningNumbers =
        numbers
        |> List.get 0
        |> Result.withDefault ""
        |> Str.split " "
        |> List.map Str.trim

    myPicks =
        numbers
        |> List.get 1
        |> Result.withDefault ""
        |> Str.split " "
        |> List.map Str.trim

    List.keepIf myPicks \pick -> List.contains winningNumbers pick
    |> List.keepOks Str.toI16

exampleInput =
    """
    Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
    Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
    Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
    Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
    Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
    Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11
    """
    |> Str.trim

debug = \v, ctx ->
    dbg
        ctx

    dbg
        v

    v

Axel (Dec 04 2023 at 21:52):

No surprises in my solution either.
Biggest take away: Using the language server is shortens feedback significantly :pray:
Biggest :see_no_evil: : When something is off with the types all tests get reported as well. Which is quite cumbersome when you have all the tests at the bottom, because you have to scroll waaaay up after running roc check to get to the actual error.
image.png

Brendan Hansknecht (Dec 04 2023 at 22:09):

Personally, I use this ls *.roc | entr -cc roc /_

automatically runs the day*.roc file whenever I save it.

Brendan Hansknecht (Dec 04 2023 at 22:09):

Also a nice a short feedback loop

John Murray (Dec 05 2023 at 02:26):

Heres my day 4 https://github.com/JRMurr/AdventOfCode2023/blob/main/roc/D04/Day.roc

Started using more expects as i write each helper which was a nice flow

John Murray (Dec 05 2023 at 02:26):

Brendan Hansknecht said:

Personally, I use this ls *.roc | entr -cc roc /_

automatically runs the day*.roc file whenever I save it.

I wonder how hard it would be to have something like https://github.com/Canop/bacon for roc. Would be a nice flow to have a tab open with the most up to date checks/tests

Ayaz Hafiz (Dec 05 2023 at 04:47):

My day 4 https://gist.github.com/ayazhafiz/d4eea34a9c4830dfb0307a512abbee80

Ayaz Hafiz (Dec 05 2023 at 04:47):

Roc is so nice especially with dbg and the LS now. I can't get over it

Ayaz Hafiz (Dec 05 2023 at 04:47):

So much progress over the last year. Congrats everybody!

Isaac Van Doren (Dec 05 2023 at 05:40):

This one was very pleasant https://github.com/isaacvando/aoc/blob/main/2023/day4.roc

Ryan Bates (Dec 05 2023 at 08:53):

Here's my solution for day 4. Fun one!
https://github.com/ryanb/advent-2023-roc/blob/main/day04/main.roc

Ahmad Sattar (Dec 05 2023 at 10:28):

Here's my day 4 :)
https://gist.github.com/thehabbos007/dd053edca578454c4418c0ee6eee6618

Nikolaus Wettstein (Dec 07 2023 at 21:56):

just used https://lukewilliamboswell.github.io/roc-parser/ for the first time to solve day 4 (https://github.com/ni-ko-o-kin/advent-of-code/blob/main/2023/04-solution-part1-v1.roc) instead of Str.split/List.drop*/aso. It is so nice to use. Thank you a lot for this great library @Luke Boswell Have I used it correctly?

Luke Boswell (Dec 07 2023 at 22:06):

Looks good :+1: Glad it's helpful, I really enjoy using it too

Jonas Schell (Jan 29 2024 at 23:30):

My day 4 solutions: https://github.com/Ocupe/advent-of-code-2023/tree/main/day_04
My implementation for part 2 was so slow that I thought I had an infinite loop, but it finished after 172 seconds :D
Lots of room for improvement, but I am starting to like the expect workflow. It makes a test-driven way of writing a programme super easy. It would be cool if it would return the actual and expected value though.
I also really like the dbg (<call your solve function>) setup that @Brendan Hansknecht posted

Jonas Schell (Jan 29 2024 at 23:36):

Nevermind, I just learned how to print the actual value in an expect. :)

expect
    actual = matchesCount { id: "1", winningNumbers: [41, 48, 83, 86, 17], numbers: [83, 86, 6, 31, 17, 9, 48, 53] }
    actual == 5

Last updated: Jul 06 2025 at 12:14 UTC