Project Euler Problem 7 finding the 10001st prime

As previously mentioned in my post before I’m not going to post the complete source code for my solutions (written in C#). Instead I’m just going to talk through some of the techniques that I’ve used to solve the problems.

Here is problem 7:
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?

Now this is actually quite easy (and quick) to solve if you know a little trick with primes. As you probably know a number is said to be prime if it’s divisible by itself and 1. A quick way of checking to see if it’s prime is to ensure that it’s not divisble by any prime lower than the square root of the number that you are checking.

Obviously as you find a new prime number you need to add it to your running list of primes so that can be used to check subsequent numbers. Using this technique gives you the answer very fast.

Project Euler

 

Upon reading Eric Lippert’s wonderful blog which can be found here. I read about him solving problems on project Euler for fun.

Being interesting in problem solving I decided to look up project Euler and discovered the website http://projecteuler.net. The website is really addictive if you enjoy solving logic problems.

I dont want to put all of the answers to the problems on here (I dont actually have them all yet) but then I figure someone could Google them and cheat. Instead I’m going to do some posts on some techniques I’ve used to solve them.

Adding one to System.Int32.MaxValue

What would you expect to be displayed when you execute the following C# code:

int i = System.Int32.MaxValue;

i = i + 1;

Console.WriteLine("{0}", i);

What you end up getting is -2147483648. Let me explain why that is…

I’m not going to go into the ins and outs of how binary numbers work, as that is way beyond the scope of this blog post. A 32 bit number is represented by 32 1’s & 0’s. Each bit from right to left goes up in magnitude as to what it’s worth (much like the normal decimal based number system we are used to). So each bit is worth it’s value * (2^p) (where ^ means ‘to the power of’ and p is position of the bit). So the lsb (least significant bit) is worth it’s value * 2^0. Anything to the power of 0 is one so the lsb is worth 0 or 1 (or 0*1 or 1*1). The next significant bit is worth it’s value * 2^1 so 0 or 2. This process carries on for each of the first 31 bits.

Now due to the fact an Int32 is a signed integer (we can represent negative numbers) the msb (most significant bit) doesn’t represent it’s value * 2^31 (31 not 32 as we start counting at 0) but instead it represents it’s value * – (2^31). So effectively either 0 or -2147483648.

If we think about the actual binary representation of System.Int32.MaxValue it is 0111 1111 1111 1111 1111 1111 1111 1111 (note I’ve added spaces to make it easier to read), well when you add one to that value it becomes 1000 0000 0000 0000 0000 0000 0000 0000 or -2147483648. A more in depth summary of how binary counting works is available on Wikipedia.

As an aside -1 is represented by 32 1’s (1111 1111 1111 1111 1111 1111 1111 1111). So when you add 1 to -1 you end up with 32 0’s which is 0. Representing binary numbers in this way is known as two’s complement. It is done like this as it means you can logically add numbers for addition and subtraction (for subtraction simply turn a number negative and add it). Wikipedia has a very informative article on two’s comlement if you’re interested in reading more.