数组中最长质数子序列的长度

给定一个包含非负整数的数组arr ，任务是打印数组中质数最长的子序列的长度。

例子：

Input: arr[] = { 3, 4, 11, 2, 9, 21 }
Output: 3
Longest Prime Subsequence is {3, 2, 11} and hence the answer is 3.

Input: arr[] = { 6, 4, 10, 13, 9, 25 }
Output: 1

方法：

• 遍历给定的数组。
• 对于数组中的每个元素，检查其是否为素数。
• 如果元素是质数，它将在最长质数子序列中。因此，将最长质数子序列的所需长度增加1

下面是上述方法的实现：

C++

// C++ program to find the length of
// Longest Prime Subsequence in an Array
  
#include 
using namespace std;
#define N 100005
  
// Function to create Sieve
// to check primes
void SieveOfEratosthenes(
    bool prime[], int p_size)
{
  
    // False here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
  
    for (int p = 2; p * p <= p_size; p++) {
  
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p]) {
  
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * 2;
                 i <= p_size;
                 i += p)
                prime[i] = false;
        }
    }
}
  
// Function to find the longest subsequence
// which contain all prime numbers
int longestPrimeSubsequence(int arr[], int n)
{
    bool prime[N + 1];
    memset(prime, true, sizeof(prime));
  
    // Precompute N primes
    SieveOfEratosthenes(prime, N);
  
    int answer = 0;
  
    // Find the length of
    // longest prime subsequence
    for (int i = 0; i < n; i++) {
        if (prime[arr[i]]) {
            answer++;
        }
    }
  
    return answer;
}
  
// Driver code
int main()
{
    int arr[] = { 3, 4, 11, 2, 9, 21 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function call
    cout << longestPrimeSubsequence(arr, n)
         << endl;
  
    return 0;
}

Java

// Java program to find the length of
// Longest Prime Subsequence in an Array
import java.util.*;
  
class GFG
{
static final int N = 100005;
   
// Function to create Sieve
// to check primes
static void SieveOfEratosthenes(
    boolean prime[], int p_size)
{
   
    // False here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
   
    for (int p = 2; p * p <= p_size; p++) {
   
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p]) {
   
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * 2;
                 i <= p_size;
                 i += p)
                prime[i] = false;
        }
    }
}
   
// Function to find the longest subsequence
// which contain all prime numbers
static int longestPrimeSubsequence(int arr[], int n)
{
    boolean []prime = new boolean[N + 1];
    Arrays.fill(prime, true);
   
    // Precompute N primes
    SieveOfEratosthenes(prime, N);
   
    int answer = 0;
   
    // Find the length of
    // longest prime subsequence
    for (int i = 0; i < n; i++) {
        if (prime[arr[i]]) {
            answer++;
        }
    }
   
    return answer;
}
   
// Driver code
public static void main(String[] args)
{
    int arr[] = { 3, 4, 11, 2, 9, 21 };
    int n = arr.length;
   
    // Function call
    System.out.print(longestPrimeSubsequence(arr, n)
         +"\n"); 
}
}
  
// This code is contributed by 29AjayKumar

Python3

# Python 3 program to find the length of
# Longest Prime Subsequence in an Array 
N = 100005
   
# Function to create Sieve
# to check primes
def SieveOfEratosthenes(prime,  p_size):
   
    # False here indicates
    # that it is not prime
    prime[0] = False
    prime[1] = False
   
    p = 2
    while  p * p <= p_size:
   
        # If prime[p] is not changed,
        # then it is a prime
        if (prime[p]):
   
            # Update all multiples of p,
            # set them to non-prime
            for i in range( p * 2, p_size + 1, p):
                prime[i] = False 
  
        p += 1
        
# Function to find the longest subsequence
# which contain all prime numbers
def longestPrimeSubsequence( arr, n):
    prime = [True]*(N + 1)
   
    # Precompute N primes
    SieveOfEratosthenes(prime, N)
   
    answer = 0
   
    # Find the length of
    # longest prime subsequence
    for i in range (n):
        if (prime[arr[i]]):
            answer += 1
   
    return answer
   
# Driver code
if __name__ == "__main__":
    arr = [ 3, 4, 11, 2, 9, 21 ]
    n = len(arr)
   
    # Function call
    print (longestPrimeSubsequence(arr, n))
  
# This code is contributed by chitranayal

C#

// C# program to find the length of
// longest Prime Subsequence in an Array
using System;
  
class GFG
{
static readonly int N = 100005;
    
// Function to create Sieve
// to check primes
static void SieveOfEratosthenes(
    bool []prime, int p_size)
{
    
    // False here indicates
    // that it is not prime
    prime[0] = false;
    prime[1] = false;
    
    for (int p = 2; p * p <= p_size; p++) {
    
        // If prime[p] is not changed,
        // then it is a prime
        if (prime[p]) {
    
            // Update all multiples of p,
            // set them to non-prime
            for (int i = p * 2;
                 i <= p_size;
                 i += p)
                prime[i] = false;
        }
    }
}
    
// Function to find the longest subsequence
// which contain all prime numbers
static int longestPrimeSubsequence(int []arr, int n)
{
    bool []prime = new bool[N + 1];
    for (int i = 0; i < N+1; i++)
        prime[i] = true;
    
    // Precompute N primes
    SieveOfEratosthenes(prime, N);
    
    int answer = 0;
    
    // Find the length of
    // longest prime subsequence
    for (int i = 0; i < n; i++) {
        if (prime[arr[i]]) {
            answer++;
        }
    }
    
    return answer;
}
    
// Driver code
public static void Main(String[] args)
{
    int []arr = { 3, 4, 11, 2, 9, 21 };
    int n = arr.Length;
    
    // Function call
    Console.Write(longestPrimeSubsequence(arr, n)
         +"\n"); 
}
}
   
// This code is contributed by 29AjayKumar

输出：

3