Project Nayuki

Project Euler solutions

Nayuki’s stats on Project Euler


I solve Project Euler problems to practice and extend my math and programming skills, all while having fun at the same time. Here I make my solutions publicly available for other enthusiasts to learn from and to critique. This page lists all of my Project Euler solution code, along with other helpful information like benchmark timings and my overall thoughts on the nature of math and programming in Project Euler.

Each problem that I solved always includes a Java program. Almost all my solved problems also include a Python program (except for a few). Many problems additionally have a Mathematica and Haskell program. Numerous solutions contain a detailed mathematical proof to justify why the implemented algorithm is correct. Among the web, this is perhaps the largest collection of Project Euler solutions in the Java programming language. All my code is original work, not based on anyone else’s code, although a couple of times I obtained the high-level approach from reading various literature on the web.


Solution code

Git repositories

Web host Browse files Download package Numerical answers
GitHub (primary) Browse files Download ZIP Answers.txt
Eigenstate (mirror) Browse files Download .tar.gz Answers.txt

Individual files

Every Java solution depends on these shared classes:,
Many Python solutions depend on my shared math library module:
Some solution code contains a detailed mathematical proof of correctness.

Problem Java Python Mathematica Haskell Explanation
Problem 1 p001.mathematica p001.hs Yes
Problem 2 p002.mathematica p002.hs Yes
Problem 3 p003.mathematica p003.hs Yes
Problem 4 p004.mathematica p004.hs Yes
Problem 5 p005.mathematica p005.hs Yes
Problem 6 p006.mathematica p006.hs Yes
Problem 7 p007.mathematica p007.hs Yes
Problem 8 p008.mathematica p008.hs Yes
Problem 9 p009.mathematica p009.hs Yes
Problem 10 p010.mathematica p010.hs Yes
Problem 11 p011.mathematica p011.hs Yes
Problem 12 p012.mathematica p012.hs Yes
Problem 13 p013.mathematica p013.hs Yes
Problem 14 p014.mathematica p014.hs Yes
Problem 15 p015.mathematica p015.hs Yes
Problem 16 p016.mathematica p016.hs Yes
Problem 17 p017.mathematica p017.hs Yes
Problem 18 p018.mathematica p018.hs Yes
Problem 19 p019.mathematica p019.hs Yes
Problem 20 p020.mathematica p020.hs Yes
Problem 21 p021.mathematica p021.hs Yes
Problem 22 p022.mathematica p022.hs Yes
Problem 23 p023.mathematica p023.hs
Problem 24 p024.mathematica p024.hs Yes
Problem 25 p025.mathematica p025.hs Yes
Problem 26 p026.mathematica p026.hs
Problem 27 p027.mathematica
Problem 28 p028.mathematica p028.hs Yes
Problem 29 p029.mathematica p029.hs Yes
Problem 30 p030.mathematica p030.hs Yes
Problem 31 p031.mathematica p031.hs Yes
Problem 32 p032.mathematica p032.hs Yes
Problem 33 p033.mathematica p033.hs Yes
Problem 34 p034.mathematica p034.hs Yes
Problem 35 p035.mathematica
Problem 36 p036.mathematica p036.hs
Problem 37 p037.mathematica
Problem 38 p038.mathematica p038.hs
Problem 39 p039.mathematica p039.hs
Problem 40 p040.mathematica p040.hs
Problem 41 p041.mathematica
Problem 42 p042.mathematica p042.hs Yes
Problem 43 p043.mathematica
Problem 44 p044.mathematica Yes
Problem 45 p045.mathematica
Problem 46 p046.mathematica
Problem 47 p047.mathematica
Problem 48 p048.mathematica p048.hs
Problem 49 p049.mathematica
Problem 50 p050.mathematica
Problem 51
Problem 52 p052.mathematica
Problem 53 p053.mathematica p053.hs
Problem 54
Problem 55 p055.mathematica p055.hs
Problem 56 p056.mathematica p056.hs
Problem 57 p057.mathematica
Problem 58 p058.mathematica
Problem 59
Problem 60 p060.hs Yes
Problem 61
Problem 62
Problem 63 p063.mathematica p063.hs Yes
Problem 64 p064.mathematica
Problem 65 p065.mathematica
Problem 66 p066.mathematica Yes
Problem 67 p067.mathematica p067.hs Yes
Problem 68
Problem 69 p069.mathematica
Problem 70 p070.mathematica
Problem 71 p071.mathematica p071.hs
Problem 72 p072.mathematica
Problem 73 Yes
Problem 74
Problem 75 Yes
Problem 76 p076.mathematica p076.hs
Problem 77 p077.mathematica p077.hs Yes
Problem 78 Yes
Problem 79
Problem 80 p080.mathematica Yes
Problem 81 p081.mathematica p081.hs
Problem 82 p082.mathematica
Problem 83 p083.mathematica
Problem 84
Problem 85 p085.mathematica
Problem 86
Problem 87
Problem 88 Yes
Problem 89 p089.mathematica p089.hs
Problem 90
Problem 91 p091.mathematica
Problem 92 p092.mathematica p092.hs
Problem 93
Problem 94 Yes
Problem 95
Problem 96
Problem 97 p097.mathematica p097.hs
Problem 98
Problem 99 p099.mathematica
Problem 100 Yes
Problem 101 p101.mathematica Yes
Problem 102 p102.mathematica p102.hs
Problem 104 p104.mathematica Yes
Problem 105
Problem 107 Yes
Problem 108 p108.mathematica Yes
Problem 109 p109.mathematica
Problem 111 Yes
Problem 112 p112.mathematica
Problem 113 p113.mathematica p113.hs Yes
Problem 114 p114.mathematica p114.hs Yes
Problem 115 p115.mathematica p115.hs Yes
Problem 116 p116.mathematica p116.hs Yes
Problem 117 p117.mathematica p117.hs Yes
Problem 118
Problem 119 Yes
Problem 120 p120.mathematica p120.hs Yes
Problem 121 p121.mathematica p121.hs Yes
Problem 122 Yes
Problem 123 p123.mathematica p123.hs Yes
Problem 124
Problem 125
Problem 127 Yes
Problem 128 p128.mathematica Yes
Problem 129 p129.mathematica
Problem 130
Problem 132 p132.mathematica
Problem 133 p133.mathematica Yes
Problem 134 p134.mathematica Yes
Problem 135 Yes
Problem 139
Problem 142 Yes
Problem 145 p145.mathematica p145.hs Yes
Problem 146 Yes
Problem 149
Problem 150
Problem 151
Problem 155
Problem 160 p160.mathematica p160.hs Yes
Problem 162 p162.mathematica p162.hs Yes
Problem 164 p164.mathematica p164.hs Yes
Problem 166 Yes
Problem 169 p169.mathematica
Problem 171 p171.mathematica Yes
Problem 172 p172.mathematica Yes
Problem 173 p173.mathematica p173.hs Yes
Problem 174 p174.mathematica
Problem 179 p179.mathematica
Problem 182
Problem 186
Problem 187 p187.mathematica Yes
Problem 188 p188.mathematica p188.hs
Problem 191 p191.mathematica p191.hs
Problem 197 p197.mathematica Yes
Problem 203 p203.mathematica
Problem 204
Problem 205 p205.mathematica
Problem 206 Yes
Problem 211
Problem 214
Problem 215
Problem 216 Yes
Problem 218 p218.mathematica p218.hs Yes
Problem 222
Problem 225
Problem 231 p231.mathematica
Problem 243 p243.mathematica Yes
Problem 249
Problem 250 p250.mathematica
Problem 265
Problem 267 Yes
Problem 271 Yes
Problem 280
Problem 301 p301.mathematica p301.hs Yes
Problem 303 Yes
Problem 304
Problem 315
Problem 323 p323.mathematica p323.hs Yes
Problem 345
Problem 346 Yes
Problem 347
Problem 357 Yes
Problem 381 p381.mathematica Yes
Problem 387
Problem 401 p401.mathematica Yes
Problem 407 Yes
Problem 417 Yes
Problem 425 Yes
Problem 429 p429.mathematica Yes
Problem 431
Problem 433 Yes
Problem 451
Problem 493
Problem 500 Yes
Problem 518 Yes
Problem 549 Yes

Language usage


For every problem that I solved, I have a Java solution for it (and possibly code in other languages as well). I like using Java because it is fast, safe, and expressive. To elaborate on these points, I will compare it to other programming languages: Python and Mathematica are slow for basic integer arithmetic (~1/30× of Java speed) because they natively use bigint and are also dynamically typed. Also, Mathematica uses a lot of memory to store an array of integers because it doesn’t have packed fixed-width integers. C and C++ are unsafe because of the lack of array bounds checking, having signed integer overflow, and having tons of easily invoked undefined behaviors. Custom data structures like graphs are difficult to express cleanly in Mathematica. Custom algorithms like the sieve of Eratosthenes, especially ones most naturally expressed in terms of imperative state updates, are difficult to implement correctly or efficiently in Haskell. Non-strict evaluation in Haskell makes it easy to accidentally leak large amounts of memory in unexpected places.

However on the flip side, I prefer to solve a problem in Mathematica first if it’s possible. This is because it has many useful built-in mathematical functions (like prime testing) and objects (like fractions) that would require manual effort to implement in Java. Also, my Java solutions tend to be long due to types on every variable, lots of custom code, and low-level loops instead of higher-order functions. If I was aiming for raw execution speed, writing comparable code in C or C++ would probably run 3× as fast as Java.

Note that for problems involving non-whole numbers, I try to use exact integer arithmetic or fractions as much as possible, which ensures that the solution is provably correct. As a result I strongly avoid any floating-point arithmetic at all, unless there is no other reasonable way (that I know of) to solve the problem. Also I study the numerical bounds carefully to avoid integer overflow, and use the most reasonably narrow type for speed (choosing between int, long, or BigInteger).

To run a Java solution, compile the Java file (e.g. and also the shared classes and Then run with a command like java p001, and the answer will be printed to standard output.

Sample code (problem 117) (most other solutions are many times longer):

public class p117 {
  private static final int LENGTH = 50;
  public static void main(String[] args) {
    // Dynamic programming
    long[] ways = new long[LENGTH + 1];
    ways[0] = 1;
    for (int n = 1; n <= LENGTH; n++) {
      for (int k = 1; k <= 4 && k <= n; k++)
        ways[n] += ways[n - k];



Many solutions are made available in Python, which is an imperative object-oriented language with many conceptual similarities to Java. These pieces of code are interesting for a couple of reasons: One is that it caters to programmers who prefer to read Python code over Java due to familiarity with the language. Another is that the Python code has less syntactic “noise” due to the lack of types, variable declarations, and integer size distinctions – so the Python code expresses the essential ideas of the mathematical algorithms more directly. My Python code is designed to be compatible with Python 2.7 and 3.4 alike.

The Python solutions were initially based on the Java solutions, often starting with a direct literal port of the Java code into Python. Over time, the Python code was adapted to fit the characteristics of the language – such as using idiomatic/Pythonic approaches, tweaking or changing algorithms to increase speed (whereas Java can sometimes get away with less efficient but simpler algorithms), and making heavy use of generators. The style of using generators/filters/itertools can be considered about halfway between Java’s imperative style and {Haskell or Mathematica}’s functional style. Unfortunately due to Python’s slow performance on arrays and short integer values, it will be difficult for me to make Python solutions available for the CPU- or memory-intensive Project Euler problems.

Sample code (problem 10):

# Sieve of Eratosthenes
ans = 0
isprime = [True] * 2000001
for i in range(2, len(isprime)):
	if isprime[i]:
		ans += i
		for j in range(i * i, len(isprime), i):
			isprime[j] = False



I used Mathematica for many of the earlier problems, because compactness and convenient library functions were more important than running time or memory. Mathematica provides easy access to prime numbers, big integers, high-precision floats, fractions, continued fractions, and more. My code tends to be quite short: one-liners are very common, and typically the solution is less than 5 lines of code. For problems that involve computing and/or storing millions of numbers, my experience has been that Mathematica takes too long to run my algorithm or exceeds the memory limit.

In Mathematica, I make heavy use of nested expressions, functional programming core functions like Map and Select, and aggregation functions like Total, Length, Sum. Occasionally I write imperative code in Mathematica, usually for unbounded searching. I write Mathematica code in a rather plain style, using only [] for function application (not @ or //), avoid pattern processing, and avoid declaring functions with the #-and-& syntax.

To run a Mathematica solution, copy the entire code into a new Mathematica notebook and evaluate the whole block of text. The solution is shown in the output.

Sample code (problem 7):


Sample code (problem 20):


Sample code (problem 29):

Length[Union[Flatten[Table[a^b, {a, 2, 100}, {b, 2, 100}]]]]

Sample code (problem 323):

cdf[n_] := (1 - (1/2)^n) ^ 32
pdf[n_] := cdf[n] - cdf[n - 1]
Sum[n * pdf[n], {n, Infinity}]  (* Exact *)
N[%, 11]  (* Rounded *)



I’m a beginner at Haskell programming, and only know how to use it to solve the easier problems in Project Euler. When I do use it, I end up learning many new concepts in functional programming, such map/filter/fold, infinite lists, converting iterative algorithms to recursive functions, memoization, etc. When a problem can be solved in a purely functional way without imperatively updating variables, my Haskell solution will be structured very similarly to my Mathematica solution.

To run a Haskell solution, run the Haskell file as a main program.

Sample code (problem 21):

main = putStrLn (show ans)
ans = sum [n | n <- [1..10^4], amicable n]

amicable :: Int -> Bool
amicable n = let m = divisorSum n in (m /= n) && (divisorSum m) == n

divisorSum :: Int -> Int
divisorSum n = sum [k | k <- [1..n-1], (mod n k) == 0]


Benchmark timings

The Project Euler solution programs listed above were benchmarked to see how much time it took to compute the answer. This information gives a rough sense of which problems are easy or hard, and how the choice of programming language affects the running time.

Note that the benchmark does not attempt to be “fair” in any way. My solution code is first designed to run within an “acceptable” running time (not targeting absolute fastest code), and then heavily optimized for human clarity (both in terms of the code implementation and the underlying mathematical concepts). Sometimes, slightly inefficient constructs (such as list comprehensions) are used for the sake of clarity. The algorithms between different languages are not exactly the same; instead I try to write code that is most idiomatic and clear for the given language. However, it can still be observed that Python is generally 10× to 30× slower than Java for pure number-crunching code.

All the numbers listed in the table below are in seconds, and these computing environments were used:

Problem Java Python 2 Python 3 Mathematica
Problem 10.0004150.0000.0010.000
Problem 20.0001990.0000.0000.016
Problem 30.0026340.0440.0020.000
Problem 40.1604850.2590.3073.328
Problem 50.0051490.0000.0000.000
Problem 60.0002000.0010.0000.000
Problem 70.0333430.1620.3800.000
Problem 80.0024010.0060.0030.000
Problem 90.0082250.0210.0362.265
Problem 100.0570900.2880.2941.797
Problem 110.0014780.0020.0010.032
Problem 120.1674522.3685.1170.140
Problem 130.0048930.0000.0000.000
Problem 140.2769891.1601.316114.187
Problem 150.0005590.0000.0000.000
Problem 160.0020400.0000.0010.000
Problem 170.0025500.0010.0010.031
Problem 180.0002480.0000.0000.141
Problem 190.0013050.0010.0010.031
Problem 200.0009660.0000.0000.000
Problem 210.2467480.0090.0130.203
Problem 220.0325020.0070.0080.109
Problem 230.0801701.8062.63419.766
Problem 240.0362490.0200.02121.891
Problem 250.0105490.0290.0290.406
Problem 260.0440020.0140.0200.078
Problem 270.1013470.6991.08934.063
Problem 280.0002260.0000.0000.000
Problem 290.0545160.0120.0060.031
Problem 300.0459893.3713.35418.109
Problem 310.0004770.0000.0010.047
Problem 320.2134230.1160.17120.890
Problem 330.0007560.0010.0010.062
Problem 340.1588592.3384.168125.062
Problem 350.1925381.4341.37648.328
Problem 360.1079720.3670.4095.610
Problem 370.0671131.0962.1205.953
Problem 380.0193360.0270.0280.453
Problem 390.1234993.4195.758151.453
Problem 400.0629110.1860.2801.813
Problem 410.0634971.3122.45813.125
Problem 420.0060120.0030.0040.047
Problem 430.1429454.2114.680250.453
Problem 440.78708713.91115.060
Problem 450.0348220.0620.0790.672
Problem 460.0037430.0230.0541.797
Problem 470.1049771.4592.5931.156
Problem 480.0454960.0020.0010.031
Problem 490.0792700.5620.66040.594
Problem 500.0503530.3350.40819.719
Problem 510.1426125.4038.134
Problem 520.0680700.3470.3331.156
Problem 530.0561390.0350.0110.016
Problem 540.0483450.0510.091
Problem 550.0875070.0590.0500.750
Problem 560.0904750.3510.1730.094
Problem 570.0378840.0020.0023.156
Problem 580.1647542.2925.645
Problem 590.1554064.5347.132
Problem 605.12928999.801129.375
Problem 610.0087400.0020.010
Problem 620.0399360.0960.107
Problem 630.0005750.0000.0000.000
Problem 640.5226532.1436.00612.390
Problem 650.0006940.0000.0010.000
Problem 660.1133450.1830.3091.204
Problem 670.0014190.0020.0020.047
Problem 680.0704713.3864.680
Problem 690.0620095.4394.280
Problem 700.43609910.06212.642
Problem 710.0243330.2640.2644.750
Problem 720.0443770.7370.8828.140
Problem 730.0806494.2475.202
Problem 741.11333522.02230.977
Problem 750.0897990.9000.691
Problem 760.0022230.0010.0020.000
Problem 770.0005080.0020.003
Problem 783.4257262.3524.395
Problem 790.6561095.4685.229
Problem 800.0844690.0500.0250.078
Problem 810.0021240.0030.0050.078
Problem 820.0011200.0060.01210.703
Problem 830.3035040.0800.1151.922
Problem 842.63245922.32430.817
Problem 850.0382031.2161.132
Problem 860.58395036.11650.369
Problem 870.2386950.3790.353
Problem 881.44098336.56138.757
Problem 890.0083050.0110.0170.250
Problem 900.0300070.3480.389
Problem 910.0499481.5892.359
Problem 920.61555522.80426.797209.875
Problem 930.83367622.26714.322
Problem 942.28009238.333104.038
Problem 950.5796445.3965.742
Problem 960.1760191.5461.925
Problem 970.0009880.0000.0000.016
Problem 980.41447030.94757.231
Problem 990.0827290.1430.166
Problem 1000.0005090.0000.000
Problem 1010.0029950.0030.0110.000
Problem 1020.0011900.0010.003
Problem 1040.7166053.5883.58729.312
Problem 1050.0464670.0680.088
Problem 1070.0031490.0020.003
Problem 1080.1029091.5813.657
Problem 1090.0065640.0110.011
Problem 1110.0521570.3580.241
Problem 1120.0732811.9722.03122.938
Problem 1130.0002940.0010.0000.000
Problem 1140.0002930.0000.0000.000
Problem 1150.0020260.0000.0010.000
Problem 1160.0003600.0010.0010.000
Problem 1170.0002870.0000.0010.000
Problem 1180.74030926.52948.952
Problem 1190.0269780.0350.019
Problem 1200.0002620.0000.0000.000
Problem 1210.0003560.0000.0010.875
Problem 1220.63177959.02371.990
Problem 1230.0150560.1360.1360.046
Problem 1240.1183650.0970.117
Problem 1250.0620110.1270.163
Problem 1271.8809912.5923.649
Problem 1280.0888262.1722.126
Problem 1290.0627980.2820.5499.000
Problem 1300.1115150.9451.672
Problem 1320.0597630.3340.6940.094
Problem 1330.0662560.0710.0600.219
Problem 1340.0565400.4600.5789.391
Problem 1350.0570210.9731.702
Problem 1390.0964562.9004.729
Problem 1420.22106712.56024.227
Problem 1450.0001970.0000.000
Problem 1469.755274342.145243.793
Problem 1490.2506829.61311.037
Problem 1500.39213256.16570.040
Problem 1510.0160200.0010.001
Problem 1557.40493028.93265.697
Problem 1600.0369950.7930.74412.235
Problem 1620.0005890.0010.0000.000
Problem 1640.0199200.0550.090
Problem 1660.4157668.88714.165
Problem 1690.0240020.0030.004
Problem 1710.0636770.4550.5062.954
Problem 1720.0018410.0000.0010.000
Problem 1730.0203750.3040.36115.953
Problem 1740.0279950.4330.502
Problem 1790.97719614.70219.306
Problem 1820.7965501.3766.981
Problem 1860.46969111.2709.861
Problem 1870.3303718.5838.719
Problem 1880.0014250.0020.0030.000
Problem 1910.0002880.0000.0010.016
Problem 1970.0070680.0000.0000.062
Problem 2030.1102822.3292.129
Problem 2040.1071587.3476.986
Problem 2050.0007590.0010.000
Problem 2060.967101213.680187.947
Problem 2112.804733367.945207.948
Problem 2141.48139551.65238.786
Problem 2150.7618231.1091.118
Problem 2166.55709786.65068.302
Problem 2180.0001720.0000.0000.000
Problem 2226.874569200.225277.472
Problem 2250.1195933.4034.194
Problem 2311.86495929.43931.209
Problem 2430.0003060.0000.0000.000
Problem 2491.436237131.87194.038
Problem 2500.26530618.90214.753
Problem 2650.765436252.204195.030
Problem 2670.8309932.3513.271
Problem 2710.0103330.0040.016
Problem 2800.507233
Problem 3010.0001780.0000.0000.000
Problem 3030.52550638.46530.216
Problem 3043.0838028.8007.006
Problem 3150.1577208.6249.814
Problem 3230.0007060.0000.0011.641
Problem 3450.0254560.1560.201
Problem 3460.2625321.5330.756
Problem 3470.3121042.1132.134
Problem 3571.51648756.380106.791
Problem 3810.79418313.99218.010205.875
Problem 3871.67111015.35210.502
Problem 4016.45220441.96831.580850.921
Problem 4074.09125585.753112.527
Problem 41713.857084
Problem 4251.70978851.83061.863
Problem 4290.76007421.26818.788155.015
Problem 431715.889810
Problem 433> 1 day
Problem 45127.888166
Problem 4930.0246180.0030.018
Problem 5184.737045115.295285.233
Problem 5492.44453993.495108.880

More info