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.

Comparing two numbers written in index form like 2¹¹ and 3⁷ is not difficult, as any calculator would confirm that 2¹¹ = 2048 < 3⁷ = 2187.

However, confirming that 632382⁵¹⁸⁰⁶¹ > 519432⁵²⁵⁸⁰⁶ would be much more difficult, as both numbers contain over three million digits.

Using base_exp.txt (right click and ‘Save Link/Target As…’), a 22K text file containing one thousand lines with a base/exponent pair on each line, determine which line number has the greatest numerical value.

NOTE: The first two lines in the file represent the numbers in the example given above.

Analysis

Very simple to compare the product of the exponent by the log of the base and keep the maximum value and respective line number.

Solution

Runs < 1 second in Python.

from math import log
 
mv, ml, ln = 0, 0, 0 
for line in file('base_exp.txt'): 
  ln += 1
  b, e = line.split(',') 
  v = int(e) * log(int(b)) 
  if v > mv: 
    mv, ml = v, ln 
print "Answer to PE99 = ", ml

Comments

A bag contains one red disc and one blue disc. In a game of chance a player takes a disc at random and its colour is noted. After each turn the disc is returned to the bag, an extra red disc is added, and another disc is taken at random.

The player pays £1 to play and wins if they have taken more blue discs than red discs at the end of the game.

If the game is played for four turns, the probability of a player winning is exactly 11/120, and so the maximum prize fund the banker should allocate for winning in this game would be £10 before they would expect to incur a loss. Note that any payout will be a whole number of pounds and also includes the original £1 paid to play the game, so in the example given the player actually wins £9.

Find the maximum prize fund that should be allocated to a single game in which fifteen turns are played.

Analysis

This problem, a series of independent events, can be solved by a ordinary generating function for the numerators of the respective probabilities. The nth coefficients of (x+1)(x+2)(x+3)…(x+15) are the sum of the products taken n at a time. We are only concerned with a winning scenario, which, for this problem, would be selecting 8 or more blue disks. Therefore, only the top eight coefficients are required.

What’s left is to take the reciprocal of the sum of the eight coefficients divided by (n+1)!.

Example: for n=7, the equation is (x+1)(x+2)(x+3)(x+4)(x+5)(x+6)(x+7) because we keep adding a red disk after each turn leaving 1 blue disk and 7 red disks for a total of 8 disks by the end of the game. This equation expands to:
x⁷ + 28x⁶ + 322x⁵ + 1960x⁴ + 6769x³ + 13132x² + 13068x + 5040.
A winning scenario is selecting the blue disk 4 or more times (7 times out of 7 tries, 6 out of 7, 5 out of 7 or 4 out of 7) with the respective sum of the coefficients 1 + 28 + 322 + 1960 = 2311. The probability of winning is 2311/8! = 2311/40320. The prize fund would have to be the reciprocal of the winning probability, 40320/2311 ≈ £17.

Solution

Runs < 1 second in Python.

def fact(n):
        return reduce(lambda x,y:x*y,range(1,n+1),1)
 
n = 15
r = (n-1)/2
p = [1]+[0]*r
for k in range(n+1):
  for i in range(r, 0, -1):
    p[i] += k*p[i-1]
print "Answer to PE121 = ", fact(n+1) / sum(p)

Comments

for n=100 the value (34316…) is calculated less than 1 second.

n! means n × (n − 1) × … × 3 × 2 × 1

Find the sum of the digits in the number 100!

Analysis

Same solution as problem 16.

Solution

Runs < 1 second in Python.

def fact(n): return reduce(lambda x,y:x*y,range(1,n+1),1)
 
print "Answer to PE20 = ", sum(int(i) for i in str(fact(100)))

Comments

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

A unit fraction contains 1 in the numerator. The decimal representation of the unit fractions with denominators 2 to 10 are given:

1/2	=	0.5
1/3	=	0.(3)
1/4	=	0.25
1/5	=	0.2
1/6	=	0.1(6)
1/7	=	0.(142857)
1/8	=	0.125
1/9	=	0.(1)
1/10	=	0.1

Where 0.1(6) means 0.166666…, and has a 1-digit recurring cycle. It can be seen that ¹/₇ has a 6-digit recurring cycle.

Find the value of d < 1000 for which ¹/_d contains the longest recurring cycle in its decimal fraction part.

Analysis

This is a useful application of Fermat’s little theorem that says: 1/d has a cycle of n digits if 10ⁿ−1 mod d = 0 for prime d. It also follows that a prime number in the denominator, d, can yield up to d-1 repeating decimal digits.

Since the problem wants the longest string of repeating digits from 1 < d < 1000 we started at the top and worked down calculating the length of the chain until we found one with d − 1 digits.

Calculating a cycle length:
d=7 ; c=1
9 % 7 = 2 ; c=2
99 % 7 = 1; c=3
999 % 7 = 5; c=4
9999 % 7 = 3; c=5
99999 % 7 = 4; c=6
999999 % 7 = 0; break

Solution

Runs < 1 second in Python.

from Euler import is_prime
 
for d in range(999, 1, -2):
  if not is_prime(d): continue
  c = 1
  while (pow(10, c) - 1) % d != 0:
    c += 1
  if (d-c) == 1: break
print "Answer to PE26 = ",d

Comments

More information on the Euler module can be found on the tools page.
for d < 2000: 1997
for d < 2500: 2473
for d < 10,000: 9967
for d < 20,000: 19993
for d < 25,000: 24989

The hyperexponentiation or tetration of a number a by a positive integer b, denoted by a↑↑b or ^ba, is recursively defined by:

a↑↑1 = a,
a↑↑(k+1) = a^(a↑↑k).

Thus we have e.g. 3↑↑2 = 3³ = 27, hence 3↑↑3 = 3²⁷ = 7625597484987 and 3↑↑4 is roughly 10^{3.6383346400240996*10^12}.

Find the last 8 digits of 1777↑↑1855.

Analysis

Using the little known optional third parameter of Python’s pow(x, y [,z]) function that provides x to the power y, modulo z (computed more efficiently than pow(x, y) % z) we were able to simply loop through the hyperexponentiation of a↑↑b.

This is similar to problem 97.

Solution

Runs < 1 second in Python.

def hyper_exp(a, b, m):
    temp = 1
    while b:
        temp = pow(a, temp, 10**m)
        b -= 1
    return temp
 
print "Answer to PE188 = ",hyper_exp(1777, 1855, 8)

Comments

Note: The last eight digits remain constant by the eighth iteration.
See problem 48 & problem 97

The number 512 is interesting because it is equal to the sum of its digits raised to some power: 5 + 1 + 2 = 8, and 8³ = 512. Another example of a number with this property is 614656 = 28⁴.

We shall define a_n to be the nth term of this sequence and insist that a number must contain at least two digits to have a sum.

You are given that a₂ = 512 and a₁₀ = 614656.

Find a₃₀.

Analysis

Taking advantage of the easy large integer support in Python, we iterated two loops representing the base and exponent with the intention of accommodating inquiries up to a₂₀₀. Ignoring a^b values < 10 it was a simple process of adding the digits of the powers and comparing that sum to the base. After collecting relevant values into an array, it was sorted and the proper index printed for the answer.

Solution

Runs < 1 second in Python.

def sum_of_digits(n):
  return sum(map(int,str(n)))
 
a = []
n = 30  #tested up to n = 220
for b in xrange(2, 600):
  for e in xrange(2, 50):
     p = b**e
     if sum_of_digits(p) == b: a.append(p); 
     if len(a)>n*1.1: break
a.sort()
print "Answer to PE119 = a(%d) =" % n, a[n-1]

Comments

The base index of arrays in Python begin with 0. We need to subtract one from our index because the problem is using a base of 1; a₃₀ = a[29].
We provide an early escape when we have calculated enough values to provide the result for the given index.

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)!