Skip to content
Related Articles

Related Articles

Improve Article

Length of longest Fibonacci subarray

  • Last Updated : 02 Jul, 2021

Given an array arr[] of integer elements, the task is to find the length of the largest sub-array of arr[] such that all the elements of the sub-array are Fibonacci numbers.

Examples:

Input: arr[] = {11, 8, 21, 5, 3, 28, 4}
Output: 4
Explanation:
Maximum length sub-array with all elements as Fibonacci number is {8, 21, 5, 3}.

Input: arr[] = {25, 100, 36}
Output: 0

Approach: This problem can be solved by traversing through the array arr[]. Follow the steps below to solve this problem.



  • Initialize variables say, max_length and current_length as 0 to store the maximum length of the sub-array and the current length of the sub-array such that every element in the sub-array is Fibonacci number.
  • Iterate in the range [0, N-1] using the variable i:
    • If the current number is a Fibonacci number then increment current_length by 1, otherwise, set current_length as 0.
    • Now, assign max_length as maximum of the current_length and max_length.
  • After completing the above steps, print max_length as the required answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// A utility function that returns
// true if x is perfect square
bool isPerfectSquare(int x)
{
    int s = sqrt(x);
    return (s * s == x);
}
 
// Returns true if n is a
// Fibinacci Number, else false
bool isFibonacci(int n)
{
    // Here n is Fibinac ci if one of 5*n*n + 4
    // or 5*n*n - 4 or both is a perferct square
    return isPerfectSquare(5 * n * n + 4)
           || isPerfectSquare(5 * n * n - 4);
}
 
// Function to find the length of the
// largest sub-array of an array every
// element of whose is a Fibonacci number
int contiguousFibonacciNumber(int arr[], int n)
{
 
    int current_length = 0;
    int max_length = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < n; i++) {
 
        // Check if arr[i] is a Fibonacci number
        if(isFibonacci(arr[i])) {
            current_length++;
        }
        else{
           current_length = 0;
        }
 
        // Stores the maximum length of the
        // Fibonacci number subarray
        max_length = max(max_length, current_length);
    }
   
    // Finally, return the maximum length
    return max_length;
}
 
// Driver code
int main()
{
 
    // Given Input
    int arr[] = { 11, 8, 21, 5, 3, 28, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << contiguousFibonacciNumber(arr, n);
 
    return 0;
}

Java




/*package whatever //do not write package name here */
import java.io.*;
 
class GFG
{
 
  // A utility function that returns
  // true if x is perfect square
  public static boolean isPerfectSquare(int x)
  {
    int s =(int) Math.sqrt(x);
    return (s * s == x);
  }
 
  // Returns true if n is a
  // Fibinacci Number, else false
  public static boolean isFibonacci(int n)
  {
 
    // Here n is Fibinacci if one of 5*n*n + 4
    // or 5*n*n - 4 or both is a perferct square
    return isPerfectSquare(5 * n * n + 4)
      || isPerfectSquare(5 * n * n - 4);
  }
 
  // Function to find the length of the
  // largest sub-array of an array every
  // element of whose is a Fibonacci number
  public static int contiguousFibonacciNumber(int arr[], int n)
  {
 
    int current_length = 0;
    int max_length = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < n; i++) {
 
      // Check if arr[i] is a Fibonacci number
      if (isFibonacci(arr[i])) {
        current_length++;
      }
      else {
        current_length = 0;
      }
 
      // Stores the maximum length of the
      // Fibonacci number subarray
      max_length = Math.max(max_length, current_length);
    }
 
    // Finally, return the maximum length
    return max_length;
  }
 
  // Driver code
  public static void main (String[] args)
  {
 
    // Given Input
    int arr[] = { 11, 8, 21, 5, 3, 28, 4 };
    int n = arr.length;
 
    // Function Cal
    System.out.println( contiguousFibonacciNumber(arr, n));
  }
}
 
 // This code is contributed by Potta Lokesh

Python3




# Python3 program for the above approach
import math
 
# A utility function that returns
# true if x is perfect square
def isPerfectSquare(x):
     
    s = int(math.sqrt(x))
     
    if s * s == x:
        return True
    else:
        return False
 
# Returns true if n is a
# Fibonacci Number, else false
def isFibonacci(n):
     
    # Here n is fibonacci if one of 5*n*n+4
    # or 5*n*n-4 or both is a perfect square
    return (isPerfectSquare(5 * n * n + 4) or
            isPerfectSquare(5 * n * n - 4))
   
# Function to find the length of the
# largest sub-array of an array every
# element of whose is a Fibonacci number
def contiguousFibonacciNumber(arr, n):
     
    current_length = 0
    max_length = 0
     
    # Traverse the array arr
    for i in range(0, n):
         
        # Check if arr[i] is a Fibonacci number
        if isFibonacci(arr[i]):
            current_length += 1
        else:
            current_length = 0
             
        # stores the maximum length of the
        # Fibonacci number subarray
        max_length = max(max_length, current_length)
         
    # Finally, return the maximum length
    return max_length
 
# Driver code
if __name__ == '__main__':
 
    # Given Input
    arr = [ 11, 8, 21, 5, 3, 28, 4 ]
    n = len(arr)
     
    # Function Call
    print(contiguousFibonacciNumber(arr, n))
 
# This code is contributed by MuskanKalra1

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
  
// A utility function that returns
// true if x is perfect square
static bool isPerfectSquare(int x)
{
    int s = (int)Math.Sqrt(x);
    return(s * s == x);
}
 
// Returns true if n is a
// Fibinacci Number, else false
static bool isFibonacci(int n)
{
     
    // Here n is Fibinacci if one of 5*n*n + 4
    // or 5*n*n - 4 or both is a perferct square
    return isPerfectSquare(5 * n * n + 4) ||
           isPerfectSquare(5 * n * n - 4);
}
 
// Function to find the length of the
// largest sub-array of an array every
// element of whose is a Fibonacci number
static int contiguousFibonacciNumber(int []arr, int n)
{
    int current_length = 0;
    int max_length = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < n; i++)
    {
         
        // Check if arr[i] is a Fibonacci number
        if (isFibonacci(arr[i]))
        {
            current_length++;
        }
        else
        {
            current_length = 0;
        }
 
        // Stores the maximum length of the
        // Fibonacci number subarray
        max_length = Math.Max(max_length,
                              current_length);
    }
 
    // Finally, return the maximum length
    return max_length;
}
 
// Driver code
public static void Main()
{
     
    // Given Input
    int []arr = { 11, 8, 21, 5, 3, 28, 4 };
    int n = arr.Length;
 
    // Function Call
    Console.Write(contiguousFibonacciNumber(arr, n));
}
}
         
// This code is contributed by SURENDRA_GANGWAR

Javascript




<script>
      // JavaScript program for the above approach
 
      // A utility function that returns
      // true if x is perfect square
      function isPerfectSquare(x) {
          let s = parseInt(Math.sqrt(x));
          return (s * s == x);
      }
 
      // Returns true if n is a
      // Fibinacci Number, else false
      function isFibonacci(n)
      {
       
          // Here n is Fibinacci if one of 5*n*n + 4
          // or 5*n*n - 4 or both is a perferct square
          return isPerfectSquare(5 * n * n + 4)
              || isPerfectSquare(5 * n * n - 4);
      }
 
      // Function to find the length of the
      // largest sub-array of an array every
      // element of whose is a Fibonacci number
      function contiguousFibonacciNumber(arr, n) {
 
          let current_length = 0;
          let max_length = 0;
 
          // Traverse the array arr[]
          for (let i = 0; i < n; i++) {
 
              // Check if arr[i] is a Fibonacci number
              if (isFibonacci(arr[i])) {
                  current_length++;
              }
              else {
                  current_length = 0;
              }
 
              // Stores the maximum length of the
              // Fibonacci number subarray
              max_length = Math.max(max_length, current_length);
          }
 
          // Finally, return the maximum length
          return max_length;
      }
 
      // Driver code
 
      // Given Input
      let arr = [11, 8, 21, 5, 3, 28, 4];
      let n = arr.length;
 
      // Function Call
      document.write(contiguousFibonacciNumber(arr, n));
 
// This code is contributed by Potta Lokesh
  </script>
Output
4

Time Complexity: O(N)
Auxiliary Space: O(1)

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :