## Project Euler 22: What is the total of all the name scores in the file of first names?

Project Euler has a large variety in the sort of problems they pose. Problem 22, as we will solve now, has nothing to do with mathematics and everything to do with computer science and sorting algorithms. The problem reads

Using names.txt (right click and ‘Save Link/Target As…’), a 46K text file containing over five-thousand first names, begin by sorting it into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.

For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would obtain a score of 938 x 53 = 49714.

What is the total of all the name scores in the file?

The way I want to solve this problem, is to split it into three parts

1. Read the input file and turn the data into a manageable data structure
2. Sort the data
3. Sum up and provide the answer
Posted by Kristian in Project Euler, 22 comments

## Project Euler 21: Sum of Amicable Pairs Under 10000

After a few exercises with the focus on other areas, we are in Problem 21 of Project Euler back to focusing on number theory and factorisation. The problem reads

Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n).
If d(a) = b and d(b) = a, where ab, then a and b are an amicable pair and each of a and b are called amicable numbers.

For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.

Evaluate the sum of all the amicable numbers under 10000.

Posted by Kristian in Project Euler, 16 comments

## Project Euler 20: Sum of Digits in 100!

In this post I will elaborate a bit on the answer to Project Euler problem 20.  The problem reads

n! means n x (n – 1) x … x 3 x 2 x 1

Find the sum of the digits in the number 100!

Posted by Kristian in Project Euler, 13 comments

## Project Euler 19: How many Sundays on the first of a month

Problem 19 of Project Euler is a curious little problem. It states

You are given the following information, but you may prefer to do some research for yourself.

• 1 Jan 1900 was a Monday.
• Thirty days has September,
April, June and November.
All the rest have thirty-one,
Saving February alone,
Which has twenty-eight, rain or shine.
And on leap years, twenty-nine.
• A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.

How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?

I thought a while about this, before I realised that the easiest way to solve this is most likely to exploit the .NET API. Like many other high level languages .NET offers a really good day/time API, which is easy to use for a problem like this.

The solution is two simple loops to reach all the dates we need to check, and then check if that is a Sunday. In C# this can be implemented as

```int sundays = 0;

for (int year = 1901; year <= 2000; year++) {
for (int month = 1; month <= 12; month++) {
if ((new DateTime(year, month, 1)).DayOfWeek == DayOfWeek.Sunday) {
sundays++;
}
}
}
```

Pretty simple, and an output as

```There are 171 sundays on the first of a month
Solution took 0 ms
```

I have seen a solution proposed which works for the exact question. Since there are 12 month and 100 years, we have 1200 months with a uniform distribution 1/7th of them is mondays, totalling 171 mondays. This solution works nicely for this period, but not for 1903 – 2002.

## Closing remarks

It was a curious little problem to find an answer for, however using the date/time API it was fairly easy to provide a brute force solution. As usual I have uploaded the source code for you.

Posted by Kristian in Project Euler, 10 comments

## Project Euler 18: Maximum Sum from Top to Bottom of the Triangle

The problem presented by Project Euler in Problem 18 is an optimization problem where you need to find the route through a triangle which maximizes the sum.  The problem reads

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 4
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
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

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)

I will present you with two different solutions for this Project Euler problem. First a brute force solution, which the note state is possible for this problem, but not for Problem 67.  And latter I will present a Dynamic programming solution which can be reused for Problem 67. However, before addressing the algorithm part of the answer I will address the data representation, and how to read the data input.

At each level in the pyramid we always have two choices; we can go either left or right. Choosing left all he time will make us end up in the lower left corner, while choosing right will end us up in the lower right corner.

## Data Representation

I have chosen to store the input data in a 2-dimensional array (int[ , ] in C# syntax) for this problem, instead of an array of arrays (int[ ][ ] in C# syntax). I know that I could have saved almost half of the memory by doing it the other way, but I felt it was easier.

I have stored the problem in memory such in the following way

3 0 0 0
7 4 0 0
2 4 6 0
8 5 9 3

such that going right increases the index by one, and going left keeps the index, and the triangle is padded with zeros.

I wrote a small input function so I could read the problem data from a text file and store it in a 2-dimensional array. I will use the input reader for both solutions. The C# implementation of the input function looks like

```private int[,] readInput(string filename) {
string line;
string[] linePieces;
int lines = 0;

while ((line = r.ReadLine()) != null) {
lines++;
}

int[,]  inputTriangle = new int[lines, lines];
r.BaseStream.Seek(0, SeekOrigin.Begin);

int j = 0;
while ((line = r.ReadLine()) != null) {
linePieces = line.Split(' ');
for (int i = 0; i < linePieces.Length; i++) {
inputTriangle[j, i] = int.Parse(linePieces[i]);
}
j++;
}
r.Close();
return inputTriangle;
}
```

All it does is find the number of lines in the file, allocate an array that fits, and read in the data.

## Brute Force

When answering the problem with a brute force solution, it is pretty simple to go through the steps, we just need to try all combinations. Since we have a binary choice each time. We can iterate through all possibilities with a normal integer counter, and use the bits of the number to pick the direction left or right. While running through the path, we sum up the numbers and check if they are larger than the current maximum found.

I chose an implementation where I bitshift to find the left/right direction. It can be implemented in C# as

```string filename = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\input.txt";

int posSolutions = (int)Math.Pow(2, inputTriangle.GetLength(0) - 1);
int largestSum = 0;
int tempSum, index;

for (int i = 0; i <= posSolutions; i++) {
tempSum = inputTriangle[0, 0];
index = 0;
for (int j = 0; j < inputTriangle.GetLength(0) - 1; j++) {         index = index + (i >> j & 1);
tempSum += inputTriangle[j + 1, index];
}
if (tempSum > largestSum) {
largestSum = tempSum;
}
}
```

It is a simple and easy approach, which works fine for this problem. The output of the code is

```The largest sum through the triangle is: 1074
Solution took 15 ms
```

## Dynamic Programming

The given problem is a classical example of dynamic programming, and it really works well for it. The methodology is a bit more complex than the brute force solution, but I will take a shot at explaining it anyway.
I will use the four line example to explain the idea throughout this section.

Standing at the top of the triangle we have to choose between going left and right. In order to make the optimal choice (which maximizes the sum), we would have to know how large a sum we can get if we go either way. So in order to answer the question we would basically have to solve the two smaller problems which I have marked with blue and the orange in the figure to the right.

We can break each of the sub-problems down in a similar way, and we can continue to do so until we reach a sub-problem at the bottom line consisting of only one number, then the question becomes trivial to answer, since the answer is the number it self. Once that question is answered we can move up one line, and answer the questions posed there with a solution which is a + max(b,c).

Once we know the answer to all 3 sub-problems on the next to last line, we can move up and answer the posed sub-problems by the same formula already applied. And we can continue to do so until we reach the original question of whether to go left or right.

### Optimal Sub-structure

If we break down the problem into sub-problems we can see that breaking the orange sub-problem into two and breaking the blue sub-problem into two would yield us 4 sub-problems. However the sub-problem in the overlapping part is identical.  In this problem solving the sub-problem yields the same result no matter how we reached the it. This is fairly easy to see in this example. When a problem has this property it is said to have optimal sub-structure. Since we have a problem with optimal we only have to solve three sub-problem in the next to bottom line, and therefore the dynamic programming is effective.

It can be proven that the problem has an optimal sub-structure. However, I wont go into the details of that here, but leave that as an open end you can pick up and explore.

### Savings with Dynamic Programming

If we want to solve the small problem with brute force, we would need to test all 8 paths, each resulting in 3 additions, in total 24 additions.

If we use dynamic programming, the first iteration would require 3 maximum comparison operations and 3 additions. The next line would require 2 maximum comparison operations and 2 additions, and the first line would require one of each. So a total of 6 maximum comparison operations and 6 additions.

For small problems this saving is small if any at all, but for a problem with 15 lines, solving the first iteration would and brute forcing from there would reduce the number of brute force additions from 15*214 to 14*213 a saving of approximately 131000 fewer additions, at the cost of 15 additions and 15 maximum comparison operations. That is a pretty good saving.

### Dynamic Programming – The Algorithm

We can make a short-cut with the algorithm, as we don’t have to break the problem into sub-problems, but can start from the bottom and work the way up through the triangle until we reach the top and the algorithm spits out a number.

3
7 4
2 4 6
8 5 9 3

Applying the algorithm to the small problem we will need three iterations. The first iteration we apply the rule a + max(b,c) which creates a new triangle which looks as

3
7 4
10 13 15

Making the second iteration of the algorithm makes the triangle look

3
20 19

And if we run the algorithm once more, the triangle collapses to one number – 23 – which is the answer to the question.

My implementation of the algorithm in C# looks like

```string filename = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\input.txt";
int lines = inputTriangle.GetLength(0);

for (int i = lines - 2; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
inputTriangle[i, j] += Math.Max(inputTriangle[i+1,j], inputTriangle[i+1, j+1]);
}
}
```

The output of the algorithm is

```The largest sum through the triangle is: 1074
Solution took 3 ms
```

## Closing Remarks

For Problem 18 as we have solved here, the difference is very small. However, once we apply the algorithms one Problem 67, the different approaches will be a matter of getting the answer or not.

I have seen another solution using Dynamic Programming over at Functional fun, where he goes the other way through the triangle. I think mine is easier to understand, and ends up with one solution rather than a series of numbers you need to find the maximum of, but I will let you decide.

As usual I have uploaded the source code for you to play around with. Any comments, suggestions or improvements are very welcome; both for the code and for the explanation. I love to get feedback on how to improve my communication and problem solving skills.

Posted by Kristian in Project Euler, 31 comments

## Project Euler 17: Letters in the numbers 1-1000

Problem 17 of Project Euler changes character completely compared to the previous exercises. The problem reads

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.

Posted by Kristian in Project Euler, 23 comments

## Project Euler 16: The sum of digits in 2^1000

Just like the solution to problem 13 the answer to problem 16 of Project Euler has become trivial with .NET 4.0. And since I am lazy I intend to exploit the tools I am given. The problem description reads

215 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
What is the sum of the digits of the number 21000?

If there didn’t exist a BigInteger class in .NET, then we would have needed to implement a way of storing the large result, which would need 1000 bits of storage, or around the size of 32 integers. Continue reading →

Posted by Kristian in Project Euler, 24 comments

## Project Euler 15: Routes through a 20×20 grid

The problem description in Problem 15 of Project Euler contains a figure, which I wont copy, so go ahead an read the full description at the Project Euler site. The problem can be understood without it though. The problem reads

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?

My first question for many of the problems has been – Can it be brute forced? And my best answer to that is “probably”, but I cannot figure out how to generate all the routes. So instead I will give you two other approaches, which are both efficient. One is inspired by dynamic programming and the other gives an analytic solution using combinatorics. Continue reading →

Posted by Kristian in Project Euler, 39 comments

## Project Euler 14: Longest Collatz Sequence

Project Euler is asking a question regarding the Collatz Conjecture in Problem 14

The following iterative sequence is defined for the set of positive integers:

nn/2 (n is even)
n
→ 3n + 1 (n is odd)

Using the rule above and starting with 13, we generate the following sequence:

13 40 20 10 5 16 8 4 2 1

It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.

Which starting number, under one million, produces the longest chain?

Posted by Kristian in Project Euler, 45 comments

## Project Euler 13: Sum of 50-digit numbers

There is nothing particularly mathematically interesting in Problem 13 of Project Euler.  Since the question is about summing numbers. The tricky part of the question is that the numbers are so big they don’t fit into an ordinary data type. The question goes

Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.

I have left out the actual numbers, but check the question for them.  I originally solved the question using arrays of integers to store each number in, and then I thought I was very smug and all. But when I sought a bit of inspiration on the internet before writing this blog post, I realised that many other languages has built in support for large integers. Continue reading →

Posted by Kristian in Project Euler, 23 comments