# Count composite fibonacci numbers from given array

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++

 `// C++ program to implement``// the above approach``#include ``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;``}`

## Java

 `// 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 ``       ``createhashmap(``int` `Max)``{``  ``// Store all Fibonacci numbers``  ``// upto Max``  ``HashSet 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 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`

## Python3

 `# 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`

## C#

 `// 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 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`

## Javascript

 ``

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)

Previous
Next