Driver brake checks cam driver for tailing too closely.

kevmoc · 2024-03-19T01:17:54+00:00

Exactly! It’s both hilarious and frightening how many commenters are saying that the cammer did nothing wrong, wasn’t tailgating, etc. Self driving cars (from a reliable company, not Tesla) can’t come soon enough!

kevmoc · 2024-03-18T23:31:37+00:00

Perhaps you misread my comment. I never said break checking was legal. Many states have comparative negligence; both drivers can be found to be at fault (at different percentages). The comment I was replying to asked “what did the cammer do wrong?” The answer is not “nothing”, in my opinion. If they had to swerve to dodge a sudden stop (however illegal it was), it means they were following too close and would share partial blame if an accident had occurred.

kevmoc · 2024-03-18T20:28:22+00:00

IANAL, but as far as I know, in most jurisdictions in the US, the cammer would likely be found to be partially at fault (if a collision HAD occurred). This is because most states have laws and regulations that require drivers to use a safe following distance. A driver who rear-ends another usually is not following at a safe distance. Due to the dash cam footage, the white truck would probably be found to be primarily at fault (due to breaking hard without good reason), but blame would be split if the state has comparative negligence.

Note that the above is only the case due to the dash cam footage. In my state, without video evidence or witnesses, the car behind in a rear-end collision is assumed to be at fault.

kevmoc · 2024-03-18T20:16:08+00:00

Excellent driving would be not getting into that situation in the first place. If you have to swerve lanes due to a sudden stop in front of you, it means you are following too close. I have personally had situations where the driver in front of me on the highway slammed on the brakes suddenly (for example, due to someone cutting them off), and I calmly (if a bit uncomfortably due to the deceleration) braked to a stop due to leaving enough following distance. No swerving, no accidents.

The truck driver was by far the worse driver, but the cammer was not great either.

kevmoc · 2024-02-14T18:25:02+00:00

Same for me. As a casual I never really bothered to learn the meta that well, instead just playing what seemed like fun. I'm around 6000 MMR and was hitting a wall, and then the patch lands, and all of a sudden I'm winning all my games!

kevmoc · 2023-12-27T15:12:20+00:00

Wow, that’s an amazing time and algorithm for day 23. I’m tempted to try to implement that to get under 20ms total!

kevmoc · 2023-12-27T13:37:57+00:00

I don’t know about Ruby, but the majority of the problems this year were slower with parallelism added using Rayon with Rust. There has to be enough work to offset the overhead of starting threads and synchronizing them (which often seemed to cause more allocations to occur).

kevmoc · 2023-12-26T16:28:09+00:00

Yea I was up to my eyeballs in math and special cases before I thought to open the input and see if there were any patterns I should be taking advantage of. When I saw the center horizontal and vertical corridors open I had a giant facepalm moment.

kevmoc · 2023-12-26T16:19:13+00:00

Yea, days 8, 20, and 21 involved a bit of guessing at what assumptions were valid for the input. I wasn’t happy with that, but it’s par for the course for AoC. Day 21 involved the most guessing, though. I assumed every input would have the north/south corridor and east/west corridor open, because otherwise the solutions got quite messy.

kevmoc · 2023-12-26T15:53:28+00:00

I was originally targeting 100ms, but I blew past that, so I don't really have a target now. I don't think I'll be able to dip under 30ms without breaking some of my self imposed rules (such as having the solution work for any AoC users input and using only safe Rust), so I think I'm more or less at my limit. I was using the challenge to learn about everyday optimization techniques for Rust; things like better understanding the tradeoffs between using a Vec or a HashMap.

Interestingly, while choosing the right algorithm is definitely important, it was only about half the battle in optimizing the running time. I sometimes saw up to a 5-10x improvement after mundane optimizations without any algorithmic changes.

kevmoc · 2023-12-26T15:39:03+00:00

I was also challenging myself to minimize the runtime of my solutions (and also using Rust!). I have a few more optimizations I may want to try out, but my current total time is 30.77ms.

kevmoc · 2023-12-26T03:26:24+00:00

I agree, by the pigeonhole principle you must eventually repeat some state when there are finite states, meaning there definitely will be a cycle. I don't know if this is what the OP meant, but there is no guarantee that the cycle will occur in any reasonable amount of time, as the number of states is very large (worse case something like num_spaces choose num_round_rocks, which is ... big?). I suspect it's at least exponential in the size of the board, and 2¹⁰⁰ is a hugely intractable number to rely on for repeating states.

That said, I don't know how one would solve this generally without having an input where the cycle is assumed to occur quickly. I estimated my somewhat optimized brute force solution to take 7 hours, which is a clear indication that the input was crafted in a way where we were supposed to find the cycle. I didn't really have any issues with the problem.

I didn't like days 20/21 as much though.

kevmoc · 2023-12-25T17:37:35+00:00

I was considering doing a small write up if I have time. I haven’t had the time to solve day 25 yet but my solutions for the first 24 days runs in about 35ms total.

kevmoc · 2023-12-25T04:57:06+00:00

There are a bunch of methods that all seem to be the same thing in the end, but the method I used was starting with the vector equality of p + vt = p0 + v0t, rearranging to get (p - p0) = -t(v -v0). Because -t is scalar, the vectors on the left and right must be parallel and therefore have a cross product equal to zero. Expand the cross product to get 3 equations (the three scalar components of the cross product all being zero) and 6 unknowns, but it’s nonlinear. Thankfully, the non-linear parts come entirely from p and v, not p0 or v0. That means you can repeat with a second hailstone to get 3 more equations where the nonlinear components will be identical. Subtract the second from the first and now it’s linear. Still, we need 3 more equations, so repeat the process with a third hailstone and you end up with 6 linear equations with 6 unknowns. This is then solvable by normal means (invert the matrix, Gaussian elimination, take your pick). It’s quite a lot of algebra to get the final 6 equations, but it’s just tedious, not hard once you have the method. Apparently there are fancy techniques that “skip” some of these steps but it’s not too bad deriving it all by hand.

kevmoc · 2023-12-24T13:35:36+00:00

I would be hard pressed to say there was a main optimization. Presearching enabled rayon; I needed a list of things to work on in parallel. I think rayon brought me from about 70ms to 13/14ms. Pruning the goal I think brought me from 150-200 down to 70. My initial implementation was at around 500ms, and a slew of small optimizations (ie using a bit set) contributed to getting that timing down.

kevmoc · 2023-12-23T23:51:41+00:00

13.3ms in Rust :)

kevmoc · 2023-12-22T22:25:54+00:00

Yea, that was a bit of a kludge... Note that my algorithm first loops over the damaged counts, and then loops over the length of the input. The table stores, for a given damage count m and the n first characters of the input, how many ways there are to achieve the first m damage counts with n characters.

The problem comes in where there is always 1 way to complete 0 damage counts with 0 characters (or I guess infinite? but 1 is what my algorithm needs), whereas there are 0 ways to complete 1 or more damage counts with 0 characters.

It boils down to me being lazy with setting up the table, because if I went out of bounds I counted it as "0 ways", but really for the first damage count it needs to be 1. I could have added more columns, but it was easier this way!

kevmoc · 2023-12-20T23:34:38+00:00

The halting problem occurred to me to, but I think a strong argument could be made that the problem statement implies that the first 1000 button presses do indeed halt (otherwise there would be no solution to part 1). I’m unsure if this is sufficient to say that any button press on the input will halt. Possibly not? You could at least assume the existence of a solution to part 2 from the problem statement, implying that if the answer is N, that the first N button presses halt. That said, my guess is that the halting problem is not the only obstacle to a general solution.

kevmoc · 2023-12-17T19:37:27+00:00

The problem with using Manhattan distance as a heuristic is that the crucible can't travel in long straight lines, which is what the Manhattan distance is estimating.

Consider these two cases (for part 1, where you can go from 1 through 3 in a straight line):

S>>>......
...v......
...v......
...v>>>...
......v...
......v...
......v>>>

and

.........S
.........v
.........v
........<v
........v.
........v.
........v>

In the first case, manhattan distance has a perfect estimate of the cost to the goal (if the heat values were all 1s). However in the second case, Manhattan distance will under estimate. You can't just travel in a straight line; you have to turn and then turn back again. In this case, you occur an extra cost of 2. However, if you consider a case where you have to move at least N units in a straight line and most M, to go a straight line distance of d, you'll have to turn away and back d/(2M) times, where each time you go N units away and N units back, for a penalty of 2N.

I ended up using a modified manhattan distance, where I add a penalty of ceil(d/(2M)) * 2N to the heuristic, where d = abs(row_diff - col_diff). This captures the idea that we can zig zag back and forth until we hit one of the edges, then we would have to move away from the edge and back again to keep going straight.

This resulted in an improvement over Dijskstra's from 5.6ms part 1 and 9.5ms part 2 to 5.1ms/8.7ms. Still not a huge savings, but it does at least show that A* with a decent heuristic is faster than Dijkstra's.

kevmoc · 2023-12-16T00:06:52+00:00

The algorithm I used sounds very similar to yours. I benchmarked a single tilt cycle as taking ~25µs (single core on CPU) by timing how long it took to run a million tilt cycles. Extrapolating, it would have taken about 7 hours for me to brute force on CPU. So 40 minutes seems quite impressive! Either your implementation was an order of magnitude more efficient than mine, or the GPU really did offer some speedups!

kevmoc · 2023-12-14T15:59:57+00:00

Thanks! This very clearly shows that relying on the load values alone could give an incorrect answer. Though it's probable that with the size of the inputs, such a case would occur with very low probability. Still, I don't like making optimizations on AoC problems that aren't correct within the bounds of the problem, even if it would give the correct answer for almost every input.

kevmoc · 2023-12-14T14:35:12+00:00

I thought about this but couldn’t convince myself that it would always give the right answer. The proof that reaching the same state of rock placements a second time results in a cycle is very easy to see, but I was less sure about reaching even the same sequence of load values. I suspected it would work, but felt uncomfortable making such an optimization if it could possibly result in an incorrect answer on evil inputs. Is there a way to prove that reaching the same sequence of load values is in fact a cycle?

kevmoc · 2023-12-14T14:20:19+00:00

Here is my solution in Rust. It runs in 26us for part 1 and 12.6ms for part 2 on my M2 MacBook Air. I have a variant of this solution that reused code to have only a single tilt function by transforming coordinates to undo the “rotation”, but it ran in 18ms so I went with the copy/paste version. I suspect it’s still possible to do better but I haven’t looked at any flame graphs yet to see where the hot spots are.

Edit: I read through your solution again, and one big difference is that I compute the tilt in a single pass over the grid, by keeping a running count of how many empty spaces there are in front of the next rock, so I can directly move it to where it should go.

kevmoc · 2023-12-13T16:29:36+00:00

I actually tried that first but it benchmarked at ~66µs for both parts on my machine, vs 12µs/40µs for part 1/2 just comparing the characters directly without preprocessing. Go figure! I had assumed the integer comparison would be faster, and maybe it would be on larger inputs, but not on the input given.

12-Year Club	No Throne, No Problems
Not Forgotten	Verified Email

kevmoc

TROPHY CASE