2024 Day 25: Code Chronicle & puzzle difficulty ranking

Advent of Code
1

Srsly? Umadbro? &c.

Most years, day 25 involves at least a mild challenge. Last year, day 25 was insane. This year, it’s the easiest puzzle I can remember of all the AoC’s I’ve done.

In lieu of that, what do people think about rating the puzzles by difficulty? I’ll suggest two listings: one “objective” and one definitely subjective.

An “objective” approach

The website gives a leaderboard for each day, listing the first 100 competitors to solve both puzzles, along with the time used. Links are to the relevant leaderboard.

Caveat: A lot of “the pros” are solving problems in a mere handful of seconds. I can’t even read the puzzle’s first few words that quickly! Anyone know what’s going on there? Massively parallel AI brute-forcing using pre-made programs, with a touch of LLM, perhaps?

:star_struck: Quick 'n easy puzzles

Anything that takes roughly 10 minutes or less for “the pros” to solve both puzzles. I’m not listing these.

:thinking: Puzzles needing a little more thought

Anything that takes a “significant” number of “the pros” 10-15 minutes.

:fearful: Problems requiring a lot of thought, or trickier ideas

Anything that takes a “significant” number of “the pros” 30-45 minutes. Weirdly, I placed both of these in a lower category, which makes me think these were a challenge for the AI & LLM-wielding competitors.

:scream: Great puzzles that are jes’ plain ornery

Problems that took most of “the pros” an hour or more.

A subjective approach

I provide a brief explanation for each.

:thinking: Puzzles needing a little more thought

(Anything needing a search algorithm automatically lands here for me.)

  • :policeman: Day 6: Guard Gallivant

    Part 2: How do you detect an infinite loop?

  • :hiking_boot: Day 10: Hoof It

    • Part 1: Some sort of search algorithm: BFS, DFS, …
    • Part 2: How do you count the distinct paths?

  • :8ball: Day 11: Plutonian Pebbles

    Part 2: A brute force approach will not work.

  • :computer: Day 17: Chronospatial Computer

    • Part 1 is almost trivial.
    • Part 2 requires you to figure out which input produces a given output. Those always require at least a little thought. It’s almost obvious once you have it, but until you have it, it can be maddening.

  • :rock: Day 18: RAM Run

    • Part 1 is more or less a straightforward BFS.
    • Part 2 can be solved using a repeated BFS as you drop more bytes, and can be solved faster using a technique a la Method of Bisection.

  • :monkey: Day 22: Monkey Market

    I thought about listing this under “quick 'n easy”, because Part 1 really is, and I worked out Part 2 almost immediately. On reflection, though, I worked out Part 2 so quickly only because I did some preparatory study, so technically it belongs in this category.

    But just barely.

:fearful: Problems requiring a lot of thought, or trickier ideas

  • :corn: Day 12: Garden Groups

    • Part 1 already requires a bit of care, since there is not just 1 but multiple BFS (at least, that’s how I did it).
    • Without the wrinkle in Part 2, this would be in the lower category, but that wrinkle was non-trivial.

  • :deer: Day 16: Reindeer Maze

    • A lot of people are solving this with Dijkstra’s Algorithm, but I used BFS. Already that gets you into “needing a little more thought,” but the scoring is a bit funny, so your queue needs to be a little smarter than a dumb queue. So I implemented a queue using a vector that I sort after each iteration. I should have implemented a proper queue, but… oh, well.

    • To top that off, Part 2 decides that you need to find all the lowest-scoring paths. That’s not so hard by itself, but it cranks up the solution time, at least using my terrible, self-implemented queue.

  • :hotsprings: Day 19: Linen Layout

    • Essentially you’re building a parser, but the straightforward recursive descent parser chokes on the potential branches from the very first “word”! So you already have to find a better approach in Part 1, which “merely” asks you to determine which “words” parse.

    • Part 2 dials it up to 11 by asking you to determine how many ways there are to parse it, and of course that number is larger than Ada’s Natural type, and of course no attempt at recursion appeared feasible to me at the time. So… think backwards! (or cache, or memoize, as many did… not sure why I didn’t see it, but I rather like the backwards approach, so it was providential.)

  • :brick: Day 20: Race Condition

    • Part 1 can be solved using repeated breadth-first-search or some similar approach, but it’s quite slow.
    • Part 2 has far too many possibilities to allow for that, but it becomes quite tractable with a little arithmetic.

  • 🛜 Day 23: LAN Party

    • Part 1 isn’t too bad; a straightforward approach works.

    • Part 2 has a combinatorial explosion. This probably belongs in the lower category, since quite a few people managed to make it work with simple, cached search algorithms (or even self-described “naive” algorithms) but it took me a while so here it stays. :grin:

      (A previous edition of this writeup misspelled “naive” as “native”.)

:scream: Great puzzles that are jes’ plain ornery

:sob: What was the puzzle master thinking?!?

:astonished: Nothing in this category this year! (In the 2023 Advent of Code, Day 24 took this distinction.)

6 Likes