Skip to content
Related Articles

Related Articles

Count of consecutive Fibonacci pairs in the given Array

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 14 Jan, 2022

Given an array arr[], the task is to count the number of consecutive Fibonacci pairs in this array.
Examples: 

Input: arr[] = { 3, 5, 6, 11 } 
Output:
The only pair is (3, 5) which is consecutive fibonacci pair in the array
Input: arr[] = { 3, 5, 8, 11 } 
Output:
There are two pairs (3, 5) and (5, 8) in the array, which is consecutive Fibonacci pair. 

Approach:  

  • Find out all the pairs of the array.
  • For each pair, 
    • Find the minimum and maximum of the pair
    • Find the next consecutive fibonacci number after minimum_element and check that it is equal to the maximum of the pair.
    • If the next consecutive fibonacci number is equal to the maximum element of the pair, then increment the count by 1.
  • Return the total count as the required number of pairs.

Below is the implementation of the above approach:

C++




// C++ implementation to count the
// consecutive fibonacci pairs in the array
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the previous
// fibonacci for the number N
int previousFibonacci(int n)
{
    double a = n / ((1 + sqrt(5)) / 2.0);
    return round(a);
}
 
// Function to find the next
// fibonacci number for the number N
int nextFibonacci(int n)
{
    double a = n * (1 + sqrt(5)) / 2.0;
    return round(a);
}
 
// Function to check that a Number
// is a perfect square or not
bool isPerfectSquare(int x)
{
    int s = sqrt(x);
    return (s * s == x);
}
 
// Function to check that a number
// is fibonacci number or not
bool isFibonacci(int n)
{
    // N is Fibonacci if one of
    // (5*n*n + 4) or (5*n*n - 4)
    // is a perfect square
    return (isPerfectSquare(5 * n * n + 4)
            || isPerfectSquare(5 * n * n - 4));
}
 
// Function to count the fibonacci
// pairs in the array
int countFibonacciPairs(int arr[], int n)
{
    int res = 0;
 
    // Loop to iterate over the array
    // to choose all pairs of the array
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
 
            // Condition to check if both
            // the number of pair is a
            // fibonacci number
            if (isFibonacci(arr[i])
                && isFibonacci(arr[j])) {
 
                int prevFib = previousFibonacci(arr[i]);
                int nextFib = nextFibonacci(arr[i]);
 
                // Condition to check if both
                // the number form consecutive
                // fibonacci numbers
                if (prevFib == arr[j]
                    || nextFib == arr[j]) {
                    res++;
                }
            }
 
    return res;
}
 
// Driver Code
int main()
{
    int a[] = { 3, 5, 8, 11 };
    int n = sizeof(a) / sizeof(a[0]);
    cout << countFibonacciPairs(a, n);
    return 0;
}

Java




// Java implementation to count the
// consecutive fibonacci pairs in the array
import java.util.*;
import java.lang.*;
 
class GFG
{
  
// Function to find the previous
// fibonacci for the number N
static int previousFibonacci(int n)
{
    double a = n / ((1 + (int)Math.sqrt(5)) / 2.0);
    return (int)Math.round(a);
}
  
// Function to find the next
// fibonacci number for the number N
static int nextFibonacci(int n)
{
    double a = n * (1 + (int)Math.sqrt(5)) / 2.0;
    return (int)Math.round(a);
}
  
// Function to check that a Number
// is a perfect square or not
static boolean isPerfectSquare(int x)
{
    int s = (int)Math.sqrt(x);
    return (s * s == x);
}
  
// Function to check that a number
// is fibonacci number or not
static boolean isFibonacci(int n)
{
    // N is Fibonacci if one of
    // (5*n*n + 4) or (5*n*n - 4)
    // is a perfect square
    return (isPerfectSquare(5 * n * n + 4)
            || isPerfectSquare(5 * n * n - 4));
}
  
// Function to count the fibonacci
// pairs in the array
static int countFibonacciPairs(int arr[], int n)
{
    int res = 0;
  
    // Loop to iterate over the array
    // to choose all pairs of the array
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
  
            // Condition to check if both
            // the number of pair is a
            // fibonacci number
            if (isFibonacci(arr[i])
                && isFibonacci(arr[j])) {
  
                int prevFib = previousFibonacci(arr[i]);
                int nextFib = nextFibonacci(arr[i]);
  
                // Condition to check if both
                // the number form consecutive
                // fibonacci numbers
                if (prevFib == arr[j]
                    || nextFib == arr[j]) {
                    res++;
                }
            }
  
    return res;
}
  
// Driver Code
public static void main(String []args)
{
    int []a = { 3, 5, 8, 11 };
    int n = a.length;
    System.out.print(countFibonacciPairs(a, n));   
}
}
 
// This code is contributed by chitranayal

Python3




# Python3 implementation to count the
# consecutive fibonacci pairs in the array
from math import sqrt
 
# Function to find the previous
# fibonacci for the number N
def previousFibonacci(n):
 
    a = n / ((1 + sqrt(5)) / 2.0)
    return round(a)
 
# Function to find the next
# fibonacci number for the number N
def nextFibonacci(n):
 
    a = n * (1 + sqrt(5)) / 2.0
    return round(a)
 
# Function to check that a Number
# is a perfect square or not
def isPerfectSquare(x):
 
    s = sqrt(x)
    return (s * s == x)
 
# Function to check that a number
# is fibonacci number or not
def isFibonacci(n):
 
    # N is Fibonacci if one of
    # (5*n*n + 4) or (5*n*n - 4)
    # is a perfect square
    return (isPerfectSquare(5 * n * n + 4)
            or isPerfectSquare(5 * n * n - 4))
 
# Function to count the fibonacci
# pairs in the array
def countFibonacciPairs(arr, n):
 
    res = 0
 
    # Loop to iterate over the array
    # to choose all pairs of the array
    for i in range(n):
        for j in range(i+1,n):
 
            # Condition to check if both
            # the number of pair is a
            # fibonacci number
            if (isFibonacci(arr[i])
                and isFibonacci(arr[j])):
 
                prevFib = previousFibonacci(arr[i])
                nextFib = nextFibonacci(arr[i])
 
                # Condition to check if both
                # the number form consecutive
                # fibonacci numbers
                if (prevFib == arr[j]
                    or nextFib == arr[j]):
                    res += 1
 
    return res
 
# Driver Code
a = [3, 5, 8, 11]
n = len(a)
print(countFibonacciPairs(a, n))
 
# This code is contributed by mohit kumar 29

C#




// C# implementation to count the
// consecutive fibonacci pairs in the array
using System;
 
class GFG
{
   
// Function to find the previous
// fibonacci for the number N
static int previousFibonacci(int n)
{
    double a = n / ((1 + (int)Math.Sqrt(5)) / 2.0);
    return (int)Math.Round(a);
}
   
// Function to find the next
// fibonacci number for the number N
static int nextFibonacci(int n)
{
    double a = n * (1 + Math.Sqrt(5)) / 2.0;
    return (int)Math.Round(a);
}
   
// Function to check that a Number
// is a perfect square or not
static bool isPerfectSquare(int x)
{
    int s = (int)Math.Sqrt(x);
    return (s * s == x);
}
   
// Function to check that a number
// is fibonacci number or not
static bool isFibonacci(int n)
{
    // N is Fibonacci if one of
    // (5*n*n + 4) or (5*n*n - 4)
    // is a perfect square
    return (isPerfectSquare(5 * n * n + 4)
            || isPerfectSquare(5 * n * n - 4));
}
   
// Function to count the fibonacci
// pairs in the array
static int countFibonacciPairs(int []arr, int n)
{
    int res = 0;
   
    // Loop to iterate over the array
    // to choose all pairs of the array
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
   
            // Condition to check if both
            // the number of pair is a
            // fibonacci number
            if (isFibonacci(arr[i])
                && isFibonacci(arr[j])) {
   
                int prevFib = previousFibonacci(arr[i]);
                int nextFib = nextFibonacci(arr[i]);
   
                // Condition to check if both
                // the number form consecutive
                // fibonacci numbers
                if (prevFib == arr[j]
                    || nextFib == arr[j]) {
                    res++;
                }
            }
   
    return res;
}
   
// Driver Code
public static void Main(String []args)
{
    int []a = { 3, 5, 8, 11 };
    int n = a.Length;
    Console.Write(countFibonacciPairs(a, n));   
}
}
 
// This code is contributed by sapnasingh4991

Javascript




<script>
 
// Javascript implementation to count the
// consecutive fibonacci pairs in the array
 
// Function to find the previous
// fibonacci for the number N
function previousFibonacci(n)
{
    var a = n / ((1 + Math.sqrt(5)) / 2.0);
    return Math.round(a);
}
 
// Function to find the next
// fibonacci number for the number N
function nextFibonacci(n)
{
    var a = n * (1 + Math.sqrt(5)) / 2.0;
    return Math.round(a);
}
 
// Function to check that a Number
// is a perfect square or not
function isPerfectSquare(x)
{
    var s = Math.sqrt(x);
    return (s * s == x);
}
 
// Function to check that a number
// is fibonacci number or not
function isFibonacci(n)
{
    // N is Fibonacci if one of
    // (5*n*n + 4) or (5*n*n - 4)
    // is a perfect square
    return (isPerfectSquare(5 * n * n + 4)
            || isPerfectSquare(5 * n * n - 4));
}
 
// Function to count the fibonacci
// pairs in the array
function countFibonacciPairs(arr, n)
{
    var res = 0;
 
    // Loop to iterate over the array
    // to choose all pairs of the array
    for (var i = 0; i < n; i++)
        for (var j = i + 1; j < n; j++)
 
            // Condition to check if both
            // the number of pair is a
            // fibonacci number
            if (isFibonacci(arr[i])
                && isFibonacci(arr[j])) {
 
                var prevFib = previousFibonacci(arr[i]);
                var nextFib = nextFibonacci(arr[i]);
 
                // Condition to check if both
                // the number form consecutive
                // fibonacci numbers
                if (prevFib == arr[j]
                    || nextFib == arr[j]) {
                    res++;
                }
            }
 
    return res;
}
 
// Driver Code
var a = [ 3, 5, 8, 11 ];
var n = a.length;
document.write(countFibonacciPairs(a, n));
 
</script>

Output: 

2

 

Performance Analysis: 

  • Time Complexity: As in the above approach, there are two nested loops which takes O(N2) time, Hence the Time Complexity will be O(N2).
  • Space Complexity: As in the above approach, there is no extra space used, Hence the space complexity will be O(1).

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!