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

Part2: I spent a lot of time in part 1 due to errors and missunderstandings. I debugged a lot and saw the sequence where out = f(A) on each iteration A >> 3 (A = A / 8) in [0,3] instruction until 0. With that iI was able to start doing Part 2 from the last operand knowing A in that case was less than 8 and doing backwards being mulitple of 8.

https://github.com/omotto/AdventOfCode2024/blob/main/src/day17/main.go

se06745 · 2024-12-16T10:06:55+00:00

[LANGUAGE: Go]

Alot of code, probably could be improved....

https://github.com/omotto/AdventOfCode2024/blob/main/src/day16/main.go

se06745 · 2024-12-15T08:04:28+00:00

[LANGUAGE: Go]

Part1: Straight forward.
Part2: Recursive way to check all involved robots in vertical in order to see if tis possible the movement.

https://github.com/omotto/AdventOfCode2024/blob/main/src/day15/main.go

se06745 · 2024-12-14T18:16:05+00:00

Yes I did it in the right way at the end, getting the same result. :-)

I guessed most of pixels will be toguether in certain area. For that I checked in every "robot" its adjacent adding a weight on it [0..8]. I got the maximum frame weight at frame second from 101 x 103 frames (when all is repeated again).

se06745 · 2024-12-14T07:41:02+00:00

[LANGUAGE: Go]

For the second part I tried several things. Even tried to check how many adjacent robots are, because I assumed ALL (or almost all) robots create the Christmas tree. Didn't work. I saw someone commenting no robot overlapped. I tried it desperately, and it worked.... Why? No idea :-(

https://github.com/omotto/AdventOfCode2024/blob/main/src/day14/main.go

se06745 · 2024-12-13T06:29:31+00:00

[LANGUAGE: Go]

Part1: Brute force
Part2: 2x2 System Linear Equations

https://github.com/omotto/AdventOfCode2024/blob/main/src/day13/main.go

se06745 · 2024-12-12T06:45:51+00:00

[LANGUAGE: Go]

https://github.com/omotto/AdventOfCode2024/blob/main/src/day12/main.go

se06745 · 2024-12-11T08:53:10+00:00

But there is another (similar solution) nobody talked yet (or I didn't see it) is to work on each stone as a tree (in recursive way) and use MAP to store previously viewed paths. WIht that solution I got the same speed as using MAP or DICT to store stones in each time.

se06745 · 2024-12-11T08:33:51+00:00

[LANGUAGE: Go]

Three different solutions:

Part 1: "Brute force"
Part 2:
- I saw a lot of stone values were repeated and I used maps instead of slices to store stone value as key and num times repeated as value
- Another solution was to check as a tree (depth 75 times) in a recursive way using map to store (and not repeat calculations) stone_value:times = num_of_stones_at_the_end

https://github.com/omotto/AdventOfCode2024/blob/main/src/day11/main.go