计算给定数组中的复合斐波那契数

给定一个大小为N的数组arr[] ，任务是找到给定数组中存在的复合斐波那契数。

例子：

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}.

处理方法：按照以下步骤解决问题：

• 初始化一个变量，比如Max来存储数组的最大元素。
• 创建一个 Set 来存储最大为Max 的所有斐波那契数。
• 初始化一个数组，比如sieve[] ，使用Sieve Of Eratosthenes 存储所有素数。
• 最后，遍历数组并检查当前数组元素是否既是复合数又是斐波那契数。如果发现为真，则打印当前元素。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
#include 
using namespace std;
 
// Function to find all Fibonacci
// numbers up to Max
set createhashmap(int Max)
{
    // Store all Fibonacci numbers
    // upto Max
    set 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 SieveOfEratosthenes(
    int Max)
{
 
    // isPrime[i]: Stores if i is
    // a prime number or not
    vector 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 isPrime
        = SieveOfEratosthenes(Max);
 
    // Stores all the Fibonacci numbers
    set 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 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 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

 
// Javascript program to implement
// the above approach
 
// Function to find all Fibonacci
// numbers up to Max
function createhashmap(Max)
{
     
    // Store all Fibonacci numbers
    // upto Max
    var hashmap = new Set();
 
    // Stores previous element
    // of Fibonacci sequence
    var curr = 1;
 
    // Stores previous element
    // of Fibonacci sequence
    var 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
        var temp = curr;
 
        // Update curr
        curr = curr + prev;
 
        // Update prev
        prev = temp;
    }
    return hashmap;
}
 
// Function to find all Composite
// numbers up to Max
function SieveOfEratosthenes(Max)
{
     
    // isPrime[i]: Stores if i is
    // a prime number or not
    var isPrime = Array(Max + 1).fill(true);
 
    isPrime[0] = false;
    isPrime[1] = false;
 
    // Calculate all prime numbers up to
    // Max using Sieve of Eratosthenes
    for(var p = 2; p * p <= Max; p++)
    {
         
        // If P is a prime number
        if (isPrime[p])
        {
             
            // Set all multiple of P
            // as non-prime
            for(var 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
function cntFibonacciPrime(arr, N)
{
     
    // Stores the largest element
    // of the array
    var Max = arr[0];
 
    // Traverse the array arr[]
    for(var i = 1; i < N; i++)
    {
         
        // Update Max
        Max = Math.max(Max, arr[i]);
    }
 
    // isPrim[i] check i is
    // a prime number or not
    var isPrime = SieveOfEratosthenes(Max);
 
    // Stores all the Fibonacci numbers
    var hashmap = createhashmap(Max);
 
    // Traverse the array arr[]
    for(var 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.has(arr[i]) &&
               !isPrime[arr[i]])
        {
             
            // Print current element
            document.write( arr[i] + " ");
        }
    }
}
 
// Driver Code
var arr = [ 13, 55, 7, 3, 5, 21,
            233, 144, 89 ];
var N = arr.length;
 
cntFibonacciPrime(arr, N);
 
// This code is contributed by itsok
 

输出：

55 21 144

时间复杂度： O(N + Max * log(log(Max)))，其中Max是数组中最大的元素
辅助空间： O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。