斐波那契数词在Java中

Question

I have the following code:

function fib(n) {

  let first=BigInt(0);
  let snd=BigInt(1);
  let currentNumber;
  let countMax=Math.abs(n)+1;
  let counter=2;
  if(n==0){

    return first;
  } 
  else if (n==1||n==-1){

    return snd;
  }
  while(counter<countMax)
  {
        currentNumber=first+snd;
        first=snd;
        snd=currentNumber;
        counter++;
  }
  if((n<0) && (n % 2 ==0))
  {
    return -currentNumber;
  }
  return currentNumber;
}

That returns the fibonacci number for the given (n).

My issue is that I have to improve the performance of this code. I tried to use different fibonacci formulas (exponential ones) but I lose a lot of precision cause phi number has infinite decimals, so I have to truncate and for big numbers I lost a lot of precision.

When I execute for instance fib(200000) I get the huge number but the code spends more than 12000 ms.

For other hand I tried using recursion but the performance decreases.

Could you provide me an article or clue to follow?

Thanks & Regards.

Answer 1

If you just add the previous value to the current one and then use the old current value as the previous one you get a significant improvement in performance.

 function fib(n) { var current = 1; var previous = 0; while (--n) { var temp = current; current += previous; previous = temp; } return current; } console.log(fib(1)); // 1 console.log(fib(2)); // 1 console.log(fib(3)); // 2 console.log(fib(4)); // 3 console.log(fib(5)); // 5 

You can also use an array in the parent scope to store the previous values to avoid redoing the same calculations.

 var fibMap = [1, 1]; function fib(n) { var current = fibMap[fibMap.length - 1]; var previous = fibMap[fibMap.length - 2]; while (fibMap.length < n) { var temp = current; current += previous; previous = temp; fibMap.push(current); } return fibMap[n - 1]; } console.log(fib(1)); // 1 console.log(fib(2)); // 1 console.log(fib(3)); // 2 console.log(fib(4)); // 3 console.log(fib(5)); // 5 

Benchmark for getting the 1000th number 3 times

Answer 2

First of all, you can refer the answer here which says that

Fib(-n) = -Fib(n)

Here's the recursive implementation which is not efficient as you mentioned

function fib(n) {
    // This is to handle positive and negative numbers
    var sign = n >= 0 ? 1 : -1;
    n = Math.abs(n);

    // Now the usual Fibonacci function
    if(n < 2)
        return sign*n;
    return sign*(fib(n-1) + fib(n-2));
}

This is pretty straightforward and I leave it without explaining because if you know Fibonacci series, you know what the above code does. As you already know, this is not good for very large numbers as it recursively calculate the same thing again and again. But we'll use it in our approach later on.

Now coming towards a better approach. See the below code similar to your code just a bit concise.

function fib(n) {
    if(n == 0)
        return 0;
    var a = 1;
    var b = 1;
    while(n > 2) {
        b = a + b;
        a = b - a;
    }
    // If n is negative then return negative of fib(n)
    return n < 0 ? -1*b : b;
}

This code is better to use when you want to call this function only a few times. But if you want to call it for frequently, then you'll end up calculating the same thing many times. Here you should keep track of already calculated values.

For example, if you call fib(n) it will calculate n th Fibonacci number and return it. For the next time if you call fib(n) it will again calculate it and return the result. What if we store this value somewhere and next time retrieve it whenever required?

This will also help in calculating Fibonacci numbers greater than n th Fibonacci number. How?

Say we have to calculate fib(n+1), then by definition fib(n+1) = fib(n) + fib(n-1) . Because, we already have fib(n) calculated and stored somewhere we can just use that stored value. Also, if we have fib(n) calculated and stored, we already have fib(n-1) calculated and stored. Read it again.

We can do this by using a JavaScript object and the same recursive function we used above (Yes, the recursive one!). See the below code.

// This object will store already calculated values
// This should be in the global scope or atleast the parent scope
var memo = {};

// We know fib(0) = 0, fib(1) = 1, so store it
memo[0] = 0;
memo[1] = 1;

function fib(n) {
    var sign = n >= 0 ? 1 : -1;
    n = Math.abs(n);

    // If we already calculated the value, just use the same
    if(memo[n] !== undefined)
        return sign*memo[n];

    // Else we will calculate it and store it and also return it
    return sign*(memo[n] = fib(n-1) + fib(n-2));
}

// This will calculate fib(2), fib(3), fib(4) and fib(5). 
// Why it does not calculate fib(0) and fib(1) ? 
// Because it's already calculated, goto line 1 of this code snippet
console.log(fib(5)); // 5

// This will not calculate anything 
// Because fib(-5) is -fib(5) and we already calculated fib(5)
console.log(fib(-5)); // -5

// This will also not calculate anything
// Because we already calculated fib(4) while calculating fib(5)
console.log(fib(4)); // 3

// This will calculate only fib(6) and fib(7)
console.log(fib(7)); // 13

Try out some test cases. It's easy to understand why this is faster.

Now you know you can store the already calculated values, you can modify your solution to use this approach without using recursion as for large numbers the recursive approach will throw Uncaught RangeError . I leave this to you because it's worth trying on your own!

This solution uses a concept in programming called Dynamic Programming. You can refer it here .