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.

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.

In the 5 by 5 matrix below, the minimal path sum from the top left to the bottom right, by only moving to the right and down, is indicated in red and is equal to 2427.

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 top left to the bottom right by only moving right and down.

Analysis

As with problems 18 & 67 we have a designated starting and ending place. We can use the same technique that solved those problems by starting at the bottom and replacing with minimal sums. See those problems for further information.

Out of bounds (undefined) spaces are ignored from determining a minimum.

Solution

Runs < 1 second in Perl.

my @rows = map { [split /,/] } <DATA>;
my $nrows = $#rows;
 
for (my $i = $nrows; $i >= 0; $i--) {
    for (my $j = $nrows; $j >= 0; $j--) {
        $rows[$i][$j] += min_n($rows[$i+1][$j], $rows[$i][$j+1]);
    }
}
print "Answer to PE81 = $rows[0][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.

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.

3
7 5
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom in triangle.txt (right click and ‘Save Link/Target As…’), a 15K text file containing a triangle with one-hundred rows.

NOTE: This is a much more difficult version of Problem 18. It is not possible to try every route to solve this problem, as there are 2⁹⁹ altogether! If you could check one trillion (10¹²) routes every second it would take over twenty billion years to check them all. There is an efficient algorithm to solve it. ;o)

Analysis

Used the program from problem 18. It takes less than a second as compared to waiting for the sun to burn out.

Solution

Runs < 1 second in Perl.

my @rows = map { [split /s/] } <DATA>;
my $nrows = $#rows;
 
for (my $i = $nrows; $i>0; $i--) {
  for my $j (0 .. $i-1) { 
    $rows[$i-1][$j] += max_n( $rows[$i][$j], $rows[$i][$j+1] );
  }
}
print "Answer to PE67 = $rows[0][0]";
__DATA__
3
7 5
2 4 6
8 5 9 3

Comments

• We’ve included the sample data 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 3.

• Check here for more information on max_n().
• See problem 18, problem 81, 82 & 83.

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.

3
7 5
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom of the triangle below:

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
… {data continues} …

NOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)

Analysis

To solve this problem and problem 67, which is much larger, start the search from the bottom to the top, adding the maximums along the way. This will “bubble” the maximum total to the top of the pyramid.

Let’s follow this technique, step by step, with the 4 row triangle example to show how this works.

3
7 5
2 4 6
8 5 9 3
OK, starting at the bottom,
We look at 8 and 5, pick the maximum, 8 in this case, and replace the 2 in the previous row with their sum 10.
We look next at 5 and 9, pick the maximum, 9, and replace the 4 in the previous row with their sum 13.
We look lastly at 9 and 3, pick the maximum, 9, and replace the 6 in the previous row with their sum 15.
Now our array looks like:
3
7 5
10 13 15

Let’s do it again. Take the larger of 10 and 13 and add it to 7 making 20.
Take the larger of 13 and 15 and add it to 5 making 20.
Now our array looks like:
3
20 20

At last we take the larger of 20 and 20 (yes, I know they’re the same) and add it to 3 making 23.
And our array looks like:
23
The maximum total path in the triangle.

Solution

Runs < 1 second in Perl.

my @rows = map { [split /s/] } <DATA>; 
my $nrows =  $#rows;
 
for (my $i = $nrows; $i>0; $i--) {
  for my $j (0 .. $i-1) { 
    $rows[$i-1][$j] += max_n( $rows[$i][$j], $rows[$i][$j+1] ); 
  }
} 
print "Answer to PE18 = $rows[0][0]"; 
__DATA__ 
3
7 5
2 4 6
8 5 9 3

Comments

• We’ve included the sample data 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 3.
• Check here for more information on the max_n function.
• See also problem 67, 81, 82 & 83.

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.

In England the currency is made up of pound, £, and pence, p, and there are eight coins in general circulation:

1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) and £2 (200p).
It is possible to make £2 in the following way:

1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
How many different ways can £2 be made using any number of coins?

Analysis

This is a typical problem that demonstrates the use of partitions which can be solved by dynamic programming. To keep this problem simple: order does not matter, there are always enough coins to make a combination and were not looking for the optimal way to make change. This a perfect application for tested algorithms where this problem has been used as an example. As the details and nuances of dynamic programming are somewhat involved; we have provided some links below for a better explanation:
Coin Change – Algorithmist
Dynamic Programming Solution to the Coin Changing Problem

Solution

Runs < 1 second in Perl.

my $target = 200;
my @coins = (1,2,5,10,20,50,100,200);
my @ways = (1);
 
for $coin (@coins) {
  $ways[$_] += $ways[$_-$coin] for $coin..$target;
}
 
print "Answer to PE31 = $ways[$target]";

Comments

• See Problem 76. The advantage this code has is the problem only wants the number of combinations. It would be a different approach if they wanted a set of combinations.
• In Perl, the default variable, $_, takes the index value of the loop. In this case, values from $coin to $target.