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.

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

There are exactly ten ways of selecting three from five, 12345:

123, 124, 125, 134, 135, 145, 234, 235, 245, and 345

In combinatorics, we use the notation, ⁵C₃ = 10.
In general, ⁿC_r = n! / r!(n−r)!, where r ≤ n, n! = n×(n−1)×…×3×2×1, and 0! = 1.
It is not until n = 23, that a value exceeds one-million: ²³C₁₀ = 1144066.
How many, not necessarily distinct, values of  ⁿC_r, for 1 ≤ n ≤ 100, are greater than one-million?

Analysis

There is an efficient way to solve this using Pascal’s triangle.

Each row of this triangle is vertically symmetric, so C(n, r) = C(n, n-r) and any C(n, x) for x from r to (n-r) is greater than C(n, r).

If C(n, r) > 10⁶ then C(n, x) for x from r to (n-r) will also > 10⁶, therefore, the number of C(n, r) > 10⁶, is simply (n-r)-r+1 for that row n.

Solution

Runs < 1 second in Python.

from Euler import binomial
limit, maxn, c = 1e6, 100, 0
 
for n in range(23, maxn+1):
  for r in range(2, n/2+1):
    if binomial(n, r) > limit:
      c += n + 1 - 2*r
      break
print "Answer to PE53 = ", c

Comments

• More information on the Euler module can be found on the tools page.
• How many, not necessarily distinct, values of  ⁿC_r, for 1 ≤ n ≤ 1000, are greater than ten-billion? 490,806

The number 145 is well known for the property that the sum of the factorial of its digits is equal to 145:

1! + 4! + 5! = 1 + 24 + 120 = 145

Perhaps less well known is 169, in that it produces the longest chain of numbers that link back to 169; it turns out that there are only three such loops that exist:

169 → 363601 → 1454 → 169
871 → 45361 → 871
872 → 45362 → 872

It is not difficult to prove that EVERY starting number will eventually get stuck in a loop. For example,

69 → 363600 → 1454 → 169 → 363601 (→ 1454)
78 → 45360 → 871 → 45361 (→ 871)
540 → 145 (→ 145)

Starting with 69 produces a chain of five non-repeating terms, but the longest non-repeating chain with a starting number below one million is sixty terms.

How many chains, with a starting number below one million, contain exactly sixty non-repeating terms?

Analysis

Knowing of a clever solution and debating the use of making one weighed in favor of utilizing some of the code from problem 34. We wrote a recursive solution that was slow but intuitive (As the the saying goes, ‘In order to understand recursion, one must first understand recursion’).

By placing the factorials in an array saved having to recalculate them as we only needed the first 10. Also, starting from 70 was a parameter inferred from the problem description.

We did want a solution that was somewhat extensible and able to answer other questions if the need ever arose. Making changes to bounds or to the size of the series would be easy to change.

Solution

Runs < 55 seconds in Perl.

my %sum;
my @fact = (1, 1, 2, 6, 24, 120, 720, 5_040, 40_320, 362_880);
for (my $i=70; $i<999999; $i++) {
  %h=();
  $x60++ if chains($i)==60; 
}
print "Answer to PE74 = $x60";
 
sub chains {
  $n = shift;
  return scalar keys %h if $h{$n};
  $h{$n}++;
  unless ( $sum{$n} ) { $sum{$n} += $fact[$_] for split //,$n }
return chains($sum{$n});
}

Comments

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}]