This repo aims to solve ALL Project Euler problems in openly licensed Python code, mostly using LLMs to generate the bulk of the solutions. Status:

• 1-1009: done

Tested on Python 3.13.7, PyPy 7.3.20, Ubuntu 25.10.

Ridiculous stretch goal: solve the first 100 problems in Lean with mathematically proven correctness! Status: TBD.

• 1. Goals
  • 1.1. Solution guidelines
• 2. Status
• 3. Setup
• 4. Generating solvers
  • 4.1. generate-solvers.py
  • 4.2. generate-solvers.py --codex
  • 4.3. Manual prompt on web UI
• 5. Testing
  • 5.1. Linting
    • 5.1.1. Autoformatting
  • 5.2. Multilanguage support
    • 5.2.1. Lean
      • 5.2.1.1. Lean prompts
• 6. Folders
• 7. Build README locally
• 8. License
• 9. Solvers
  • 9.1. Slowest solvers
  • 9.2. Benchmarking other solvers
    • 9.2.1. Failed ports
    • 9.2.2. eulersolve.org

Before this repo was published, there were a few solution collections out there such as:

• https://github.com/nayuki/Project-Euler-solutions

• https://github.com/stbrumme/euler

• https://github.com/igorvanloo/Project-Euler-Explained/tree/master/Finished%20Problems

but we couldn’t find any complete ones, and the reason is obvious: before LLMs were able to solve most of the problems, there was no single human who had both the patience and the willingness to spoil problems and get banned from the leaderboards forever: once you publish any solution online, they hunt you down and forever block any account they manage to match back to you, even though LLMs now solve all their recent problems. The existing solution repos were also partially a showcase of users’s skills rather than pure a mass collaborative effort to just get it done. Contributors of this project however have attained Buddhahood and completely freed themselves of their own ego: we do stupid things and we are not proud. As such, we have come closer to the more fundamental reason for doing PE problems: autism.

Not long after this repo was published, https://eulersolve.org/ was also published, which also contained all solutions to date. That repo has valuable content, but it’s license is not fully open, see further comments at: Section 9.2.2, “eulersolve.org”.

We also have https://github.com/lucky-bai/projecteuler-solutions which contains the numerical solutions. And of course, once you have the numerical solution you can enter the private forum threads where people freely share their solutions. But they don’t use open licenses, so we can’t republish them openly.

At least initially, we are not going to restrict ourselves only to LLM solutions, or attempt to carefully benchmark LLM capability with this repo. If one problem is hard and we manually find a solution, it is fine to add it manually. It is also fine to raid the private Project Euler forums to understand the key tricks and feed insights to LLMs (though we must never ever touch code from there), since mathematical ideas themselves cannot be copyrighted. The initial goal is just to have all solvers legally with as little effort and money as possible. Editing LLM output to make it work in any way is also OK.

The main reasons for creating this repo are:

• let people and LLMs get solutions without wasting more GPUs

• pissing off Project Euler people who say solutions must not be published

• beauty

• get a feeling for how much LLMs cost vs how powerful they are for hard but non-frontier tasks

Of course, it can be argued that https://github.com/eth-sri/matharena infrastructure does everything that this repository does and more, but because we focus solely on Project Euler and openly give answers, our repo can be cuter. Also they are not trying to do the older ones like we are.

We are focusing on Python solutions at first because this is the language that LLMs seems to speak better. It is also cute and avoid compilation overhead. Also pypy3 does a lot to bring runtime closer to that of compiled languages. We are not against adding solutions in every single language in existence in the future, but that is becoming increasingly cheap and easy with vibe translation with Codex CLI, so we are not too concerned either.

May this repo free unsuspecting nerds from the ambition to solve some useless problems. You need to pick something even harder to do now.

After trying more automated approaches which failed due to reliability/cost issues, we ended up painstakingly (but also meditatively) doing at least a single pass of "paste on chatgpt.com", which solves 90% of them. When that fails the algorithm is a mixture of:

• Codex locally with generate-solvers.py --codex N. Sometimes works.

• raid the forum for insight

The above was after we have vibe ported all solutions from the following repositories into this one with Codex CLI, both of which are CC0:

• https://github.com/stbrumme/euler

• https://github.com/igorvanloo/Project-Euler-Explained/tree/master/Finished%20Problems

Here is a description of how we previously tried to more automatically tackle things but mostly failed:

• generate-solvers.py managed to solve 1-100 for very little money, but then quickly spent 20 dollars on the API to try and solve 101-200 with GPT-5.2. We didn’t limit output tokens per prompt however, so it is possible that a small number of tasks took up all the tokens.

  We then tried to load up 10$ and see if I could solve any unsolved problems above 200 on API with:

  ./generate-solvers.py --max-output-tokens 50000 --model gpt-5.2 202 210 212

  but that ate up 7$ and ended up in three timeouts thus wasting most of my money. So I’m never trying to use this shitty API again. Plus plan Web UI solved all three immediately after.

• generate-solvers.py --codex managed to solve 400-413, but it is slow and then it hit the 5 hour usage limit on my Plus plan.

• https://chatgpt.com web UI: GPT-5.2 models seem to easily solve all the old problems when I ask for it on the , it’s just that the API feels way more expensive. Maybe this is just an illusion as we start to hit web UI limits as well later on. But if those are not hit, worse case we could solve all problems by manually copy pasting on web UI, it’s then just a matter of kicking it repeatedly until it gives the results.

Run just one manually solver solvers/400.py:

A small number of the earlier problems actually need input data from a separate file, to run those manually you also need to cd into the directory that contains them first e.g. for solvers/22.py:

Each solver should print the final solution to stdout and nothing else.

They should also assert any other given test values to increase the probability that the solver is actually correct.

Run all solvers and check for correctness against the numerical solutions published at lucky-bai/projecteuler-solutions:

Same for one specific solver:

Same for an inclusive range of solvers:

Set timeout in seconds under which solvers must run with -t. The default value is 600. Having a timeout is useful when trying several solvers for the first time before you know if they are correct or not:

Solvers that fail to terminated under that time fail with something like:

One extremely convenient automation to ./test.py is the -A --autoupdate flag which automatically updates this README with updated results as tests are run, saving you a lot of copy paste:

Benchmark Python solvers from another directory without changing the default ./test.py suite by using --set. The flag is repeatable, which is useful for comparing this repository against another solver set:

With -A, solver timings are recorded in benchmark.yaml and in the [other-solvers] comparison list. Timings with missing reference answers are kept as unverified timings; existing solvers that fail or produce incorrect answers are recorded with an `error: ` entry in the comparison list.

• solvers/: the solver programs

  • solvers/400.py: a solver program

  • solvers/400.md: optional high level Markdown description of the solution

  • solvers/2.py.json: optional LLM metadata describing the generation process. This one was done on API:

    {
      "output_tokens": 432,
      "model": "gpt-5.2-2025-12-11",
      "interface": "api",
      "reasoning_effort": "high",
      "input_prompt": "TASK\n\nSolve the following problem by coding a Python program that runs on pypy3. Add asserts for the test cases given in the problem statement if any, and a print with the final result at the end. Your code must run in a few minutes at most, usually a few seconds. Don't try to brute force the solution, only use brute forcing if needed to better understand the problem on small instances. Don't use external libraries, only the Python standard library. Don't use multithreading, only a single CPU core. Use typing for function signatures.\n\nOUTPUT FORMAT\n\nmain.py\n\n<Python implementation>\n\nREADME.md\n\n<Markdown summary of the reasoning/insights used (high level; no chain-of-thought)>\n\nPROBLEM\n\n# Even Fibonacci Numbers\n\nEach new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with $1$ and $2$, the first $10$ terms will be:\n$$1, 2, 3, 5, 8, 13, 21, 34, 55, 89, \\dots$$\n\nBy considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.\n",
      "generation_time_seconds": 9.143
    }

    • solvers/976.py.json is how it should look like for Codex runs (TODO not currently automated):

      {
        "output_tokens": 131264,
        "model": "gpt-5.2-codex",
        "interface": "codex-0.77.0",
        "input_prompt": "\"Solve the following problem with a program main.py, make sure it runs in pypy3: <p>\\n  Two players X and O play a game with $ strips of squares of lengths ,\\\\dots,n_k$, originally all blank.</p>\\n\\n  <p>\\n  Starting with X, they make moves in turn. At X's turn, X draws an \\\"X\\\" symbol; at O's turn, O draws an \\\"O\\\" symbol.<br>\\n  The symbol must be drawn in one blank square with either red or blue pen, subject to the following restrictions:</p>\\n  <ol>\\n  <li>two symbols in adjacent squares on one strip must be different symbols <b>and</b> must have different colour;</li>\\n  <li>if there is at least one blank strip, then one must draw on a blank strip.</li></ol>\\n  <p>\\n  Whoever does not have a valid move loses the game.</p>\\n\\n  <p>\\n  Let (K, N)$ be the number of tuples $ such that  \\\\leq k \\\\leq K$, \\\\leq n_1\\\\leq\\\\cdots\\\\leq n_k\\\\leq N$ and that X has a winning strategy to the\\n  corresponding game.<br>\\n  For example, (2, 4)=7$ and (5, 10) = 901$.</p>\\n\\n  <p>\\n  Find (10^7, 10^7)\\\\bmod 1234567891$.</p>\\n\"",
        "generation_time_seconds": 1695
      }

Install the Asciidoctor gem via Bundler and generate HTML:

and then build with:

The nominal license for this entire repo is CC0 (public domain) with the following caveats:

• README.adoc: written manually, so certain CC0

• solvers/: double check the file headers. In a very small number of cases we have copied code from random public places, notably https://github.com/lucky-bai/projecteuler-solutions/issues where it seemed clear that the author wanted a free license but they might have not specified it. We never ever take code from the private forums, or from public solvers that clearly label their code as proprietary (https://github.com/nayuki/Project-Euler-solutions lol), where we would almost certain receive DMCA takedown.

    Otherwise, the vast majority of solvers is very likely safely CC0, or whatever your lawyer says is the license for code generated by LLMs (for those that are LLM generated, some were imported from properly licensed existing human solvers like https://github.com/stbrumme/euler and https://github.com/igorvanloo/Project-Euler-Explained/tree/master/Finished%20Problems and are for sure CC0), or CC-By-NC-SA if your lawyer says that problem solutions must have the same license as problem statements.
  * infrastructure code such as link:test.py[] and link:generate-solvers.py[], link:logo.jpg[]: mostly vibe coded in Codex, so CC0 on our side or take your lawyer's pick again

Benchmarked on Lenovo ThinkPad P14s by running ./main.py: