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

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.

Let p(n) represent the number of different ways in which n coins can be separated into piles. For example, five coins can separated into piles in exactly seven different ways, so p(5)=7.

Analysis

This problem is really asking to find the first term in the sequence of integer partitions that’s divisible by 1,000,000.

A partition of an integer, n, is one way of describing how many ways the sum of positive integers, ≤ n, can be added together to equal n, regardless of order. The function p(n) is used to denote the number of partitions for n. Below we show our 5 “coins” as addends to evaluate 7 partitions, that is p(5)=7.

We have the following generating function which uses our pentagonal numbers as exponents:

Solution

Runs < 10 seconds in Perl.

($p[0], $n, $i, $m) = (1, 0, 1, 1e6);
 
for $i (1..250) {             #generate pentagonal numbers for generating function
  $p = $i*(3 * $i - 1)/2;
  push @k, $p, $p+$i;
}
 
while ($p[$n++]) {         #expand generating function to calculate p(n)
  my ($p, $i) = (0, 0);
  $p += ($i%4>1 ? -1 : 1 ) * $p[$n - $k[$i++]] while ($k[$i] <= $n); 
  $p[$n] = $p % $m; 
} 
print "Answer to PE78 = ",$n-1;

Comments

The full answer is:
363253009254357859308323315773967616467
158361736338932270710864607092686080534
895417314045435376684389911706807452721
591544937406153858232021581676352762505
545553421158554245989201590354130448112
450821973350979535709118842524107301749
07784762924663654000000

Euler’s Totient function, φ(n) [sometimes called the phi function], is used to determine the number of positive numbers less than or equal to n which are relatively prime to n. For example, as 1, 2, 4, 5, 7, and 8, are all less than nine and relatively prime to nine, φ(9)=6.
The number 1 is considered to be relatively prime to every positive number, so φ(1)=1.

Interestingly, φ(87109)=79180, and it can be seen that 87109 is a permutation of 79180.

Find the value of n, 1 <n < 10⁷, for which φ(n) is a permutation of n and the ratio n/φ(n) produces a minimum.

Analysis

We can reduce our search significantly by selecting prime pairs (p₁, p₂ ) and calculate n as n = p₁ x p₂. This allows the totient to be calculated as φ(n) = (p₁-1)(p₂-1) for n. Now, just find the minimum ratio n/φ(n) for those n and φ(n) that are permutations of one another.

The range of primes was selected by taking the square root of the upper bound, 10,000,000, which is about 3162 and taking ±25% for a range of primes from 2000 to 4000 (247 primes).

Solution

Runs < 3 seconds in Perl.

@p = split /s/,<DATA>;
($min_q, $min_n, $i, $max) = (2, 0, 1, 10_000_000);
 
for $p1 (@p) {
  for $p2 (@p[$i++ .. $#p]) { 
    $n = $p1 * $p2;
    last if $n > $max;
    $phi = ($p1-1) * ($p2-1);
    $q = $n / $phi;
    ($min_q, $min_n) = ($q, $n) if permutation($phi, $n) && $min_q > $q;
  } 
}
print "Answer to PE70 = $min_n";
 
sub permutation { join('', sort split //, @_[0]) eq join('', sort split //, @_[1]) }
__DATA__
2003 2011 2017 2027 2029 2039 2053 2063 2069 2081 2083 2087 2089 ... 3967 3989

Comments

The prime numbers from 2000 – 4000 were included at the end of the script and abbreviated here to save space.
We tried the same method for n, 1 <n < 10⁹, using the square root 31623 and the 25% bounds of 23,700 through 39,500. The result was 990326167 in about 50 seconds.

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

It is possible to write five as a sum in exactly six different ways:

4 + 1
3 + 2
3 + 1 + 1
2 + 2 + 1
2 + 1 + 1 + 1
1 + 1 + 1 + 1 + 1

How many different ways can one hundred be written as a sum of at least two positive integers?

Analysis

See Problem 31 as it is the same type of solution.

Solution

Runs < 1 second.

my $target = 100;
my @n = (1..99);
my @ways = (1);
 
for $i (@n) {
  $ways[$_] += $ways[$_-$i] for $i..$target;
}
print "Answer to PE76 = $ways[$target]";

Comments

We were able to re-use our code from Problem 31.