AdventOfCode VS advent-of-code-wim

Here's an example implementation in Rust, using rayon's parallel iterators to automatically distribute the computation of a range of hashes over all available cores. It solves both parts together in around 3 seconds on my M2 MacBook Pro. Single-threaded, it takes around 25s in Rust and 35s in Python.

Here are mine: https://github.com/benediktwerner/AdventOfCode

I love doing optimizations like this but I don't really have enough time anymore to really do it. In 2020 I spent a fair amount of time writing super optimized solutions for the first 10 or so days (repo solving all those days together in 150us i.e. <1ms) but even back then, I eventually stopped since I had other things to do and it took more and more time as the days went on.

Python 3 116/125

Wow, my final solution looks almost exactly the same. Though I calculated my initial answers by hand.

That's certainly not necessary though and really not what makes most of the speed, especially for problems like today's. I don't really look at other leaderboard competitor's solutions much but at least my solutions (ranked ~20 today) are almost always completely vanilla Python (the only exception is networkx for the occasional graph problem but even that isn't really that much of a speedup if you know the common graph algorithms) and always self-contained.

Interesting approach. I guess mine could be considered a bit nicer, doing it recursively and returning the number to add to the left or right.

My priority Q/heap Dijkstra in Python runs just fine. I don't remember and can't check rn if it was instant or took a second but it definitely wasn't longer than that.

Thanks for the extra example. I've added it to my CI and test suite in https://github.com/wimglenn/advent-of-code-wim/pull/89

Full code here

I'm using Python so I'll never be as fast as the people using Rust or C, but am still able to solve most puzzles in under 1 second (repo: https://github.com/wimglenn/advent-of-code-wim).

Thanks for the kind words, well the source is here so you can just take a look. You have to run with var AOC_DEBUG=1 in env to enable the rendering.

I used an AStar pathfinder already prepared from earlier years (aoc2022/q12.py), just leaving the default null heuristic. If I understand correctly that is just a BFS.

https://github.com/wimglenn/advent-of-code-wim/blob/main/aoc_wim/ocr.py has nearly all the letters we've seen (including a larger font used once in 2018) although it is missing the 5-wide Y that was in my 2016-day 08 puzzle

By the way, I found that if you're willing to use pathlib and a guard, you actually only need 2 of those 6 case statements - it looks like this.

Python (repo). I was particularly pleased with how quick the parsing was.

Python + "AOCR" + complex numbers.

Python