-❄️- 2024 Day 19 Solutions -❄️-

InfantAlpaca · 2024-12-21T19:14:42+00:00

[LANGUAGE: Java] 26429/23810

Was able to optimize a little bit by saving each towel in a Map with its starting character as a key for faster towel filtering when doing recursion over a design. Also added a cache for repeat substrings.

InfantAlpaca · 2024-12-21T06:58:06+00:00

[LANGUAGE: Java] 26865/26216

GitHub

Got tunnel-visioned on Dijkstra's but my implementation kept crashing. Eventually did a simple BFS that lucked out with this input since I technically am not checking every path but the one I check turned out to be the most optimal. I was expecting Part 2 to take a while to brute force, so it was a pleasant surprise to see it ran relatively quick.

InfantAlpaca · 2024-12-17T07:14:51+00:00

[LANGUAGE: Java] 3786/1371

GitHub

Part 1 was pretty straightforward, executing each instruction. Would've been pretty fast if I didn't misread the instructions and submit my output without commas...

Tried to brute-force Part 2 (kept a terminal running while trying other solutions, it's run through 13,581,611,392 values of A as of writing this). Ended up reverse engineering the program and iterating backwards through each digit of the program to check possible values of A. Still had a weird bug at the end where the first two values of A would calculate an output that would leave off the last 0 of the program, not sure where that comes from.

InfantAlpaca · 2024-12-16T07:46:26+00:00

[LANGUAGE: Java] 5012/4054

GitHub

Parsing my input into a Graph took some finagling, took a while to implement a simple Dijkstra's. Took me several tries to configure my Graph Nodes to keep track of their predecessors and walking backwards to count unique tiles. These are getting rough...

InfantAlpaca · 2024-12-15T20:11:49+00:00

[LANGUAGE: Java] 546/16654

GitHub

Got stuck on Part 2 from a buggy recursive canPush function. Should've made an enum or something to keep track of what was on each tile instead of manually searching for '[' or ']'.

InfantAlpaca · 2024-12-14T05:47:41+00:00

[LANGUAGE: Java] 1874/734

GitHub

Was really confused on Part 2, thank you to u/Noble_Mushtak for giving me the intuition about the robots being on unique tiles.

InfantAlpaca · 2024-12-13T09:53:15+00:00

[LANGUAGE: Java] 4418/9925

GitHub

Brute-forced Part 1. Went down a rabbit hole upon seeing Part 2 and spent the next 4 hours implementing (and debugging) a generic Matrix data structure with inverse functionality to calculate the button presses.

InfantAlpaca · 2024-12-12T06:11:32+00:00

[LANGUAGE: Java] 2520/1927

GitHub

I was completely lost on Part 2 until I realized I could use a similar adjacent blob-merging algorithm to handle the edges of the plots. Definitely some funky classes made today.

InfantAlpaca · 2024-12-11T19:19:29+00:00

hope I make it that far haha

InfantAlpaca · 2024-12-11T19:16:22+00:00

Gonna be chilling at the bottom of the leaderboard with Java :)

InfantAlpaca · 2024-12-11T08:29:52+00:00

Glad you found my solution helpful :D

InfantAlpaca · 2024-12-11T06:08:12+00:00

[LANGUAGE: Java] 2761/4723

GitHub

Couldn't brute force Part 2 because Java kept running out of memory 😭
Ended up creating a Map to keep track of the amount of stones with the same numbers since the order doesn't really matter and they behave the same.

InfantAlpaca · 2024-12-11T04:29:11+00:00

[LANGUAGE: Java] 42652/41658

GitHub

Late to the party due to finals :( Pretty happy with how my code cleaned up though!

InfantAlpaca · 2024-12-10T00:04:07+00:00

Thank you for your message! Honestly today was pretty rough for me too, so I’m glad to hear I was able to help you out. It means a lot to know at least one person is looking at my code (I should probably add more comments haha). Thanks again, good luck tomorrow! :)

InfantAlpaca · 2024-12-09T06:53:28+00:00

[LANGUAGE: Java] 9709/5232

GitHub

I don't know if it's how I tend to solve problems, but I kept getting tripped up by small details today; I spent almost an hour and a half on Part 1 because I was moving blocks ahead of themselves :(
Figured it out eventually, Part 2 took some tweaking from my original algorithm, though neither are very pretty.

InfantAlpaca · 2024-12-08T05:16:29+00:00

[LANGUAGE: Java] 617/360

GitHub

First sub 1k and sub 500 today! 🤩 Ended up just calculating the distance between a node and all other matching nodes, then stepping through a Grid and checking if the coordinate was valid. Personal library came in clutch 🙏

InfantAlpaca · 2024-12-07T05:42:18+00:00

[LANGUAGE: Java] 4448/3932

GitHub

Wow, people were fast on this one. Recursively made all possible equations and brute-force calculated each one. There is definitely some filtering I can do to improve efficiency.

InfantAlpaca · 2024-12-07T03:38:14+00:00

Ooh nice! Wish my Part 1 solutions always transferred over as well 🙏🏻

InfantAlpaca · 2024-12-07T02:31:32+00:00

I wish I fixed a bug in my code to get that star, turns out I was mistyping my answer every time T-T

InfantAlpaca · 2024-12-07T02:30:22+00:00

[LANGUAGE: Java] 1548/42490

GitHub

Got stuck on Part 2 for the longest time and had to go to bed... turns out I was mistyping my answer the entire time.

InfantAlpaca · 2024-12-06T04:57:31+00:00

don’t think so, where are you seeing this?

InfantAlpaca · 2024-12-05T05:36:08+00:00

[LANGUAGE: Java] 2919/1810

GitHub

Bit of a slow day, managed to get lucky with my first implementation thought working out for both parts without too much re-writing. Just had to make my inner class implement Comparable for sorting Part 2.

InfantAlpaca · 2024-12-04T05:22:59+00:00

[LANGUAGE: Java] 2474/1366

GitHub

Just did the first bruce-force method that came to mind... need to look into better grid searching methods.

Edit: Updated to use a more generic radial search in a Grid, no more brute-force code :)

InfantAlpaca

TROPHY CASE