Geekality » Fibonacci http://www.geekality.net With a hint of Social Ineptitude Tue, 27 Jul 2010 16:15:56 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Project Euler: Problem 25 http://www.geekality.net/2009/11/06/project-euler-problem-25/ http://www.geekality.net/2009/11/06/project-euler-problem-25/#comments Fri, 06 Nov 2009 22:51:56 +0000 Torleif http://www.geekality.net/?p=751 Continue reading →]]>

The Fibonacci sequence is defined by the recurrence relation:
F_n = F_{n-1} + F_{n-2}, where F_1 = 1 and F_2 = 1.

Hence the first 12 terms will be:

  • F_1=1
  • F_2=1
  • …
  • F_{11}=89
  • F_{12}=144

The 12th term, F_{12}, is the first term to contain three digits.

What is the first term in the Fibonacci sequence to contain 1000 digits?

Solution

We touched on the Fibonacci sequence a while ago in the second euler problem. This time, however, we are in a whole different league. That time we were supposed to sum up all even Fibonacci numbers below 4 million, which might sound like a lot, but not when we compare it to the number we are asked for this time! The last Fibonacci number below 4 million is 3524578. That would be 7 digits. The maximum value of the datatype I used in the generator I made for that (ulong) is 18446744073709551615. That would be 20 digits. Quite a distance left to a thousand!

So, once again we turn to our big integer class, IntX. And since we have that, a solution to this problem is actually pretty straight forward. We simply have to make a new generator that uses the IntX data type instead of tiny ulong (it’s all relative…).

public class LargeFibonacciSequence : IEnumerable<IntX>
{
    public IEnumerator<IntX> GetEnumerator()
    {
        var a = new IntX(0);
        var b = new IntX(1);

        while (true)
        {
            yield return a;

            var c = a + b;
            a = b;
            b = c;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

The straight forward solution should then be fairly obvious.

var n = 0;
var sequence = new LargeFibonacciSequence();

using (var e = sequence.GetEnumerator())
{
    while (e.MoveNext() && e.Current.ToString().Length < 1000)
        n++;
}

var answer = n;

That pretty much just moves through one Fibonacci number after the other, increasing n as it goes, until it reaches the first one that has 1000 or more digits.

Very brute-force, not very fast (takes around 500 ms) and not very interesting, but that’s pretty much it… ooor is it?

Take two!

Alright, while reading up on Fibonacci numbers I found some interesting mathematical formulas and such. I’m not going to come with an in-depth explanation or lots proofs here, but I will share the formulas that matters and go through how we use them. If you want the elaborate explanations you can find them where smarter people than I reign. For example at Wikipedia, or at this site. Anyways, here we go. Take cover if you fear math…

The Fibonacci sequence

The nth number in the Fibonacci sequence, F_n, is defined by the recurrence relation

F_n = F_{n-1} + F_{n-2}

with the seed values F_0=0 and F_1 = 1.

This recurrence, since it is linear, can be expressed by a closed-form solution known as the Binet’s formula:

Fib(n)=\dfrac{\varphi^n-(1-\varphi)^n}{\sqrt{5}}=\dfrac{\varphi^n-(\frac{-1}{\varphi})^n}{\sqrt{5}}
\varphi=\dfrac{1+\sqrt{5}}{2}\approx1.6180339887\ldots — (The Golden ratio)

Now, why 1-\varphi and \frac{-1}{\varphi} is considered the same, or even why that formula works or looks like that, I will leave as an exercise for the reader (Cause I have no idea :P Please share if you do…). But anyways, as an example, if you put 20 into that formula, you will get 6765 which is the 20th number in the Fibonacci sequence. Fantastic. We could now use that formula to make another brute-force solution to find the term we are after. But that wouldn’t make much sense and would be much much slower. So, we must move on further into this crazy land.

Before we move on to the next part, since we will be working with quite large values of n, we can simplify that expression a bit. That is because \frac{-1}{\varphi}^n will move pretty fast towards 0 as n increases. In other words, we can pretty much just skip that part and use the following formula instead:

Fib(n)=\dfrac{\varphi^n}{\sqrt{5}}

The length of a number

How do you calculate the length of a number? I actually had to do this in an earlier post and then I kind of cheated. I just converted the number into a string and just count the characters (In C#, string.Length). But, I recently discovered that there actually is a way you can do this mathematically! I had no idea… The key lays in the logarithm to base 10.

\log_{10}{n} (often written as just \log{n}) for any 1-digit number will give you 0.something. For any 2-digit number it gives you 1.something, and so on. So a formula for getting the length of any number:

Len(n)=\lfloor\log{n}\rfloor+1

In case you were wondering, those weird square brackets are called the floor function.

The length of a Fibonacci number

Now we are able to calculate the length of a certain Fibonacci number by using the following formula, which I for no good reason will call G:

G(n)=Len(Fib(n))=\lfloor\log{\dfrac{\varphi^n}{\sqrt{5}}}\rfloor+1

There is a problem here though. And the problem is \varphi^n. Why is it a problem? Because it get’s seriously large very quick. A value of around 500 actually makes my calculator overflow and just give me an error.

But fear not! There are a couple of formulas having to do with roots and logarithms that we can use to our advantage:

\sqrt{c}=\sqrt[2]{c}

\sqrt[b]{c}=c^{\frac{1}{b}}

\log_a{\dfrac{b}{c}}=\log_a{b}-\log_a{c}

\log_a{b^c}=c\log_a{b}

With those formulas we can handily rewrite our formula into one that is easier to handle:

G(n)=\lfloor\log{\dfrac{\varphi^n}{\sqrt{5}}}\rfloor+1

G(n)=\lfloor\log{\varphi^n}-\log{5^{\frac{1}{2}}}\rfloor+1

G(n)=\lfloor n\log{\varphi}-\dfrac{\log{5}}{2}\rfloor+1

Tadaa! Now we can push in 20 and get 4. And as we calculated earlier, the 20th Fibonacci number is 6769, which in fact is 4 digits long! Amazing…

The first Fibonacci number with 1000 digits

Now we are almost ready to solve our problem. The formula we have now works perfectly. The only problem is that it’s backwards! We are not looking for the length of a certain Fibonacci number, but rather what Fibonacci number has a certain length. In other words, we want n, not G(n). Luckily, using pretty basic algebra and some guessing, we can make a new formula that finds exactly what we are looking for. (My way of skipping the floor stuff and introducing a ceiling function in the end is purely based on guessing and observation. But it gives the correct answer :P Now, if you know the proper way of handling it, please let me know! )

G(n)=\lfloor n\log{\varphi}-\dfrac{\log{5}}{2}\rfloor+1

n\log{\varphi}=G(n)+\dfrac{\log{5}}{2}-1

n=\lceil\dfrac{G(n)+\dfrac{\log{5}}{2}-1}{\log\varphi}\rceil

Now we can just substitute G(n) with 1000, and calculate n, which should be the answer to this problem!

As usual, I will not put the actual answer here though ;)

This has been the longest blog post yet about these problems, I think, but I must say it was pretty fun to solve this one. I didn’t really get much at first, just saw that the formulas worked, but now that I have written about it and gone through it all step by step, it actually makes sense. Most of it anyways. If you know how to properly handle that floor and ceiling stuff, let me know :P

Anyways, that was it for now! Stay tuned for more good stuff like this :P

]]> http://www.geekality.net/2009/11/06/project-euler-problem-25/feed/ 1 Project Euler: Problem 2 http://www.geekality.net/2009/09/17/project-euler-problem-2/ http://www.geekality.net/2009/09/17/project-euler-problem-2/#comments Thu, 17 Sep 2009 20:18:17 +0000 Torleif http://www.geekality.net/?p=165 Continue reading →]]> Alright, next Project Euler problem:

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, …

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

Solution

I pretty soon decided I wanted to solve these problems in a good way, and also to sort of try to build up a collection of useful tools that I could hopefully use when solving later Euler problems as well. And even if I didn’t find any use for them later, at least I would have gotten some practice when making them :P

So, the first thing I figured I needed, was a source of Fibonacci numbers. So I created an interface for it, and an implementation (in case I wanted to swap out the implementation more easily later).

    public interface IFibonacciSequence : IEnumerable<ulong> {}

    public class FibonacciSequence : IFibonacciSequence
    {
        #region IFibonacciSequence Members
        public IEnumerator<ulong> GetEnumerator()
        {
            var a = 0UL;
            var b = 1UL;
            var c = a + b;

            while (true)
            {
                yield return c;

                c = a + b;
                a = b;
                b = c;
            }
        }


        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        #endregion
    }

After having created that class, solving the problem was pretty straight forward with a simple LINQ statement. I simple start taking numbers from the generator, filtering out the ones that are not even, up till I reach the highest number, and then I sum all of those up.

var answer = new FibonacciSequence()
    .Where(x => x%2 == 0)
    .TakeWhile(x => x < 4000000)
    .Aggregate((sum, x) => sum + x);

Voila :) The reason why I don’t use the Summethod is that it doesn’t seem to be one for ulong, only for long. And I decided that I for the first would try to use long instead of int since the answer to some of these problems seems to be quite large. And to use ulong here since there aren’t really any need for negative numbers…

Anyways, that was my solution to this problem. According to my test results, it takes less than 5 ms to find it, which is fast enough to me.

So, what do you think? How did you do it?

]]> http://www.geekality.net/2009/09/17/project-euler-problem-2/feed/ 0