The palindromic number 595 is interesting because it can be written as the sum of consecutive squares: 6² + 7² + 8² + 9² + 10² + 11² + 12².

There are exactly eleven palindromes below one-thousand that can be written as consecutive square sums, and the sum of these palindromes is 4164. Note that 1 = 0² + 1² has not been included as this problem is concerned with the squares of positive integers.

Find the sum of all the numbers less than 10⁸ that are both palindromic and can be written as the sum of consecutive squares.

Analysis

To solve this problem requires a simple search to the square root of the limit (10⁸) or 5,000. We use a set to eliminate duplicate sum-of-squares.

Solution

Runs < 1 second in Python.

from Euler import is_palindromic
 
limit = 10**8
sqrt_limit = int(limit**.5)
pal = set()
 
for i in range(1, sqrt_limit):
  sos = i*i
  for j in range(i+1, sqrt_limit):
    sos += j*j
    if sos>=limit: break
    if is_palindromic(sos): pal.add(sos)
 
print "Answer to PE125 = ", sum(pal), len(pal)

Comments

• More information on the Euler module can be found on the tools page.
• Takes 371,234 iterations.
• The second number printed is the size of the set.

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.

Working from left-to-right if no digit is exceeded by the digit to its left it is called an increasing number; for example, 134468.

Similarly if no digit is exceeded by the digit to its right it is called a decreasing number; for example, 66420.

We shall call a positive integer that is neither increasing nor decreasing a "bouncy" number; for example, 155349.

As n increases, the proportion of bouncy numbers below n increases such that there are only 12951 numbers below one-million that are not bouncy and only 277032 non-bouncy numbers below 10¹⁰.

How many numbers below a googol (10¹⁰⁰) are not bouncy?

Analysis

Whenever a problem asks for the number of elements in a set, as does this one, then the solution in typically a counting problem solved with combinometrics.

Our solution uses the general formula that counts the monotonically increasing/decreasing digits ignoring leading zeros.

Solution

Runs < 1 second in Python.

from Euler import binomial
 
n=100
print binomial(n+10,10) + binomial(n+9,9) - 10*n - 2

Comments

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

Working from left-to-right if no digit is exceeded by the digit to its left it is called an increasing number; for example, 134468.

Similarly if no digit is exceeded by the digit to its right it is called a decreasing number; for example, 66420.

We shall call a positive integer that is neither increasing nor decreasing a "bouncy" number; for example, 155349.

Clearly there cannot be any bouncy numbers below one-hundred, but just over half of the numbers below one-thousand (525) are bouncy. In fact, the least number for which the proportion of bouncy numbers first reaches 50% is 538.

Surprisingly, bouncy numbers become more and more common and by the time we reach 21780 the proportion of bouncy numbers is equal to 90%.

Find the least number for which the proportion of bouncy numbers is exactly 99%.

Analysis

It was a surprise how long this program took to run. The is_bouncy() routine seemed to slow things down. We begin at the 90% point specified in the problem description and wait for the ratio to hit 99%.

Solution

Runs < 7 seconds in Python.

def is_bouncy(n):
  inc, dec, s = False, False, str(n)
  for i in range(len(s)-1):
    if s[i+1] > s[i]: inc = True
    elif s[i+1] < s[i]: dec = True
    if inc and dec: return True
  return False
 
n, p = 21780, 0.90
b = n * p
while p != 0.99:
  n += 1
  if is_bouncy(n): b += 1
  p = float(b)/n
 
print "Answer to PE112 = ", n

Comments

The float() function was required to convert to floating point.

The Fibonacci sequence is defined by the recurrence relation:

F_n = F_n−1 + F_n−2, where F₁ = 1 and F₂ = 1.

It turns out that F₅₄₁, which contains 113 digits, is the first Fibonacci number for which the last nine digits are 1-9 pandigital (contain all the digits 1 to 9, but not necessarily in order). And F₂₇₄₉, which contains 575 digits, is the first Fibonacci number for which the first nine digits are 1-9 pandigital.

Given that F_k is the first Fibonacci number for which the first nine digits AND the last nine digits are 1-9 pandigital, find k.

Analysis

Even calculating the Fibonacci sequence without any optimization this solution was lightning fast. Getting the bottom 9 digits was easy and has been done in previous problems. The top 9 required the formula:

phi = (1 + sqrt(5)) / 2
t = n * log10(phi) + log10(1/sqrt(5))
t = int((pow(10, t – int(t) + 8)))

So, after finding a candidate with the bottom 9 digits pandigital we query the formula to see if the top 9 are pandigital. The first one found will be our first solution.

Solution

Runs < 2 seconds in Python.

from Euler import is_pandigital
 
def top_digits(n):
# t = n * log10(phi)          + log10(1/sqrt(5))
  t = n * 0.20898764024997873 - 0.34948500216800940
  t = int((pow(10, t - int(t) + 8)))
  return t
 
fn, f0, f1 = 2, 1, 1
while not is_pandigital(f1) or not is_pandigital(top_digits(fn)):
 f0, f1 = f1, (f1+f0)%10**9
 fn += 1
print "Answer to PE104 = ", fn

Comments

Given the positive integers, x, y, and z, are consecutive terms of an arithmetic progression, the least value of the positive integer, n, for which the equation, x² − y² − z² = n, has exactly two solutions is n = 27:

34² − 27² − 20² = 12² − 9² − 6² = 27

It turns out that n = 1155 is the least value which has exactly ten solutions.

How many values of n less than one million have exactly ten distinct solutions?

Analysis

Concept code. More later.

Solution

Runs < 1 second in Python.

from Euler import is_prime
 
nmax = 55992
s = 0
inc=3
for n in range(3, nmax , 4):
  if is_prime(n): s += inc
  if is_prime(n+2): s += (inc-1)
  if n>nmax//16: inc=2
  if n>nmax//4: inc=1
 
print "Answer to PE135 = ", s

Comments

If a box contains twenty-one coloured discs, composed of fifteen blue discs and six red discs, and two discs were taken at random, it can be seen that the probability of taking two blue discs, P(BB) = (15/21)×(14/20) = 1/2.

The next such arrangement, for which there is exactly 50% chance of taking two blue discs at random, is a box containing eighty-five blue discs and thirty-five red discs.

By finding the first arrangement to contain over 10¹² = 1,000,000,000,000 discs in total, determine the number of blue discs that the box would contain.

Analysis

Given b=blue discs, n=total number of discs then the general equation is:
(b/n) (b-1) / (n-1) = 1/2, which implies:
(b²-b) / (n²-n) = 1/2, or
(2b²-2b) / (n²-n) = 1, or
2b²-2b = n²-n, or finally
2b² – 2b – n² + n = 0 which is, in fact, a Diophantine Quadratic Equation and can be solved using a program provided on the following website: http://www.alpertron.com.ar/QUAD.HTM

Here is the input to the program for our equation:
[ 2] x² +
[ 0] xy +
[-1] y² +
[-2] x +
[ 1] y +
[ 0] = 0

Here is the output from the program:

2x² – y² – 2x + y = 0

X₀ = 0
Y₀ = 1

and also:
X₀ = 1
Y₀ = 1

X_n+1 = P X_n + Q Y_n + K
Y_n+1 = R X_n + S Y_n + L

P = 3
Q = 2
K = -2
R = 4
S = 3
L = -3

From here we have two equations that can calculate b and n for each term in the series. Instead of starting at b=1, n=1 we start with the values in the problem description to save a few iterations; b=85, n=120. We continue this series until n>10¹².

The equations are: blue disks = 3b + 2n – 2; n disks = 4b + 3n – 3 (also n = int(b/√2/2), but that’s another story).

Solution

Runs < 1 second in Python.

b = 85
n = 120
while n < 10**12:
  b,n = 3*b + 2*n - 2, 4*b + 3*n - 3
print "Answer to PE100 = ",b

Comments