检查数字是否在斐波那契数列中？

Question

It was asked to find a way to check whether a number is in the Fibonacci Sequence or not. The constraints are
1≤T≤10^5

1≤N≤10^10

where the T is the number of test cases,

and N is the given number, the Fibonacci candidate to be tested.

I wrote it the following using the fact a number is Fibonacci if and only if one or both of (5*n2 + 4) or (5*n2 – 4) is a perfect square :-

import java.io.*;
import java.util.*;

public class Solution {

 public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();

    for(int i = 0 ; i < n; i++){
        int cand = sc.nextInt();
        if(cand < 0){System.out.println("IsNotFibo"); return; }
        int aTest =(5 * (cand *cand)) + 4;
        int bTest = (5 * (cand *cand)) - 4;
        int sqrt1 = (int)Math.sqrt(aTest);// Taking square root of aTest, taking into account only the integer part.
        int sqrt2 = (int)Math.sqrt(bTest);// Taking square root of bTest, taking into account only the integer part.
        if((sqrt1 * sqrt1 == aTest)||(sqrt2 * sqrt2 == bTest)){
            System.out.println("IsFibo");
        }else{
            System.out.println("IsNotFibo");
        }
       }
     }
  }

But its not clearing all the test cases? What bug fixes I can do ?

Answer 1

A much simpler solution is based on the fact that there are only 49 Fibonacci numbers below 10^10 .

Precompute them and store them in an array or hash table for existency checks.

The runtime complexity will be O(log N + T):

Set<Long> nums = new HashSet<>();
long a = 1, b = 2;
while (a <= 10000000000L) {
    nums.add(a);
    long c = a + b;
    a = b;
    b = c;
}
// then for each query, use nums.contains() to check for Fibonacci-ness

If you want to go down the perfect square route, you might want to use arbitrary-precision arithmetics:

// find ceil(sqrt(n)) in O(log n) steps
BigInteger ceilSqrt(BigInteger n) {
    // use binary search to find smallest x with x^2 >= n
    BigInteger lo = BigInteger.valueOf(1),
               hi = BigInteger.valueOf(n);
    while (lo.compareTo(hi) < 0) {
        BigInteger mid = lo.add(hi).divide(2);
        if (mid.multiply(mid).compareTo(x) >= 0)
            hi = mid;
        else
            lo = mid.add(BigInteger.ONE);
    }
    return lo;
}
// checks if n is a perfect square
boolean isPerfectSquare(BigInteger n) {
    BigInteger x = ceilSqrt(n);
    return x.multiply(x).equals(n);
}

Answer 2

Your tests for perfect squares involve floating point calculations. That is liable to give you incorrect answers because floating point calculations typically give you inaccurate results. (Floating point is at best an approximate to Real numbers.)

In this case sqrt(n*n) might give you n - epsilon for some small epsilon and (int) sqrt(n*n) would then be n - 1 instead of the expected n .

Restructure your code so that the tests are performed using integer arithmetic. But note that N < 10 ¹⁰ means that N ² < 10 ²⁰ . That is bigger than a long ... so you will need to use ...

UPDATE

There is more to it than this. First, Math.sqrt(double) is guaranteed to give you a double result that is rounded to the closest double value to the true square root. So you might think we are in the clear (as it were).

But the problem is that N multiplied by N has up to 20 significant digits ... which is more than can be represented when you widen the number to a double in order to make the sqrt call. (A double has 15.95 decimal digits of precision, according to Wikipedia.)

On top of that, the code as written does this:

int cand = sc.nextInt();
int aTest = (5 * (cand * cand)) + 4;

For large values of cand , that is liable to overflow. And it will even overflow if you use long instead of int ... given that the cand values may be up to 10^10. (A long can represent numbers up to +9,223,372,036,854,775,807 ... which is less than 10 ²⁰ .) And then we have to multiply N ² by 5.

In summary, while the code should work for small candidates, for really large ones it could either break when you attempt to read the candidate (as an int ) or it could give the wrong answer due to integer overflow (as a long ).

Fixing this requires a significant rethink. (Or deeper analysis than I have done to show that the computational hazards don't result in an incorrect answer for any large N in the range of possible inputs .)

Answer 3

According to this link a number is Fibonacci if and only if one or both of (5*n2 + 4) or (5*n2 – 4) is a perfect square so you can basically do this check.

Hope this helps :)

Answer 4

Use binary search and the Fibonacci Q-matrix for a O((log n)^2) solution per test case if you use exponentiation by squaring .

Your solution does not work because it involves rounding floating point square roots of large numbers (potentially large enough not to even fit in a long ), which sometimes will not be exact.

The binary search will work like this: find Q^m : if the m -th Fibonacci number is larger than yours, set right = m , if it is equal return true , else set left = m + 1 .

Answer 5

As it was correctly said, sqrt could be rounded down. So:

• Even if you use long instead of int, it has 18 digits.
• even if you use Math.round(), not simply (int) or (long). Notice, your function wouldn't work correctly even on small numbers because of that.

double have 14 digits, long has 18, so you can't work with squares, you need 20 digits.

BigInteger and BigDecimal have no sqrt() function.

So, you have three ways:

• write your own sqrt for BigInteger.
• check all numbers around the found unprecise double sqrt() for being a real sqrt. That means also working with numbers and their errors simultaneously. (it's horror!)
• count all Fibonacci numbers under 10^10 and compare against them.

The last variant is by far the simplest one.

Answer 6

Looks like to me the for-loop doesn't make any sense ?

When you remove the for-loop for me the program works as advertised:

    import java.io.*;
    import java.util.*;

    public class Solution {

     public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int cand = sc.nextInt();

            if(cand < 0){System.out.println("IsNotFibo"); return; }
            int aTest = 5 * cand *cand + 4;
            int bTest = 5 * cand *cand - 4;
            int sqrt1 =  (int)Math.sqrt(aTest);
            int sqrt2 = (int)Math.sqrt(bTest);
            if((sqrt1 * sqrt1 == aTest)||(sqrt2 * sqrt2 == bTest)){
                System.out.println("IsFibo");
            }else{
                System.out.println("IsNotFibo");
            }


    }

}

Answer 7

You only need to test for a given candidate, yes? What is the for loop accomplishing? Could the results of the loop be throwing your testing program off?

Also, there is a missing } in the code. It will not run as posted without adding another } at the end, after which it runs fine for the following input:

10 1 2 3 4 5 6 7 8 9 10
IsFibo
IsFibo
IsFibo
IsNotFibo
IsFibo
IsNotFibo
IsNotFibo
IsFibo
IsNotFibo
IsNotFibo

Answer 8

Taking into account all the above suggestions I wrote the following which passed all test cases

import java.io.*;

import java.util.*;

public class Solution {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    long[] fib = new long[52];
    Set<Long> fibSet = new HashSet<>(52);
    fib[0] = 0L;
    fib[1] = 1L;
    for(int i = 2; i < 52; i++){
        fib[i] = fib[i-1] + fib[i - 2];
        fibSet.add(fib[i]);
    }

    int n = sc.nextInt();
    long cand;

    for(int i = 0; i < n; i++){
        cand = sc.nextLong();
        if(cand < 0){System.out.println("IsNotFibo");continue;}
        if(fibSet.contains(cand)){
            System.out.println("IsFibo");
        }else{
            System.out.println("IsNotFibo");
        }  
     }
   }
 }

I wanted to be on the safer side hence I choose 52 as the number of elements in the Fibonacci sequence under consideration.