The Musings of an Adkins

Project Euler - Problem 16

2011-07-10T12:01:00.042+02:00

Welcome to week 16 of my Project Euler series.

Problem 16:

What is the sum of the digits of the number 2¹⁰⁰⁰?

Details:

2¹⁵ = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.

What is the sum of the digits of the number 2¹⁰⁰⁰?

Code:

//What is the sum of the digits of the number 2¹⁰⁰⁰?

class Problem0016

{

static void Main(string[] args)

{

const int numberBase = 10; // The base that we are going to be using (2, 10, and 16 are the most common)

const int power = 1000; // The power that will be used.

int arraySize = power / (numberBase * 3); // The size of the array can be approximated to the power / base * 3

int[] bigNumber = new int[arraySize + 1];

bigNumber[0] = 2; // Our big number will start as 2.

for (int i = 2; i <= power; i++)

{

DoubleNumber(bigNumber);

}

var numberAsString = NumberToString(bigNumber);

Console.WriteLine("The sum of digits of 2^" + power + " is " + SumTheDigits(numberAsString));

Console.Read();

}

private static void DoubleNumber(int[] n)

{

int carry = 0;

for (int i = 0; i < n.Length; i++)

{

n[i] <<= 1;

n[i] += carry;

if (n[i] >= 1000000000)

{

carry = 1;

n[i] -= 1000000000;

}

else

{

carry = 0;

}

private static String NumberToString(int[] n)

{

int i = n.Length;

while (i > 0 && n[--i] == 0)

;

String ret = "" + n[i--];

while (i >= 0)

{

ret += String.Format("{0:000000000}", n[i--]);

}

return ret;

}

private static int SumTheDigits(string text)

{

int returnValue = 0;

foreach (var number in text)

returnValue += int.Parse(number.ToString());

return returnValue;

}

Solution:

This one requires a little more digging into what was learned long long ago in math. It also involves thinking about more than just "int" or "long" to get it figured out. We have once again a number that is going to be well beyond the scale of what is available to us for numeric data types. That hasn't stood in our way before and it won't this time either. We are going to take a, once again, different approach to things. This time we are going to work with the number as if it were an array. The trick is that we are going to work with an array of 9 digit numbers (numbers under 1 billion).

As we all might or might not know a signed int has a value right around +- 2 billion. That would be a bit awkward to work with if we are going to be using the various elements of the array for continuous calculations. We can however put a cap on the number that we use where ever we want to. If we wanted to work with over sized arrays, we could just as easily have worked with the 3 digit numbers (under 1 thousand). For simplicity though, we went with the largest number that .NET data types would allow.

If you check out the DoubleNumber method you will get a better idea of what I mean. I am doing binary addition to each number in the array. If there is something that goes over our 9 digit cap that we self imposed, then it is used as a carry over into the next element of the array. At the end we get a truly impressive sized number to work with. That is also why we have to transfer it into a string in order to add all the digits. I suppose technically it would have worked to just pace through the array and do it that way, but I had implemented the method to turn it into a string in order to check my output during testing and solving of it, so I just left it in and used it here.

This brings me to another good point. I decided to start breaking this code up into methods for two reasons. First off, I was having some issues when I was trouble shooting the code and wanted to get things a little more spread out and easier to work with. Once I was able to get the return value I wanted and expected from a method then I knew that that chunk of code worked. I could safely move on and let the method enjoy a long and happy life. That actually ties directly into the second reason; Readability. To really prove this point, I will put some extra code onto my Google code repository. I could have very easily squeezed all this code into the main method and not had to worry about making sure my method calls were right and my return values were what I wanted. The problem is that I would have then had a very hard task ahead of me when I started trying to isolate code for debugging purposes. It would have been possible (and shorter) but the readability and future maintenance would have suffered. I like to consider the rule of thumb that a method should fit comfortably on your screen. Of course buying a bigger screen is not the solution if it doesn't but rather trying to take out some code that both, logically fits together, and is capable of standing alone without causing issues. Since it is a rule of thumb it is not necessary to do, but rather nice if possible. It allows you to focus one line of thought on the screen at a time.

Until next time...

Enjoy!

Project Euler - Problem 15

2011-07-03T12:01:00.016+02:00

Welcome to week 15 of my Project Euler series.

Problem 15:

Starting in the top left corner in a 20 by 20 grid, how many routes are there to the bottom right corner?

Details:

Starting in the top left corner of a 22 grid, there are 6 routes (without backtracking) to the bottom right corner.

How many routes are there through a 2020 grid?

Code:

// Starting in the top left corner in a 20 by 20 grid, how many routes are there to the bottom right corner?

class Problem0015

{

static void Main(string[] args)

{

Console.WriteLine(binomialCoefficient(40,20));

Console.Read();

}

public static long binomialCoefficient(int n, int k)

{

long c = 1;

for (int i = 0; i < k; i++)

{

c = c * (n - i);

c = c / (i + 1);

}

return c;

}

Solution:

The code for this one is short, sweet, and to the point. The journey there was not however. This one required a lot of research on my part to come to the answer. Once I was there and it all started to come back however it was painfully obvious. I really hate how hindsight has 20/20 vision. It would be so much more useful to have that kind of clarity before hand.

What I ended up going with was the equation for a simple Binomial Equation as it was the fastest of the options available and the most straight forward. I simply had to implement in C#. Simple right? Once you have a grasp of C# and binomial coefficients it really is. The only real question that was left over was, what are n and k in this example? In reading some interesting articles about path finding, I found people using this equation to solve the number of paths from one side of a 2d map to the other. k was the length of on of the sides and n was the number of steps from one side to the other. Plop those in the proper place in your equation and you have yourself an answer.

Until next time...

Enjoy!

Variable names are overly important

2011-06-29T13:42:00.041+02:00

As you might or might not have read in my previous post (Project Euler Problem 14) I value a good variable name above a great many other things in life. That might seem a bit exaggerated, but really it isn't. If you need proof, then break out some of your old code (by old I mean more than 12 months without having looked at it) and try to remember what you were doing and why. It is not nearly as easy as you might think. The problem is, projects come and go for programs pretty rapidly. Those past projects, no matter how brilliant they were at the time, are simply that. They are past projects. Most programmers don't take the time, when they stop work on a project, to document what exactly they were planning for it, working on, struggling with, etc. Most projects are abandoned for something bigger and better. It is the nature of working in a cutting edge field. There is always that allure to the bigger and better. That is where the value of variable names can really shine through (if properly implemented with other good practices that I will mention at the end of this).

decimal x = 100.00m;
decimal y = 2.34m;
x*=y;

What are those three (perfectly legal) C# statements doing? Could be anything really and if a method has a chunk like that with some error checking and a return statement you are going to be left in the dark.

decimal capital = 100.00m;
decimal interest = 2.34m;
capital *= interest;

What are those three (perfectly legal) C# statements doing? Well as you can plainly see they are implementing a gross simplification of interest calculations. The example might not be the best, but the principle stands. With proper variable names the logic of the code can make more sense.

Aside from just helping improve the logic, well thought out variable names can also cut back on the number of comments that you have to write. In the second example that I gave above I could have added in comments stating that I was calculating interest, but they are not at all needed. The vast majority of people that can program have had enough math that they would recognize that. I would even go so far as to say that it is more often true, rather than not, that properly improved variable names will reduce the amount of commenting that is needed.

This practice of using well thought out variable names can actual lead to better comments that are actually read instead of just skipped over. If you are replacing good naming conventions with comments that means that the person reading your code has to take a break from the code and read the comments to see what this particular variable is supposed to do or supposed to represent. I think it is pretty obvious why this is a bad thing.

Aside from good variable names, the readability of your code can be improved by including comments where needed to clarify what is not evident from the code itself, keeping method size down so it can all be viewed on the screen at once, and experience. I know the last one is kind of mean, but it is true. Sometimes only experience can teach the student what the teacher knows.

Until next time...

Enjoy!

Project Euler - Problem 14

2011-06-26T12:01:00.001+02:00

Welcome to week 14 of my Project Euler series.

Problem 14:

Find the longest sequence using a starting number under one million.

Details:

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

n n/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?

NOTE: Once the chain starts the terms are allowed to go above one million.

Code:

// Find the longest sequence using a starting number under one million.

class Problem0014

{

static void Main(string[] args)

{

int startOfLongest = 0;

int longestChain = 0;

for (int i = 1; i < 1000000; i++)

{

int chainLength = 0;

long n = i;

while (n > 1)

{

if (n % 2 == 0)

n /= 2;

else

n = (3 * n) + 1;

chainLength++;

}

if (chainLength > longestChain)

{

longestChain = chainLength;

startOfLongest = i;

}

Console.WriteLine(startOfLongest);

Console.Read();

}

Solution:

This is an interesting problem. We have the solution given to us, we just have to use it to find right answer. The algorithm that we are following is that we will divide an even number by 2 and triple an odd number then add one. We will continue this pattern until we get the number down to one. This seems easy enough, except that we are looking for the number with the longest chain. Theoretically every number will end up at one so we are looking for the one that takes the longest to get there.

We got our starting point (one) and our ending point (999,999) and our route. Now to implement it. We obviously need a loop (in the shape of a "while" since we don't actually have a set number of iterations to complete) and a couple of "if" statements in the middle to handle each situation. The rest is simply translating the algorithm into source code. This is a very important skill to master, because most people that are going to tell you what they want from programs are not going to tell you in source code, or even easily translated pseudo code. If they were already that far along in the software development cycle they would most likely finish it themselves!

One final note before I finish this off for today. n is a terrible variable name! I used it simply to conform to the question and make it easier for people who are struggling to understand the logic to link it to the question. I can not stress enough the need for proper, logical, understandable, and valuable variable names. These little things can make or break the readability, and by extension the maintainability, of your code.

Until next time...

Enjoy!

Project Euler - Problem 13

2011-06-19T12:01:00.013+02:00

Welcome to week 13 of my Project Euler series.

Problem 13:

Find the first ten digits of the sum of one-hundred 50-digit numbers.

Details:

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

37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690

Code:

// Find the first ten digits of the sum of one-hundred 50-digit numbers.

class Problem0013

{

static void Main(string[] args)

{

var numbers = GetInput();

var list = from num in numbers

select double.Parse(num.Insert(25, "."));

var sum = list.Sum();

string answer = sum.ToString().Replace(".", "").Substring(0, 11);

Console.WriteLine(answer);

Console.Read();

}

static string[] GetInput()

{

return @"37107287533902102798797998220837590246510135740250

46376937677490009712648124896970078050417018260538

74324986199524741059474233309513058123726617309629

91942213363574161572522430563301811072406154908250

23067588207539346171171980310421047513778063246676

89261670696623633820136378418383684178734361726757

28112879812849979408065481931592621691275889832738

44274228917432520321923589422876796487670272189318

47451445736001306439091167216856844588711603153276

70386486105843025439939619828917593665686757934951

62176457141856560629502157223196586755079324193331

64906352462741904929101432445813822663347944758178

92575867718337217661963751590579239728245598838407

58203565325359399008402633568948830189458628227828

80181199384826282014278194139940567587151170094390

35398664372827112653829987240784473053190104293586

86515506006295864861532075273371959191420517255829

71693888707715466499115593487603532921714970056938

54370070576826684624621495650076471787294438377604

53282654108756828443191190634694037855217779295145

36123272525000296071075082563815656710885258350721

45876576172410976447339110607218265236877223636045

17423706905851860660448207621209813287860733969412

81142660418086830619328460811191061556940512689692

51934325451728388641918047049293215058642563049483

62467221648435076201727918039944693004732956340691

15732444386908125794514089057706229429197107928209

55037687525678773091862540744969844508330393682126

18336384825330154686196124348767681297534375946515

80386287592878490201521685554828717201219257766954

78182833757993103614740356856449095527097864797581

16726320100436897842553539920931837441497806860984

48403098129077791799088218795327364475675590848030

87086987551392711854517078544161852424320693150332

59959406895756536782107074926966537676326235447210

69793950679652694742597709739166693763042633987085

41052684708299085211399427365734116182760315001271

65378607361501080857009149939512557028198746004375

35829035317434717326932123578154982629742552737307

94953759765105305946966067683156574377167401875275

88902802571733229619176668713819931811048770190271

25267680276078003013678680992525463401061632866526

36270218540497705585629946580636237993140746255962

24074486908231174977792365466257246923322810917141

91430288197103288597806669760892938638285025333403

34413065578016127815921815005561868836468420090470

23053081172816430487623791969842487255036638784583

11487696932154902810424020138335124462181441773470

63783299490636259666498587618221225225512486764533

67720186971698544312419572409913959008952310058822

95548255300263520781532296796249481641953868218774

76085327132285723110424803456124867697064507995236

37774242535411291684276865538926205024910326572967

23701913275725675285653248258265463092207058596522

29798860272258331913126375147341994889534765745501

18495701454879288984856827726077713721403798879715

38298203783031473527721580348144513491373226651381

34829543829199918180278916522431027392251122869539

40957953066405232632538044100059654939159879593635

29746152185502371307642255121183693803580388584903

41698116222072977186158236678424689157993532961922

62467957194401269043877107275048102390895523597457

23189706772547915061505504953922979530901129967519

86188088225875314529584099251203829009407770775672

11306739708304724483816533873502340845647058077308

82959174767140363198008187129011875491310547126581

97623331044818386269515456334926366572897563400500

42846280183517070527831839425882145521227251250327

55121603546981200581762165212827652751691296897789

32238195734329339946437501907836945765883352399886

75506164965184775180738168837861091527357929701337

62177842752192623401942399639168044983993173312731

32924185707147349566916674687634660915035914677504

99518671430235219628894890102423325116913619626622

73267460800591547471830798392868535206946944540724

76841822524674417161514036427982273348055556214818

97142617910342598647204516893989422179826088076852

87783646182799346313767754307809363333018982642090

10848802521674670883215120185883543223812876952786

71329612474782464538636993009049310363619763878039

62184073572399794223406235393808339651327408011116

66627891981488087797941876876144230030984490851411

60661826293682836764744779239180335110989069790714

85786944089552990653640447425576083659976645795096

66024396409905389607120198219976047599490197230297

64913982680032973156037120041377903785566085089252

16730939319872750275468906903707539413042652315011

94809377245048795150954100921645863754710598436791

78639167021187492431995700641917969777599028300699

15368713711936614952811305876380278410754449733078

40789923115535562561142322423255033685442488917353

44889911501440648020369068063960672322193204149535

41503128880339536053299340368006977710650566631954

81234880673210146739058568557934581403627822703280

82616570773948327592232845941706525094512325230608

22918802058777319719839450180888072429661980811197

77158542502016545090413245809786882778948721859617

72107838435069186155435662884062257473692284509516

20849603980134001723930671666823555245252804609722

53503534226472524250874054075591789781264330331690".Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

}

Solution:

As imposing as this one looks, it is really not that bad at all. Granted if I would have been using .NET Framework 4.0 it would have been extremely easy. In .NET 4.0 they decided to implement a new number type called BigInteger. That would have allowed me to simply add the numbers together and find the part that I wanted as if it were any other supported data type. Since I am using .NET Framework 3.5 I was without this ability so it took a little more work. Not a lot though.

Even without BigInteger I was able to let the framework do the work for me. It was through a nuance that programming makes available to us. I converted these seemingly clear integers into doubles. I placed a decimal after the first 25 numbers, thereby "shrinking" the number down to usable size. I summed the list of "doubles" and took the part required by the problem. Since we are dealing with addition here it didn't change the answer in the least if it was split in half by a decimal point, completely behind the decimal point, or left as an integer. Sometimes it really pays off to take a step back and think before letting your fingers start coding.

Until next time...

Enjoy!

Project Euler - Problem 12

2011-06-12T12:01:00.001+02:00

Welcome to week 12 of my Project Euler series.

Problem 12:

What is the value of the first triangle number to have over five hundred divisors?

Details:

The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

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

Let us list the factors of the first seven triangle numbers:
1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

Code:

// What is the value of the first triangle number to have over five hundred divisors?

class Problem0012

{

static void Main(string[] args)

{

int triangleNumber = 0;

int factors = 0;

int counter = 1;

while (factors <= 500)

{

factors = 0;

triangleNumber += counter;

for (int i = 1; i < (int)Math.Sqrt(triangleNumber); i++)

if (triangleNumber % i == 0)

factors+=2;

counter++;

}

Console.Write(triangleNumber);

Console.Read();

}

Solution:

This one is a pretty easy brute force solution. Go through all the triangle numbers starting at one and see how many factors they have. If it is more than 500 then we have a winner. Print and finished. The method needed to solve this one is given right in the details. It can be improved though. Because of the size of the numbers that we are working with here, I decided to apply one small bit of optimization just to spice things up.

This optimization that I applied was not a programmatic one, but rather a mathematical subtlety that I happened to remember. If you add two to the factor count, you only have to go up to the square root. This works because it is not asking what the factors are, but rather just for the count. After the square root, you are just going to be going through the other side of the list. I went ahead and skipped that list in lieu of using this shortcut.

Until next time...

Enjoy!

Updates to code base

2011-06-06T12:01:00.001+02:00

I am going to be uploading the code to a project that I have started with Google Code (as I mentioned here) but I have not found a way that I can schedule the upload with the publishing of my blog posts so expect delays. I will try and get it done within a day or two of the publishing of the posts, but since a lot of those are written ahead of time and scheduled, I can't promise much. Just keep checking back and it will be there. That I promise.

Until next time...
Enjoy!

Project Euler - Problem 11

2011-06-05T12:01:00.001+02:00

Welcome to week 11 of my Project Euler series.

Problem 11:

What is the greatest product of four numbers on the same straight line in the 20 by 20 grid?

Details:

In the 2020 grid below, four numbers along a diagonal line have been marked in red.

02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26 63 78 14 = 1788696.

What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally) in the 2020 grid?

Code:

// What is the greatest product of four numbers on the same straight line in the 20 by 20 grid?

class Problem0011

{

static void Main(string[] args)

{

int[,] numbers = LoadNumbers();

int topProduct = 0;

for (int i = 0; i < 20; i++)

{

for (int j = 0; j < 20; j++)

{

int rightProduct = 0;

int downProduct = 0;

int leftDownProduct = 0;

int rightDownProduct = 0;

if (j + 3 < 20)

{

downProduct = numbers[i, j] * numbers[i, j + 1] * numbers[i, j + 2] * numbers[i, j + 3];

if (i + 3 < 20)

{

rightProduct = numbers[i, j] * numbers[i + 1, j] * numbers[i + 2, j] * numbers[i + 3, j];

rightDownProduct = numbers[i, j] * numbers[i + 1, j + 1] * numbers[i + 2, j + 2] * numbers[i + 3, j + 3];

}

if ((i - 3 < 20) && (i-3 >= 0))

{

leftDownProduct = numbers[i, j] * numbers[i - 1, j + 1] * numbers[i - 2, j + 2] * numbers[i - 3, j + 3];

}

if (rightProduct > topProduct)

topProduct = rightProduct;

if (downProduct > topProduct)

topProduct = downProduct;

if (rightDownProduct > topProduct)

topProduct = rightDownProduct;

if (leftDownProduct > topProduct)

topProduct = leftDownProduct;

}

Console.Write(topProduct);

Console.Read();

}

static int[,] LoadNumbers()

{

return new int[20,20]

{{08, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 08},

{49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00},

{81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65},

{52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91},

{22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80},

{24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50},

{32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70},

{67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 08, 40, 91, 66, 49, 94, 21},

{24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72},

{21, 36, 23, 09, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95},

{78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 09, 53, 56, 92},

{16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57},

{86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58},

{19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40},

{04, 52, 08, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66},

{88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69},

{04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 08, 46, 29, 32, 40, 62, 76, 36},

{20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16},

{20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54},

{01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48}};

}

Solution:

In this problem there are a total of eight directions that one could take from a given number in a straight line to find the sum. With a bit of cleaver thinking though, you will notice that you only need to check 4. That will cover the rest of them automatically. I have chose to go with right from the number, right and down, down, and left and down. Just as easily you could have used left instead of right and up instead of down, but that is all just a random choice that was made on my part. I chose down since I was starting my search in the top left corner and I chose right for the same reason. I suppose it would be possible (although slightly more confusing) to start in the bottom right and then use right and up, but I digress.

I found my position in the table by using nested 'for' statements. This allowed me to proceed through one complete column before I moved on to the next (iterate through 'j' completely before incrementing 'i'). This i,j combination was used in essence as a grid system for this problem.

Starting in the top left I first check if I can in fact go 3 down from my current position. If so then I get the product for that line of characters. Doing this means that I don't have to check four numbers in a row going up from the number at the end of the line. That would produce the same product. I then do the same check and calculation to the right. Since I chose the directions to match up to where I was starting this is of course a bit of a wasted effort for the first several checks, but near the end of the row, and the end of the list it starts to pay off.

At the end of each round of checks for each number, I simply checked the values against the current top value that I had. Naturally, if it was bigger than the top, it took top honors. At the end, as always, print and submit. It is really that easy!

The next two problems are going to look like simple brute force answers, but really there is a level of subtlety that needs to be applied to them, but I will talk more about those in the coming weeks. Until next time...

Enjoy!

Research can be better than knowledge.

2011-06-01T18:30:00.022+02:00

The problem from this week for my Project Euler series was something that I was not immediately aware how to answer. Let's just say it has been a little while since I took my last math course, and doing up the house hold budget doesn't involve a lot of searching for the sum of primes, nor does it have anything to do with numbers in the millions. I was out of my league on this one. I needed help. I hit the net and did some research into various techniques of summing primes.

This is important enough to warrant it's own post because I think this is an insanely important thing to know for programming. No one is going to know everything that there is to know about anything. It just isn't possible. More important (at least in my eyes) is the ability to research and comprehend what you don't know in a timely fashion. I stressed the comprehend part of that because it doesn't help out, in the long run, if you simply search for an answer on a website (or an amazing blog), copy and paste the code into your own project, and give the answer to the Project Euler website. Sure, it will make you feel good about having a large number of solutions on your cool little icon, but that is about the extent of what you will get out of it. If you comprehend it, however, you will be able to retain a bit of it in the back of your mind, and you will have a much greater chance of recalling it next time something like that comes up.

This doesn't just apply to the Project Euler problems either. This can be applied to anything. If you come across something in your programming journey that you just don't know how to do, embrace the opportunity. Take some time, whatever time you can, and look into the topic. Dig a little deeper than just the answer to your immediate problem. Find the answer to greater questions.

Also don't get stuck. This can vary easily get out of had. In addition to looking into, comprehending, and retaining answers, you also need to know when to call it good enough and move on. Your boss will hopefully be able to appreciate you expanding your knowledge base to some extent, but if you expand it to the point of neglecting your work, his views might change slightly. Getting an understanding of a topic is different than researching the topic for your PhD thesis.

Until next time...

Enjoy!

Project Euler souce code on Google Code

2011-05-31T18:30:00.000+02:00

This is just a quick note that I have created a project hosted by Google Code for all the source code that has been given out for my Project Euler series. It is called adkins-project-euler. It is open source and just waiting for someone to come in and look it over. If you want to join the project and give some input about the code I would be more than happy to accept you into it, even though I would ask that you limit to discussing changes to the code instead of just making them (simply so I can keep the blog up to date with the changes in the code).

As of right now I have just dumped my local project on the server, but I am going to be going through and cutting it back to just the problems that were included in the blog so far. A little added bonus that I think I will leave is some other implementations that I have done for a couple of projects. There was a game going on at one of the forums that I frequent (Dream.In.Code) called Code Golf. The point was to solve the given problem with as few characters as possible. I didn't do the best, but I wasn't the worst either.

Without any further babbling, go check it out and let me know what you think.

Until next time...

Enjoy!

Project Euler - Problem 10

2011-05-29T12:01:00.000+02:00

Welcome to week 10 of my Project Euler series.

Problem 10:

Calculate the sum of all the primes below two million.

Details:

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.

Code:

// Calculate the sum of all the primes below two million.

class Project0010

{

static void Main(string[] args)

{

var numbers = SieveEratosthenes(2000000);

long total = 0;

foreach (var num in numbers)

total += num;

Console.Write(total);

Console.Read();

}

// Sieve of Eratosthenes

public static int[] SieveEratosthenes(int upperLimit)

{

int sieveBound = (int)(upperLimit - 1) / 2;

int upperSqrt = ((int)Math.Sqrt(upperLimit) - 1) / 2;

BitArray PrimeBits = new BitArray(sieveBound + 1, true);

for (int i = 1; i <= upperSqrt; i++)

{

if (PrimeBits.Get(i))

{

for (int j = i * 2 * (i + 1); j <= sieveBound; j += 2 * i + 1)

{

PrimeBits.Set(j, false);

}

List numbers = new List((int)(upperLimit / (Math.Log(upperLimit) - 1.08366)));

numbers.Add(2);

for (int i = 1; i <= sieveBound; i++)

{

if (PrimeBits.Get(i))

{

numbers.Add(2 * i + 1);

}

return numbers.ToArray();

}

Solution:

This one certainly had me thinking and even doing a bit of research. It is possible to brute force your way through it, but the problem is that Project Euler explicitly states that each problem can be solved by a moderate computer in under a minute. After the brute force route had run for about 5 minutes I decided that another approach was needed. Since it has been a while since I had a math course I hit the web and did some searching. I checked into different algorithms for working with primes and particularly with the sum of primes. One name that kept popping up was "Sieve of Eratosthenes."

Wikipedia describes the Sieve so - "In mathematics, the Sieve of Eratosthenes (Greek: κόσκινον Ἐρατοσθένους) is a simple, ancient algorithm for finding all prime numbers up to a specified integer. It works efficiently for the smaller primes (below 10 million)." It goes on to give a great description of how it works with a nice animation to really help drive the point home. The general idea behind it is that if 2 is a prime, then all multiples of 2 can not be. By eliminating all of those from the list of numbers that is being searched the field narrows itself relatively quickly. This is done until you reach the square root of the number that you are looking for. Once you get past the Square Root of the maximum number that you are looking for then it is safe to assume that all the primes have been found. This is more of an optimization step, but it is still one that can be taken if you want. It can even be taken one step further by starting the elimination of numbers with the square of the prime that you found, since it has been proven that all numbers between the prime you found and it's square should already be crossed out by process of elimination. It really is quite the interesting piece of mathematical info to have.

I have recreated this by first creating an array with the number of elements being equal to the number that I am searching to. It is a BitArray to minimize the overhead and speed up the whole process. I go through this list to decide if a number is prime or not (true or false). At the end I translate this list from simple set or not set values to actual numbers. Send this back as a return value and some addition later I have my answer.

Just as a side note, it is possible to start your Sieve with the number three and then bump up your iterator by two each pass to improve the performance even more. This is possible because the first round of eliminations will automatically knock out each even number so there is no need to even check them.

Enjoy!

New WiX open source project

2011-05-26T09:59:00.000+02:00

I have started doing a series of tutorials for a forum that I tend to frequent (Dream-In-Code.net) about the Windows Installer XML toolkit (WiX). It is a toolset that allows you to make MSI's (Windows Installer Packets) using just XML, a linker, and a compiler. Pretty neat stuff.

I have decided in my spare time to start an open source project that is going to work as a standardization tool that can be used to, you guessed it, standardize a large number of WiX source files. I short the plan is that it will take certain settings (either through the GUI or a settings XML) and apply the changes to all listed WXS files. This is going to be completely useless to people who only have one or two files, but if more WXS files are involved it could really help out.

So far I have started a project with Google Code and checked in the first couple of dummy files to show the basic idea of how the project will be set up. I have also started working on the Schema that will be used for the settings file, and will whip up a quick settings parser as soon as I am happy with the schema. Anyone who wants to help out is more than welcome to do so; you just have to send me a quick mail and I will add you to the project.

Until next time,
Enjoy!

Project Euler - Problem 9

2011-05-22T12:01:00.001+02:00

Welcome to week 9 of my Project Euler series.

Problem 9:

Find the only Pythagorean triplet, {a, b, c}, for which a + b+ c = 1000.

Details:

A Pythagorean triplet is a set of three natural numbers, a b c, for which,
a2 + b2 = c2

For example, 32 + 42 = 9 + 16 = 25 = 52.

There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.

Code:

// Find the only Pythagorean triplet, {a, b, c}, for which a + b + c = 1000.

class Problem0009

{

static void Main(string[] args)

{

int answer = 0;

for (int a = 1; a < 500; a++) // a + b + c = 1000 so a and b can not be more than 500

{

for (int b = a; b < 500; b++)

{

int c = 1000 - a - b;

if ((a * a) + (b * b) == (c * c))

{

answer = a * b * c;

break;

}

if (answer > 0)

break;

}

Console.Write(answer);

Console.ReadLine();

}

Solution:

This one was once again pretty simple (I am really going to miss being able to say that in a couple of weeks). The details do an adequate job of explaining a Pythagorean triplet so there is no need to reiterate that here, but one thing that will make life easier is keeping in mind that the sum of the three numbers has to be 1000. That allowed me to shrink my for statement down to only include numbers less than (exclusive) 500. I could have in all honesty shrunk it down quite a bit further, but finding that fine line was not really worth the effort. There was no chance that one of the numbers could be over 500 since 'b' has to be bigger than 'a' and there sum has to be 1000.

Once getting a grip on that and putting my two for statements in place I just go ahead and figure out what 'c' would be given the other two numbers and check if they are in fact a Pythagorean triplet. If they are I have my answer and since it is explicitly stated in the problem that there is only one I went ahead and added a break in. No point in searching for an answer that I already have.

Next week is going to get a bit tricky to be honest so make sure and check it out. Until next time...

Enjoy!

Project Euler - Problem 8

2011-05-15T12:01:00.003+02:00

Welcome to week 8 of my Project Euler series.

Problem 8:
Discover the largest product of five consecutive digits in the 1000-digit number.

Details:

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

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Code:
// Discover the largest product of five consecutive digits in the (given) 1000-digit number.
class Problem0008
{
static void Main(string[] args)
{
var rawString = LoadString();
List characterList = rawString.ToCharArray().ToList();
List products = new List();
for (int i = 0; i < characterList.Count() - 4; i++)
{
int first = int.Parse(characterList[i].ToString());
int second = int.Parse(characterList[i+1].ToString());
int third = int.Parse(characterList[i+2].ToString());
int fourth = int.Parse(characterList[i+3].ToString());
int fifth = int.Parse(characterList[i+4].ToString());
products.Add(first * second * third * fourth * fifth);
}

Console.WriteLine(products.Max());
Console.Read();
}

private static string LoadString()
{
return "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
}
}

Solution:
For starters a little clarification. The number that is given, and subsequently used, is a number, not a list of numbers. It is only written the way it is in the description, and subsequently in my code, for readability purposes.

This exercise turned out to be more of a raw data practicing exercise than anything else. I simply took all the input as string and converted it into a list of characters ( rawString.ToCharArray().ToList() ). With that done I created on additional list (of integers) that stores all the products that I get as I run through the list. In order to shave off a good 2 or 3 milliseconds I used a for loop that only goes as long as there are enough characters after the fact to warrant it. For each character I place it and the next four into variables and add their product to my list. A simple call to the Max() method of my list and I have my answer. Nothing to it.

Until next time...

Enjoy!

Project Euler - Problem 7

2011-05-08T12:01:00.017+02:00

Welcome to week 7 of Project Euler.

Problem 7:

Find the 10001st prime.

Details:

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10001st prime number?

Code:

// Find the 10001st prime.

class Problem0007

{

static void Main(string[] args)

{

List primes = new List();

int number = 2;

while (primes.Count() != 10001)

{

bool isPrime = true;

for (var j = 2; j < number; j++)

{

if (number % j == 0)

{

isPrime = false;

break;

}

if (isPrime)

{

primes.Add(number);

primes.Sort();

}

number++;

}

primes.Sort();

Console.WriteLine(primes.Last());

Console.ReadLine();

}

Solution:

This one is pretty similar to Problem 3 except that instead of making a list of primes of a certain number, we are making a list of primes until the list has a certain number of entries. That, however, is pretty much where the differences end. I start off my search for primes with the number two (one is not technically a prime number) and go from there. I have a list that is collecting all the primes that are found along the journey. As soon as a number is found to not be prime, I break out of that iteration of the loop and try again with the next number. A bool helps me keep track of whether or not it is actually a prime and at the end, if it is, then I add it to my list. At the end all that needs to be done is sort the list and display the last one. Done!

Up next week will be problem 8 which is another brute force solution. The next prime number problem (number 10 I believe), however, is shaping up to be pretty interesting. Until then...

Enjoy!

Project Euler - Problem 6

2011-05-01T12:01:00.004+02:00

Welcome to week 6 of Project Euler.

Problem 6:

What is the difference between the sum of the squares and the square of the sums?

Details:

The sum of the squares of the first ten natural numbers is,
12 + 22 + ... + 102 = 385

The square of the sum of the first ten natural numbers is,
(1 + 2 + ... + 10)2 = 552 = 3025

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 - 385 = 2640.

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Code:

// What is the difference between the sum of the squares and the square of the sums?

class Problem0006

{

static void Main(string[] args)

{

int sum = 0;

int sumOfSquares = 0;

for (int i = 1; i <= 100; i++)

{

sum += i;

sumOfSquares += (i * i);

}

int squareOfSums = (sum * sum);

Console.WriteLine((squareOfSums - sumOfSquares).ToString());

Console.Read();

}

Solution:

I am not entirely sure how this problem made the cut. Granted, squaring the first 100 natural numbers would take a bit, but this is not challenging in any programming language at all. In fact most graphing calculators can be programmed to do this with little to no effort. That being said...

I started off simply with two variables, one for the sum of the integers themselves, and one for the sum of the squares. For through the numbers needed adding each one to the sum variable and the square (number * number) to the sumOfSquares variable. At the end I squared the sum that I had running (not the sumOfSquares), subtracted the two, and printed the answer.

Up next week will be problem 7 dealing with Prime Numbers again. Those really seem to be a running favorite, at least in the early questions. Until then...

Enjoy!

Premature Optimization or Excessive Optimization

2011-04-29T10:33:00.000+02:00

Premature Optimization refers to the process of optimizing incomplete code, or optimizing a program before that program is even finished. Excessive Optimization refers to adding absurd amounts of optimization to a program that do not result in any noticeable gains.

I am bringing these two points up now because they directly relate to what is currently happening with the Project Euler problems. They are at a point, still early on, when a simple brute force approach will suffice. Is it possible to whip up an algorithm that will do it in a fraction of the time? Sure. Is it worth it when the amount of time saved will not even be noticeable unless you are taking benchmarks of the apps? Not so much. What about since the whole point of these exercises (at least in my opinion) is to get the ground work laid out showing what can be expected in terms of mathematical difficulty? Even less so.

Many beginners to programming tend to worry far too much about getting a program to run as fast as possible. I have chatted with people that were trying to optimize their code so that the answer is given faster than the current speed of 0.5 SECONDS. This is all well and good if used in a learning context, but if this is used in a production environment, then you just completely wasted your time since the end user won't even notice that change. As with everything in this world there are exceptions, like if your program is going to be run several thousand times in a row, but that is just what needs to be taken into consideration here.

Optimization is a good thing and is fairly important in the high-speed world of today, but it's value fades if improperly used. If there is a tool that you are going to use (on average) once a week for a couple of months and then dispose of it, is there really a point in spending an extra 2 hours to get it milliseconds faster? Following are a couple of things that I look at when making a tool or application to decide what level of optimization is really needed (in no particular order):

Target Audience

Personal use
For my wife or other family member
For general release

Frequency of Use

One time use
Once a week
Once a day
Several times throughout the day
Several times, one right after the other

Work/Play

Am I being payed to make it?

Time Involved

Couple of minutes to streamline a couple of loops
Couple of hours to rewrite main logic

This is not an exhaustive list of course, just the main things that I run through in my head. The target audience is pretty self explanatory. If I am making a quick tool for myself to go through 5,000 files and check that the version number is correct on them all I am not going to invest any time at all into optimizing. If the program is going to be used in an automated build process by the company that I work for, I will optimize a little, but not much. If I am working on a game that I am planning to release to the general public I am going to optimize it as much as I can. This ties directly into the frequency of use issue. If I am making a tool that I am going to use once then erase optimizing is less likely to happen than if it is a program that is going to be (hopefully) used daily by millions of people all over the world. This also ties loosely into the work/play scenario. If I am doing something for my job I have to take into account how much time it will cost me to optimize and if that would be a good investment for my company to make. Everything that I code at work is costing the company money. That is a perfect lead in to the last point, time involved. If a program takes me 20 minutes to make and 90 minutes to optimize is that really worth it? however if it takes me 5 hours to make and 5 minutes to optimize is that better? Like I said though, these are just some of the things that I think about when it comes to optimization. I would like to hear what others think about it though.

Until next time...
Enjoy!

Project Euler - Problem 5

2011-04-24T12:00:00.029+02:00

Welcome to week 4 of my Project Euler series.

Problem 4:
What is the smallest number divisible by each of the numbers 1 to 20?

Details:
2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

Code:

// What is the smallest number divisible by each of the numbers 1 to 20?

class Problem5

{

static void Main(string[] args)

{

bool notFound = true;

int number = 20;

while (notFound)

{

bool evenlyDivisible = true;

for (int i = 1; i <= 20; i++)

{

if (number % i != 0)

evenlyDivisible = false;

}

if (!evenlyDivisible)

number++;

else

notFound = false;

}

Console.WriteLine(number);

Console.Read();

}

Solution:

This one was really easy. A simple brute force approach yields the result in no time. Sadly the days of brute forcing our way through this problems is coming very quickly to an end.

Since the end result was unclear, I chose to go with a while loop. A do-while loop would have worked just as well since I new it was going to run at least once, but that is simply a matter of personal opinion. I prefer the while loop (when I have a choice) simply because it allows you to see the condition, when reading the code, before you actually get to what it will be doing. A basic bool is used as the test criteria so I can change it with an if check in the loop. I start the loop off at number 20, because no number under that is going to be divisible by 20. At least not in the sense of what they are looking for. In all honesty it could have started a great deal higher than that, but I chose to let the program do all the work, with only hard coding what can be gained from the question. For each consecutive number I check if it is divisible by every number between 1 and 20. If it is then we have a winner! Toss it on the console and wait for the user to press any key to continue. If it is not a match then I move right along to the next number. It doesn't get much simpler than that.

After this one, we have a couple of more brute force approaches, then things really start to take off. As I said in the beginning, these problems are not overly difficult. Some of them are of course, but there are some that are really simple. The thing that complicates them is that they are stretched out. For example finding the first number that is divisible by every number between 1 and 5 could be done by hand. It would take some time, effort, sweet, and tears, but it is in the end possible. So is this problem, but from the time that is needed it is no longer what a normal person would consider solvable by hand. A couple of magic keystrokes later and a couple of seconds wait and we have an answer. That is really the beauty of programming.

Until next time...

Enjoy!

Project Euler - Problem 4

2011-04-17T12:00:00.028+02:00

Welcome to week 4 of my Project Euler series.

Problem 4:
Find the largest palindrome made from the product of two 3-digit numbers.

Details:

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 99.

Find the largest palindrome made from the product of two 3-digit numbers.

Code:

// Find the largest palindrome made from the product of two 3-digit numbers.

class Problem4

{

static void Main(string[] args)

{

int product;

int answer = 0;

string productString;

for (int i = 999; i > 99; i--)

{

for (int j = 999; j > 99; j--)

{

product = i * j;

productString= product.ToString();

if (productString == ReverseString(productString))

{

if (product > answer)

{

answer = product;

}

Console.WriteLine(answer);

Console.Read();

}

private static string ReverseString(string input)

{

var inputArray = input.ToCharArray();

var reversedValue = string.Empty;

for (int i = input.Length-1; i >= 0; i--)

{

reversedValue += inputArray[i];

}

return reversedValue;

}

Solution:

I am not sure why, but this one caused me a little too much grief. I was thinking entirely too hard about it. Once I decided to simplify it to ridiculous proportions, then it worked. I have three variables. The first is for the product of the current three digit numbers, the second is the current highest product, and the third is the current product as a string. The main loop of this program is a for inside a for, so that we can go through the list from 100 to 999 twice, since it is the sum of two three digit numbers. The following steps go pretty fast. I take the product, check if it is the same reversed, then see if it is larger than the reigning champ. If so swap it out, then move on to the next. The final steps as always are print and finish.

The reversal of the number is also very easy. I simply turn it into an array of characters, then loop through it backwards, placing them at the first empty space that is found. A quick save and return, and all is well in the world.

This problem really moved along first when I stopped thinking about it too much. I could hear every programming instructor or professor that I have ever had yelling "KISS - Keep It Simple Stupid" over and over. Perhaps they didn't yell it, but it got drilled into us all in either case. And it really is true as I found out first hand.

Until next time...

Enjoy!

Project Euler - Problem 3

2011-04-10T12:00:00.003+02:00

Welcome to week 3 of my Project Euler series.

Problem 3:

Find the largest prime factor of a composite number.

Details:

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Code:

// Find the largest prime factor of a composite number.

class Problem3

{

static void Main(string[] args)

{

var list = PrimeFactors(600851475143);

Console.WriteLine(list.Last());

Console.Read();

}

///

/// Returns a list of the prime factors of a number in ascending order.
///

///

The number to factor

/// List of prime factors

public static List PrimeFactors(long i)

{

if (i < 2)

{

throw new ArgumentOutOfRangeException("Numbers less than 2 don't have prime factors");

}

List result = new List();

int divisor = 2;

while (divisor <= i)

{

if (i % divisor == 0)

{

result.Add(divisor);

i /= divisor;

}

else

{

divisor++;

}

return result;

}

Solution:

This one took slightly more work then the previous ones did. Right from the beginning I could see the appeal of prime numbers to the people that created the questions for Project Euler, so I decided to make that into a method by itself that could be then reused whenever they came up.

The method PrimeFactors does just that. It takes in a number and finds all prime numbers that are available up to that number. I started off with a check to see if the number that is given to the method is less than 2 simply because no number under 2 can be a prime number so no point even checking. If that checks out to be okay I then lay out a couple of variables. One for the list of primes that are found, and the other is the divisor that is currently used (starting at 2 of course). Now the meat and potatoes of this method, the loop. I have done it in a while loop just to have the constant checking without an actual value to use as the endpoint. It will keep going until the divisor is less than or equal to the number (not prime numbers are going to come after that point so no point in checking). Inside the loop I check for a remainder when I divide the number by the divisor. If there isn't one the divisor is obviously a prime and it is added to the list. The number is then divided by that number to remove the instances where that number will have to be rechecked. If a remainder is found, then the divisor is increased. In this manor it continues until the divisor and the number meet or pass each other. The list is returned at the end.

I simply take the list that is returned, display the last number (which will be the largest) and close with the next key stroke. All the action here takes place solely in the prime method so it might have worked out this time to simply print the answer from within, but I wanted to make a method that was transportable and reusable so I have those three lines in my main to display results.

Problem 4 did cause me a little bit of grief to be perfectly honest, but once the caffeine got kicked into high gear and the ball started rolling it was fairly simple as well. Most of these seem to be pretty easy to get once the answer is known. That is true with most problems though. Until next time...

Enjoy!

Project Euler - Clarification and Explanation

2011-04-04T11:58:00.001+02:00

I have recently started a series that I am going to be running about the solutions that I have come up with for Project Euler. The first two solutions are already posted and I thought it might be a good idea to clarify how I am going to be presenting the info and why. Better late than never after all...

I will present the problem as it states on the Project Euler page followed by the details that are given about the problem. Both of these sections will be nothing more than a quick copy and paste. Next will come the code. Unless stated otherwise it will be in C# with .NET 3.5 (although until the writing of this post I have not used any functionality that is not available in .NET 1.1). Following the code will be an explanation of how I went about solving the problem and why.

This does make an interesting predicament as most of the problems could be solved with a "brute force" approach. To that end, the Project Euler team has specified that the problems were designed so that they can be solved by a computer of reasonable capabilities in no more than one minute. If it takes longer than that, then most likely there is a better approach that could be used.

The solutions presented here are my solutions. They are not the only solution, and they might not even be the best solution, but they are how I solved the problem. I won't post a solution here unless it is the one that I actually used to get the answer that was accepted by Project Euler. If you have another way of doing it, or some other comment about my solution I will gladly read the comments that I get.

These posts will be coming once a week, and I will try and have them ready to post even if I am not available to post them personally at the right time. I think that about covers the organizational "good to know"s about this series. I hope you like it and perhaps even learn a little something from it. Until next time...

Enjoy!

Project Euler - Problem 2

2011-04-04T11:19:00.001+02:00

I have decided to make the Project Euler posts a weekly thing. That being said...

Welcome to week 2 of Project Euler.

Problem 2:
By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

Details:

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

Code:

//By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

class Problem2

{

static void Main(string[] args)

{

int term1 = 1;

int term2 = 2;

int term3 = 3;

int total = 2; // first even numbered element won't be found by Fibonacci logic

{

if(term3%2 == 0)

total += term3;

term1 = term2;

term2 = term3;

term3 = term1 + term2;

} while (term3<4000000);

Console.Write(total);

Console.Read();

}

Solution:
This problem was another overly easy one if you have a grasp of what the Fibonacci sequence is all about. It is, simply put, that each number is equal to the sum of the two previous numbers. This requires nothing more than three variables. The third variable is equal to the first two, then each variable is shifted back one. To expand slightly, after the addition is made the second variable is stored in the first, and the third variable is stored in the second. This leaves you free to use the third to hold the new sum. I repeated this process over and over again until the third value was over 4,000,000 (as per the problem). After the addition each time I checked what the remainder was of the third term (our sum) and two. I simpler words, I checked if it was even. If it was then it went into our running total. As will always be the case, at the end I printed out the answer so I could enter it into the site, just to make sure I was right.

This one really didn't have any subtleties that needed to be addressed, and with some very basic math it was easily solvable. I didn't take the time to try and optimize my code at all do the simplicity involved, but I might do that at some point in the future. For example, the logic for finding the Fibonacci sequence to a certain point could be moved to a different method and then the list parsed for even number values. We will have to see if I decide to do that or not.

Up next week will be problem 3 dealing with Prime Numbers. The post is looking like it will be a little more involved than these first two were. Until then...

Enjoy!

Project Euler - Problem 1

2011-03-27T23:24:00.002+02:00

I am going to do a series on here based on the problems that are presented at Project Euler. They will not only show the solution that I came up with, along with an explanation of why I did it that way, and (possibly) some other ideas I have tried out. There could be some significant breaks in the series since I don't have all 330+ problems solved, so please bare with me.

Problem 1:
Add all the natural numbers below one thousand that are multiples of 3 or 5.

Details:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

Code:

class Problem1
{
   static void Main(string[] args)
   {
       int result = 0;

       for (int i = 1; i < 1000; i++)
           if ((i % 3 == 0) || (i % 5 == 0))
               result += i;

       Console.Write(result);
       Console.Read();
   }
}

Solution:
This one was pretty straight forward and easy. I simple loop through all the numbers, checking each one if it is divisible by 3 or 5. If it is then add it to the pot. At the end I simply displayed this value so that I could enter it into the site for the go ahead. The one thing that could be tricky about this problem is that it says all numbers below 1000, non inclusive. I have found that it can be very frustrating if the problem and additional information are not carefully read.

The next problem has a bit more math involved, but it is also pretty straight forward. I will post that one in a couple of days. No point overwhelming anyone.

Until next time...Enjoy!

Project Euler

2011-03-25T14:49:00.001+01:00

I am holding off on more WiX tutorials until I find out if the one I already did was approved or not. That doesn't mean I have been bored. I have recently discovered Project Euler. It is a site that posts various mathematical questions that are best solved with programming. I suppose it is possible to do them with pen and paper, but that would take immense amounts of work and defeat the purpose. The purpose being of course to expand my mathematical thinking in my programming. So far it has been a bit slow getting started, because I don't normally do a lot of real heavy math programming, and it has been a while since my last math class of any kind. The cob webs are on their way out, and I am starting to get quicker at finding the solutions. On the right you can see a picture that shows my current progress. This is kind of fun to be honest.

Until next time, Enjoy!

It is like seeing a ghost

2011-03-21T16:51:00.000+01:00

I am back again! After an long absence due to work, personal stuff, non personal stuff, and about 3.5 million other things, I am back once again.

I have not been very busy working on my games in my absence sadly, but I have been working on my books, and I have started writing tutorials for Dream In Code. I am going to be doing a serious about WiX (Windows Installer XML). That is my current project at the real job, and one that could pay dividends when it comes to my games. Every program that is worth making, should be worth distributing as well. Windows Installer is the easiest way to distribute .NET applications, and WiX is my way of doing that.

Enough rambling about real life though, it is now on to the games. I have (finally) gotten my hands on a real reference to a graphics library that explains things in a way that both teaches me, and keeps me from falling asleep. It is, once again, a new library with a learning curve and everything, but this time I have a guide to help me learn. Also I am going to programming directly to OpenGL so there is a rather large support community there. I should clarify, a rather large active support community. No promises on a new game, or even a new idea, or anything really. Just the promise that I am still alive and still learning and expanding.

Till next time, Enjoy!