Count twin prime pairs in an Array

Given an array arr[] of N natural numbers. The task is to count all possible pairs in the arr[] that are Twin Primes.

A Twin prime are those numbers that are prime and having a difference of two ( 2 ) between the two prime numbers. In other words, a twin prime is a prime that has a prime gap of two.

Examples:

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

Input: arr[] = { 2, 4, 6, 11 }
Output: 0
Explanation:
There are no such pairs forming Twin Primes.



Naive Approach:
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 2, then the current pairs form Twin Primes.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count Twin
// 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 + 2) == 0) {
            return false;
        }
    }
  
    return true;
}
  
// A utility function that check
// if n1 and n2 are Twin Primes
// or not
bool twinPrime(int n1, int n2)
{
    return (isPrime(n1)
            && isPrime(n2)
            && abs(n1 - n2) == 2);
}
  
// Function to find Twin Prime
// pairs from the given array
int countTwinPairs(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
            // twin prime pair
            if (twinPrime(arr[i], arr[j])) {
                count++;
            }
        }
    }
  
    return count;
}
  
// Driver's code
int main()
{
    int arr[] = { 2, 3, 5, 11 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function call to find
    // Twin Primes pair
    cout << countTwinPairs(arr, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count Twin
// 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 + 2) == 0) {
            return false;
        }
    }
   
    return true;
}
   
// A utility function that check
// if n1 and n2 are Twin Primes
// or not
static boolean twinPrime(int n1, int n2)
{
    return (isPrime(n1)
            && isPrime(n2)
            && Math.abs(n1 - n2) == 2);
}
   
// Function to find Twin Prime
// pairs from the given array
static int countTwinPairs(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
            // twin prime pair
            if (twinPrime(arr[i], arr[j])) {
                count++;
            }
        }
    }
   
    return count;
}
   
// Driver's code
public static void main(String[] args)
{
    int arr[] = { 2, 3, 5, 11 };
    int n = arr.length;
   
    // Function call to find
    // Twin Primes pair
    System.out.print(countTwinPairs(arr, n));
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program to count Twin
# 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 + 2) == 0):
            return False
  
    return True
  
# A utility function that check
# if n1 and n2 are Twin Primes
# or not
def twinPrime(n1, n2):
    return (isPrime(n1) and isPrime(n2) and abs(n1 - n2) == 2)
  
# Function to find Twin Prime
# pairs from the given array
def countTwinPairs(arr, n):
    count = 0
  
    # Iterate through all pairs
    for i in range(n):
        for j in range(i + 1,n):
              
            # Increment count if
            # twin prime pair
            if (twinPrime(arr[i], arr[j])):
                count += 1
  
    return count
  
# Driver's code
if __name__ == '__main__':
    arr = [2, 3, 5, 11]
    n = len(arr)
  
    # Function call to find
    # Twin Primes pair
    print(countTwinPairs(arr, n))
  
# This code is contributed by Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to count Twin
// 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 + 2) == 0) {
            return false;
        }
    }
    
    return true;
}
    
// A utility function that check
// if n1 and n2 are Twin Primes
// or not
static bool twinPrime(int n1, int n2)
{
    return (isPrime(n1)
            && isPrime(n2)
            && Math.Abs(n1 - n2) == 2);
}
    
// Function to find Twin Prime
// pairs from the given array
static int countTwinPairs(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
            // twin prime pair
            if (twinPrime(arr[i], arr[j])) {
                count++;
            }
        }
    }
    
    return count;
}
    
// Driver's code
public static void Main(String[] args)
{
    int []arr = { 2, 3, 5, 11 };
    int n = arr.Length;
    
    // Function call to find
    // Twin Primes pair
    Console.Write(countTwinPairs(arr, n));
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

1

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:

  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 arr[].
  3. Sort the given array arr[].
  4. For each element in the array, check if the element is prime or not.
  5. If the element is prime number then check if (element+2) is prime number and is present in the given array arr[].
  6. If the (element+2) is present, then the frequency of (element+2) will give the count of pairs for the current element.
  7. Repeat the above step for all the element in the array.

    Below is the implementation of the above approach:

    C/C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // C++ program to count Twin
    // 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 Twin Prime Pairs
    int countTwinPairs(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 Twin Primes
        for (int i = 0; i < n; i++) {
      
            // If current element is
            // Prime, then check for
            // (current element + 2)
            if (Prime[arr[i]]) {
                if (freq[arr[i] + 2] > 0
                    && Prime[arr[i] + 2]) {
                    count++;
                }
            }
        }
      
        // Return the count of pairs
        return count;
    }
      
    // Driver's code
    int main()
    {
        int arr[] = { 2, 4, 3, 5, 7 };
        int n = sizeof(arr) / sizeof(arr[0]);
      
        // Function call to find
        // Twin Primes pair
        cout << countTwinPairs(arr, n);
        return 0;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Java program to count Twin
    // 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 Twin Prime Pairs
    static int countTwinPairs(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 Twin Primes
        for (int i = 0; i < n; i++) {
       
            // If current element is
            // Prime, then check for
            // (current element + 2)
            if (Prime[arr[i]]) {
                if (arr[i] + 2 < freq.length && freq[arr[i] + 2] > 0
                    && Prime[arr[i] + 2]) {
                    count++;
                }
            }
        }
       
        // Return the count of pairs
        return count;
    }
       
    // Driver's code
    public static void main(String[] args)
    {
        int arr[] = { 2, 4, 3, 5, 7 };
        int n = arr.length;
       
        // Function call to find
        // Twin Primes pair
        System.out.print(countTwinPairs(arr, n));
    }
    }
      
    // This code is contributed by PrinciRaj1992

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # Python 3 program to count Twin
    # 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 Twin Prime Pairs
    def countTwinPairs(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 + 2)
      
        for i in range( n):
            freq[arr[i]] += 1
      
        # Sort before traversing the array
        arr.sort()
      
        # Traverse the array and find
        # the pairs with Twin Primes
        for i in range(n):
      
            # If current element is
            # Prime, then check for
            # (current element + 2)
            if (Prime[arr[i]]):
                if ((arr[i] + 2) <= (maxE) and freq[arr[i] + 2] > 0
                    and Prime[arr[i] + 2]):
                    count += 1
      
        # Return the count of pairs
        return count
      
    # Driver's code
    if __name__ == "__main__":
          
        arr = [ 2, 4, 3, 5, 7 ]
        n = len(arr)
      
        # Function call to find
        # Twin Primes pair
        print( countTwinPairs(arr, n))
          
    # This code is contributed by chitranayal

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // C# program to count Twin
    // 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 Twin Prime Pairs
    static int countTwinPairs(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 Twin Primes
        for (int i = 0; i < n; i++) {
        
            // If current element is
            // Prime, then check for
            // (current element + 2)
            if (Prime[arr[i]]) {
                if (arr[i] + 2 < freq.Length && freq[arr[i] + 2] > 0
                    && Prime[arr[i] + 2]) {
                    count++;
                }
            }
        }
        
        // Return the count of pairs
        return count;
    }
        
    // Driver's code
    public static void Main(String[] args)
    {
        int []arr = { 2, 4, 3, 5, 7 };
        int n = arr.Length;
        
        // Function call to find
        // Twin Primes pair
        Console.Write(countTwinPairs(arr, n));
    }
    }
       
    // This code is contributed by PrinciRaj1992

    chevron_right

    
    

    Output:

    2
    

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

    Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




    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.