AOC 2022 Day Five 🏗️

[bogdaaamn]

Discussion of solutions for Advent of Code Day 5 here.

Don't forget about VC Advent of Code private leaderboard:

• Go to leaderboard/private
• Use join code 363496-e6f42283

[davidalpert]

Day 05 in F#

• part 1 and part 2 are nice and succinct
• the parser is pretty succinct too (once I chased down a whitespace bug that was stacking the [D] crate into the wrong column)

[bogdaaamn]

I was proud yesterday I could read fs, but today I see this 🤪🤪

let pInstruction =
    %% %"move" -- ws -- +.p<int> -- ws -- %"from" -- ws -- +.p<int> -- ws -- %"to" -- ws -- +.p<int> -- ws

Very nice and clean anyways!

[bogdaaamn]

* this is about my reading skills, not about fs or your coding at all

[davidalpert]

that syntax with all the % and -- is from a library called FParsec.Pipes which builds on top of the FParsec parser combinator library I'm using and adds in custom F# operators (the %% is one operator that starts a pipe, the -- is an infix operator that continues a pipe, etc). I like this combo as it lets me define parsers that look like the grammar I'm parsing.

[tkshill]

Using FParsec like this would've deffo been the smart thing to do. I thought it would take me too long to re-familiarize myself with it. I was wrong.

[aishwarya-mali]

JS: https://github.com/aishwarya-mali/advent-of-code/blob/main/2022/Day-5/script.js
Took me whole day. Not best practices but works.

[bogdaaamn]

Very concise and neat solution 🏗️

[tkshill]

Love it!

[danieltott]

TS solution:

https://github.com/danieltott/aoc2022/blob/main/src/day05/index.ts

Pull request:
danieltott/aoc2022#2

This one definitely took a little longer!

[danieltott]

Although Part 2 was literally a one-line change for me, so that was nice.

[bogdaaamn]

stacksRows
        .slice(0, stacksRows.length - 1)
        .map((row) => {
          return row[index * 4 + 1].trim();
        })
        .filter(Boolean),

God I wish to have your skills of seeing things 😂

[tkshill]

I think our solutions are actually really similar actually, and that's very validating for me 😄

[bogdaaamn]

Not proud of this one at all. I tried to find more efficient ways to do it but I wasted all my energy on parsing the input 😂 I spent a lot of time trying to do some regex magic, but I quit at some point, so here we go.

https://github.com/BogDAAAMN/advent-of-code-2022/blob/main/day-05.js

I also tried to be more functional to make @tkshill and @davidalpert proud, but the reducers and the forEachs at the end feel wrong. I feel like I could have done it way much better in a functional way 🏗️

[bogdaaamn]

Also just realised I don't actually need to remove the brackets lol, I check for letters anyways 😮‍💨 Consider that line removed ahahaha

[danieltott]

.map((line) => line.map(Number))

Nice 😎

[bogdaaamn]

Right @danieltott??

[tkshill]

I think this is great!

[turingtestable]

Ruby solution today was pretty fun, i really need to remember to commit in between part 1 and part 2, because I made a change to the method signatures to pass the crane_type and I think it might be interesting to see that. Thought that today's challenge was pretty interesting, one of the more difficult initial processing ones.

Also definitely had the most random print statements to chase down bugs today lol.

[danieltott]

Yeah - I thought the same thing so I started doing that plus PRs so that I could see the difference

[tkshill]

lots of console logs, scripting and tests for this one. 👍🏾

[doleraj]

https://github.com/doleraj/adventofcode/blob/main/aoc2022/src/day05/index.ts

It's me, I'm the idiot who failed to parse the crates with regex and ended up wasting probably 30m trying before giving up

[rhdeck]

Is it ok that I am kind of proud of my one-line stacks parser using list comprehensions and zip? https://github.com/rhdeck/aoc-2022/blob/main/src/5/day_5.ipynb

[bogdaaamn]

I love python for good list comprehensions! Also nice github renders jupyter notebooks

[tkshill]

I am proud of you! Also, love the use of the notebooks for breaking it all down!

[clandau]

JS: https://github.com/clandau/advent-of-code/blob/main/2022/day-5/index.js
definitely did the first one inefficiently then went back and refactored.

[bogdaaamn]

OHHH good use of reverse function. I didn't even know it's a thing 🤡

[tkshill]

Finally here.

What a cursed problem.

Tried to do it without the lovely FParsec library like @davidalpert . Also not smart enough for regex. So just regular degular sequences, lists, and arrays.

And this is what happened: solution

My solution for one made part 2 so similar I just factored out the 7 character difference? But that just makes me angrier.

[bogdaaamn]

What is the difference between |> and >>? Tried to google function chaining in fs, but I am not sure how to call these 🥲

[tkshill]

|> is the pipe operator. Left pipe to be specific.

It could be defined (in TS for example) as
const pipe = (value, function) => function(value) or value (pipe) function => function(value)

In other words, |> just takes a value on the left, and feeds it into the function on the right.

This of course, only works if the types match.

So if I have a value of type A and a function of type A -> B, then I can pipe them.

|> : A -> (A -> B) -> B

It's main use is avoiding parentheses since so much of functional programming involves chaining functions and values.

---

Now for Compose.

>> is the compose operator

It's similar but with a subtle and powerful difference. It feeds functions, not values.

So func1 >> func2 is equal to func2(func1)

If I have a function that goes from A -> B and a function that goes from B -> C, then I can >> compose them together.

So (h >> g >> f) x is the same as f(g(h(x)))

And the type is what you'd expect

(>>): (A -> B) -> (B -> C) -> (A -> C)

so when I say

let solve order =
    parseInput
    >> unpack (Seq.fold (folder order))
    >> Array.choose Array.tryHead
    >> System.String

I'm saying solve is the composition of the functions parseInput, unpack (Seq.fold.., `Array...

Notably, it lets me omit the actual input value. I'm saying sort've, how the functions combine, not how they handle inputs. But they're still functions. This is called point free programming and there's much debate over it 😄 (for readability purposes)

let solve order input =
    input
    |> parseInput
    |> unpack (Seq.fold (folder order))
    |> Array.choose Array.tryHead
    |> System.String

This does exactly the same, thing, but with the argument included. Now i'm threading a value through a bunch of functions, so I use the pipe operator.

[bogdaaamn]

Oh wow, thank you, that sounds very understandable and comprehensive!

I like the idea of passing down functions, but is there a specific reason to do it instead of feeding values?

LE: I mean in this example specifically

[tkshill]

In this example, not really, it's just slightly less words. It's more useful imho inside other operations.

Like if I'm doing a series of transformations inside a sequence.

Instead of

input
|> Seq.map func1
|> Seq.map func2
|> Seq.map func3

Or

input
|> Seq.map (fun v -> v |> func1 |> func2 |> func3)

I can just do

input |> Seq.map (func1 >> func2 >> func3)

And then you realize, if you're just feeding input in at the end, you don't really need to mention it at all until you want to run the function, not just define it.

It's just a little more expressive, and maybe in that FP ethos of not saying what things do, but rather what they are.

JavaScript can do the first 2, but not the third unless you use a library like Rambda or fp-ts or maybe underscore js?

Maybe it's just a bad habit I picked up. I never really do it in Elm, even though I can. Everybody seems to do it almost exclusively in Haskell. In fsharp? Sometimes.

[davidalpert]

I find in F# it's very idiomatic to use that left pipe operator and it reads much like a conversation

something
|> doSomthingWithIt
|> doSomethingElseWithIT

something else that does is that it works with currying/partial application which impacts the sequence of your parameters, because if you have a function that takes two args let multiplyBy a b = a * b and you want to pipe it, you will pipe into the last arg

let result =
    4
    |> multiplyBy 2
    |> multiplyBy 10
    
// result = 80

[danimeyer]

Ruby: https://github.com/danimeyer/advent-of-code/blob/main/2022/5.rb

I tried to create copies of the object I made to store the stacks so that I could manipulate both of them in one each iteration, but for some reason I couldn't get it to work, and I apparently spent all of my energy working on parsing the input instead of just hard coding the input stacks 😂 Maybe tomorrow I'll have the energy to refactor

[danimeyer]

Not sure I like this solution much better, but I did refactor it so at least I don't have to comment code in and out to get the two solutions

[Cerchie]

Didn't get a chance to code yesterday so here are parts 1 (index.js) and 2 (index2.js) for day 5. Definitely hard-coded the first chunk of input. https://github.com/Cerchie/adventofcode2022/tree/main/day-05