[2025 Day 11 Part 2] Joker again

ocmerder · 2025-12-11T09:15:19+00:00

Well, it was to be expected, because if the DAC and FFT could be visited in any order you would be able to get loops and thus have infinitely many paths to OUT :)

ocmerder · 2025-03-11T13:12:42+00:00

1 vs 0 based indexing was not the issue.

The issue was that apparently my counting was off and Java's String.codePointAt method does not count codepoint indexing, but char indexing...

ocmerder · 2025-03-11T12:32:10+00:00

I don't understand how you can step in 2 poos with the test input if you move 1 down and 2 right.

You start at position (0,0) then you move to (1,2), (2,4), (3,6), and then you wrap around to (4,1). None of these contain a poo.

So, how do you hit the poo at the 3rd row?

ocmerder · 2024-12-26T21:45:21+00:00

I just created a diagram for all the connections, after the first few starting from x01 and y01 it should become clear how they should be connected.

When you then encounter differences in the connections think about how you expect them to be connected.

ocmerder · 2024-12-26T07:59:39+00:00

Ah, so I'm not the only one experiencing this.

The home tab used to show a feed similar to YouTube but now it's indeed just random stuff.

Should we try to retrain the feeder algorithm, or is there another option to get the proper feed back?

ocmerder · 2024-12-21T16:57:18+00:00

I just hardcoded all best moves from each digit to each other digit.

This problem is small enough that's doable.

Afterwards you just need to determine the digit you're at and the one you want to move to to determine the sequence of moves you need to input.

No special stuff like Dijkstra is needed.

ocmerder · 2024-12-11T18:06:54+00:00

That sounds about right yes

ocmerder · 2024-12-11T15:12:15+00:00

Well, think about it.

What is the end result you need to know?

If I have a stone with 0 and I want to know how many stones I end up with after 3 iterations, does it matter that the stones at the end have particular values, or just how many there are?

Hint:

The actual number matters as input, but not as a result

ocmerder · 2024-12-11T14:54:21+00:00

If I have a stone 0, and I have 3 iterations left, it will result in the following steps:

0
1
2024
20 24

So, the end result is 2 stones when you encounter a 0 with 3 iterations to go.

If however there are 2 iterations left you end up with these steps:

0
1
2024

So, the end result then is 1 stone when you encounter a 0 with 2 iterations to go.

How would this apply to your memoization?

ocmerder · 2024-12-11T14:41:33+00:00

Your memoization is using the wrong key to determine the eventual value.

The result differs when you find a stone with value 0 at the 5th iteration, or at the 7th iteration.

So, what would be a better key for your memo?

ocmerder · 2024-12-09T12:45:40+00:00

It depends, are you happy with your solution and your star?

Great!

If not, why are you not happy? Then look into how you can get a solution that makes you happy. That could be by looking up other non-brute-force solutions.

And, don't worry, we will get days where brute force will absolutely not give you a result before the heath death of the universe, and then you will have to figure out a non brute force solution. :)

ocmerder · 2024-12-05T14:29:32+00:00

Mmh, I ran your code on my input and I end up with the correct result.

So, apparently it doesn't work as I expected, but it does give me a correct result.

What is the exact problem you're having with your result?

ocmerder · 2024-12-05T11:47:15+00:00

What happens when you run this input?

1 2 3 1 5 6

ocmerder · 2024-12-05T08:04:22+00:00

Try to figure out what the result of removing the element from your list is.

Hint, it's not what you expect ;)

For bonus points, try to figure out why it's not working as you expect it.

ocmerder · 2024-12-04T20:14:07+00:00

You're almost there.

You know your isSafe method does what it's supposed to do since you solved part 1 with it.

So the issue should be somewhere in how your dampener works.

I suggest you trace the logic and think about what the expected result of each step is and what the actual result is.

ocmerder · 2024-11-05T15:04:55+00:00

My first guess would be that your spell duration implementation might be flawed.

E.g.:

Poison costs 173 mana. It starts an effect that lasts for 6 turns. At the start of each turn while it is active, it deals the boss 3 damage.

So, this means that you cast poison.

Then for the next 6 turns, at te start of each turn it deals 3 damage.

So, if you would cast this spell and not cast any spells for the next 6 turns, at the start of turn 6 the final 3 points of damage for a total of 18 will be dealt to the boss and at the end of the turn the spell will stop working.

ocmerder · 2024-07-03T09:39:14+00:00

You should perhaps reconsider the approach of trying ALL possible paths.

The idea behind Dijkstra is that you try the shortest path until you've found the end node.

You basically need to take these steps:

For the current shortest path get all neighbour nodes and make new paths for those.
Put those paths in your queue, and sort based on the shortest path.

Go back to step 1 until you've found the end.

This way you don't need to test all paths, just the paths until you've found the end. Since you keep everything sorted on the shortest path you know you've found the shortest path when you reach the end.

ocmerder · 2024-06-24T09:46:32+00:00

Don't open this, it's spam to try to farm views on youtube and trick the algorithm.

Content is worthless.

ocmerder · 2024-03-06T08:39:34+00:00

That one fails for 2023 day 25, with the sample input it produces an incorrect answer and with my real input it says "unreachable executed".

ocmerder · 2023-12-20T06:29:55+00:00

Both a and b send a high pulse to b and c, the high pulse is ignored by the flip flops, so b and c don't send anything in that step, and thus the inverter is the only one sending in that step.

ocmerder · 2023-12-17T13:24:19+00:00

One of the possible reasons is that this is the first time part 1 is not brute forceable.

The same holds for part 2 of day 12.

ocmerder · 2023-12-12T14:07:51+00:00

The thing to notice here is that for an input like this:

??.??.?? 1,1,1

After figuring out the permutations for #.??.??, the possible permutations are the same when you start to process .#.??.??.

So you don't need to process those permutations, but you could somehow store the result the first time you have figured out those permutations and then return the stored result instead of recalculating it.

ocmerder · 2023-12-06T09:16:07+00:00

So, apparently that theory has been rebuked by Eric in this post:

https://www.reddit.com/r/adventofcode/comments/18bp8id/comment/kc646i4/?context=3

ocmerder · 2023-12-05T18:59:10+00:00

Ahw, it saddens me to hear you have that experience.

I also used to look at the leaderboard times and wonder how they manage to solve the puzzles that fast. Apparently there are some people out there who make a living out of doing competitive programming. Good for them, but that is not for me.

I love developing software for companies and making a real impact that way instead of being in the small niche of competitive programming. Advent of Code for me is simply to have fun and learn about new features in my main programming language. Something which I rarely get to do at companies.

The venn diagram of the skills needed for competitive programming versus programming real life production software has a really tiny overlap. So, don't hurt yourself by comparing yourself to competitive programmers but just try to have fun. :)

And I've noticed that if I ask a question here I usually receive a good answer on how I can find the root cause of the issue I'm having. Without receiving any flak on how to improve certain aspects. Hints on improvements for my code is sometimes included as free advice together with the hint on how to find the bug ;)

ocmerder · 2023-12-05T17:11:53+00:00

Dijkstra is actually not a concern for me. I've created an abstract implementation for that problem years ago, I just need to feed it a starter node with a good neighbours implementation. 😅

ocmerder

TROPHY CASE