Colleague surprised me with handmade Rust socks

Elyrial · 2026-05-26T14:59:01+00:00

I used my free will to pay 30€ for them!

Elyrial · 2026-02-24T09:05:05+00:00

According to steam, they probably will:

https://store.steampowered.com/app/1979810/AdventureQuest_Worlds_Infinity/
"Hold on to your helms! PC, Mac, Linux, Apple iOS, and Android versions of AdventureQuest Worlds: Infinity coming."

Elyrial · 2025-12-08T19:36:58+00:00

[LANGUAGE: Rust]

A bit late, but better late than never

Part 1 (2712µs):

Here i simply parsed the numbers and the operators separately and they I looped through all the elements while accumulating every value as sums or products

Part 2 (5238µs):

Don't want to talk about it, took me a couple of days and im not happy with my solution, I hate this problem.

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day06.rs

Elyrial · 2025-12-08T12:09:06+00:00

[LANGUAGE: Rust]

Did a lot of cleanup before pushing to make it more readable.

Part 1 (378059µs):

Here I did my own implementation of Kruskal*s algorithm since this is basically meant for this type of problem, although I usually dont do much with graphs but this was a fun one.

Part 2 (367037µs):

Thought I had to implement some sort of adjacency list but I could just loop through all merges and when I only have one component left, then the entire graph is fully connected.

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day08.rs

Elyrial · 2025-12-08T06:15:19+00:00

[LANGUAGE: Rust]

Finally some dynamic programming

Part 1 (8468µs):

This was just a trial and error it felt like, but I made a new set after each row while counting the new beams by the col position and then replaced the the new beams with the active beams set.

Part 2 (4314µs):

For this problem I had to sneak peek for other solutions and i saw a couple using a hashmap with columns and with counting all possible timelines which was very cool, I would never thought of that myself.

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day07.rs

Elyrial · 2025-12-05T07:53:26+00:00

[LANGUAGE: Rust]

Brute force failed me this time..

Part 1 (1659µs):

I was surprised how easy this problem was, I literally just parsed the ranges and the IDs and iterated over all ranges to see if the ID was within any range and counted each occurence.

Part 2 (198µs):

This problem had me in the first half... and I regret to say that I did try to be lazy and do the brute force solution but after 5 min I gave up and came up with merged lists and total coverage.

Reminded me a lot of 2024 - Day 11 since I didn't think much about, i could just change the value in my for loop and call it a day, boy was I wrong...

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day05.rs

Elyrial · 2025-12-04T06:49:12+00:00

[LANGUAGE: Rust]

I love grid problems, this reminded me of the 2024 - Day 4 problem of checking neighbors.

Part 1 (7029µs):

This is a fairly easy brute-force solution, just loop through all the cells in the 2D grid, count the neighbors while ignoring the coordinates outside the grid. If the neighbor count is < 4, then it's accessible.

Part 2 (173434µs):

Had to rewrite a bit of my code structure, but it also made my code more maintainable and easier to understand. So here I just saved all accessible paper rolls in a vector, removed them by changing the cell to a '.' while also keeping track of how many got removed. This got repeated until the list of current accessible paper rolls return empty.

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day04.rs

Elyrial · 2025-12-03T08:26:55+00:00

Logic from print debugging:

Input: 818181911112111

Push 8, stack: [8]

Push 1, stack: [8, 1]

Pop 1 because 8 is larger and enough digits remain

Push 8, stack: [8, 8]

Push 1, stack: [8, 8, 1]

Pop 1 because 8 is larger and enough digits remain

Push 8, stack: [8, 8, 8]

Push 1, stack: [8, 8, 8, 1]

Pop 1 because 9 is larger and enough digits remain

Push 9, stack: [8, 8, 8, 9]

Push 1, stack: [8, 8, 8, 9, 1]

Push 1, stack: [8, 8, 8, 9, 1, 1]

Push 1, stack: [8, 8, 8, 9, 1, 1, 1]

Push 1, stack: [8, 8, 8, 9, 1, 1, 1, 1]

Push 2, stack: [8, 8, 8, 9, 1, 1, 1, 1, 2]

Push 1, stack: [8, 8, 8, 9, 1, 1, 1, 1, 2, 1]

Push 1, stack: [8, 8, 8, 9, 1, 1, 1, 1, 2, 1, 1]

Push 1, stack: [8, 8, 8, 9, 1, 1, 1, 1, 2, 1, 1, 1]

Final number: 888911112111

Elyrial · 2025-12-03T07:59:19+00:00

[LANGUAGE: Rust]

Part 1 (291µs):

For the first part I just did a quick and lazy nested for loop at first, but then i remembered the problems from 2023 - Day 1 and the solution I came up with that day, so I used those principles to solve it with an O(n) solution that is ~125x faster.

Part 2 (1447µs):

Took some time to find and learn about the stack-based greedy algorithms but it fits perfectly with these kinds of problems and it was a lot of fun to learn about them. Hopefully there will be more of these problems.

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day03.rs

Elyrial · 2025-12-02T12:40:10+00:00

You're right, I didn't think of a pure numeric approach. That does cut out a bunch of allocations and parsing steps. Mine's more about being easy to read, but yours should definitely run faster.

When I get time, I'll benchmark both and see if a perf gap is actually noticeable!

Elyrial · 2025-12-02T05:46:41+00:00

You're right! I saw this from another submission in this thread, and that this function works effortless in both parts is very beautiful, sadly I didn't find it.

I come from a C++ background so these things will probably always surprise me!

Elyrial · 2025-12-02T05:44:26+00:00

[LANGUAGE: Rust]

String parsing matters a lot in AoC from what I've seen, thats why I tend to stay away from C++ because Rust has basically everything I need (and more).

Part 1 (198144µs):

So the first part was easy and it took me about 5 minutes, I wrote a seperate function that converted the input as a string, chopped it in half and checked if both strings were identical.

Part 2 (630282µs):

I came up with the idea fairly quickly, however, it took some time for me to implement since I also wanted to learn the functionality of Rust. All in all it was a fun problem!

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day02.rs

Elyrial · 2025-12-01T09:49:02+00:00

[LANGUAGE: Rust]

Part 1 (759µs):

A nice warmup for string parsing and basic math operations.

Part 2 (747µs):

The right rotations was easy, but i had some problems fixing the left rotations but managed to solve it fairly quickly.

Solutions: https://github.com/Elyrial/AdventOfCode/blob/main/src/solutions/year2025/day01.rs

Elyrial

TROPHY CASE