The sequence of triangle numbers is generated by adding the natural numbers. So the 7^th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, …

Let us list the factors of the first seven triangle numbers:

 1: 1
 3: 1,3
 6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

Analysis

Our algorithm for solving this one was improved nicely by a detailed explanation provided by a Project Euler moderator named ‘rayfil’. His wonderful explanation is published as a PDF document that is available after you solve the problem. What follows is our own interpretation written in Python.

Solution

Runs < 1 second in Python.

def expx(n,p):
  exp=1
  while n % p == 0: 
    exp+=1; 
    n = n/p
  return n,exp
 
def prime_exp(n):
  dx = 1
  for p in primes: 
    if p*p > n: return dx * 2 
    n,exp=expx(n,p)
    dx*= exp
    if n==1: break
  return dx
 
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
nx=3
dx=2 
ndiv=0
max_div = 500
while ndiv <= max_div: 
  nx+= 1 
  dxx = prime_exp(nx/2 if nx % 2 == 0 else nx)
  ndiv, dx = dx*dxx, dxx 
print "Answer to PE12 = ", nx*(nx-1)/2

Comments

The following iterative sequence is defined for the set of positive integers:

n → n/2 (n is even)
n → 3n + 1 (n is odd)

Using the rule above and starting with 13, we generate the following sequence:

It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.

Which starting number, under one million, produces the longest chain?

NOTE: Once the chain starts the terms are allowed to go above one million.

Analysis

Brute forcing a solution may break the one minute rule especially if the limit of this problem changes. Two ways we improved the performance to mere seconds was to cache the chain lengths and only check odd n from half the range, in this case 500,001 to 1,000,000. We can do this because the results are symmetrical either side of the half-way point.

Solution

Runs < 3 seconds in Python.

cache = { 1: 1 }
def chain(n):
    if not n in cache:
        cache[n] = chain(3*n+1 if n%2 else n/2) + 1
    return cache[n]
 
max = (0,0)
for i in range(500001,1000000,2):
    if chain(i) > max[1]: max = (i,chain(i))
print "Answer to PE14 = ", max

Comments

This solution prints both the starting number and chain length

2¹⁵ = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.

What is the sum of the digits of the number 2¹⁰⁰⁰?

Analysis

Calculate 2¹⁰⁰⁰, split the digits and add them together.

Solution

Runs < 1 second in Python.

print "Answer to PE16 = ", sum(int(i) for i in str(2**1000))

Comments

Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.

Analysis

Only the first 11 digits of each of the 100 numbers are required for the first 10 digits of the sum. The numbers were written to a file, pe13.txt, to save space.

Solution

Runs < 1 second in Python.

f = open('pe13.txt').read().split()
total = sum( [int(x[:11]) for x in f] )
print "Answer to PE13 ", str(total)[:10]

Comments

In the 20×20 grid below, four numbers along a diagonal line have been marked in red.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26 × 63 × 78 × 14 = 1788696.

What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally) in the 20×20 grid?

Analysis

No other option but to load matrix into an array and iterate through the rows, columns and diagonals to find four consecutive cells that produce a maximum product.

Solution

Runs < 1 second in Python.

n = [[8,2,22,97,38,15,0,40,0,75,4,5,7,78,52,12,50,77,91,8],
[49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,4,56,62,0],
[81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,3,49,13,36,65],
[52,70,95,23,4,60,11,42,69,24,68,56,1,32,56,71,37,2,36,91],
[22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80],
[24,47,32,60,99,3,45,2,44,75,33,53,78,36,84,20,35,17,12,50],
[32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70],
[67,26,20,68,2,62,12,20,95,63,94,39,63,8,40,91,66,49,94,21],
[24,55,58,5,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72],
[21,36,23,9,75,0,76,44,20,45,35,14,0,61,33,97,34,31,33,95],
[78,17,53,28,22,75,31,67,15,94,3,80,4,62,16,14,9,53,56,92],
[16,39,5,42,96,35,31,47,55,58,88,24,0,17,54,24,36,29,85,57],
[86,56,0,48,35,71,89,7,5,44,44,37,44,60,21,58,51,54,17,58],
[19,80,81,68,5,94,47,69,28,73,92,13,86,52,17,77,4,89,55,40],
[4,52,8,83,97,35,99,16,7,97,57,32,16,26,26,79,33,27,98,66],
[88,36,68,87,57,62,20,72,3,46,33,67,46,55,12,32,63,93,53,69],
[4,42,16,73,38,25,39,11,24,94,72,18,8,46,29,32,40,62,76,36],
[20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,4,36,16],
[20,73,35,29,78,31,90,1,74,31,49,71,48,86,81,16,23,57,5,54],
[1,70,54,71,83,51,54,69,16,92,33,48,61,43,52,1,89,19,67,48]]
 
maxp = 0
rows, cols, token = 20, 20, 4
for i in range(rows):
  for j in range(cols-token+1):
    phv = max(n[i][j] * n[i][j+1] * n[i][j+2] * n[i][j+3],
              n[j][i] * n[j+1][i] * n[j+2][i] * n[j+3][i])
    if i<rows-token:
      pd = max(n[i][j] * n[i+1][j+1] * n[i+2][j+2] * n[i+3][j+3],
               n[i][j+3] * n[i+1][j+2] * n[i+2][j+1] * n[i+3][j])
    maxp = max(maxp, phv, pd)
print "Answer to PE11 = ",maxp

Comments

If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.

If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?

NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of “and” when writing out numbers is in compliance with British usage.

Analysis

Converted the integers from 1 to 999 to the written equivalent, removed spaces and hyphens, added the character count for each one, including “onethousand”.

Solution

Runs < 1 second in Perl.

@D{0 .. 20, 30,40,50,60,70,80,90} = qw|
 zero one two three four five six seven eight nine ten
 eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen
 twenty thirty forty fifty sixty seventy eighty ninety|;
 
for $i (1..999) {
  $x= num2en($i); $x=~s/[s-]//g;
  $l+= length($x);
}
print "Answer to PE17 = ",$l+length('onethousand');
 
sub num2en {
  my($x) = $_[0];
  return $D{$x} if defined $D{$x};
  return  $D{$1 . '0'} . '-' . $D{$2} if( $x =~ m/^(.)(.)$/ );
  if ( $x =~ m/^(.)(..)$/ ) {
      my($h, $rest) = ("$D{$1} hundred", $2);
      return $h if $rest eq '00';
      return "$h and " . num2en($rest);
  }
}

Comments

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.

Analysis

Sieve the prime numbers less than 2,000,000 and sum them. Having a fast algorithm to sieve primes helps a solution run under a few seconds.

Solution

Runs < 2 seconds in Python.

limit = 2000000
sieve = range(limit)
for n in xrange(2, int(limit**.5) + 1):
  if sieve[n]: 
    for i in xrange(n ** 2, limit, n): 
      sieve[i] = 0
print "answer to PE10 = ",sum(sieve)

Comments

This problem changed from a limit of one million in 2008.

Starting in the top left corner of a 2×2 grid, there are 6 routes (without backtracking) to the bottom right corner.

How many routes are there through a 20×20 grid?

Analysis

This question has been posed as: “Starting at the top left corner, how many ways through town are possible using only one-way streets and ending at the bottom right corner of a n x n grid?”

The solution is the central binomial coefficient or the center number in the 2n+1 row of pascal’s triangle. The formula in general for an n x m grid is (n+m)! / (n!m!). Any combination using nDs and mLs would be a valid move.

In the example provided in the problem description there would be (2+2)! or 24 possible moves, but many would be indistinguishable, and we would have to divide by (2! · 2!) to eliminate them. So, (2 + 2)! / (2! · 2!) = 24 / 4 = 6. Namely, LLDD, LDLD, LDDL, DLLD, DLDL and DDLL. By indistinguishable we mean DDL₁L₂ is the same move as DDL₂L₁.

Solution

Runs < 1 second in Python.

f = lambda n:[1,0][n>0] or f(n-1)*n
n = 20
m = 20
 
print "Answer to PE15 = ", f(n+m) / ( f(n)*f(m) )

Comments

The OEIS for this series is A000984
If we added the condition “which do not pass below the diagonal” to our problem statement, we would use a Catalan number. It is calculated as 2n! / n! / (n+1)!

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.

3
7 5
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom of the triangle below:

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
… {data continues} …

NOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)

Analysis

To solve this problem and problem 67, which is much larger, start the search from the bottom to the top, adding the maximums along the way. This will “bubble” the maximum total to the top of the pyramid.

Let’s follow this technique, step by step, with the 4 row triangle example to show how this works.

3
7 5
2 4 6
8 5 9 3
OK, starting at the bottom,
We look at 8 and 5, pick the maximum, 8 in this case, and replace the 2 in the previous row with their sum 10.
We look next at 5 and 9, pick the maximum, 9, and replace the 4 in the previous row with their sum 13.
We look lastly at 9 and 3, pick the maximum, 9, and replace the 6 in the previous row with their sum 15.
Now our array looks like:
3
7 5
10 13 15

Let’s do it again. Take the larger of 10 and 13 and add it to 7 making 20.
Take the larger of 13 and 15 and add it to 5 making 20.
Now our array looks like:
3
20 20

At last we take the larger of 20 and 20 (yes, I know they’re the same) and add it to 3 making 23.
And our array looks like:
23
The maximum total path in the triangle.

Solution

Runs < 1 second in Perl.

my @rows = map { [split /s/] } <DATA>; 
my $nrows =  $#rows;
 
for (my $i = $nrows; $i>0; $i--) {
  for my $j (0 .. $i-1) { 
    $rows[$i-1][$j] += max_n( $rows[$i][$j], $rows[$i][$j+1] ); 
  }
} 
print "Answer to PE18 = $rows[0][0]"; 
__DATA__ 
3
7 5
2 4 6
8 5 9 3

Comments

• We’ve included the sample data as an example.
• The first line of the program reads the data file, which is appended to the end of the program after the __DATA__ separator, into a two dimensional array named @rows. $nrows is the last index of the array so in this case 3.
• Check here for more information on the max_n function.
• See also problem 67, 81, 82 & 83.

You are given the following information, but you may prefer to do some research for yourself.

1 Jan 1900 was a Monday.
Thirty days has September,
April, June and November.
All the rest have thirty-one,
Saving February alone,
Which has twenty-eight, rain or shine.
And on leap years, twenty-nine.

A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.

How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?

Analysis

There are 1200 months (therefore 1200 firsts of the month) in 100 years (1/1/1901 – 12/31/2000). One in every 7 days is a Sunday (or Monday, Tuesday, etc.) which are (roughly) uniformly distributed over the date range. An estimate of 1200/7 Sundays should be close to the answer. As the date range widens this estimate becomes less precise.

We wrote a quick piece of JavaScript (great native calendar support) to prove it to ourselves.

Solution

Runs < 1 second in Javascript.

var count=0, y=1901, years=100;
for (var m=0; m<12*years; m++)
  if (new Date(y,m,1).getDay()==0) count ++;
 
document.write ('answer to PE19 = ' + count + ' Sundays')

Comments

JavaScript numbers the months starting from 0 to 11 so month m=12 is the 1st month (January) of the next year (1902) and so month m=24 is January 1903. Also, getDay() returns 0 for Sunday. As an exercise you could pose questions for other date ranges and other days of the week and compare it to the estimating formula.