Ok I’ve had a bit of change of heart. I’m going to park the Atari 2600 game for a bit. Because frankly I was finding it hard to get motivated to do it, hence the radio silence for a few months. So I’ve decided I’m going to start another project that I am quite excited about.
Ever since I wrote my first game BlackJack in Turbo Pascal 7, I’ve been wanting to write another game. I’ve got an idea of a game in my head that I want to write called Rotation (more details in later posts). I’ve decided to write the game using Microsoft’s XNA framework, as I use C# in my day job it makes sense to write a game in a language that I’m comfortable in.
I’ve downloaded XNA framework and setup a git repository on bitbucket. I have to say that so far I’m really impressed with bitbucket. They provide a free account and it gives you a really easy way to access your code from anywhere. As a git user in my day job for 6 months or so now, git was the obvious choice for source control.
I’d like to point out that I’m a business web applications developer by day. My programming habits come from a world of unit tests and IoC containers. I’m going to keep mainly to the style I’m used to when I write this game. I’m pretty sure that a game developer would go about this game in a very different way and optimise for performance not maintainability and test coverage (perhaps I’m doing those guys a disservice but that’s the impression I get).
Next post will explain more about the game and some of my early design decisions.
Problem 8 of Project Euler can be done by just using a simple for loop. The problem is detailed as:
Find the greatest product of five consecutive digits in the 1000-digit number.
In C# this is pretty trivial as all we need to do is loop round mulitplying 5 digits in a row and checking if that number is higher than anything we’ve got so far. Of course you could do something elaborate with the 0s, ie not bother to calculate the product of any 5 digits containing one or more zero as it’ll always be 0. But on a modern computer this computes so fast you dont really need to code that into your answer.
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.
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.
What would you expect to be displayed when you execute the following C# code:
int i = System.Int32.MaxValue;
i = i + 1;
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.
After spending quite decent amount of time over the last few years reading blogs, I though it was about time I started my own one. This blog is going to stay technical and be my humble view on the world of programming.
I hope to at least have one person (other than myself) read each post so this isn’t a complete waste of my time.