A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.

Let us consider repunits of the form R(10ⁿ).

Although R(10), R(100), or R(1000) are not divisible by 17, R(10000) is divisible by 17. Yet there is no value of n for which R(10ⁿ) will divide by 19. In fact, it is remarkable that 11, 17, 41, and 73 are only four primes below one-hundred that can ever be a factor of R(10ⁿ).

Find the sum of all the primes below one-hundred thousand that will never be a factor of R(10ⁿ).

Analysis

This is a modified solution from problem 132. Really all we’re doing is finding the prime factors of a very large R(n) using the Python modulus power function. We sum only those primes which are not factors.

Solution

Runs < 3 seconds in Python.

from Euler import is_prime
 
limit, q, s = 100000, pow(10, 50), 5
for p in xrange(5, limit, 2):
  if is_prime(p) and pow(10, q, p) != 1: s += p
 
print "Answer to PE133 = ", s

Comments

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

A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k.

For example, R(10) = 1111111111 = 11×41×271×9091, and the sum of these prime factors is 9414.

Find the sum of the first forty prime factors of R(10⁹).

Analysis

Another quick solution using the modulus power function to find the prime factors of a large repunit, r(10⁹).

Solution

Runs < 2 seconds in Python. Made some simple clarifications 3/17/10.

from Euler import is_prime
 
s = set()
n, q = 7, 10**9
while len(s) < 40:
  if is_prime(n) and pow(10, q, n) == 1: s.add(n)
  n += 2
 
print "Answer to PE132 = ", sum(s)

Comments

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

Here’s the first 40 prime factors: [11, 17, 41, 73, 101, 137, 251, 257, 271, 353, 401, 449, 641, 751, 1201, 1409, 1601, 3541, 4001, 4801, 5051, 9091, 10753, 15361, 16001, 19841, 21001, 21401, 24001, 25601, 27961, 37501, 40961, 43201, 60101, 62501, 69857, 76001, 76801, 160001]

A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.

Given that n is a positive integer and GCD(n, 10) = 1, it can be shown that there always exists a value, k, for which R(k) is divisible by n, and let A(n) be the least such value of k; for example, A(7) = 6 and A(41) = 5.

You are given that for all primes, p > 5, that p minus 1 is divisible by A(p). For example, when p = 41, A(41) = 5, and 40 is divisible by 5.

However, there are rare composite values for which this is also true; the first five examples being 91, 259, 451, 481, and 703.

Find the sum of the first twenty-five composite values of n for which
GCD(n, 10) = 1 and n − 1 is divisible by A(n).

Analysis

We started with the given information and added to it by simply checking which composite values of n-1 were divisible by A(n). The problems 129, 130, 132 and 133 were all solved with recreation in mind so not a lot of thought transpired. Compared to some solutions these do appear to be slower but simpler to understand.

Solution

Runs < 3 seconds in Python.

from Euler import is_prime, gcd
 
def A(n):
  if is_prime(n) or gcd(n, 10) != 1: return None
  x, k = 1, 1
  while x != 0:
    x = (x*10+1) % n
    k += 1
  return k
 
s = [91, 259, 451, 481, 703]
n = s[-1]
while len(s)< 25:
  n += 2
  an = A(n)
  if an != None and (n-1) % an == 0: 
    s.append(n)
 
print "Answer to PE130 = ", sum(s)

Comments

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

A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.

Given that n is a positive integer and GCD(n, 10) = 1, it can be shown that there always exists a value, k, for which R(k) is divisible by n, and let A(n) be the least such value of k; for example, A(7) = 6 and A(41) = 5.

The least value of n for which A(n) first exceeds ten is 17.

Find the least value of n for which A(n) first exceeds one-million.

Analysis

This was an obvious solution to the problem. Still not sure about the relevance of repunits so we just took the recreational approach and created a set of solutions that are easy to follow.

Solution

Runs < 2 seconds in Python.

from Euler import is_prime, gcd
 
def A(n):
  if is_prime(n) or gcd(n, 10) != 1: return None
  x, k = 1, 1
  while x != 0:
    x = (x*10+1) % n
    k += 1
  return k
 
limit = 1000001
n = limit
while A(n)<limit: n += 2
 
print "Answer to PE129 = ", n

Comments

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

It is possible to write ten as the sum of primes in exactly five different ways:

7 + 3
5 + 5
5 + 3 + 2
3 + 3 + 2 + 2
2 + 2 + 2 + 2 + 2

What is the first value which can be written as the sum of primes in over five thousand different ways?

Analysis

A straightforward extension to problem 76 using primes instead of counting numbers and having a variable target instead of a fixed one.

Solution

Runs < 1 second in Python.

primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79]
 
target = 11
while True:
  ways = [1] + [0]*target
  for i in primes:
    for j in range(i, target+1):
      ways[j] += ways[j-i]
  if ways[target] > 5000: break
  target += 1;
print "Answer to PE77 = ", target;

Comments

We selected this method because it uses fewer primes than having to guess at both the target and the number of primes needed. Also, from the example, we can start at 11 for our search.

The arithmetic sequence, 1487, 4817, 8147, in which each of the terms increases by 3330, is unusual in two ways: (i) each of the three terms are prime, and, (ii) each of the 4-digit numbers are permutations of one another.

There are no arithmetic sequences made up of three 1-, 2-, or 3-digit primes, exhibiting this property, but there is one other 4-digit increasing sequence.

What 12-digit number do you form by concatenating the three terms in this sequence?

Analysis

An obvious solution. Start with the known solution plus 2 (1487+2) and find the next set checking only odd numbers.

Solution

Runs < 1 second in Python.

from Euler import is_prime, is_perm
 
n = 1489  # must be odd
while True:
  b, c = n+3330, n+6660
  if is_prime(n) and is_prime(b) and is_prime(c) \
    and is_perm(n,b) and is_perm(b,c): break
  n += 2
print "Answer to PE49 = ", str(n)+str(b)+str(c)

Comments

• More information on the Euler module can be found on the tools page.
• It wasn’t clear, perhaps intentionally, that the terms in the sequence would increase by the same amount (3330) as the example.

It was proposed by Christian Goldbach that every odd composite number can be written as the sum of a prime and twice a square.

9 = 7 + 2×1²
15 = 7 + 2×2²
21 = 3 + 2×3²
25 = 7 + 2×3²
27 = 19 + 2×2²
33 = 31 + 2×1²

It turns out that the conjecture was false.

What is the smallest odd composite that cannot be written as the sum of a prime and twice a square

Analysis

Generate primes as needed and check the conjecture until a prime isn’t found.

Solution

Runs < 1 second in Python.

n = 5
f = 1
primes = set()
 
while (1):
  if all( n % p for p in primes ):
    primes.add(n)
  else:
    if not any( (n-2*i*i) in primes for i in xrange(1, n) ):
      break
  n += 3-f
  f = -f
print "Answer to PE46 = ", n

Comments

By replacing the 1^st digit of *57, it turns out that six of the possible values: 157, 257, 457, 557, 757, and 857, are all prime.

By replacing the 3^rd and 4^th digits of 56**3 with the same digit, this 5-digit number is the first example having seven primes, yielding the family: 56003, 56113, 56333, 56443, 56663, 56773, and 56993. Consequently 56003, being the first member of this family, is the smallest prime with this property.

Find the smallest prime which, by replacing part of the number (not necessarily adjacent digits) with the same digit, is part of an eight prime value family.

Analysis

It looked obvious from the example that the minimum prime value for an 8 prime family had to have at least 6 digits. For that size of prime it would take at least 3 digits to have to be replaced. The last digit couldn’t be part of the replacement because that would make it non-prime.

So we took all 68,906 6-digit primes and reduced it to 11,066 by keeping only those primes that had 3 or more repeating digits. We also remembered which digit was repeating so that replacing it would be easy.

All that was left was to iterate through the primes and report the first one that followed the instructions outlined above.

Solution

Runs < 1 second in Perl.

open IN, "<primes51.txt" or die "Cannot open file: $!";
%primes = map {chomp; split /,/} <IN>;
for $p (sort keys %primes) {
  $dd = $primes{$p}; $c=1; $i=0;
  for $d ( grep {$_!=$dd} (0..9) ) {
    last if $i-$c>2;
    $xx=$p; $xx=~s/$dd/$d/g;
    $c++ if exists $primes{$xx};
    $i++;
    next if $c<8;
    print "Answer to PE50 = $p";exit;
  }
}

Comments

Example of what file ‘primes51.txt’ looks like:
104999,9
105211,1
105557,5
106121,1

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 prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Analysis

The request to find the prime factors of a number comes up much too often. To satisfy these requests we wrote a small javascript program that can be accessed here: prime factor calculator. It can easily handle numbers up to 16 digits long in an instant.

The solution below is the essence of that script.

Solution

Runs < 1 second in Python.

def lpf(n):
  if n < 2: return False
  for p in (2,3):
    while n % p == 0: n /= p
    if n == 1: return p
 
  p = 5; fl = 1
  while (p*p<=n): 
    while n % p == 0: n /= p
    if n == 1: return p
    p+= 3-fl
    fl = -fl
  return n
print "Answer to PE3 = ",lpf(600851475143)

Comments