计算给定数组中的性感素数对

给定大小为N的包含自然数的数组arr [] ，任务是计算arr []中所有可能的对，即性感素数对。

A SPP (Sexy Prime Pair) are those numbers that are prime and having a difference 6 between the prime numbers. In other words, an SPP (Sexy Prime Pair) is a prime that has a prime gap of six.

例子：

Input: arr[] = { 6, 7, 5, 11, 13 }
Output: 2
Explanation:
The 2 pairs are (5, 11) and (7, 13).

Input: arr[] = { 2, 4, 6, 11 }
Output: 0
Explanation:
There are no such pairs forming SPP (Sexy Prime Pair).

天真的方法：解决上述问题的想法是在给定数组arr []中找到所有可能的对，并检查对中的两个元素是否均为素数，并且相差6 ，则当前对形成SPP(性感素数)。一对)。

下面是上述方法的实现：

C++

// C++ program to count Sexy
// Prime pairs in array
  
#include 
using namespace std;
  
// A utility function to check if
// the number n is prime or not
bool isPrime(int n)
{
    // Base Cases
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;
  
    // Check to skip middle five
    // numbers in below loop
    if (n % 2 == 0 || n % 3 == 0)
        return false;
  
    for (int i = 5; i * i <= n; i += 6) {
  
        // If n is divisible by i and i+2
        // then it is not prime
        if (n % i == 0
            || n % (i + 6) == 0) {
            return false;
        }
    }
  
    return true;
}
  
// A utility function that check
// if n1 and n2 are SPP (Sexy Prime Pair)
// or not
bool SexyPrime(int n1, int n2)
{
    return (isPrime(n1)
            && isPrime(n2)
            && abs(n1 - n2) == 6);
}
  
// Function to find SPP (Sexy Prime Pair)
// pairs from the given array
int countSexyPairs(int arr[], int n)
{
    int count = 0;
  
    // Iterate through all pairs
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
  
            // Increment count if
            // SPP (Sexy Prime Pair) pair
            if (SexyPrime(arr[i], arr[j])) {
                count++;
            }
        }
    }
  
    return count;
}
  
// Driver code
int main()
{
    int arr[] = { 6, 7, 5, 11, 13 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function call to find
    // SPP (Sexy Prime Pair) pair
    cout << countSexyPairs(arr, n);
    return 0;
}

Java

// Java program to count Sexy
// Prime pairs in array
import java.util.*;
  
class GFG {
  
    // A utility function to check if
    // the number n is prime or not
    static boolean isPrime(int n)
    {
        // Base Cases
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
  
        // Check to skip middle five
        // numbers in below loop
        if (n % 2 == 0 || n % 3 == 0)
            return false;
  
        for (int i = 5; i * i <= n; i += 6) {
  
            // If n is divisible by i and i+2
            // then it is not prime
            if (n % i == 0 || n % (i + 6) == 0) {
                return false;
            }
        }
  
        return true;
    }
  
    // A utility function that check
    // if n1 and n2 are SPP (Sexy Prime Pair)
    // or not
    static boolean SexyPrime(int n1, int n2)
    {
        return (isPrime(n1)
                && isPrime(n2)
                && Math.abs(n1 - n2) == 6);
    }
  
    // Function to find SPP (Sexy Prime Pair)
    // pairs from the given array
    static int countSexyPairs(int arr[], int n)
    {
        int count = 0;
  
        // Iterate through all pairs
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
  
                // Increment count if
                // SPP (Sexy Prime Pair) pair
                if (SexyPrime(arr[i], arr[j])) {
                    count++;
                }
            }
        }
  
        return count;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 6, 7, 5, 11, 13 };
        int n = arr.length;
  
        // Function call to find
        // SPP (Sexy Prime Pair) pair
        System.out.print(
            countSexyPairs(arr, n));
    }
}

Python 3

# Python 3 program to count Sexy
# Prime pairs in array
from math import sqrt
  
# A utility function to check if
# the number n is prime or not
def isPrime(n):
      
    # Base Cases
    if (n <= 1):
        return False
    if (n <= 3):
        return True
  
    # Check to skip middle five
    # numbers in below loop
    if (n % 2 == 0 or n % 3 == 0):
        return False
  
    for i in range(5, int(sqrt(n))+1, 6):
          
        # If n is divisible by i and i + 2
        # then it is not prime
        if (n % i == 0 or n % (i + 6) == 0):
            return False
  
    return True
  
# A utility function that check
# if n1 and n2 are SPP (Sexy Prime Pair)
# or not
def SexyPrime(n1, n2):
    return (isPrime(n1)
           and isPrime(n2)
           and abs(n1 - n2) == 6)
  
# Function to find SPP (Sexy Prime Pair)
# pairs from the given array
def countSexyPairs(arr, n):
    count = 0
  
    # Iterate through all pairs
    for i in range(n):
        for j in range(i + 1, n):
              
            # Increment count if
            # SPP (Sexy Prime Pair) pair
            if (SexyPrime(arr[i], arr[j])):
                count += 1
  
    return count
  
# Driver code
if __name__ == '__main__':
    arr = [6, 7, 5, 11, 13]
    n = len(arr)
  
    # Function call to find
    # SPP (Sexy Prime Pair) pair
    print(countSexyPairs(arr, n))

C#

// C# program to count Sexy
// Prime pairs in array
using System;
  
class GFG {
  
    // A utility function to check if
    // the number n is prime or not
    static bool isPrime(int n)
    {
        // Base Cases
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
  
        // Check to skip middle five
        // numbers in below loop
        if (n % 2 == 0 || n % 3 == 0)
            return false;
  
        for (int i = 5; i * i <= n; i += 6) {
  
            // If n is divisible by i and i+2
            // then it is not prime
            if (n % i == 0
                || n % (i + 6) == 0) {
                return false;
            }
        }
  
        return true;
    }
  
    // A utility function that check
    // if n1 and n2 are SPP (Sexy Prime Pair)
    // or not
    static bool SexyPrime(int n1, int n2)
    {
        return (isPrime(n1)
                && isPrime(n2)
                && Math.Abs(n1 - n2) == 6);
    }
  
    // Function to find SPP (Sexy Prime Pair)
    // pairs from the given array
    static int countSexyPairs(int[] arr, int n)
    {
        int count = 0;
  
        // Iterate through all pairs
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
  
                // Increment count if
                // SPP (Sexy Prime Pair) pair
                if (SexyPrime(arr[i], arr[j])) {
                    count++;
                }
            }
        }
  
        return count;
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 6, 7, 5, 11, 13 };
        int n = arr.Length;
  
        // Function call to find
        // SPP (Sexy Prime Pair) pair
        Console.Write(countSexyPairs(arr, n));
    }
}

输出：

2

时间复杂度： O(sqrt(M)* N ² )，其中N是给定数组中元素的数量，M是数组中最大的元素。

高效方法：

可以通过以下步骤优化上述方法：

1. 使用Eratosthenes筛子对给定数组arr []中的所有素数进行预计算，直到最大数。
2. 存储给定数组的所有元素的所有频率，并对数组进行排序。
3. 对于数组中的每个元素，请检查该元素是否为质数。
4. 如果元素为质数，则检查(element + 6)是否为质数，是否存在于给定数组中。
5. 如果存在(element + 6)，则(element + 6)的频率将给出当前元素的对数。
6. 对数组中的所有元素重复上述步骤。

下面是上述方法的实现：

C++

// C++ program to count Sexy
// Prime pairs in array
  
#include 
using namespace std;
  
// To store check the prime
// number
vector Prime;
  
// A utility function that find
// the Prime Numbers till N
void computePrime(int N)
{
  
    // Resize the Prime Number
    Prime.resize(N + 1, true);
    Prime[0] = Prime[1] = false;
  
    // Loop till sqrt(N) to find
    // prime numbers and make their
    // multiple false in the bool
    // array Prime
    for (int i = 2; i * i <= N; i++) {
        if (Prime[i]) {
            for (int j = i * i; j < N; j += i) {
                Prime[j] = false;
            }
        }
    }
}
  
// Function that returns the count
// of SPP (Sexy Prime Pair) Pairs
int countSexyPairs(int arr[], int n)
{
  
    // Find the maximum element in
    // the given array arr[]
    int maxE = *max_element(arr, arr + n);
  
    // Function to calculate the
    // prime numbers till N
    computePrime(maxE);
  
    // To store the count of pairs
    int count = 0;
  
    // To store the frequency of
    // element in the array arr[]
    int freq[maxE + 1] = { 0 };
  
    for (int i = 0; i < n; i++) {
        freq[arr[i]]++;
    }
  
    // Sort before traversing the array
    sort(arr, arr + n);
  
    // Traverse the array and find
    // the pairs with SPP (Sexy Prime Pair)
    for (int i = 0; i < n; i++) {
  
        // If current element is
        // Prime, then check for
        // (current element + 6)
        if (Prime[arr[i]]) {
            if (freq[arr[i] + 6] > 0
                && Prime[arr[i] + 6]) {
                count++;
            }
        }
    }
  
    // Return the count of pairs
    return count;
}
  
// Driver code
int main()
{
    int arr[] = { 6, 7, 5, 11, 13 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function call to find
    // SPP (Sexy Prime Pair) pair
    cout << countSexyPairs(arr, n);
    return 0;
}

Java

// Java program to count Sexy
// Prime pairs in array
  
import java.util.*;
  
class GFG {
  
    // To store check the prime
    // number
    static boolean[] Prime;
  
    // A utility function that find
    // the Prime Numbers till N
    static void computePrime(int N)
    {
  
        // Resize the Prime Number
        Prime = new boolean[N + 1];
        Arrays.fill(Prime, true);
        Prime[0] = Prime[1] = false;
  
        // Loop till Math.sqrt(N) to find
        // prime numbers and make their
        // multiple false in the bool
        // array Prime
        for (int i = 2; i * i <= N; i++) {
            if (Prime[i]) {
                for (int j = i * i; j < N; j += i) {
                    Prime[j] = false;
                }
            }
        }
    }
  
    // Function that returns the count
    // of SPP (Sexy Prime Pair) Pairs
    static int countSexyPairs(int arr[], int n)
    {
  
        // Find the maximum element in
        // the given array arr[]
        int maxE = Arrays.stream(arr)
                       .max()
                       .getAsInt();
  
        // Function to calculate the
        // prime numbers till N
        computePrime(maxE);
  
        // To store the count of pairs
        int count = 0;
  
        // To store the frequency of
        // element in the array arr[]
        int freq[] = new int[maxE + 1];
  
        for (int i = 0; i < n; i++) {
            freq[arr[i]]++;
        }
  
        // Sort before traversing the array
        Arrays.sort(arr);
  
        // Traverse the array and find
        // the pairs with SPP (Sexy Prime Pair)
        for (int i = 0; i < n; i++) {
  
            // If current element is
            // Prime, then check for
            // (current element + 6)
            if (Prime[arr[i]]) {
                if (arr[i] + 6 < freq.length
                    && freq[arr[i] + 6] > 0
                    && Prime[arr[i] + 6]) {
                    count++;
                }
            }
        }
  
        // Return the count of pairs
        return count;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 6, 7, 5, 11, 13 };
        int n = arr.length;
  
        // Function call to find
        // SPP (Sexy Prime Pair) pair
        System.out.print(
            countSexyPairs(arr, n));
    }
}

Python3

# Python 3 program to count Sexy
# Prime pairs in array
  
# A utility function that find
# the Prime Numbers till N
def computePrime( N):
  
    # Resize the Prime Number
    Prime = [True]*(N + 1)
    Prime[0] = False
    Prime[1] = False
  
    # Loop till sqrt(N) to find
    # prime numbers and make their
    # multiple false in the bool
    # array Prime
    i = 2
    while i * i <= N:
        if (Prime[i]):
            for j in range( i * i, N, i):
                Prime[j] = False
        i += 1
  
    return Prime
  
# Function that returns the count
# of SPP (Sexy Prime Pair) Pairs
def countSexyPairs(arr, n):
  
    # Find the maximum element in
    # the given array arr[]
    maxE = max(arr)
  
    # Function to calculate the
    # prime numbers till N
    Prime = computePrime(maxE)
  
    # To store the count of pairs
    count = 0
  
    # To store the frequency of
    # element in the array arr[]
    freq = [0]*(maxE + 6)
  
    for i in range( n):
        freq[arr[i]] += 1
  
    # Sort before traversing the array
    arr.sort()
  
    # Traverse the array and find
    # the pairs with SPP (Sexy Prime Pair)s
    for i in range(n):
  
        # If current element is
        # Prime, then check for
        # (current element + 6)
        if (Prime[arr[i]]):
            if ((arr[i] + 6) <= (maxE) 
                and freq[arr[i] + 6] > 0
                and Prime[arr[i] + 6]):
                count += 1
  
    # Return the count of pairs
    return count
  
# Driver code
if __name__ == "__main__":
      
    arr = [ 6, 7, 5, 11, 13 ]
    n = len(arr)
  
    # Function call to find
    # SPP (Sexy Prime Pair)s pair
    print( countSexyPairs(arr, n))
     

C＃

// C# program to count Sexy
// Prime pairs in array
  
using System;
using System.Linq;
  
class GFG {
  
    // To store check the prime
    // number
    static bool[] Prime;
  
    // A utility function that find
    // the Prime Numbers till N
    static void computePrime(int N)
    {
  
        // Resize the Prime Number
        Prime = new bool[N + 1];
        for (int i = 0; i <= N; i++) {
            Prime[i] = true;
        }
  
        Prime[0] = Prime[1] = false;
  
        // Loop till Math.Sqrt(N) to find
        // prime numbers and make their
        // multiple false in the bool
        // array Prime
        for (int i = 2; i * i <= N; i++) {
            if (Prime[i]) {
                for (int j = i * i; j < N; j += i) {
                    Prime[j] = false;
                }
            }
        }
    }
  
    // Function that returns the count
    // of SPP (Sexy Prime Pair) Pairs
    static int countSexyPairs(int[] arr, int n)
    {
  
        // Find the maximum element in
        // the given array []arr
        int maxE = arr.Max();
  
        // Function to calculate the
        // prime numbers till N
        computePrime(maxE);
  
        // To store the count of pairs
        int count = 0;
  
        // To store the frequency of
        // element in the array []arr
        int[] freq = new int[maxE + 1];
  
        for (int i = 0; i < n; i++) {
            freq[arr[i]]++;
        }
  
        // Sort before traversing the array
        Array.Sort(arr);
  
        // Traverse the array and find
        // the pairs with SPP (Sexy Prime Pair)s
        for (int i = 0; i < n; i++) {
  
            // If current element is
            // Prime, then check for
            // (current element + 6)
            if (Prime[arr[i]]) {
                if (arr[i] + 6 < freq.Length
                    && freq[arr[i] + 6] > 0
                    && Prime[arr[i] + 6]) {
                    count++;
                }
            }
        }
  
        // Return the count of pairs
        return count;
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 6, 7, 5, 11, 13 };
        int n = arr.Length;
  
        // Function call to find
        // SPP (Sexy Prime Pair)s pair
        Console.Write(countSexyPairs(arr, n));
    }
}

输出：

2

时间复杂度： O(N * sqrt(M))，其中N是给定数组中元素的数量，M是数组中最大的元素。

辅助空间复杂度： O(N)