Count of pairs in given Array whose GCD is not prime - Coding

Given an array arr[] consisting of N positive integers, the task is to find the number of pairs such that the Greatest Common Divisor(GCD) of the pairs is not a prime number. The pair (i, j) and (j, i) are considered the same.

Examples:

Input: arr[] ={ 2, 3, 9}
Output: 10
Explanation:
Following are the possible pairs whose GCD is not prime:

(0, 1): The GCD of arr[0](= 2) and arr[1](= 3) is 1.

(0, 2): The GCD of arr[0](= 2) and arr[2](= 9) is 1.

Therefore, the total count of pairs is 2.

Input: arr[] = {3, 5, 2, 10}
Output: 4

Approach: The given problem can be solved by finding all the prime numbers till 10⁵ and store them in a Set and then for each pair (i, j) if their GCD doesn’t lie in the set, then count this pair. Follow the steps below to solve the problem:

Define a function primeSieve() and find prime numbers up to 10⁵ using Sieve of Eratosthenes and store it in an unordered set, say S.
Initialize the variable, say count as 0 that stores the total count of pairs.
Generate all possible pairs from the given array and if their GCD doesn’t lie in the set, then increment the value of count by 1.
After performing the above steps, print the value of count as the answer.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the prime numbers
void primeSieve(bool* p)
{
    for (int i = 2; i * i <= 1000000; i++) {
 
        // If p[i] is not changed,
        // then it is a prime
        if (p[i] == true) {
 
            // Update all multiples of i
            // as non prime
            for (int j = i * 2;
                 j <= 1000000; j += i) {
                p[j] = false;
            }
        }
    }
}
 
// Function to find GCD of two integers
// a and b
int gcd(int a, int b)
{
    // Base Case
    if (b == 0)
        return a;
 
    // Find GCD Recursively
    return gcd(b, a % b);
}
 
// Function to count the number of
// pairs whose GCD is non prime
int countPairs(int arr[], int n,
               unordered_set<int> s)
{
    // Stores the count of valid pairs
    int count = 0;
 
    // Traverse over the array arr[]
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // Calculate the GCD
            int x = gcd(arr[i], arr[j]);
 
            // Update the count
            if (s.find(x) == s.end())
                count++;
        }
    }
 
    // Return count
    return count;
}
 
// Utility Function to find all the prime
// numbers and find all the pairs
void countPairsUtil(int arr[], int n)
{
    // Stores all the prime numbers
    unordered_set<int> s;
    bool p[1000005];
    memset(p, true, sizeof(p));
 
    // Find all the prime numbers
    primeSieve(p);
 
    s.insert(2);
 
    // Insert prime numbers in the
    // unordered set
    for (int i = 3; i <= 1000000; i += 2)
        if (p[i])
            s.insert(i);
 
    // Find the count of valid pairs
    cout << countPairs(arr, n, s);
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 3, 9 };
    int N = sizeof(arr) / sizeof(arr[0]);
    countPairsUtil(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find the prime numbers
static void primeSieve(boolean[] p)
{
    for (int i = 2; i * i <= 1000000; i++) {
 
        // If p[i] is not changed,
        // then it is a prime
        if (p[i] == true) {
 
            // Update all multiples of i
            // as non prime
            for (int j = i * 2;
                 j <= 1000000; j += i) {
                p[j] = false;
            }
        }
    }
}
 
// Function to find GCD of two integers
// a and b
static int gcd(int a, int b)
{
    // Base Case
    if (b == 0)
        return a;
 
    // Find GCD Recursively
    return gcd(b, a % b);
}
 
// Function to count the number of
// pairs whose GCD is non prime
static int countPairs(int arr[], int n,
               HashSet<Integer> s)
{
    // Stores the count of valid pairs
    int count = 0;
 
    // Traverse over the array arr[]
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // Calculate the GCD
            int x = gcd(arr[i], arr[j]);
 
            // Update the count
            if (!s.contains(x))
                count++;
        }
    }
 
    // Return count
    return count;
}
 
// Utility Function to find all the prime
// numbers and find all the pairs
static void countPairsUtil(int arr[], int n)
{
    // Stores all the prime numbers
    HashSet<Integer> s = new HashSet<Integer>();
    boolean []p = new boolean[1000005];
    for(int i=0;i<p.length;i++)
        p[i] = true;
 
    // Find all the prime numbers
    primeSieve(p);
 
    s.add(2);
 
    // Insert prime numbers in the
    // unordered set
    for (int i = 3; i <= 1000000; i += 2)
        if (p[i])
            s.add(i);
 
    // Find the count of valid pairs
    System.out.print(countPairs(arr, n, s));
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 2, 3, 9 };
    int N = arr.length;
    countPairsUtil(arr, N);
 
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python 3 program for the above approach
 
from math import sqrt,gcd
 
# Function to find the prime numbers
def primeSieve(p):
    for i in range(2,int(sqrt(1000000)),1):
       
        # If p[i] is not changed,
        # then it is a prime
        if (p[i] == True):
 
            # Update all multiples of i
            # as non prime
            for j in range(i * 2,1000001,i):
                p[j] = False
 
# Function to count the number of
# pairs whose GCD is non prime
def countPairs(arr, n, s):
   
    # Stores the count of valid pairs
    count = 0
 
    # Traverse over the array arr[]
    for i in range(n - 1):
        for j in range(i + 1,n,1):
           
            # Calculate the GCD
            x = gcd(arr[i], arr[j])
 
            # Update the count
            if (x not in s):
                count += 1
 
    # Return count
    return count
 
# Utility Function to find all the prime
# numbers and find all the pairs
def countPairsUtil(arr, n):
   
    # Stores all the prime numbers
    s = set()
    p = [True for  i in range(1000005)]
 
    # Find all the prime numbers
    primeSieve(p)
 
    s.add(2)
 
    # Insert prime numbers in the
    # unordered set
    for i in range(3,1000001,2):
        if (p[i]):
            s.add(i)
 
    # Find the count of valid pairs
    print(countPairs(arr, n, s))
 
# Driver Code
if __name__ == '__main__':
    arr = [2, 3, 9]
    N = len(arr)
    countPairsUtil(arr, N)
     
    # This code is contributed by SURENDRA_GANGWAR.

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG{
 
// Function to find the prime numbers
static void primeSieve(bool[] p)
{
    for (int i = 2; i * i <= 1000000; i++) {
 
        // If p[i] is not changed,
        // then it is a prime
        if (p[i] == true) {
 
            // Update all multiples of i
            // as non prime
            for (int j = i * 2;
                 j <= 1000000; j += i) {
                p[j] = false;
            }
        }
    }
}
 
// Function to find GCD of two integers
// a and b
static int gcd(int a, int b)
{
    // Base Case
    if (b == 0)
        return a;
 
    // Find GCD Recursively
    return gcd(b, a % b);
}
 
// Function to count the number of
// pairs whose GCD is non prime
static int countPairs(int []arr, int n,
               HashSet<int> s)
{
    // Stores the count of valid pairs
    int count = 0;
 
    // Traverse over the array []arr
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // Calculate the GCD
            int x = gcd(arr[i], arr[j]);
 
            // Update the count
            if (!s.Contains(x))
                count++;
        }
    }
 
    // Return count
    return count;
}
 
// Utility Function to find all the prime
// numbers and find all the pairs
static void countPairsUtil(int []arr, int n)
{
   
    // Stores all the prime numbers
    HashSet<int> s = new HashSet<int>();
    bool []p = new bool[1000005];
    for(int i = 0; i < p.Length; i++)
        p[i] = true;
 
    // Find all the prime numbers
    primeSieve(p);
 
    s.Add(2);
 
    // Insert prime numbers in the
    // unordered set
    for (int i = 3; i <= 1000000; i += 2)
        if (p[i])
            s.Add(i);
 
    // Find the count of valid pairs
    Console.Write(countPairs(arr, n, s));
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 2, 3, 9 };
    int N = arr.Length;
    countPairsUtil(arr, N);
 
}
}
 
// This code is contributed by 29AjayKumar

Javascript

<script>
// javascript program for the above approach
 
    // Function to find the prime numbers
    function primeSieve( p) {
        for (var i = 2; i * i <= 1000000; i++) {
 
            // If p[i] is not changed,
            // then it is a prime
            if (p[i] == true) {
 
                // Update all multiples of i
                // as non prime
                for (j = i * 2; j <= 1000000; j += i) {
                    p[j] = false;
                }
            }
        }
    }
 
    // Function to find GCD of two integers
    // a and b
    function gcd(a, b)
    {
        // Base Case
        if (b == 0)
            return a;
 
        // Find GCD Recursively
        return gcd(b, a % b);
    }
 
    // Function to count the number of
    // pairs whose GCD is non prime
    function countPairs(arr , n, s) {
        // Stores the count of valid pairs
        var count = 0;
 
        // Traverse over the array arr
        for (var i = 0; i < n - 1; i++) {
            for (var j = i + 1; j < n; j++) {
 
                // Calculate the GCD
                var x = gcd(arr[i], arr[j]);
 
                // Update the count
                if (!s.has(x))
                    count++;
            }
        }
 
        // Return count
        return count;
    }
 
    // Utility Function to find all the prime
    // numbers and find all the pairs
    function countPairsUtil(arr, n) 
    {
     
        // Stores all the prime numbers
        var s = new Set();
        var p = Array(1000005).fill(false);
        for (var i = 0; i < p.length; i++)
            p[i] = true;
 
        // Find all the prime numbers
        primeSieve(p);
 
        s.add(2);
 
        // Insert prime numbers in the
        // unordered set
        for (i = 3; i <= 1000000; i += 2)
            if (p[i])
                s.add(i);
 
        // Find the count of valid pairs
        document.write(countPairs(arr, n, s));
    }
 
    // Driver Code
        var arr = [ 2, 3, 9 ];
        var N = arr.length;
        countPairsUtil(arr, N);
 
// This code is contributed by gauravrajput1 
</script>

Output:

Time Complexity: O(N²)
Auxiliary Space: O(1)

Reffered: https://www.geeksforgeeks.org

Arrays

Related
Count of triplets in an Array with odd sum
Check if final remainder is present in original Array by reducing it based on given conditions
Print lexicographically smallest array by reduce K to 0 in minimum number of operations
Minimum sum of all differences between unique pairs in the Array
Longest remaining array of distinct elements possible after repeated removal of maximum and minimum elements of triplets

Type:	Geek
Category:	Coding
Sub Category:	Tutorial
Uploaded by:	Admin
Views:	9