NOTE: This problem is a more challenging version of Problem 81.

The minimal path sum in the 5 by 5 matrix below, by starting in any cell in the left column and finishing in any cell in the right column, and only moving up, down, and right, is indicated in red; the sum is equal to 994.

Find the minimal path sum, in matrix.txt (right click and ‘Save Link/Target As…’), a 31K text file containing a 80 by 80 matrix, from the left column to the right column.

Analysis

This is using the same technique that solved problem 18, 67, 81 & 83. We no longer have a fixed starting and ending point so we need to track the starting points to a vector. From there we “bubble” the minimum sums by moving from left to right.

Solution

Runs < 1 second in Perl.

@rows = map { [split /,/] } <DATA>;
$nrows = $#rows;
push @cost, $rows[$_][0] for (0..$nrows);
 
for $x (1..$nrows) {
  for $y (0..$nrows) {
    $cost[$y] = min_n($cost[$y], $cost[$y-1]) + $rows[$y][$x];
  }
  for $y (reverse (0..$nrows-2)) {
    $cost[$y] = min_n($cost[$y], $cost[$y+1] + $rows[$y][$x]);
  }
}
print min_n(@cost);
 
sub min_n { return (sort {$a<=>$b} grep {defined} @_)[0] }
__DATA__
131, 673, 234, 103, 18 
201, 96, 342, 965, 150 
630, 803, 746, 422, 111 
537, 699, 497, 121, 956 
805, 732, 524, 37, 331

Comments

• We’ve included the sample matrix as an example.
• The first line of the program reads the data file, which is appended to the end of the program after the __DATA__ separator, into a two dimensional array named @rows. $nrows is the last index of the array so in this case 4.
• Check here for more information on the min_n function.

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

Starting with 1 and spiralling counterclockwise in the following way, a square spiral with side length 7 is formed.

37 36 35 34 33 32 31
38 17 16 15 14 13 30
39 18  5  4  3 12 29
40 19  6  1  2 11 28
41 20  7  8  9 10 27
42 21 22 23 24 25 26
43 44 45 46 47 48 49

It is interesting to note that the odd squares lie along the bottom right diagonal, but what is more interesting is that 8 out of the 13 numbers lying along both diagonals are prime; that is, a ratio of 8/13 ≈ 62%.

If one complete new layer is wrapped around the spiral above, a square spiral with side length 9 will be formed. If this process is continued, what is the side length of the square spiral for which the ratio of primes along both diagonals first falls below 10%?

Analysis

Forget about the geometry and determine the series: (3, 5, 7, 9), (13, 17, 21, 25), (31, 37, 43, 49), … This represents the “corners” for every square layer.
Determine and count the primes, p_n, in the series ignoring every 4th one since it will always be a square and therefore composite. As soon as we reach a ratio of primes to series length (n), p_n/n < 10% we can calculate a side length as n/2.

It’s important to have a decent is_prime() function to achieve a better run time.

Solution

Runs < 8 seconds in Python.

from Euler import is_prime
n_prime, d, avg, n = 0, 1, 1, 2;
 
while avg >= 0.10:
  n_prime += is_prime(d + n) + is_prime(d + n*2) + is_prime(d + n*3)
  d += n*4
  n += 2
  avg = float(n_prime) / (2 * n)
 
print "Answer to PE58 = ",n-1

Comments

• More information on the Euler module can be found on the tools page.
• Note how we calculate the answer as n-1. This is because we count only even n and the sides of our layer has to be odd.
• See problem 28.

The decimal number, 585 = 1001001001₂ (binary), is palindromic in both bases.

Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.

(Please note that the palindromic number, in either base, may not include leading zeros.)

Analysis

Since leading zeros are not allowed, the top and bottom bits for binary numbers have to be one in order to be palindromic. This eliminates even numbers from consideration.

Solution

Runs < 2 second in Perl.

$s=0; 
$limit = 1e6;
 
for (my $n=1; $n<$limit; $n+=2) { 
  $s += $n if palindromic($n) && palindromic(dec2bin($n));
} 
print "Answer to PE36 = $s"; 
 
sub dec2bin { sprintf("%b",shift) }
sub palindromic { @_[0] == reverse @_[0] }

Comments

Results < one trillion:
{ 1, 3, 5, 7, 9, 33, 99, 313, 585, 717, 7447, 9009, 15351, 32223, 39993, 53235, 53835,
73737, 585585, 1758571, 1934391, 1979791, 3129213, 5071705, 5259525,
5841485, 13500531, 719848917, 910373019, 939474939, 1290880921, 7451111547,
10050905001, 18462126481, 32479297423, 75015151057, 110948849011, 136525525631 }

A list of prime numbers from 2 to a billion.
Anytime we deal with problems involving prime numbers we use our file of primes instead of generating them each time they’re called for. This is a reasonable practice since prime generation has been around for centuries.

We also use a module of routines that are used often in solving problems. Euler.py is included as needed. The example below shows typical Python usage:

from Euler import is_prime, is_perm

Here is the contents of Euler.py

def fact(n): return reduce(lambda x,y:x*y,range(1,n+1),1)
 
def is_perm(a,b): return sorted(str(a)) == sorted(str(b))
 
def is_palindromic(n): return str(n)==str(n)[::-1]
 
def is_pandigital(n, s=9): n=str(n);return len(n)==s and not '1234567890'[:s].strip(n)
 
def is_prime(n):
  if n == 2 or n == 3: return True
  if n < 2 or n%2 == 0: return False
  if n < 9: return True
  if n%3 == 0: return False
  r = int(n**.5)
  f = 5
  while f <= r:
    if n%f == 0: return False
    if n%(f+2) == 0: return False
    f +=6
  return True
 
def trial_division(n, bound=None):
    if n == 1: return 1
    for p in [2, 3, 5]:
        if n%p == 0: return p
    if bound == None: bound = n
    dif = [6, 4, 2, 4, 2, 4, 6, 2]
    m = 7; i = 1
    while m <= bound and m*m <= n:
        if n%m == 0:
            return m
        m += dif[i%8]
        i += 1
    return n
 
def factor(n):
    if n in [-1, 0, 1]: return []
    if n < 0: n = -n
    F = []
    while n != 1:
        p = trial_division(n)
        e = 1
        n /= p
        while n%p == 0:
            e += 1; n /= p
        F.append((p,e))
    F.sort()
    return F
 
def gcd(a, b):
  if a < 0:  a = -a
  if b < 0:  b = -b
  if a == 0: return b
  if b == 0: return a
  while b != 0: 
    (a, b) = (b, a%b)
  return a
 
def binomial(n, k):
  nt = 1
  for t in range(min(k, n-k)):
    nt = nt*(n-t)//(t+1)
  return nt

sum: Sum an Array

Add the elements of an array and return the sum.

sub sum { my $s=0; $s+=$_ for @_; return $s }

Explanation: Add the elements of an array. Used mostly to make a program more readable.

dec2bin: Convert a Decimal Number to Binary

Convert decimal (base 10) numbers to binary (base 2)

sub dec2bin { sprintf "%b", shift) }

Explanation: Converts a decimal number < 10¹⁵ to a binary string.

min_n & max_n: Minimum & Maximum of a Numerical List

sub max_n { return (sort {$a<=>$b} grep {defined} @_)[-1] }

sub min_n { return (sort {$a<=>$b} grep {defined} @_)[0] }

Explanation: Simple routine to accept a list of numerical values and return the minimum/maximum. The technique is fast and simple; sort the list ascending numerically and return the last element [-1] for the maximum or the first element [0] for the minimum. Undefined values are not considered.
For example: print min_n(5,7,0,-8,100) would print -8.

rotate: Rotate a String Left One Character

sub rotate { @_[0]=~s/(\d)(\d+)/\2\1/ }

Explanation: This function accepts a string as its single argument and puts the first character and remaining characters into \1 and \2 as a regular expression. They are then reassembled in reverse order effecting a left-wise rotation.
NOTE: This function DOES change the argument.
For example: print rotate(‘abcdef’) would print bcdefa.

fact: Calculate Factorial

This hash must first be defined:

my %fact = (0,1,1,1);

sub fact {
  my $n = shift;
  return $fact{$n} if exists $fact{$n};
  return ($fact{$n} = fact($n-1) * $n)
}

Explanation: Memoization helps this recursive function calculate factorials especially for frequent calls in the same program.