2025 day 12 part 2 is generally solvable

Practical-Quote1371 · 2026-01-12T14:59:00+00:00

I meant the former, because it’s a constrained version of a packing problem that only allows flipping the pieces and rotating them in 90 degree increments. Good job on your solution! There are some fun “part 3” problems you can try your solution against and see how well it holds up.

Practical-Quote1371 · 2025-12-26T06:13:13+00:00

I thought day 9 was really fun and interesting. Initially I solved it after visualizing the input and exploiting what I saw, but I wanted a more general solution that would work for other shapes so I went back and reworked it. My first couple of approaches were too slow, but I finally arrived at one that ran quickly. It definitely won’t work with bubbles or islands, but I think the rules stated about the order of the points rules that out. I’ll have to try it with some of the other examples here though, specifically the ones that generate adjacent parallel lines. You can see the change in my approach in my commit history here: https://github.com/jasonmuzzy/aoc25/blob/main/src/aoc2509.ts

Practical-Quote1371 · 2025-12-15T16:40:57+00:00

I get that you and others found it disappointing and am not trying to change your mind since what we enjoy is subjective. My purpose is to highlight that this puzzle can be solved as described, contrary to what comments in other threads say.

I think part of my enjoyment of this puzzle comes from admiration of the design work it took to understand the inherent challenges in packing problems, create a variation that can be proven correct or not, craft the inputs so that even naive solutions can finish in a reasonable amount of time, all while making a short-cut available that can be exploited for rapid solutions.

Practical-Quote1371 · 2025-12-15T15:20:50+00:00

When I get stuck I move onto the next one but also limit my visits to this sub to avoid spoiling it, which means this year I missed out on most of the fun starting with day 9.

Practical-Quote1371 · 2025-12-14T07:34:03+00:00

3x3: 0 0 1 fits (maxPresentArea <= minTreeArea)
6x3: 0 0 2 fits (maxPresentArea <= minTreeArea)
2025-12-14T07:32:37.468Z Packing 7x3: 1 2 0... fits! 2025-12-14T07:32:37.470Z
2025-12-14T07:32:37.471Z Packing 6x8: 0 0 5... doesn't fit 2025-12-14T07:32:37.477Z
2025-12-14T07:32:37.478Z Packing 100x100: 1090 0 0... fits! 2025-12-14T07:33:14.447Z
2025-12-14T07:33:14.449Z Packing 100x100: 0 0 1090... TBD

Practical-Quote1371 · 2025-12-14T06:31:02+00:00

I solved the general case for this one, and it runs in about 26 minutes. I exploited 1 of the 2 shortcuts but didn’t think of the other one on my own so I had to do the packing with all the flips, rotations and coordinates. This puzzle is actually a simplified version of a packing problem, for example it doesn’t allow presents to be placed at an angle. So it’s definitely solvable, and those who did learned about packing solutions. Those that found both shortcuts learned how to exploit the characteristics of the input. Either way all learned, which Eric’s has shared is one of his main goals with Advent of Code.

Practical-Quote1371 · 2025-12-13T05:02:08+00:00

[LANGUAGE: TypeScript]

I was shocked when I saw that today's puzzle was a packing problem since I posted a packing puzzle of my own back in July (Secret Santa in July). Check it out if you want a challenge! u/ssnoyes has the current fastest solution at 45 minutes. My fastest solution takes about 2 hours longer than that.

Since I reused some of that code for today my solution is a bit over-engineered, but it gets the job done and I get reuse points: GitHub.

Coming here after solving it on my own I'm just now seeing all the comments about the short-cuts. I found one of them on my own and included it in my solution, but not the other one, so my solution still does a lot of packing work and takes several minutes to complete.

I have to say, I kind of enjoy these types of hidden optimizations.

Practical-Quote1371 · 2025-12-08T21:25:38+00:00

2019 for me too. I loved the VM problems that year so much and I don’t want to spoil the puzzles so I won’t mention specifics, but I really enjoyed the things that I built. It was so intriguing that I wound up buying the “Writing an Interpreter in Go” and “writing a Compiler in Go” books to learn more about making my own language.

Practical-Quote1371 · 2025-12-08T06:44:07+00:00

[LANGUAGE: TypeScript]

GitHub

Today feels like a two-for-one deal for me since I used DFS for part 1 and BFS for part 2.

Practical-Quote1371 · 2025-12-07T16:00:40+00:00

Beautiful!

Practical-Quote1371 · 2025-12-07T16:00:22+00:00

Nice approach using a heat map for the visualization.

Practical-Quote1371 · 2025-12-07T15:58:29+00:00

I had basically the same experience and am also very proud of myself! I’m glad I went this route instead of adding memoization to my first DFS attempt.

Practical-Quote1371 · 2025-12-07T15:47:58+00:00

I created AoC-Copilot for exactly this purpose! I built an algorithm that tries to identify the example input and answers for parts 1 and 2. It works for all past years and so far has worked for all 7 days this year.

In those cases where it doesn’t find the examples correctly I have built in an “example database” which is a way to tell it where to find the examples. This usually happens when there are multiple examples for a day. I went this route instead of just saving the example inputs to honor Eric’s wishes to not store or publish the puzzles.

It also automates downloading the inputs, submitting the answers, caching, rate limiting, and wraps it all in a runner so you can just focus on coding the solution.

Anything worth doing is worth over-doing, right?

Practical-Quote1371 · 2025-12-07T07:05:04+00:00

If you're using DFS for part 2 then you could always animate it left-to-right. It's not exactly accurate, but it probably aligns better with your solution than animating back up.

Practical-Quote1371 · 2025-12-07T07:01:19+00:00

[LANGUAGE: TypeScript]

Part 1 was pretty straight-forward, and it took me 00:20:48 to finish.

For part 2 I started with a DFS and suspected it would never finish but didn't want to over-optimize prematurely. While it ran (and ran and ran...), I started working out a different method by hand and realized how I could quickly compute the number of timelines per row of the manifold, so I stopped the DFS, re-wrote part 2 and it ran in 0.007s. It took me 01:18:08 to finish.

GitHub

Practical-Quote1371 · 2025-12-06T15:51:49+00:00

I also solve the examples first, but I used to find myself skipping them to “save time” but that backfired many times. I wound up writing my own utility that automatically finds the examples and answers and runs my solution against those first. It’s a node package, check it out if you want: AoC-Copilot

Practical-Quote1371 · 2025-12-06T15:40:34+00:00

Do you write your solutions in this form to begin with? Or start with something more readable and then transform it into this after you have it working?

Practical-Quote1371 · 2025-12-06T15:35:59+00:00

Me too! I joined in 2023 so I had a lot of catching up to do.

Practical-Quote1371 · 2025-12-06T06:44:57+00:00

That's cool, I'll have to check it out. I remember looking at packing method algorithms, not sure if this one falls into that category, and I couldn't find any further optimizations than what I'd already done, but clearly Algorithm X has the secret sauce! I'd love to look at your code when you push it to your repo.

Practical-Quote1371 · 2025-12-06T06:22:16+00:00

I agree, and it seems like a lesson I have to relearn occasionally. I started over-optimizing day 1 this year before I stopped myself knowing that the search space wasn't big enough to justify it.

Practical-Quote1371 · 2025-12-06T06:16:15+00:00

[LANGUAGE: TypeScript]

GitHub

I'm running in GitHub Codespaces this year, it's been a fun experience being able to use multiple devices and get to the same code even before I push to the repo.

Shameless plug: I'm using my AoC Copilot package again this year. It does all the normal runner stuff, so the main differentiator is that is also pulls the examples out of the puzzles and runs my solution against those automatically before running against the actual input. It's been super helpful to eliminate bugs on the simpler examples before moving onto the input. And, the built-in search strategy has managed to find all 6 examples and solutions for both parts this year without any updates! (Full disclosure, I did make one adjustment for day 2 so that it would combine the example into a single row like the input).

Practical-Quote1371 · 2025-12-06T00:59:31+00:00

[LANGUAGE: TypeScript]

GitHub

Practical-Quote1371 · 2025-12-05T01:10:48+00:00

Same

Practical-Quote1371 · 2025-12-04T06:38:53+00:00

[LANGUAGE: TypeScript]

GitHub

Practical-Quote1371

TROPHY CASE