Advent of Code 2025

While is „only“ 12 days, are like 24 challenges. As no leaderboard is there, and I do it for fun, i will do it in 24 days.

The "only" 12 days might be disappointing (but totally understandable), however I won't mourn the global leaderboard which always felt pointless to me (even without the llm, the fact that it depends on what time you did solved problems really made it impractical for most people to actually compete). Private leaderboards with people on your timezone are much nicer.

I think I’ll set up a local leaderboard with friends this year. I was never going to make it to the global board anyway but it is sad to see it go away.

> the global leaderboard had to be pulled.

Frankly I'm better off with it being this way instead of the sweaty cupstacking LLM% speedrun it became as it gained popularity.

And this is how I know I am not a developer/programmer. I have no urge or interest in such event.

Yeah, last year I only got to Day7 (on dec 26). I hope the smaller amount reduces "the fear of falling behind".

I agree so much. Maybe I'll finally get a year done!

I’m so excited for this year.

I live in Sweden nowadays (UTC+1) and it starts at 6am so last year I woke up at 5:30, grabbed a coffee, and gave it a go.

Got nowhere near the leaderboard times so gave up after four days!

LLMs spoiled it, but it was fun to see the genuine top times. Watching competitive coders solve in real time is interesting (Youtube videos), and i wouldn't have discovered these without the leader board.

My favourite "non-mainstream" languages are, depending on my mood at the time, either:

- Array languages such as K or Uiua. Why they're good for AoC: Great for showing off, no-one else can read your solution (including yourself a few days later), good for earlier days that might not feel as challenging

- Raw-dogging it by creating a Game Boy ROM in ASM (for the Game Boy's 'Z80-ish' Sharp LR35902). Why it's good for AoC: All of the above, you've got too much free time on your hands

Just kidding, I use Clojure or Python, and you can pry itertools from my cold, dead hands.

Perl is my starting point.

It has many of the required structures (hashes/maps, ad hoc structs, etc) and is great for knocking up a rough and ready prototype of something. It's also quick to write (but often unforgiving).

I can also produce a solution for pretty much every problem in AoC without needing to download a single separate Perl module.

On the negative side there are copious footguns available in Perl.

(Note that if I knew Python as well as I knew Perl I'd almost certainly use Python as a starting point.)

I also try and produce a Go and a C solution for each day too:

* The Go solution is generally a rewrite of the initial Perl solution but doing things "properly" and correcting a lot of the assumptions and hacks that I made in the Perl code. Plus some of those new fangled "test" things.

* The C solution is a useful reminder of how much "fun" things can be in a language that lacks built-in structures like hashes/maps, etc.

C, because it makes every problem into a memory management problem, which is good for you in an 'eat your vegetables' sort of way. It's also the starting point for a lot of other programming languages and related things like HDLs, which is helpful to me.

I'm plodding my way through the 2015 challenge here: https://git.thomasballantine.com/thomasballantine/Advent_of_... , it's really sharpened me up on a number of points.

My favorite non-mainstream language for competitions like this and Project Euler is Julia. The startup time is not a factor, and the ability to use UTF-8 symbols as variables makes the code more mathematical.

I like to use Haskell, because parser combinators usually make the input parsing aspect of the puzzles extremely straightforward. In addition, the focus of the language on laziness and recursion can lead to some very concise yet idiomatic solutions.

Example: find the first example for when this "game of life" variant has more than 1000 cells in the "alive" state.

Solution: generate infinite list of all states and iterate over them until you find one with >= 1000 alive cells.

    let allStates = iterate nextState beginState # infinite list of consecutive solutions
    let solution = head $ dropWhile (\currentState -> numAliveCells currentState < 1000) allStates

I made my own, with a Haskell+Bash flavor and a REPL that reloads with each keystroke: https://www.youtube.com/watch?v=r99-nzGDapg

This year I've been working on a bytecode compiler for it, which has been a nice challenge. :)

When I want to get on the leaderboard, though, I use Go. I definitely felt a bit handicapped by the extra typing and lack of 'import solution' (compared to Python), but with an ever-growing 'utils' package and Go's fast compile times, you can still be competitive. I am very proud of my 1st place finish on Day 19 2022, and I credit it to Go's execution speed, which made my brute-force-with-heuristics approach just fast enough to be viable.

OCaml. There's just enough in the standard library to cover what you need for everything, for any non-trivial parsing tasks, there's a parser generator and lexer generator bundled, and if you want to pull in extra support libraries so you're not looking to implement, say, a trie from scratch.

Is Rust still "non-mainstream"? Because it's extremely well suited for AoC. The ergonomics of a high-level language with the performance of C++.

I think Ruby is the ideal language for AoC:

* The expressive syntax helps keep the solutions short.

* It has extensive standard library with tons of handy methods for AoC style problems: Enumerable#each_cons, Enumerable#each_slice, Array#transpose, Array#permutation, ...

* The bundled "prime" gem (for generating primes, checking primality, and prime factorization) comes in handy for at least a few of problems each year.

* The tools for parsing inputs and string manipulation are a bit more ergonomic than what you get even in Python: first class regular expression syntax, String#scan, String#[], Regexp::union, ...

* You can easily build your solution step-by-step by chaining method calls. I would typically start with `p File.readlines("input.txt")` and keep executing the script after adding each new method call so I can inspect the intermediate results.

I've always done it in a Scheme. Generally to learn a new compiler and its quirks.

Scheme is fairly well suited to both general programming, and abstract math, which tends to be a good fit for AoC.

I think Crystal, Nim, Julia and F# were my favorites from last year's AoC

I wrote a bit more about it here https://laszlo.nu/blog/advent-of-code-2024.html

AoC is a great opportunity for exploring languages!

I use python at work but code these in kotlin. The stdlib for lists is very comprehensive, and the syntax is sweet. So easy to make a chain of map, filter and some reduction or nice util (foldr, zipwithnext, windowed etc). Flows very well with my thought process, where in python I feel list comprehensions are the wrong order, lambdas are weak etc.

I write most as pure functional/immutable code unless a problem calls for speed. And with extension functions I've made over the years and a small library (like 2d vectors or grid utils) it's quite nice to work with. Like, if I have a 2D list (List<List<E>>), and my 2d vec, like a = IntVec(5,3), I can do myList[a] and get the element due to an operator overload extension on list-lists.

and with my own utils and extension functions added over years of competitive programming (like it's very fluent

Go is strong. You get something where writing a solution doesn't take too much time, you get a type system, you can brute-force problems, and the usual mind-numbing boring data-manipulation handling fits well into the standard tools.

OCaml is strong too. Stellar type system, fast execution and sane semantics unlike like 99% of all programming languages. If you want to create elegant solutions to problems, it's a good language.

For both, I recommend coming prepared. Set up a scaffold and create a toolbox which matches the typical problems you see in AoC. There's bound to be a 2d grid among the problems, and you need an implementation. If it can handle out-of-bounds access gracefully, things are often much easier, and so on. You don't want to hammer the head against the wall not solving the problem, but solving parsing problems. Having a combinator-parser library already in the project will help, for instance.

It was mind-boggling to see SQL solutions last year: https://news.ycombinator.com/item?id=42577736

AoC has been a highlight of the season for me since the beginning in 2015. I experimented with many languages over the years, zeroing in on Haskell, then Miranda as my language of choice. Finally, I decided to write my own language to do AoC, and created Admiran (based upon Miranda and other lazy, pure, functional languages) with its own self-hosted compiler and library of functional data structures that are useful in AoC puzzles:

https://github.com/taolson/Admiran https://github.com/taolson/advent-of-code

Clojure works really well for AOC.

A lot of the problems involve manipulating sets and maps, which Clojure makes really straightforward.

I've had a lot of fun using Nim for AOC for many years. Once you're familiar with the language and std lib, its almost as fast to write as python, but much faster (Nim compiles to C, which then gets compiled to your executable). This means that sometimes, if your solution isn't perfect in terms of algorithmic complexity, waiting a few minutes can still save you (waiting 5 mins for your slow Nim code is OK, waiting 5 hours for your slow Python isn't really, for me). Of course all problems have a solution that can run in seconds even in Python, but sometimes it's not the one I figure out first try.

Downsides: The debugging situation is pretty bad (hope you like printf debugging), smaller community means smaller package ecosystem and fewer reference solutions to look up if you're stuck or looking for interesting alternative ideas after solving a problem on your own, but there's still quality stuff out there.

Though personally I'm thinking of trying Go this year, just for fun and learning something new.

Edit: also a static type system can save you from a few stupid bugs that you then spend 15 minutes tracking down because you added a "15" to your list without converting it to an int first or something like that.

This question is really confusing to me because the point of AoC is the fun and experience of it

So.. a language that you're interested in or like?

Reminds me of "gamers will optimize the fun out of a game"

I'm pretty clojure-curious so might mess around with doing it in that

I have used Raku (Perl 6) with good results.

Common Lisp. Using 'iterate' package almost feels like cheating.

I have done half a year in (noob level) Haskell long ago. But can't find the code any more.

Most mind blowing thing for me was looking at someone's solutions in APL!

I’ve always used AoC as my jump-off point for new languages. I was thinking about using Gleam this year! I wish I had more profound reasons, but the pipeline syntax is intriguing and I just want to give it a whirl.

My personal choice is always Common Lisp. Absolute swiss army knife.

I've been using Elixir, which has been wonderful, mostly because of how amazing the built in `Enum` library is for working on lists and maps (since the majority of AoC problems are list / map processing problems, at least for the first while)

I am going to try and stick with Prolog as much as I can this year. Plenty of problems involve a lot of parsing and searching, both could be expressed declaratively in Prolog and it just works (though you do have to keep the execution model in mind).

I used MATLAB last year while I was re-learning it for work. It did okay, but we didn't have a license for the Image Processing Toolbox, which has a boatload of tools for the grid based problems.

If it is not solvable with a Ruby one-liner, it is not a well defined problem.

I've done AoC on what I call "hard mode", where I do the solutions in a language I designed and implemented myself. It's not because the language is particularly suited to AoC in any particular way, but it gives me confidence that my language can be used to solve real problems.

Neon Language: https://neon-lang.dev/ Some previous AoC solutions: https://github.com/ghewgill/adventofcode

For me (and most of my friends/coworkers) the point of AoC was to write in some language that you always wanted to learn but never had the chance. The AoC problems tend to be excellent material for a crash course in a new PL because they cover a range of common programming tasks.

Historically good candidates are:

- Rust (despite it's popularity, I know a lot of devs who haven't had time to play with it).

- Haskell (though today I'd try Lean4)

- Racket/Common Lisp/Other scheme lisp you haven't tried

- Erlang/Elixir (probably my choice this year)

- Prolog

Especially for those langs that people typically dabble in but never get a change to write non-trivial software in (Haskell, Prolog, Racket) AoC is fantastic for really getting a feel for the language.

Elixir Livebook is my tool of choice for Advent of Code. The language is well-suited for the puzzles, I can write some Markdown if I need to record some algebra or my thought process, the notebook format serves as a REPL for instant code testing, and if the solution doesn't fit neatly into an executable form, I can write up my manual steps as well.

I used my homemade shell language last year, called elk shell. It worked surprisingly well, better than other languages I've tried, because unlike other shell languages it is just a regular general purpose scripting language with a standard library that can also run programs with the same syntax as function calls.

I've been using Elixir since day one, and it works pretty well :)

If I remember correctly, one of the competitive programming experts from the global leaderboard made his own language, specifically tailored to help solve AoC problems:

https://github.com/betaveros/noulith

A new language every year. A language I had intended to learn. Using a different programming paradigm, or a paradigm which I have not used recently.

For some grid based problems, I think spreadsheets are very powerful and under-appreciated.

The spatial and functional problem solving makes it easy to reason about how a single cell is calculated. Then simply apply that logic to all cells to come up with the solution.

Not sure if Kotlin is non-mainstream, but being able to use the vast Java libraries choice and a much nicer syntax are great boons.

I usually do it with ruby with is well suite just like python, but last year I did it with Elixir.

I think it lends itself very well to the problem set, the language is very expressive, the standard library is extensive, you can solve most things functionally with no state at all. Yet, you can use global state for things like memoization without having to rewrite all your functions so that's nice too.

Terse languages with great collection functions in the standard libraries and tail call optimization. Haskell, OCaml, F# ...

Crystal. Expressiveness and get-shit-done ability similar to the one of Ruby while being way faster in execution.

I’d say Clojure because it has great data manipulation utilities baked into the standard library.

I've done some of the problems in R. Vectorized-by-default can avoid a lot of boilerplate. And for problems that aren't in R's happy path, I learn how to optimize in the language. And then I try to make those optimizations non-hideous to read.

Kotlin, because it’s a language I like

Another vote for Haskell. It’s fun and the parsing bit is easy. I do struggle with some of the 2d map style questions which are simpler in a mutable 2d array in c++. It’s sometimes hard to write throwaway code in Haskell!

I think that whatever you know well is the best choice.

I have been learning lua to do a VR game in lovr, so I'll probably use that to get sharper with it.

The language doesn't really matter much. I think I keep using PHP as in the years before.

Haskell is my favorite for advent of code. Finally give me an opportunity to think in a pure functional way.

I believe Eric has said he always makes his first solutions with Perl.

I’ve been doing them is JS and Common Lisp. I recommend the problems to help learning new languages.

I tried to do it in emacs lisp one year. Made it about halfway :)

The only way to win is with Brainfuck.

Or MUMPS.

With AoC I think that its fine to pick a language that is not at all suited for the challenge. That can be half the fun.

I saw someone one Twitter use Excel.

If enough inputs are available online, someone can presumably collect them and clone the entire project without having access to the puzzle input generation code, which is the "secret sauce" of the project.

I use git-crypt to encrypt the inputs in my public repo https://www.agwa.name/projects/git-crypt/ :)

This is not surprising at all, to me. Just commit the example input and write your test cases against that. In a nicely structured solution, this works beautifully with example style tests, like python or rust doctests, or even running jsdoc @example stanzas as tests with e.g. the @linus/testy module.

The inputs are part of the validation that you did the question, so they're kind of a secret.

I make my code public, and keep my inputs in a private submodule.

I never liked the global leaderboard since I was usually asleep when the puzzles were released. I likely never would have had a competitive time anyway.

I hope your wife is also glad!

Some part of me would love a job that was effectively solving AoC type problems all the time, but then I'd probably burn out pretty quickly if that's all I ever had to do.

Sometimes it's nice to have a break by writing a load of error handling, system architecture documentation, test cases, etc.

> For me it's a great chance to sharpen the tools in my toolbox.

That's a good way of putting it.

My way of taking it a step further and honing my AoC solutions is to make them more efficient whilst ensuring they are still easy to follow, and to make sure they work on as many different inputs as possible (to ensure I'm not solving a specific instance based on my personal input). I keep improving and chipping away at the previous years problems in the 11 months between Decembers.

On sorta the same topic:

In the programming world I feel like there's a lot of info "for beginners" and a lot of folks / activities for experts.

But that middle ground world is strange... a lot of it is a combo of filling in "basics" and also touching more advanced topics at the same time and the amount of content and just activities filling that in seems very low. I get it though, the middle ground skilled audience is a great mix of what they do or do not know / can or can not solve.

I don't know if that made any sense.

Someone else in the thread lamented the problems as "too easy" and I wondered what world I was living in.

It's totally true. I was doing Advent of Code before I had any training or work in programming at all, and a lot of it can be done with just thinking through the problem logically and using basic problem solving. If you can reason a word problem into what it's asking, then break it down into steps, you're 90% of the way there.

Got to agree. I'm even surprised at just how little progress many of my friends and ex-colleagues over the years make given that they hold down reasonable developer jobs.

mh, maybe it's cheating because it's still a STEM degree but I have a PhD in physics without any real computer science courses (obviously had computational physics courses etc. though) and I managed to 100% solve quite a few years without too much trouble. (though far away from the global leaderboard and with the last few days always taking several hours to solve)

I have a EE background not CS and haven't had too much trouble the last few years. I'm not aiming to be on the global leader board though. I think that with good problem solving skill, you should be able to push through the first 10 days most years. Some years were more front loaded though.

Agreed. There is no "beginner" or amateur programmer who could complete even part of a single Advent of Code problem.

In general, the problems require less background knowledge than other coding puzzles. They're not always accessible without knowing a particular algorithm, but they're more 'can you think through a problem' than 'have you done this module'.

That's not the same as saying they're easy, but it's a different kind of barrier, and (in my opinion) more a test of 'can you think?' than 'did you do a CS degree?'

The point is not that it's easy, but that you don't need much knowledge beyond knowing how to code.

In this sense it's accessible: you won't get stuck because of a word you don't understand or a concept you've never heard of.

Agreed. I have a CS background and years of experience but I don't get very far with these. At some point it becomes a very large time commitment as well which I don't have

>It's probably an unpopular stance, but I've never done Advent of Code for the competitive aspect

Is this an unpopular stance? Out of a dozen people I know that did/do AoC every year, only one was trying to compete. Everyone else did it for fun, to learn new languages or concepts, to practice coding, etc.

Maybe it helps that, because of timezones, in Europe you need to be really dedicated to play for a win.

A couple of the Slack/Discord groups I’m in do a local leaderboard with friends. It’s fun to do with a trusted group of people who are all in it for fun.

I did a post [0] about this last year, and vanilla LLMs didn’t do nearly as well as I’d expected on advent of code, though I’d be curious to try this again with Claude code and codex

[0] https://www.jerpint.io/blog/2024-12-30-advent-of-code-llms/

I know some folks were disappointed with their being 12 puzzles instead of 24 this year, but I never have time to finish anyway so it makes no difference to me lol

I'm just glad they're keeping this going.

It's really disheartening that the culture has changed so much someone would think doing AoC puzzles just for the fun of it is an unpopular stance :(

Doing things for the fun of it, for curiosity's sake, for the thrill of solving a fun problem - that's very much alive, don't worry!

While part of the fun is doing the daily tasks with your friends, you can still access the previous years and their challenges if you want to continue after advent!

Man, those people using LLMs in competitive programming ... where's the fun in that? I don't get people for whom it's just about winning, I wish everyone would just have some basic form of dignity and respect.

When I did competitions like these at uni (~10-15 years ago), we all used some thin-clients in the computer lab where the only webpages one could access were those allowed by the competition (mainly the submission portal). And then some admin/organizers would feed us and make sure people didn't cheat. Maybe we need to get back to that setup, heh.

In 1997, Deep Blue beat Gary Kasparov, the world chess champion. Today, chess grandmasters stand no chance against Stockfish, a chess engine that can run on a cheap phone. Yet chess remains super popular and competitive today, and while there are occasional scandals, cheating seems to be mostly prevented.

I don’t see why competitive debate or programming would be different. (But I understand why a fair global leaderboard for AOC is no longer feasible).

Oof. I had a great time cracking the top 100 of Advent of Code back in 2020. Bittersweet to know that I got in while it was still a fun challenge for humans.

For those who think this is a typo, uiua [1] (pronounced "wee-wuh") is a stack-based array programming language.

I solved a few problems with it last year, and it is amazing how compact the solutions are. It also messes with your head, and the community surrounding it is interesting. Highly recommended.

[1] https://www.uiua.org/

I am! I love the design of Gleam in theory but keep bouncing off it so I’m interested in seeing if AoC will help me give it a fair shake.

Isn't a publicly advertised private leaderboard - especially with cash prizes - against the new guidance? Certainly the spirit of the guidance.

>What happened to the global leaderboard? The global leaderboard was one of the largest sources of stress for me, for the infrastructure, and for many users. People took things too seriously, going way outside the spirit of the contest; some people even resorted to things like DDoS attacks. Many people incorrectly concluded that they were somehow worse programmers because their own times didn't compare. What started as a fun feature in 2015 became an ever-growing problem, and so, after ten years of Advent of Code, I removed the global leaderboard. (However, I've made it so you can share a read-only view of your private leaderboard. *Please don't use this feature or data to create a "new" global leaderboard.*)

This kind of crap is the reason we can’t just enjoy an AoC anymore.

i don't think it should be a charity of their choice. i think it should have to be one of the top 5 most reputable charities in the world, like doctors without borders or salvation army.

You can always create a throwaway account on one of those services. It's not that hard.

The "etc" is pretty important here. You can log in using Reddit, and you can create a random throwaway Reddit account without filling in any other details (no email address or phone number required).

Having done my own auth I get why they do it this way. LLMs are already a massive problem with AoC, I imagine an anonymous endpoint to validate solutions would be even worse.

Having done auth myself, I can also understand why auth is being externalised like this. The site was flooded with bots and scrapers long before LLMs gained relevance and adding all the CAPTCHAs and responding to the "why are you blocking my shady CGNAT ISP when I'm one of the good ones" complaints is just not worth it. Let some company with the right expertise deal with all of that bullshit.

I'd wish the site would have more login options, though. It's a tough nut to crack; pick a small, independent oauth login service not under control of a bit tech company and you're basically DDOSing their account creation page for all of December. Pick a big tech company and you're probably not gaining any new users. You can't do decentralized auth because then you're just doing authentication DDOS with extra steps.

If I didn't have a github account, I'd probably go with a throwaway reddit account to take part. Reddit doesn't really do the same type of tracking Twitter tries to do and it's probably the least privacy invasive of the bunch.

Agreed. I think having an option for codeberg would be great

Yes! With difficulty usually peaking on the weekends.

I propose Advent of Outage: just pull a random plug in the server room every day.

https://sadservers.com/advent

I haven't set up an advent event (maybe I should) but you can do yourself a challenge a day from SadServers.com

It may have made more sense to start on Christmas Day, matching the Twelve Days of Christmas [1].

[1] https://en.wikipedia.org/wiki/Twelve_Days_of_Christmas

I think there's a problem every other day, so it's 1, 3, ..., 23.

It's up for me (but the first puzzle won't be available until 15 hours from now).

It won't load for me right now

There's a relevant FAQ with a solution for you:

https://adventofcode.com/2025/about#faq_highcontrast

BQN or its ancestor APL are good for this.

I’m probably going to use rescript. Though I may do Gleam or Roc.

I am so glad there is no leaderboard this year. Making it a competition really is against the spirit of advent calendars in general. It’s also not a fair competition by default simply due to the issue of time zones and people’s life schedules not revolving around it.

There are plenty of programming competitions and hackathons out there. Let this one simply be a celebration of learning and the enjoyment of problem solving.

Not this time:

> The global leaderboard was one of the largest sources of stress for me, for the infrastructure, and for many users. People took things too seriously, going way outside the spirit of the contest; some people even resorted to things like DDoS attacks. Many people incorrectly concluded that they were somehow worse programmers because their own times didn't compare. What started as a fun feature in 2015 became an ever-growing problem, and so, after ten years of Advent of Code, I removed the global leaderboard.

Depends how you look at it. Some of my colleagues rave about Claude Code, so I was thinking about trying it out on these puzzles. In that sense it is "going to the gym", just for a different thing. Since I do AoC every year, I feel like it'll give me a good feel for Claude Code compared to my baseline. And it's not just "prompting", but figuring out a workflow with tests and brainstorming and iteration and all that. I guess if the LLM can just one-shot every puzzle that's less interesting, but I suppose it would be good to know it can do that...

I mean they're great programming tests, for both people and AI I'd argue - like, it'd be impressive if an AI can come up with a solution in short order, especially with minimal help / prompting / steering. But it wouldn't be a personal achievement, and if it was a competition I'd label it as cheating.

> And yet I expect the whole leaderboard to be full of AI submissions...

There will be no global leaderboard this year.

i don't think there is a global leaderboard this year. just private ones.

why would delegate to an LLM something that is supposed to be fun. THIS specifically is the kind of stuff you shouldn't delegate to an LLM

Well some people like to code and logic puzzles. And especially as it is in its raw form where you can forget all the noise you encounter while coding professionally with many hoops and responsibilities.

People like different things

I code for fun, even in December.

I agree. Didn't these puzzles ruin interviewing for many years now. AI came along and they're still doing it. Some things will needlessly drag on before they die I guess

I'm not sure I understand this. Most puzzles are number-crunching but very little to do with graphics (maybe one or two), so no usually OpenGL isn't used AFAIK.

Of course, folks may use it to visualise the puzzles but not to solve them.

I just found in Google (don't worry, SFW)

https://www.plumbingnationals.com/

https://www.youtube.com/watch?v=BWrvnNMsmeM

> I mean do plumbers have an advent of plumbing where they try and unblock shit filled toilets for fun?

Yes, plumbers and other types of craftspeople and technicians do also have these little fun competitions. Why shouldn't they?

I think the reason some of us programmers do these things, is likely because many (myself included) entered the field as enthusiasts and hobbyists in the first place.

>I mean do plumbers have an advent of plumbing where they try and unblock shit filled toilets for fun?

No, but you’ll see it for writers, musicians, and the like.

Engineering (software or not) can be an intellectually rewarding experience for many. I don’t know why some people find this something to scoff at, would you rather have no pleasure derived from your work?

It's literally just puzzles which have to be solved through code. Solving puzzles is a very normal thing to do for many people

> mean do plumbers have an advent of plumbing where they try and unblock shit filled toilets for fun?

You've obviously never watched "Drain Cleaning Australia" on YouTube!

Yes, some people find this stuff fun, because they find coding fun, and don't typically get to do the fun kind of coding on company time. Also, there'd be a hell of a lot less open source software in the world if people didn't code for fun.

Let people enjoy things. Just because you don't like that par of your job as much as them doesn't mean they're wrong.

It was pretty boring trying to place against aggressive AI pipelines like yours throughout the explicit requests not to use them[1]. I’m sorry to hear it became boring for you too.

[1] https://web.archive.org/web/20241201070128/https://adventofc...

Wow, you have some nerves.

"It was boring to run a cycling contest on a motorbike."

Although there are now rumours of hidden motors in Tour de France bicycles. So, I guess it's the same.

So, publicly admitting that you broke the rules and are part of the reason we can't have nice things. Why?

The FAQ was pretty clear about not using AI to get on the leaderboard last year.

this is why we can't have nice things