Thread: find the sum of even number not exceed four million

You're condition is testing for until your computed result is greater than or equal to 4000000. So naturally the result you have will be the very first fibonacci number larger than 4 million.

The easiest way to fix this is to keep a second variable which will keep track of the fibonacci number after the current one and stop when that number first gets larger than 4 million.

also, if I'm reading the original problem statement right, you're adding up fibonacci numbers less than 4 million. There are quite a few and it's possible that their sum (even with only ever other one) could add up to be over 4 million.

i guess the answer is :

public class Fibonacci {
 
    public static void main(String[] args) {
        int firstNum = 1;
        int seqNum = 0;
        int secNum = 1;
        long length = 1000 * 4000;
        int sumEvenNum = 0;
        System.out.println("length " + length);
 
        while (seqNum < length) {
            seqNum += firstNum;
 
            if (seqNum % 2 == 0) {
                //System.out.println("seqNum: " + seqNum);
                //System.out.println("sumEvenNum: " + sumEvenNum);
                sumEvenNum += seqNum;
                //System.out.println("even number: " + sumEvenNum);
            }
 
            if(sumEvenNum > length)
                break;
 
            firstNum = secNum;
            secNum = seqNum;
        }
 
        System.out.println("sumEvenNum: " + seqNum);
    }
}

Originally Posted by Mrc0d3r

That piece of code would certainly do the job, but it can be made more efficient by implementing recursion also you can fix the swap part to a 2 variable one. A little bit of threading should make it even more efficient.

Recursion definitely looks more elegant, but it is by no means more efficient. Fibonacci number computation is highly repetitive, so a dynamic programming solution (implemented iteratively) is the best way to compute Fibonacci numbers. Because computing Fibonacci numbers is very sequential (even with an iterative solution), I don't see any benefit of using a multi-threaded solution. If anything, the overhead from creating new threads, managing synchronization and data safety will far out-weigh any small, if any, benefit of a multi-threaded solution.

Honestly, I don't see how an iterative method can perform a swap without at least 3 variables.

Originally Posted by helloworld922

Recursion definitely looks more elegant, but it is by no means more efficient. Fibonacci number computation is highly repetitive, so a dynamic programming solution (implemented iteratively) is the best way to compute Fibonacci numbers. Because computing Fibonacci numbers is very sequential (even with an iterative solution), I don't see any benefit of using a multi-threaded solution. If anything, the overhead from creating new threads, managing synchronization and data safety will far out-weigh any small, if any, benefit of a multi-threaded solution.

Completely agree ! And regarding the multi-threading part, I thought we could split up the work to threads :S

Originally Posted by ChristopherLowe

how would I 'fix the swap part to a 2 variable one'.

Originally Posted by helloworld922

Honestly, I don't see how an iterative method can perform a swap without at least 3 variables.

This can do the job I suppose..

next = next + last;
last = next - last;

Originally Posted by Mrc0d3r

This can do the job I suppose..

next = next + last;
last = next - last;

Ahh, that's a very interesting solution. There's not any significant performance boost (or ding), but it does look cool.