Skip to content
Related Articles

Related Articles

Count composite fibonacci numbers from given array
  • Last Updated : 19 Nov, 2020

Given an array arr[] of size N, the task is to find the composite Fibonacci numbers present in the given array.

Examples:

Input: arr[] = {13, 55, 7, 3, 5, 21, 233, 144, 6}
Output: 55 21 144
Explanation: 
Composite array elements are {55, 21, 144, 6}. 
Fibonacci array elements are {55, 21, 144}. 
Therefore, array elements which are both composite as well as Fibonacci are {55, 21, 144}.

Input: arr[] = {34, 13, 11, 8, 3, 55, 233}
Output: 3
Explanation: 
Composite array elements are {34, 8, 55} 
Fibonacci array elements are {34, 8, 55} 
Therefore, array elements which are both composite as well as Fibonacci are {34, 8, 55}.

Approach: Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find all Fibonacci
// numbers up to Max
set<int> createhashmap(int Max)
{
    // Store all Fibonacci numbers
    // upto Max
    set<int> hashmap;
 
    // Stores previous element
    // of Fibonacci sequence
    int curr = 1;
 
    // Stores previous element
    // of Fibonacci sequence
    int prev = 0;
 
    // Insert prev into hashmap
    hashmap.insert(prev);
 
    // Insert all the Fibonacci
    // numbers up to Max
    while (curr <= Max) {
 
        // Insert curr into hashmap
        hashmap.insert(curr);
 
        // Stores curr into temp
        int temp = curr;
 
        // Update curr
        curr = curr + prev;
 
        // Update prev
        prev = temp;
    }
 
    return hashmap;
}
 
// Function to find all Composite
// numbers up to Max
vector<bool> SieveOfEratosthenes(
    int Max)
{
 
    // isPrime[i]: Stores if i is
    // a prime number or not
    vector<bool> isPrime(Max, true);
 
    isPrime[0] = false;
    isPrime[1] = false;
 
    // Calculate all prime numbers up to
    // Max using Sieve of Eratosthenes
    for (int p = 2; p * p <= Max; p++) {
 
        // If P is a prime number
        if (isPrime[p]) {
 
            // Set all multiple of P
            // as non-prime
            for (int i = p * p; i <= Max;
                 i += p) {
 
                // Update isPrime
                isPrime[i] = false;
            }
        }
    }
    return isPrime;
}
 
// Function to find the numbers which is
// both a composite and Fibonacci number
int cntFibonacciPrime(int arr[], int N)
{
 
    // Stores the largest element
    // of the array
    int Max = arr[0];
 
    // Traverse the array arr[]
    for (int i = 1; i < N; i++) {
 
        // Update Max
        Max = max(Max, arr[i]);
    }
 
    // isPrim[i] check i is
    // a prime number or not
    vector<bool> isPrime
        = SieveOfEratosthenes(Max);
 
    // Stores all the Fibonacci numbers
    set<int> hashmap
        = createhashmap(Max);
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        // current element is not
        // a composite number
        if (arr[i] == 1)
            continue;
 
        // If current element is a Fibonacci
        // and composite number
        if ((hashmap.count(arr[i]))
            && !isPrime[arr[i]]) {
 
            // Print current element
            cout << arr[i] << " ";
        }
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 13, 55, 7, 3, 5, 21,
                  233, 144, 89 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cntFibonacciPrime(arr, N);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
class GFG{
   
static  boolean[] isPrime;
   
// Function to find all
// Fibonacci numbers up
// to Max
static HashSet<Integer>
       createhashmap(int Max)
{
  // Store all Fibonacci numbers
  // upto Max
  HashSet<Integer> hashmap =
          new HashSet<>();
 
  // Stores previous element
  // of Fibonacci sequence
  int curr = 1;
 
  // Stores previous element
  // of Fibonacci sequence
  int prev = 0;
 
  // Insert prev into hashmap
  hashmap.add(prev);
 
  // Insert all the Fibonacci
  // numbers up to Max
  while (curr < Max)
  {
    // Insert curr into
    // hashmap
    hashmap.add(curr);
 
    // Stores curr into
    // temp
    int temp = curr;
 
    // Update curr
    curr = curr + prev;
 
    // Update prev
    prev = temp;
  }
 
  return hashmap;
}
 
// Function to find all
// Composite numbers up
// to Max
static void SieveOfEratosthenes(int Max)
{
  // isPrime[i]: Stores if i is
  // a prime number or not
  isPrime = new boolean[Max];
  Arrays.fill(isPrime, true);
 
  isPrime[0] = false;
  isPrime[1] = false;
 
  // Calculate all prime numbers
  // up to Max using Sieve of
  // Eratosthenes
  for (int p = 2;
           p * p <= Max; p++)
  {
    // If P is a prime number
    if (isPrime[p])
    {
      // Set all multiple of P
      // as non-prime
      for (int i = p * p; i <= Max;
               i += p)
      {   
        // Update isPrime
        isPrime[i] = false;
      }
    }
  }
}
 
// Function to find the numbers which is
// both a composite and Fibonacci number
static void cntFibonacciPrime(int arr[],
                              int N)
{
  // Stores the largest element
  // of the array
  int Max = arr[0];
 
  // Traverse the array arr[]
  for (int i = 1; i < N; i++)
  {
    // Update Max
    Max = Math.max(Max, arr[i]);
  }
 
  // isPrim[i] check i is
  // a prime number or not
  SieveOfEratosthenes(Max);
 
  // Stores all the Fibonacci
  // numbers
  HashSet<Integer> hashmap =
          createhashmap(Max);
 
  // Traverse the array arr[]
  for (int i = 0; i < N; i++)
  {
    // current element is not
    // a composite number
    if (arr[i] == 1)
      continue;
 
    // If current element is a
    // Fibonacci and composite
    // number
    if ((hashmap.contains(arr[i])) &&
        !isPrime[arr[i]])
    {
      // Print current element
      System.out.print(arr[i] + " ");
    }
  }
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {13, 55, 7, 3, 5,
               21, 233, 144, 89};
  int N = arr.length;
  cntFibonacciPrime(arr, N);
}
}
 
// This code is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
import math
 
# Function to find all Fibonacci
# numbers up to Max
def createhashmap(Max):
     
    # Store all Fibonacci numbers
    # upto Max
    hashmap = {""}
     
    # Stores previous element
    # of Fibonacci sequence
    curr = 1
 
    # Stores previous element
    # of Fibonacci sequence
    prev = 0
     
    # Insert prev into hashmap
    hashmap.add(prev)
     
    # Insert all the Fibonacci
    # numbers up to Max
    while (curr <= Max):
         
        # Insert curr into hashmap
        hashmap.add(curr)
         
        # Stores curr into temp
        temp = curr
         
        # Update curr
        curr = curr + prev
         
        # Update prev
        prev = temp
         
    return hashmap
 
# Function to find all Composite
# numbers up to Max
def SieveOfEratosthenes(Max):
     
    # isPrime[i]: Stores if i is
    # a prime number or not
    isPrime = [1 for x in range(Max + 1)]
    isPrime[0] = 0
    isPrime[1] = 0
     
    # Calculate all prime numbers up to
    # Max using Sieve of Eratosthenes
    for p in range(0, int(math.sqrt(Max))):
         
        # If P is a prime number
        if (isPrime[p]):
             
            # Set all multiple of P
            # as non-prime
            for i in range(2 * p, Max, p):
                 isPrime[i] = 0
                  
    return isPrime
 
# Function to find the numbers which is
# both a composite and Fibonacci number
def cntFibonacciPrime(arr, N):
     
    # Stores the largest element
    # of the array
    Max = arr[0]
     
    # Traverse the array arr[]
    for i in range(0, N):
         
        # Update Max
        Max = max(Max, arr[i])
         
    # isPrim[i] check i is
    # a prime number or not
    isPrime = SieveOfEratosthenes(Max)
     
    # Stores all the Fibonacci numbers
    hashmap = createhashmap(Max)
     
    # Traverse the array arr[]
    for i in range(0, N):
         
        # Current element is not
        # a composite number
        if arr[i] == 1:
            continue
         
        # If current element is a Fibonacci
        # and composite number
        if ((arr[i] in hashmap) and
            (not(isPrime[arr[i]]))):
                 
             # Print current element
             print(arr[i], end = " ")
 
# Driver Code
arr = [ 13, 55, 7, 3, 5,
        21, 233, 144, 89 ]
N = len(arr)
 
cntFibonacciPrime(arr, N)
 
# This code is contributed by Stream_Cipher

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
 
class GFG{
   
static bool[] isPrime;
   
// Function to find all
// Fibonacci numbers up
// to Max
static HashSet<int> createhashmap(int Max)
{
   
  // Store all Fibonacci numbers
  // upto Max
  HashSet<int> hashmap = new HashSet<int>();
   
  // Stores previous element
  // of Fibonacci sequence
  int curr = 1;
 
  // Stores previous element
  // of Fibonacci sequence
  int prev = 0;
 
  // Insert prev into hashmap
  hashmap.Add(prev);
 
  // Insert all the Fibonacci
  // numbers up to Max
  while (curr < Max)
  {
     
    // Insert curr into
    // hashmap
    hashmap.Add(curr);
 
    // Stores curr into
    // temp
    int temp = curr;
 
    // Update curr
    curr = curr + prev;
 
    // Update prev
    prev = temp;
  }
  return hashmap;
}
 
// Function to find all
// Composite numbers up
// to Max
static void SieveOfEratosthenes(int Max)
{
   
  // isPrime[i]: Stores if i is
  // a prime number or not
  isPrime = new bool[Max];
  for(int i = 0;i<Max;i++)
    isPrime[i] = true;
 
  isPrime[0] = false;
  isPrime[1] = false;
 
  // Calculate all prime numbers
  // up to Max using Sieve of
  // Eratosthenes
  for(int p = 2; p * p <= Max; p++)
  {
     
    // If P is a prime number
    if (isPrime[p])
    {
       
      // Set all multiple of P
      // as non-prime
      for(int i = p * p; i <= Max;
              i += p)
      
         
        // Update isPrime
        isPrime[i] = false;
      }
    }
  }
}
 
// Function to find the numbers which is
// both a composite and Fibonacci number
static void cntFibonacciPrime(int []arr,
                              int N)
{
   
  // Stores the largest element
  // of the array
  int Max = arr[0];
 
  // Traverse the array []arr
  for(int i = 1; i < N; i++)
  {
     
    // Update Max
    Max = Math.Max(Max, arr[i]);
  }
 
  // isPrim[i] check i is
  // a prime number or not
  SieveOfEratosthenes(Max);
 
  // Stores all the Fibonacci
  // numbers
  HashSet<int> hashmap = createhashmap(Max);
 
  // Traverse the array []arr
  for(int i = 0; i < N; i++)
  {
     
    // current element is not
    // a composite number
    if (arr[i] == 1)
      continue;
 
    // If current element is a
    // Fibonacci and composite
    // number
    if ((hashmap.Contains(arr[i])) &&
        !isPrime[arr[i]])
    {
       
      // Print current element
      Console.Write(arr[i] + " ");
    }
  }
}
 
// Driver Code
public static void Main(String[] args)
{
  int []arr = { 13, 55, 7, 3, 5,
                21, 233, 144, 89 };
  int N = arr.Length;
   
  cntFibonacciPrime(arr, N);
}
}
 
// This code is contributed by Rajput-Ji

chevron_right


Output: 

55 21 144











 

Time Complexity: O(N + Max * log(log(Max))), where Max is the largest element in the array
Auxiliary Space: O(N)

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :