Each character on a computer is assigned a unique code and the preferred standard is ASCII (American Standard Code for Information Interchange). For example, uppercase A = 65, asterisk (*) = 42, and lowercase k = 107.

A modern encryption method is to take a text file, convert the bytes to ASCII, then XOR each byte with a given value, taken from a secret key. The advantage with the XOR function is that using the same encryption key on the cipher text, restores the plain text; for example, 65 XOR 42 = 107, then 107 XOR 42 = 65.

For unbreakable encryption, the key is the same length as the plain text message, and the key is made up of random bytes. The user would keep the encrypted message and the encryption key in different locations, and without both "halves", it is impossible to decrypt the message.

Unfortunately, this method is impractical for most users, so the modified method is to use a password as a key. If the password is shorter than the message, which is likely, the key is repeated cyclically throughout the message. The balance for this method is using a sufficiently long password key for security, but short enough to be memorable.

Your task has been made easy, as the encryption key consists of three lower case characters. Using cipher1.txt (right click and ‘Save Link/Target As…’), a file containing the encrypted ASCII codes, and the knowledge that the plain text must contain common English words, decrypt the message and find the sum of the ASCII values in the original text.

Analysis

Following the instructions, we read the file and convert to ASCII. The decryption process is simplified by limiting the key to three characters from the set {a..z} for only 17,576 possibilities.

Perl makes the process easier with built in support for regular expressions. Taking the hint that the message contains common English words we look for the string ‘ the ‘ after each attempt at decryption. Surrounding our word with spaces guarantees it’s not part of another word, such as ‘they’.

We have to repeat each key cyclically until it’s the same length as the message. For example, if the message is “gduii9iu” and the password is ‘abc’ we must decrypt with ‘abcabcab’.

Solution

Runs < 1 second in Perl.

open (IN,"<cipher1.txt") or die "Can't read file: $!"; 
$message = join '', map { chr($_) } split /,/, <IN>;  #read file & convert to ASCII
 
$l = length $message;
for my $key ('aaa' .. 'zzz') {
  $text = $message ^ substr($key x ($l/3 + 1), 0, $l);
  last if $text =~ / the /i;
}
$s += ord($_) for split //, $text;
print "Answer to PE59: ", $s;

Comments

• ‘the’ was selected because it is the most common English word.
• chr() and ord() convert to/from ASCII/decimal.
• ‘^’ is Perl’s XOR operator.

By replacing the 1^st digit of *57, it turns out that six of the possible values: 157, 257, 457, 557, 757, and 857, are all prime.

By replacing the 3^rd and 4^th digits of 56**3 with the same digit, this 5-digit number is the first example having seven primes, yielding the family: 56003, 56113, 56333, 56443, 56663, 56773, and 56993. Consequently 56003, being the first member of this family, is the smallest prime with this property.

Find the smallest prime which, by replacing part of the number (not necessarily adjacent digits) with the same digit, is part of an eight prime value family.

Analysis

It looked obvious from the example that the minimum prime value for an 8 prime family had to have at least 6 digits. For that size of prime it would take at least 3 digits to have to be replaced. The last digit couldn’t be part of the replacement because that would make it non-prime.

So we took all 68,906 6-digit primes and reduced it to 11,066 by keeping only those primes that had 3 or more repeating digits. We also remembered which digit was repeating so that replacing it would be easy.

All that was left was to iterate through the primes and report the first one that followed the instructions outlined above.

Solution

Runs < 1 second in Perl.

open IN, "<primes51.txt" or die "Cannot open file: $!";
%primes = map {chomp; split /,/} <IN>;
for $p (sort keys %primes) {
  $dd = $primes{$p}; $c=1; $i=0;
  for $d ( grep {$_!=$dd} (0..9) ) {
    last if $i-$c>2;
    $xx=$p; $xx=~s/$dd/$d/g;
    $c++ if exists $primes{$xx};
    $i++;
    next if $c<8;
    print "Answer to PE50 = $p";exit;
  }
}

Comments

Example of what file ‘primes51.txt’ looks like:
104999,9
105211,1
105557,5
106121,1

An irrational decimal fraction is created by concatenating the positive integers:

0.123456789101112131415161718192021…

It can be seen that the 12^th digit of the fractional part is 1.

If d_n represents the n^th digit of the fractional part, find the value of the following expression.

d₁ × d₁₀ × d₁₀₀ × d₁₀₀₀ × d₁₀₀₀₀ × d₁₀₀₀₀₀ × d_1000000

Analysis

This is known as Champernowne’s constant (OEIS A033307).

We concatenate the counting numbers to a string from 1 until the length reaches at least 1 million digits, then multiply the digit at the appropriate positions together. We know from the problem description that the first two terms d₁ & d₁₀ will evaluate to 1 and, therefore, serve no consequence on the product.

Solution

Runs < 1 second in Perl.

my $s = '.';
my $n = 1;
 
$s.=$n++ while(length($s) <= 1_000_000);
 
print "Answer to PE40 = ",
substr($s,1e2,1) * substr($s,1e3,1) * substr($s,1e4,1) * substr($s,1e5,1) * substr($s,1e6,1);

Comments

• We initialize $s with a character to start the string index at 1 instead of 0.
• Mathematica: Times @@ Flatten[IntegerDigits@Range@2*^5][[10^Range@6]]

Find the greatest product of five consecutive digits in the 1000-digit number.

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
… {continued}

Analysis

Starting with the largest 5 digit number, 99999, count downwards until that number is a substring of the 1000 digit number. Split out the five digits and multiply them together. Ignore any products that could evaluate to zero.

Solution

Runs < 1 second in Perl.

$string = <DATA>;
$p=1;
 
for ($i=99999; ; $i--) {
  if ($i !~ /0/ && $string =~ /$i/) {
    $p*=$_ for split //,$i;
    print "Answer to PE8 = $p";
    exit;
  }
}
__DATA__
731671765313306249...

Comments

Finds the maximum in 121 iterations.

The radical of n, rad(n), is the product of distinct prime factors of n. For example, 504 = 2³ × 3² × 7, so rad(504) = 2 × 3 × 7 = 42.

If we calculate rad(n) for 1 ≤ n ≤ 10, then sort them on rad(n), and sorting on n if the radical values are equal, we get:

Let E(k) be the kth element in the sorted n column; for example, E(4) = 8 and E(6) = 9.

If rad(n) is sorted for 1 ≤ n ≤ 100000, find E(10000).

Analysis

This problem can be solved without sorting or a large list of primes by just calculating factors as we concatenate them to a group organized by rad(n). To find n, just concatenate the group together and print the index relative to zero in the array.

Solution

Runs < 1 second in Perl.

$limit = 100000;
$target=10000;
 
$rad[$_] = 1 for (2..$limit);
$buffer[1] = 1;
for ($n = 2; $n <= $limit; $n++){
  if ($rad[$n] == 1){
    for ($j = $n; $j <= $limit; $j += $n){
      $rad[$j] *= $n; }}
  $buffer[$rad[$n]].="$n "; }
 
$e = (map {split /s+/} @buffer)[$target-1];
 
print "Answer to PE124 = $e";

Comments

If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.

If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?

NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of “and” when writing out numbers is in compliance with British usage.

Analysis

Converted the integers from 1 to 999 to the written equivalent, removed spaces and hyphens, added the character count for each one, including “onethousand”.

Solution

Runs < 1 second in Perl.

@D{0 .. 20, 30,40,50,60,70,80,90} = qw|
 zero one two three four five six seven eight nine ten
 eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen
 twenty thirty forty fifty sixty seventy eighty ninety|;
 
for $i (1..999) {
  $x= num2en($i); $x=~s/[s-]//g;
  $l+= length($x);
}
print "Answer to PE17 = ",$l+length('onethousand');
 
sub num2en {
  my($x) = $_[0];
  return $D{$x} if defined $D{$x};
  return  $D{$1 . '0'} . '-' . $D{$2} if( $x =~ m/^(.)(.)$/ );
  if ( $x =~ m/^(.)(..)$/ ) {
      my($h, $rest) = ("$D{$1} hundred", $2);
      return $h if $rest eq '00';
      return "$h and " . num2en($rest);
  }
}

Comments

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.

The n^th term of the sequence of triangle numbers is given by, t_n = ½n(n+1); so the first ten triangle numbers are:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, …

By converting each letter in a word to a number corresponding to its alphabetical position and adding these values we form a word value. For example, the word value for SKY is 19 + 11 + 25 = 55 = t₁₀. If the word value is a triangle number then we shall call the word a triangle word.

Using words.txt (right click and ‘Save Link/Target As…’), a 16K text file containing nearly two-thousand common English words, how many are triangle words?

Analysis

Remember Problems 44 & 45? The same logic applies except for triangle numbers. Whenever the equation ( √(1+8n) – 1 ) / 2 evaluates to an integer the number, n, is a triangle number.

Remember Problem 22? Well, this is the same core solution.

Solution

Runs < 1 second in Perl.

$c = 0;
@h{'A' .. 'Z'} = (1 .. 26);
open (IN,"<words.txt") or die "Can't open file: $!";
@words = map { /"(w+)"/  } split /,/,<IN>;
 
foreach ( grep { is_tri(score($_)) } @words) {$c++}
 
print "Answer to PE42 = $c";
 
sub is_tri {my $n=shift; my $t=(sqrt(1+8*$n)-1)/2; return int($t) == $t }
sub score {my $score=0; $score+=$_ for @h{map uc, split //,shift}; return $score };

Comments

Even though we used Perl, we still kept it readable, mostly.

The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.

Find the sum of the only eleven primes that are both truncatable from left to right and right to left.

NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.

Analysis

The good news is the problem tells us there’s only 11. We can just keep searching a bunch of primes until 11 meet the criteria.

With just some casual thought it occurred to us that since we are going to truncate in both directions only primes ending in 3 or 7 are valid. Also any prime with at least one digit from the set [0, 2, 4, 5, 6, 8] would make the prime invalid. Add to that pairs such as ’11′, ’33′, ’77′ or ’99′ and the possible prime numbers gets smaller.

Two problems: The two digit primes 23 and 53 would violate our filter (we found these by looking at the table of prime numbers), so we will have to mark these as exceptions. And just how big can these primes get?

One way to find out is just to get started and see what happens. This code gave us our solution set and the answer.

After seeing the results, we realized we could build a tree to ferret out the set of primes. Here’s a tree for 2, 5, and 7. We’ll leave 3 as an exercise.

2 — 3

5 — 3

   3 — 9 — 3 — 9 — 7
7 — 9 — 7

When a prime starts with 7 it can only be followed by 3 or 9. For the 9 branch only a 7 can come next and no other number would follow. A 3, 1, 7 or 9 would produce a composite number as 39, 9, 77 or 1.
The same logic follows for the 3 side.

Solution

Runs < 1 second in Perl.

use integer;
my $s = 23 + 53;  #first two that are exceptions to our pattern
open IN, "<primes2.txt";
@p = grep {!/[024568]/ && /[37]$/ && /^(3[17][^1]|7[39][^13])/ && !/99|77|33|11/} <IN>;
while ($c<11) {
  $q=shift @p;
  if (trunc($q)) {
    $c++;
    $s+=$q;
  }
}
print "Answer to PE37 = $s, $c primes found";
 
sub trunc {
 my $c = $d = shift;
 while ($d) {
  return 0 unless is_prime($d) && is_prime($c);
  $c%=10**(length($c)-1);
  $d/=10;
 }
return 1
}

Comments

Didn’t have fun with this one. Here’s the set: [23, 37, 53, 73, 313, 317, 373, 797, 3137, 3797, 739397]
Here’s the start of our regex code to sift out the 11 primes from a file of primes. It reduces the list of 78,499 primes from 2 – 1,000,000 to just 28. Not up to finishing it.

open IN, "<primes2.txt";
@p = grep {!/[024568]/ && /[37]$/ && /^(3[17][^1]|7[39][^13])/ && !/99|77|33|11/} <IN>;

The binomial coefficients ⁿC_k can be arranged in triangular form, Pascal’s triangle, like this:

It can be seen that the first eight rows of Pascal’s triangle contain twelve distinct numbers: 1, 2, 3, 4, 5, 6, 7, 10, 15, 20, 21 and 35.

A positive integer n is called squarefree if no square of a prime divides n.
Of the twelve distinct numbers in the first eight rows of Pascal’s triangle, all except 4 and 20 are squarefree.
The sum of the distinct squarefree numbers in the first eight rows is 105.

Find the sum of the distinct squarefree numbers in the first 51 rows of Pascal’s triangle.

Analysis

Only a few primes are required. For example, 51! is the biggest numerator (_nC_k = n! / k! (n-k)! ) and the largest prime factor required is ≤ √51 which is 7. We added a few more to try bigger problems.

So we fill a hash’s keys with unique numbers from Pascal’s triangle and iterate through the 589 binomial coefficients and track which ones are squarefree, sum them up and print the results.

Solution

Runs < 1 second in Perl.

@primes = (2, 3, 5, 7, 11, 13, 17, 19);
$rows = 51; #more rows means more primes
$s = 0;
 
#use a hash, b, to select the distinct binomial coefficients from Pascal's triangle
while((@_=(1,map$_[$_-1]+$_[$_],1..@_))<=$rows){ grep $b{$_}++, @_}
 
for $x (keys %b) {
  $s+=$x if sqf($x);
}
print "Answer to PE203 = $s";
 
sub sqf { return ! grep @_[0]%($_*$_)==0, @primes }

Comments

Wanton use of grep and map.