The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.

Find the sum of the only eleven primes that are both truncatable from left to right and right to left.

NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.

Analysis

The good news is the problem tells us there’s only 11. We can just keep searching a bunch of primes until 11 meet the criteria.

With just some casual thought it occurred to us that since we are going to truncate in both directions only primes ending in 3 or 7 are valid. Also any prime with at least one digit from the set [0, 2, 4, 5, 6, 8] would make the prime invalid. Add to that pairs such as ’11′, ’33′, ’77′ or ’99′ and the possible prime numbers gets smaller.

Two problems: The two digit primes 23 and 53 would violate our filter (we found these by looking at the table of prime numbers), so we will have to mark these as exceptions. And just how big can these primes get?

One way to find out is just to get started and see what happens. This code gave us our solution set and the answer.

After seeing the results, we realized we could build a tree to ferret out the set of primes. Here’s a tree for 2, 5, and 7. We’ll leave 3 as an exercise.

2 — 3

5 — 3

   3 — 9 — 3 — 9 — 7
7 — 9 — 7

When a prime starts with 7 it can only be followed by 3 or 9. For the 9 branch only a 7 can come next and no other number would follow. A 3, 1, 7 or 9 would produce a composite number as 39, 9, 77 or 1.
The same logic follows for the 3 side.

Solution

Runs < 1 second in Perl.

use integer;
my $s = 23 + 53;  #first two that are exceptions to our pattern
open IN, "<primes2.txt";
@p = grep {!/[024568]/ && /[37]$/ && /^(3[17][^1]|7[39][^13])/ && !/99|77|33|11/} <IN>;
while ($c<11) {
  $q=shift @p;
  if (trunc($q)) {
    $c++;
    $s+=$q;
  }
}
print "Answer to PE37 = $s, $c primes found";
 
sub trunc {
 my $c = $d = shift;
 while ($d) {
  return 0 unless is_prime($d) && is_prime($c);
  $c%=10**(length($c)-1);
  $d/=10;
 }
return 1
}

Comments

Didn’t have fun with this one. Here’s the set: [23, 37, 53, 73, 313, 317, 373, 797, 3137, 3797, 739397]
Here’s the start of our regex code to sift out the 11 primes from a file of primes. It reduces the list of 78,499 primes from 2 – 1,000,000 to just 28. Not up to finishing it.

open IN, "<primes2.txt";
@p = grep {!/[024568]/ && /[37]$/ && /^(3[17][^1]|7[39][^13])/ && !/99|77|33|11/} <IN>;

The fraction ⁴⁹/₉₈ is a curious fraction, as an inexperienced mathematician in attempting to simplify it may incorrectly believe that ⁴⁹/₉₈ = ⁴/₈, which is correct, is obtained by cancelling the 9s.

We shall consider fractions like, ³⁰/₅₀ = ³/₅, to be trivial examples.

There are exactly four non-trivial examples of this type of fraction, less than one in value, and containing two digits in the numerator and denominator.

If the product of these four fractions is given in its lowest common terms, find the value of the denominator.

Analysis

This is curious problem and was able to solve it in just a few lines and 84 iterations. Just generated all fractions with 2 digit numerators and denominators and ignored ‘trivial’ examples. Used symmetry to consider distinct fractions – which was really not necessary, but…why not.

Solution

Runs < 1 second in Python.

d = 1
for i in xrange(1, 10):
  for j in xrange(1, i):
    for k in xrange(1, j):
      ki = k*10 + i
      ij = float(i)*10 + j
      if (ij/ki == float(j)/k):
        d *= ij/ki
print "Answer to PE33 = ",d

Comments

Added the float function to keep calculations from converting to integers.

We shall say that an n-digit number is pandigital if it makes use of all the digits 1 to n exactly once; for example, the 5-digit number, 15234, is 1 through 5 pandigital.

The product 7254 is unusual, as the identity, 39 × 186 = 7254, containing multiplicand, multiplier, and product is 1 through 9 pandigital.

Find the sum of all products whose multiplicand/multiplier/product identity can be written as a 1 through 9 pandigital.

HINT: Some products can be obtained in more than one way so be sure to only include it once in your sum.

Analysis

This is a perfect application for a simple brute force program that iterates through the possibilities and produces a solution. The only thought of optimization was to only generate as many 4 digit products as necessary in order to keep the concatenation of i, j and p at the required 9 digits. The only combinations are a 1 digit number times a 4 digit number (lowest valid = 1234) or a 2 digit number times a 3 digit number (lowest valid = 123).

A set is used to ignore duplicate products.

Solution

Runs < 1 second in Python.

from Euler import is_pandigital
 
p = set()
for i in range(2,100):
  start = 1234
  if i>9: start = 123
  for j in range(start, 10000/i+1):
    if is_pandigital(str(i)+str(j)+str(i*j)): p.add(i*j)
 
print "Answer to PE32 = ",sum(p)

Comments

• More information on the Euler module can be found on the tools page.
• This solution took 21,220 iterations.
• Of the 9 sets found, the last one was 48 × 159 = 7632

If p is the perimeter of a right angle triangle with integral length sides, {a,b,c}, there are exactly three solutions for p = 120.

{20,48,52}, {24,45,51}, {30,40,50}

For which value of p ≤ 1000, is the number of solutions maximised?

Analysis

The Pythagorean Theorem gives us: a² + b² = c² and by intuition a + b + c = p (perimeter).
The decision to iterate perimeters has many advantages over generating right triangles. Only even numbered perimeters need to be checked; below is our analysis:

No matter which integral values we choose for a, b and c such that a² + b² = c² the perimeter will be even.

By iterating perimeters we need a method to check for integral (integer) right triangles.
We can interpret the Pythagorean theorem as a² + b² = (p-a-b)² since c = p-a-b. After expanding and simplifying we have:
b = p(p – 2a) / 2(p-a) and when this equation evaluates to an integer (MOD(p(p – 2a), 2(p-a)) = 0) we have our triangle.

One last optimization. By using a+b>c and symmetry we only need to investigate values of a to p/4.

Solution

Runs < 1 second in Python.

t_max = 0;
p_limit = 1000
 
for p in xrange (2, p_limit+1, 2):
  t = 0;
  for a in xrange (2, p/4+1):
    if  p*(p - 2*a) % (2*(p-a)) == 0: t += 1
    if t > t_max: (t_max, p_max) = (t, p)
 
print "Answer to PE30 = ", p_max

Comments

Some other results:
10,000 = 9,240
100,000 = 55,440
1,000,000 = 720,720
10,000,000 = 6,126,120

The number, 197, is called a circular prime because all rotations of the digits: 197, 971, and 719, are themselves prime.

There are thirteen such primes below 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, and 97.

How many circular primes are there below one million?

Analysis

We used our file of prime numbers and included those below 1 million and excluded those greater than 10 that contained the digits {0, 2, 4, 5, 6 or 8} because as a prime is rotated it cannot end with any of these digits and remain prime.

We read these numbers into a hash (associative array) using the prime numbers as keys. The hash also serves as an ‘is prime?’ function. If a particular key exists then the number is prime and if it does not, then it’s composite. The program loops through the hash’s keys and checks each rotation as a prime number. When every rotation is prime it’s counted as a circular prime.

Solution

Runs < 1 second in Perl.

open (IN,"<primes35.txt")  or die "Error opening file: $!";
my %is_prime = map { ($_*1,1) } grep length($_)==2 || !/[024568]/, <IN>;
my $cp = 0;
 
P: for my $prime (keys %is_prime) {
      for ( 2..length($prime) )  { 
        rotate($prime); 
        next P unless $is_prime{$prime} 
     }
     $cp++;
  }
print "Answer to PE35 = $cp";

Comments

• Check out the tools post for an explanation of the rotate() function
• The next circular prime is a rep unit 19 digits long (R₁₉ = 1111111111111111111), so using this method for finding circular primes > 1,000,000 is impracticable
• OEIS A016114

145 is a curious number, as 1! + 4! + 5! = 1 + 24 + 120 = 145.

Find the sum of all numbers which are equal to the sum of the factorial of their digits.

Note: as 1! = 1 and 2! = 2 are not sums they are not included.

Analysis

These type of numbers are referred to as factorions and it’s easy to learn that only 4 exist: 1, 2, 145 & 40585. The problem description wants us to ignore 1 & 2 so the answer to this problem should become obvious.

But, let’s write a program anyway to search for factorions. As usual, when writing a brute force search algorithm, we must first determine our bounds. The lower bound is 10 because single digit candidates are to be ignored. The upper bound we discover as follows (from Wikipedia):

If n is a natural number of d digits that is a factorion, then 10^{d − 1} ≤ n ≤ 9!d and this fails to hold for d ≥ 8. Thus n has 7 digits and the maximum sum of factorials of digits for a 7 digit number is 9!7 = 2,540,160, which is the upper bound.

Afterwards, we learned 50,000 worked just fine.

Solution

Runs < 1 second in Perl.

my @fact = (1, 1, 2, 6, 24, 120, 720, 5_040, 40_320, 362_880); # 0 - 9 factorials 
my $s = 0;
 
for my $n (10..50_000) {
  $x=0;
  $x+=$fact[$_] for split //,$n;
  $s+=$n if $n == $x;
}
print "Answer to PE34 = $s";

Runs < 1 second in Python.

fact = (1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880)
s = 0
 
for n in range(10, 50000):
  x = sum( fact[int(d)] for d in str(n) )
  if n == x: s+=n
 
print "Answer to PE34 = ",s

Comment

This is a finite set of numbers and therefore a brute force solution is completely acceptable. As long as it runs under a minute no further optimization is necessary.

• We use underscores in numeric literals for readability
• See Problem 74
• Mathematica: Sum[Boole[n == Tr[IntegerDigits[n]!]] n, {n, 3, 1*^5}]

In England the currency is made up of pound, £, and pence, p, and there are eight coins in general circulation:

1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) and £2 (200p).
It is possible to make £2 in the following way:

1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
How many different ways can £2 be made using any number of coins?

Analysis

This is a typical problem that demonstrates the use of partitions which can be solved by dynamic programming. To keep this problem simple: order does not matter, there are always enough coins to make a combination and were not looking for the optimal way to make change. This a perfect application for tested algorithms where this problem has been used as an example. As the details and nuances of dynamic programming are somewhat involved; we have provided some links below for a better explanation:
Coin Change – Algorithmist
Dynamic Programming Solution to the Coin Changing Problem

Solution

Runs < 1 second in Perl.

my $target = 200;
my @coins = (1,2,5,10,20,50,100,200);
my @ways = (1);
 
for $coin (@coins) {
  $ways[$_] += $ways[$_-$coin] for $coin..$target;
}
 
print "Answer to PE31 = $ways[$target]";

Comments

• See Problem 76. The advantage this code has is the problem only wants the number of combinations. It would be a different approach if they wanted a set of combinations.
• In Perl, the default variable, $_, takes the index value of the loop. In this case, values from $coin to $target.

Surprisingly there are only three numbers that can be written as the sum of fourth powers of their digits:
1634 = 1⁴ + 6⁴ + 3⁴ + 4⁴
8208 = 8⁴ + 2⁴ + 0⁴ + 8⁴
9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴

As 1 = 1⁴ is not a sum it is not included.

The sum of these numbers is 1634 + 8208 + 9474 = 19316.

Find the sum of all the numbers that can be written as the sum of fifth powers of their digits.

Analysis

Firstly, “Find the sum” means we will need to build a solution set of valid elements that meet the problem’s criteria, and then add them together to verify we have calculated the correct and complete set.

Secondly, we make a list of constraints which place limits or restriction on the solution set. This problem excludes the candidate 1 from consideration. In fact, by intuitive extension, it is excluding all single digit candidates (numbers < 10) as they cannot form a sum of digits. This is a clue that our search range starts from at least 10. The truly ambitious may discover a method to calculate the optimal range minimum.

Finally, we write a brute-force program to see if it can derive the correct answer within the one minute time limit. The only concern is how much search range to consider. We have already determined the range minimum to be 10 so it’s finding the range maximum that remains a challenge. After just a moment of thought it becomes clear that the number of digits for the sum must have the same number of digits as a candidate, so we construct the table below:

In fact, it turns out that 9⁵ x (n-1) is actually more than adequate, which reduces the search range and improves the performance of the program. This was proved empirically.

Solution

We try our solution not only for the target exponent of 5 (about 3 seconds) but also for 3, 4, 6, and 7. This confirms that the program also works for cases of other powers and is keeping with our aim of extensibility.

$exp = 5; $t = 0;
 
for $n ( 10 .. 9**$exp * ($exp-1) ) {
  $s = 0;
  $s+= $_**$exp for split //,$n; #split the digits in $n and assign each to $_.
  if ($s==$n) {$t+=$s; print "$n  "}
}
print "n total: $t for exp = $expn";

Comments

A Google search of the given series in the problem description found:
“Fixed points for operation of repeatedly replacing a number by the sum of the fourth power of its digits.” (series A052455)
With a little further searching, we found:
“Fixed points for operation of repeatedly replacing a number by the sum of the fifth power of its digits.” (series A052464)
We also discovered a series of numbers that are related to this set called narcissistic numbers (or Armstrong numbers) which differ from our target solution set by restricting the number of digits to be equal to the exponent (series A005188).

Runs with other exponents
153 370 371 407
total: 1301 for exp = 3

1634 8208 9474
total: 19316 for exp = 4

548834
total: 548834 for exp = 6

1741725 4210818 9800817 9926315 14459929
total: 40139604 for exp = 7

Comparative Languages

Mathematica: Sum[Boole[n == Tr[IntegerDigits[n]^5]] n, {n, 2, 1*^6}]
When calculating the answer for exp=7 the Perl program took 7 minutes, 16 seconds on a modest PC. In contrast, the C++ version, listed below, took only 43 seconds; that’s about 10 times faster.
We used our C++ program to calculate exp=8 which took about 10 minutes as compared to hours in Perl.

C++ Source: 565 sec. execution time

#include "stdafx.h"
#include "math.h"
 
int main() { 
 
int i,s,t=0,exp=8;
long long  max = pow(9.0,exp) * (exp-1);
for (int n = 10; n < max; n++) {
  s=0;
  i=n;
  while (i > 0) { 
    s += pow((double)(i%10),exp); 
    i /= 10; 
  }
  if ( s == n) {printf("%11u, ", n);t+=s;} 
}
printf("n total: %11u for exp = %2d", t,exp);
}

Output:
24678050, 24678051, 88593477
total: 137949578 for exp = 8

The decimal number, 585 = 1001001001₂ (binary), is palindromic in both bases.

Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.

(Please note that the palindromic number, in either base, may not include leading zeros.)

Analysis

Since leading zeros are not allowed, the top and bottom bits for binary numbers have to be one in order to be palindromic. This eliminates even numbers from consideration.

Solution

Runs < 2 second in Perl.

$s=0; 
$limit = 1e6;
 
for (my $n=1; $n<$limit; $n+=2) { 
  $s += $n if palindromic($n) && palindromic(dec2bin($n));
} 
print "Answer to PE36 = $s"; 
 
sub dec2bin { sprintf("%b",shift) }
sub palindromic { @_[0] == reverse @_[0] }

Comments

Results < one trillion:
{ 1, 3, 5, 7, 9, 33, 99, 313, 585, 717, 7447, 9009, 15351, 32223, 39993, 53235, 53835,
73737, 585585, 1758571, 1934391, 1979791, 3129213, 5071705, 5259525,
5841485, 13500531, 719848917, 910373019, 939474939, 1290880921, 7451111547,
10050905001, 18462126481, 32479297423, 75015151057, 110948849011, 136525525631 }

Take the number 192 and multiply it by each of 1, 2, and 3:

192 × 1 = 192
192 × 2 = 384
192 × 3 = 576
By concatenating each product we get the 1 to 9 pandigital, 192384576. We will call 192384576 the concatenated product of 192 and (1,2,3)

The same can be achieved by starting with 9 and multiplying by 1, 2, 3, 4, and 5, giving the pandigital, 918273645, which is the concatenated product of 9 and (1,2,3,4,5).

What is the largest 1 to 9 pandigital 9-digit number that can be formed as the concatenated product of an integer with (1,2, … , n) where n > 1?

Analysis

We need to find a 1 to 9 pandigital number greater than 918273645 mentioned above (otherwise 918273645 would be the answer, and we tried that, and it wasn’t).

[In the following paragraph we are using ? as a wild card definition for a digit [1-9] and the ++ as the concatenation operator.]

Starting with n=2, we can eliminate (9? × 1) ++ (9? × 2) and (9?? × 1) ++ (9?? × 2) because they will never yield a 9 digit number, but (9??? × 1) ++ (9??? × 2) will, so n = 2 and our starting search must be a 4 digit number beginning with 9 and never contain a zero; namely 9123. It should be obvious that any n>2 is impossible.

Solution>

Runs < 1 second in Python.

from Euler import is_pandigital
 
for n in range(9876, 9123, -1):
  p = str(n*1) + str(n*2)
  if is_pandigital(p): 
    print "Answer to PE38 = ", p
    break

Comments

More information on the Euler module can be found on the tools page.