Tootfinder

This took just a smidge longer than the Rust solve, but still not too horrible coming in at around 1.5 to 2 seconds. Getting all of the potential coordinate combinations along with their distances sorted made everything so much easier.
Solution: https://git.jamesthebard.net/jwe…

For the last day of #AdventOfCode, I took a very simple and naive approach of: depth-first search.
Basically try all combinations until one fits. The trick to avoid a VERY long runtime is to filter out all cases where we already know from the start that the pieces (gifts) won't fit in the region, because their summed area exceeds the area of the region. Went for recursion this time around, because why not.
#AoC #AoC205 #AdventOfCode2025 #RustLang #rust

I was worried that this would be pathfinding. Thankfully it was not pathfinding. Was definitely a fun problem, and I used more than a couple of comprehensions to get this done.
Solution: https://git.jamesthebard.net/jweatherly/advent-of-code/src/branch/main/2…

Day 11 of #AdventOfCode is a classical graph problem like we're used to from previous years.
Unlike previously, I immediately thought of checking what the graph looked like with a visualization tool. Luckily, `petgraph` allows to export a graphviz file which can be then used to visualize the nodes and edges.
From that, it was clear that a few nodes were acting as "bridges" between largers subnets of nodes with no particular arrangement besides being directed towards the next "bridge" layer. Those bridge layers comprised 4 to 5 nodes in my input, and were the only ones with more than 6 incoming edges, so I used that as my filter criterion.
To gather them, I sorted the graph in topological order and chunked them by their position offset compared to the previous node. When doing this, all the nodes from a bridge layer end up being at most 20 positions away from the previous node in the sorted list.
Finally, I progressed through each subnet, collecting information about how many paths lead to each one of the end layer's nodes. By multiplying with all the paths leading to each start layer's node, we get the overall total number of paths.
#AoC #AoC2025 #AdventOfCode2025 #RustLang #rust

This one was disturbingly easy for Part 1, then got more fun on Part 2. The name of the game is rotations, and rotating the input was the key to getting it done without too much bother.
Solution: https://git.jamesthebard.net/jweatherly/advent-of-co…

Aaaaa why doesn’t a game this good have a happy ending ;-;
I’m a romantic lil girl I like happy endings

Changed the code structure slightly from the Python solve, added the `itertools` package because I wanted `product`. Works perfectly and I'd argue slightly more readable than the Python version. Overall pretty satisfied with the solution.
Solution: https://git.jamesthebard…

Ooooo, I knew that my initial solution for Part 1 was going to get absolutely discarded for Part 2 (which inevitably came true). Lots of string sorting, grabbing an index, and a moving window to find the largest value.
Pretty proud of the solve, it's fast and it's all that janky.
Solution: https://<…

The #nim solution looks very similar to the Python one, but that works out well enough as the method works great on both. Didn't check to see if Nim had a `for/else` construction, but a friend threatened me with death if I tried.
Solution:

I'm so glad I'm writing the solutions in both #nim and Python because I tend to find ways to improve the Python solution with the Nim one and vice versa. Today was one of those days. The biggest thing I learned though is that solving these damned puzzles exhausted will never lead to good things quality-wise.
Solution:

Once I pulled my head out of my ass this wasn't horrible. Part 1 was straightforward, decided to do some set stuff and managed to get it right the first time. Part 2 made my brain hurt a bit because all of the ideas that came to me were very, very slow and memory intensive. Then decided to scrap it and just do what the directions told me to do: count the paths...so I replaced the dumb with a dictionary which was so much better as an idea.
Solution:

Figured I'd give `nim` some love this #aoc along with Python. I'm rusty as hell, but I think the initial take looks pretty great. Easy enough to compile/run and fairly readable.
Solution for day 1: http…

This one was fun, probably should've waited until tomorrow to start on it. However, think it turned out pretty well. Got some slicing, lots of strings, and as always: modulo comparisons.
My solve: https://git.jamesthebard.net/jweatherly/advent-of-code/src…

Yes! Today's puzzle in #AdventOfCode was quite hard (especially part 2) but so rewarding and I learned a lot!
For part 1, I implemented A* from scratch, my favorite little pathfinding algo that I use pretty much every year for #AoC (sometimes I use a lib instead of implementing it but it's been a while so a refresher was in order).
For part 2, after trying A* again and noticing it was running for way too long, I went back to the drawing board and solved the first machine by hand. I noticed the constraints were a system of linear equations.
I then researched algorithms to solve such integer programming problems and didn't feel like learning AND implementing the algorithms in one day (ain't nobody got time fo that). But this lead me to discover the `good_lp` #rust crate which is really good and that I will keep in my back pocket from now on!
So I used the library to define a system of variables and constraints which could be solved magically for me.
#AoC2025 #AdventOfCode2025 #RustLang

This one took a smidge more thought as I can't abuse `zip` to rotate 2D sequences. However, just rewrote the rotation as a proc and used that. Instead of `reduce`, it was all `foldl`, and I fought with `char` vs `string` due to some of the processing operations between the normal and cephalopod problem processing.
Overall, definitely a fun solve.
Solution:

This took waaaay too long because I kept overlooking a glaring mistake at the range reduction algorithm, but once I saw it things went much more smoothly.
The #nim solution actually optimizes the range reduction step and comes in under a millisecond to execute which was nice.
Solution:

I stayed up far too long tonight for this one, but it was fun. Saw that we were dealing with an absolute metric ton of ranges at the very beginning so my initial thought was to reduce/merge those ranges and that's what I spent most of my time on before even tackling part 1.
It paid off tremendously and made solving everything very, very easy. There's still the Nim version to write, but I'll handle that after I get some sleep.
Solution:

A nice bump in difficulty for today's #AdventOfCode problem!
Although the first part came to me very easily, I spent way too much time trying to implement a flooding algorithm for part 2, only to find out that it would take too much time and there should be a better way.
The worst part is that I had the intuition for my final solution super early on, but couldn't materialize it in a simple way until tonight.
I also must admit I realized quite late that the points were sorted in the input :D I should RTFM better sometimes.
My final #rust solution runs very quickly and is reasonably clean.
#AoC #AoC2025 #AdventOfCode2025 #RustLang

This solve felt more like #nim and less like me writing Python. More uses of `map` and `apply`, using `if/then` as a proper ternary, integer -> string conversions, etc. Also the `sugar` module makes me a happy person.
The day 2 solution in Nim:

Oh, why’re elevators illegal?

A cool graph problem today in #AdventOfCode
Nothing special here, I leveraged the `petgraph` #rust crate which I love! Calculating all pairs' distances (squared) and joining the pairs that are closest with an edge.
Only thing I wish I had more time to implement would be the graph traversal algo during sub-net aggregation, but swamped with work at the moment.
#AoC #AoC2025 #AdventOfCode2025 #RustLang

Today's puzzle in #AdventOfCode was another grid puzzle, where I again represented the entities as a sparse set.
Part 1 was relatively straightforward, a simplified BFS-like process allowed to construct the beams going through the system.
For part 2, additionally to gathering where a beam was present, I added metadata about how many paths were going through each position, adding them up and splitting them as required. Summing the paths for the last row gave the required result.
#AoC #AoC2025 #AdventOfCode2025 #RustLang #rust

Today's #AdventOfCode problem was more about parsing than about complex logic, but it was fun!
I opted to keep the parsing with winnow simple and do most of it by hand from the raw characters, to exercise my #rust iterators a bit.
#AoC #AoC2025 #AdventOfCode2025 #RustLang

Another easy challenge in today's #AdventOfCode puzzle.
Part 1 is straightforward, and for part 2, the trick was to sort the list of ID ranges first, which made the merging pretty easy.
#AoC #AoC2025 #AdventOfCode2025 #rust #RustLang

Didn't feel like thinking too much for today's problem of #AdventOfCode, so my solution is quite naive and runs in a few tens of milliseconds for part 2 (thanks, #RustLang!).
I went for a HashSet for the grid just because it made looking up neighbours simpler at the edges, probably also not the most performant solution, but gets better as the grid becomes sparser.
#AoC #AoC2025 #AdventOfCode2025 #rust

Super happy with my solution for today's #AdventOfCode problem!
It initially took me a little bit of time to find a suitable strategy, but it all clicked when I noticed that the left-most selected digit had the most significance in the final value. Thus, I maximized the value of that left-most digit, leaving enough digits on the right side to be able to pick the required total number of batteries in the bank.
The solution is relatively short and sweet:
#AdventOfCode2025 #AoC #AoC2025 #RustLang #rust

Today's #AdventOfCode problem was fun! I kept a different implementation for part 1 vs part 2 as they both run relatively fast.
For part 1, I iterated over all IDs (the ranges are quite small) and split them in half mathematically (no string representation) to compare both halves.
For part 2, I instead generated all interestings IDs (mathematically again) up to a length of 10 digits (the max in my input) and checked if any of the ranges contained them.
#AoC #AoC2025 #AdventOfCode2025 #RustLang #rust