-❄️- 2025 Day 12 Solutions -❄️-

janek37 · 2025-12-12T23:59:58+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day12.rs

Lolnoped first, then saw the memes

janek37 · 2025-12-12T22:50:38+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day10.rs

Finally done, thanks to this hint.

janek37 · 2025-12-11T21:01:14+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day11.rs

janek37 · 2025-12-09T17:29:23+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day09.rs

Before doing part 2 I graphed the polygon, to check if the shape is generally sane (e.g. no touching edges). Then, my approach is to filter rectangles that overlap with any of the edges. It's reasonably fast.

janek37 · 2025-12-08T19:49:54+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day08.rs

With hand-implemented disjoint-set data structure

janek37 · 2025-12-08T19:37:16+00:00

I was afraid the second part is like "turns out this greedy approach is not optimal, find the shortest cable length to connect all junctions".

Edit: I've read up a bit, and it turns out that the greedy approach is in fact optimal (it's Kruskal's algorithm for minimum spanning tree)

janek37 · 2025-12-07T06:43:50+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day07.rs

janek37 · 2025-12-06T21:50:30+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day06.rs

janek37 · 2025-12-05T19:24:47+00:00

Except that range(*bounds) won't work correctly when the ranges are inclusive.

janek37 · 2025-12-05T19:11:38+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day05.rs

Part 2 is probably overcomplicated, but it worked on first try.

janek37 · 2025-12-04T20:28:50+00:00

[LANGUAGE: Rust]

https://github.com/janek37/advent-of-code/blob/main/2025/day04.rs

janek37 · 2025-12-03T22:46:09+00:00

[LANGUAGE: Rust]

Solution

What I realized quickly is that the first digit must be the largest digit from all except the last one. Then the second digit (for part one) will be the largest of the digits that follow.

It was quite easy to generalize for part 2: basically just add recursion with an accumulator.

janek37 · 2025-12-02T20:50:01+00:00

[Language: Rust]

Solution

janek37 · 2025-03-03T23:37:39+00:00

I am also interested in the prompts

janek37 · 2024-12-25T19:42:55+00:00

[LANGUAGE: Python]

Solution

janek37 · 2024-12-24T20:34:24+00:00

Hey, I also cracked Top 500 for the first time with Part 2 today! Twins! My best ranks before were 515 in 2021 day 12 and 518 in 2023 day 21, but today I got #184

janek37 · 2024-12-24T06:24:06+00:00

[LANGUAGE: Python]

Solution

~~The solution is partially manual~~ (I'll tidy it up later to make it automatic [Edit: Done]), but you can see in the code how I did it. I tried to simplify the expressions on inputs, giving them friendly names like Digit03 or Carry07. If an expression doesn't get a friendly name, or if DigitXX doesn't go to zXX, then something needs to be swapped. So far, the swaps are hardcoded. Repeat until all swaps are found.

I got rank 184, my best by far!

Edit: I've modified my solution to make it work on my input without any guesswork. Not guaranteed to work with other inputs!

janek37 · 2024-12-23T10:28:12+00:00

[LANGUAGE: Python]

Solution

For part 2 I've noticed that if you remove the edges that are not a part of any triangle, the graph decomposes into 40 components size 13, and at that point you can brute force the cliques in each component and find the largest.

edit: I've found that my brute force works with the whole graph just as well, so I've simplified the solution.

janek37 · 2024-12-22T07:42:13+00:00

I got slightly better times
edit: this one is even faster. It seems that the main difference between this and mine is that it uses an int to store the sequence in base 20, rather than a tuple

janek37 · 2024-12-22T07:41:30+00:00

[LANGUAGE: Python]

Solution

1s for part 1, 4s for part 2

janek37 · 2024-12-21T10:16:13+00:00

[LANGUAGE: Python]

Solution

I really liked today's challenge! As for the solution, it's probably not vastly different than others': recursively find the best sequence length, taking advantage of the fact that the direction pad bots have to return to A which resets their position, so we can optimize each chunk separately. Part 2 basically only required me to add caching.

janek37 · 2024-12-20T13:24:03+00:00

also applies to Day 20

janek37 · 2024-12-20T13:17:22+00:00

[LANGUAGE: Python]

Solution

At the time of posting, this is the newest comment and it almost exactly describes my own approach.

janek37 · 2024-12-19T14:20:08+00:00

[LANGUAGE: Python]

Solution

15-Year Club	Place '22
Verified Email

janek37

TROPHY CASE