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.

Consider the following "magic" 3-gon ring, filled with the numbers 1 to 6, and each line adding to nine.

Working clockwise, and starting from the group of three with the numerically lowest external node (4,3,2 in this example), each solution can be described uniquely. For example, the above solution can be described by the set: 4,3,2; 6,2,1; 5,1,3.

It is possible to complete the ring with four different totals: 9, 10, 11, and 12. There are eight solutions in total.

By concatenating each group it is possible to form 9-digit strings; the maximum string for a 3-gon ring is 432621513.

Using the numbers 1 to 10, and depending on arrangements, it is possible to form 16- and 17-digit strings. What is the maximum 16-digit string for a "magic" 5-gon ring?

Analysis

see Solution.

Solution

The clues “magic” and 16-digit not 17-digit number give this one away. Just as the example, the bigger numbers go on the outside and the smaller numbers on the inside. They total 14 from all views, and, following the instructions above:
Working clockwise, and starting from the group of three with the numerically lowest external node, each solution can be described uniquely.

On our first try we discovered the answer and have included it below, so don’t look if you want to face the challenge yourself.

Comments

A common security method used for online banking is to ask the user for three random characters from a passcode. For example, if the passcode was 531278, they may asked for the 2nd, 3rd, and 5th characters; the expected reply would be: 317.

The text file, keylog.txt, contains fifty successful login attempts.

Given that the three characters are always asked for in order, analyse the file so as to determine the shortest possible secret passcode of unknown length.

Analysis

See Solution.

Solution

Runs < 3 minutes in Human mind.
There are four question to answer before a solution can be determined.
1. How many discrete digits are in the code?
2. What are those digits?
3. What order are those digits in?
4. Do the digits repeat?

By analysing the file we can quickly answer 1 and 2: There are eight digits in the code from the set {0,1,2,3,6,7,8,9}. We know this because {4,5} are missing and in order to answer the question we would have to know that.
Question 4 is answered by default because if they did repeat we would never know how long the code would be. So they don't!
So the only real challenge is to answer question 3, which is the typical:
If Mary is taller than Jan and Johnny is taller than Mary, but Pee-Wee, blah, blah, blah...
So we don't really need a computer just a set of examples, for which we have plenty, to make our decision.

Given that the samples are in the order of the original 8 digit code we look at the most frequent last digit and maximize the number of digits that come before it:
{1,2,3,6,7,8,9} come before 0. 0 is the last digit (samples: 680, 710, 290, 380).
{1,2,3,6,7,8} come before 9. 9 is the second to the last digit (samples: 689, 729, 318).
{1,2,3,6,7} come before 8. 8 is the third to the last number (samples: 168, 728, 318).
{1,3,6,7} come before 2. So, 2 is next. (samples: 762, 162, 362)
{1,3,7} come before 6. 6 is next (samples: 316, 762).
{3,7} come before 1. 1 is next (sample: 731)
and 7 comes before 3. 7 is the first number (again, sample: 731)

Comments

It turns out that 12 cm is the smallest length of wire that can be bent to form an integer sided right angle triangle in exactly one way, but there are many more examples.

12 cm: (3,4,5)
24 cm: (6,8,10)
30 cm: (5,12,13)
36 cm: (9,12,15)
40 cm: (8,15,17)
48 cm: (12,16,20)

In contrast, some lengths of wire, like 20 cm, cannot be bent to form an integer sided right angle triangle, and other lengths allow more than one solution to be found; for example, using 120 cm it is possible to form exactly three different integer sided right angle triangles.

120 cm: (30,40,50), (20,48,52), (24,45,51)

Given that L is the length of the wire, for how many values of L ≤ 2,000,000 can exactly one integer sided right angle triangle be formed?

Analysis

This is an extension to the Problem 9 solution.

Solution

Runs < 3 seconds in Python.

from Euler import gcd
 
limit = 2000000
sqrt_limit = int(limit**.5)
tx = [0]*limit
for i in xrange(1, sqrt_limit, 2):
  for j in xrange(2, sqrt_limit, 2):
    if gcd(i, j) == 1: 
      sum = abs(j*j - i*i) + 2*i*j + i*i + j*j
      for s in range(sum, limit, sum):
        tx[s]+=1
 
print "Answer to PE75 = ", tx.count(1)

Comments