Count Sexy Prime Pairs in the given array

Given an array arr[] of size N containing natural numbers, the task is to count all possible pairs in the arr[] that are Sexy Prime Pairs.

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.

Examples:



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

Naive Approach: To solve the problem mentioned above the idea is to find all possible pairs in the given array arr[] and check whether both the element in pairs are Prime Numbers and they differ by 6, then the current pairs form SPP (Sexy Prime Pair).

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count Sexy
// Prime pairs in array
  
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Output:

2

Time Complexity: O(sqrt(M) * N2), where N is the number of elements in the given array and M is the maximum element in the array.

Efficient Approach:

The method mentioned above can be optimized by the following steps:

  1. Precompute all the Prime Numbers till maximum number in the given array arr[] using Sieve of Eratosthenes.
  2. Store all the frequency of all element for the given array and sort the array.
  3. For each element in the array, check if the element is prime or not.
  4. If the element is prime, then check if (element + 6) is a prime number or not and is present in the given array.
  5. If the (element + 6) is present, then the frequency of (element + 6) will give the count of pairs for the current element.
  6. Repeat the above step for all the element in the array.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count Sexy
// Prime pairs in array
  
#include <bits/stdc++.h>
using namespace std;
  
// To store check the prime
// number
vector<bool> 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Output:

2

Time Complexity: O(N * sqrt(M)), where N is the number of elements in the given array, and M is the maximum element in the array.

Auxillary Space Complexity: O(N)

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.