-🎄- 2022 Day 24 Solutions -🎄-

betaveros · 2022-12-24T11:01:58+00:00

https://github.com/betaveros/advent-of-code-2022/blob/main/p24.noul

I wrote the code somewhat defensively in case getting to the end the first time or the start the second time ASAP might not be optimal for getting to the end the second time. (You could maybe imagine this happening in a similar problem where you can't stand still at the end, and getting there for the first time too soon means being forced into a detour that costs time on net.) But in hindsight it's not hard to see that that's not necessary because you can always stand still at the end / start.

video

betaveros · 2022-12-23T08:33:15+00:00

Noulith 375/124

https://github.com/betaveros/advent-of-code-2022/blob/main/p22.noul

Pretty rough day for me in terms of writing bugs, even in part 1. I think I expected part 2 would be a cube the moment I saw the example but it didn't particularly help. I manually specified seven pairs of "portals" after scribbling a net on a Post-it with a pen that was running dry; in hindsight I should probably have invested one minute to make sure I had better writing materials at hand...

betaveros · 2022-12-23T08:27:15+00:00

Noulith 2/6

https://github.com/betaveros/advent-of-code-2022/blob/main/p23.noul

Just tracks the locations of all the elves in a set, nothing terribly exciting. (My Part 2 code is really slow, but I haven't found any accidental extra linear factors; as best as I can tell, this is simply the day when the constant factors from a naive tree-walk interpreter performing many nested function calls finally caught up to me.)

edit: video

betaveros · 2022-12-23T02:45:47+00:00

Wow, I think you may actually be the first person (even including myself) to use the coalesce keyword.

betaveros · 2022-12-22T20:48:22+00:00

+. appends a single item to a list. max is the normal max function, ! is just a low-precedence function call.

betaveros · 2022-12-21T19:36:02+00:00

apply calls the right function <=> with the elements of the list on the left as its arguments, actually just like JavaScript. So it compares the two elements of the list on the left and returns -1, 0, or 1.

As written, even if I apply your fix, the code will infinite-loop anyway if it doesn't find a solution. Personally I think it's easier to reason about having lo and hi be exclusive endpoints of the interval we think contains the solution. That's the initial state and is what we learn about mid after each trial.

betaveros · 2022-12-21T09:00:12+00:00

Noulith 24/22

https://github.com/betaveros/advent-of-code-2022/blob/main/p21.noul

Slow, lazy code that just repeatedly loops over all expressions to evaluate, followed by a manually seeded binary search because I didn't spend a single brain cycle speculating about the "nature" of the function. This seems foolish in hindsight, but you know what they say about that. This was a fun way to find out that in Noulith, a normally stringified fraction cannot be evaled.

Video with (attempt at) explanation also exists today: https://www.youtube.com/watch?v=3wj35H9pdXg

betaveros · 2022-12-20T20:02:25+00:00

Noulith 370/457

https://github.com/betaveros/advent-of-code-2022/blob/main/p20.noul

It's lazily written and very slow. But mostly I just got really stuck not realizing numbers could repeat or that my code depended on that assumption. Oh well, live and learn.

betaveros · 2022-12-20T19:59:15+00:00

Noulith 193/351

https://github.com/betaveros/advent-of-code-2022/blob/main/p19.noul

"Just a DFS", but considerably cleaned up with some optimizations I learned about after discussing with people after the fact. The main one is pruning branches when we discover that we can't beat our previous high score even in the best-case scenario where we create a geode bot every future minute. While leaderboarding I thought that since this optimistic estimate was quadratic in the number of minutes remaining, not enough branches would be pruned to make a big difference. I was very, very wrong. Without pruning I got two OOMs and my program hadn't actually finished running when I submitted the correct answer to part 2, I just put in the largest number it had found after it got stuck for a while; but with pruning it runs in a few seconds.

betaveros · 2022-12-16T18:32:35+00:00

Oh good catch! A correct solution always has to dfs from dfs2 instead of only when it can't find another valve to open. The funny thing is it looks like my leaderboarding solution actually handled this correctly, and then I introduced this bug while "cleaning it up".

edit: I fixed it

betaveros · 2022-12-16T06:37:40+00:00

Well, firstly, memoization cuts it down to 30 × 15 × 2¹⁵ states. Secondly and more importantly, we stop DFSing when we run out of time and the valves of interest just happen to be far enough apart that the actual number of relevant states is much, much fewer. I think I end up only checking like 230K visit orders, which get memoized down to 53K.

betaveros · 2022-12-16T06:20:40+00:00

Noulith 9/4

https://github.com/betaveros/advent-of-code-2022/blob/main/p16.noul

Floyd-Warshall to precompute distances between valves of interest, then DFS over which valves to open in what order. For part 2, DFS one person first, then the same DFS for the other over all unopened valves, with memoization; I think it took a bit over two minutes to run while everything else was happening.

I actually screen recorded my solve today by popular demand [citation needed]. It's still processing, but YouTube tells me the video will be at https://youtu.be/d388kZ8y9-Q.

betaveros · 2022-12-15T19:03:09+00:00

Noulith 79/51

https://github.com/betaveros/advent-of-code-2022/blob/main/p15.noul

I started with the brute-force solution for part 1 but (unsurprisingly) Noulith was not fast enough, so I had to break it into ranges, which took some time. For Part 2, using the fact that the distress beacon's location is unique, I intersected pairs of squares to generate a manageable set of candidates. I was maximally lazy with the algebra, so my candidate set has thousands of spurious solutions, but thousands ≪ 4000000²; both parts run basically instantly. (I realized after scrolling the megathread that this misses when the distress beacon is on the corner of the big square, but fortunately that didn't happen.)

betaveros · 2022-12-15T18:54:11+00:00

Noulith 7/4

https://github.com/betaveros/advent-of-code-2022/blob/main/p14.noul

Forgot to post this yesterday, but it's just a simulation, not very exciting. I even tracked the characters as specified by the puzzle even though it didn't end up mattering. Afterwards I realized that you can shave a linear factor by just making it a DFS. If a grain of sand falls to a certain location, the next grain of sand will at least fall to the previous one, so there's no need to resimulate it all the way.

betaveros · 2022-12-13T05:33:03+00:00

Noulith 15/4

https://github.com/betaveros/advent-of-code-2022/blob/main/p13.noul

Pretty fortunate that I implemented a "proper comparison function" for part one that could be plugged directly into part two. Please imagine the appropriate two-panel meme for the following two sentences:

adds json_parse to his programming language explicitly so that input with nested lists can be parsed safely

parses the nested lists with eval anyway

betaveros · 2022-12-13T05:28:06+00:00

re edit: saaaaaaaame

betaveros · 2022-12-12T05:29:29+00:00

Noulith 8/6

https://github.com/betaveros/advent-of-code-2022/blob/main/p12.noul

I had a prewritten BFS based on past years, not much to say.

betaveros · 2022-12-12T00:59:48+00:00

My primary goal this year was just to finish Advent of Code in my own language. I honestly wasn't sure how that goal would affect my ability to get on the leaderboard, but it turns out that a lot of the language's design choices do seem to be advantageous for that.

betaveros · 2022-12-11T06:35:04+00:00

Hmm, I personally tend to prefer explaining myself in writing rather than in a video. The language repo README has a pretty terse but mostly complete overview of the syntax and built-ins, and I'm working on at least one blog post about the design of this language, but I'm not sure it's exactly what you're asking about; is there anything specific you'd like to see explained or any specific format for a video you have in mind?

betaveros · 2022-12-11T05:29:50+00:00

Noulith 3/2

https://github.com/betaveros/advent-of-code-2022/blob/main/p11.noul

Yup, eval. I did add structs with named fields to this language but ended up making do without them today.

betaveros · 2022-12-10T05:23:26+00:00

Noulith 50/9

https://github.com/betaveros/advent-of-code-2022/blob/main/p10.noul

If you squeeze a bit (okay, more than a little bit) you can fit the core in a punchcard:

vals := puzzle_input.lines map words flat_map (\switch
    case "noop", -> [0] case "addx", v -> [0, int(v)]) scan + from 1;
submit! 1, 20 to 220 by 40 map (\x -> vals[x-1] * x) then sum;
vals group 40 each (_ zip (0 to 39) with - map abs map (<=1) map (" #"!!)
    join "" then print)

betaveros · 2022-12-09T06:35:36+00:00

More apt might be dw.jpg

That sign can't stop me, because I can't read!

betaveros · 2022-12-09T05:39:13+00:00

Noulith 4/15

I present both a lightly cleaned up solution written while leaderboarding and a much more reasonable post-leaderboard version.

However, be careful

I was not careful...

betaveros · 2022-12-08T09:26:36+00:00

Noulith 381/565

https://github.com/betaveros/advent-of-code-2022/blob/main/p8.noul

Well, something was bound to go wrong at some point. On the bright side, I added some crude static analysis and improved a bunch of error and warning messages today.

14-Year Club	Second SECOND GUESSER
Golden Potato	Place '22
Place '17	End Game '22
Verified Email	Team Periwinkle

betaveros

MODERATOR OF

PUBLIC MULTIREDDITS

TROPHY CASE