Skip to content
Related Articles

Related Articles

Improve Article
Count pairs whose product contains single distinct prime factor
  • Last Updated : 09 Jun, 2021

Given an array arr[] of size N, the task is to count the number of pairs from the given array whose product contains only a single distinct prime factor.

Examples:

Input: arr[] = {1, 2, 3, 4}
Output: 4
Explanation: 
Pairs having single distinct prime factor in their product is as follows: 
arr[0] * arr[1] = (1 * 2) = 2. Therefore, the single distinct prime factor is 2. 
arr[0] * arr[2] = (1 * 3) = 3. Therefore, the single distinct prime factor is 3. 
arr[0] * arr[3] = (1 * 4) = 22 Therefore, the single distinct prime factor is 2. 
arr[1] * arr[3] = (2 * 4) = 8 23 Therefore, the single distinct prime factor is 2. 
Therefore, the required output is 4.

Input: arr[] = {2, 4, 6, 8}
Output: 3

Naive Approach: The simplest approach to solve this problem is to traverse the array and generate all possible pairs of the array and for each pair, check if the product of elements contains only a single distinct prime factor or not. If found to be true, then increment the count. Finally, print the count.



Time Complexity: O(N2 * √X), where X is the maximum possible product of a pair in the given array.
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach the idea is to use Hashing. Follow the steps below to solve the problem:

  • Initialize a variable, say cntof1 to store count of array elements whose value is 1.
  • Create map, say mp to store the count of array elements which contains only a single distinct prime factor.
  • Traverse the array and for each array elements, check if the count of distinct prime factors is 1 or not. If found to be true then insert the current element into mp.
  • Initialize a variable, say res to store the count of pairs whose product of elements contains only a single distinct prime factor.
  • Traverse the map and update the res += cntof1 * (X) + (X *(X- 1)) / 2. Where X stores the count of the array element which contains only a single distinct prime factor i.
  • Finally, print the value of res.

Below is the implementation of the above approach

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
 
// Function to find a single
// distinct prime factor of N
int singlePrimeFactor(int N)
{
     
    // Stores distinct
    // prime factors of N
    unordered_set<int>
              disPrimeFact;
   
   
    // Calculate prime factor of N
    for (int i = 2; i * i <= N; ++i) {
         
         
        // Calculate distinct
        // prime factor
        while (N % i == 0) {
             
             
            // Insert i into
            // disPrimeFact
            disPrimeFact.insert(i);
             
             
            // Update N
            N /= i;
        }
    }
    
    
    // If N is not equal to 1
    if (N != 1)
    {
         
        // Insert N into
        // disPrimeFact
        disPrimeFact.insert(N);
    }
     
     
    // If N contains a single
    // distinct prime factor
    if (disPrimeFact.size() == 1) {
         
         
        // Return single distinct
        // prime factor of N
        return *disPrimeFact.begin();
    }   
     
     
    // If N contains more than one
    // distinct prime factor   
    return -1;
}
 
 
// Function to count pairs in the array
// whose product contains only
// single distinct prime factor
int cntsingleFactorPair(int arr[], int N)
{
     
   // Stores count of 1s
   // in the array
    int countOf1 = 0;
     
     
    // mp[i]: Stores count of array elements
    // whose distinct prime factor is only i
    unordered_map<int, int> mp;
     
     
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
         
         
        // If current element is 1
        if(arr[i] == 1)
        {
            countOf1++;
            continue;
        }
       
       
        // Store distinct
        // prime factor of arr[i]
        int factorValue
          = singlePrimeFactor(arr[i]);
         
         
        // If arr[i] contains more
        // than one prime factor
        if (factorValue == -1) {
            continue;
        }
         
         
        // If arr[i] contains
        // a single prime factor
        else {
            mp[factorValue]++;
        }
    }
       
       
    // Stores the count of pairs whose
    // product of elements contains only
    // a single distinct prime factor
    int res = 0;
   
   
    // Traverse the map mp[]
    for (auto it : mp) { 
         
         
        // Stores count of array elements
        // whose prime factor is (it.first)
        int X = it.second;
         
         
        // Update res
        res += countOf1 * X +
              (X * (X - 1) ) / 2;
    }
     
    return res;
}
 
 
// Driver Code
int main()
{
 
    int arr[] = { 1, 2, 3, 4 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << cntsingleFactorPair(arr, N);
 
    return 0;
}
Java



// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Function to find a single
// distinct prime factor of N
static int singlePrimeFactor(int N)
{
  // Stores distinct
  // prime factors of N
  HashSet<Integer> disPrimeFact =
                   new HashSet<>();
 
  // Calculate prime factor of N
  for (int i = 2;
           i * i <= N; ++i)
  {
    // Calculate distinct
    // prime factor
    while (N % i == 0)
    {
      // Insert i into
      // disPrimeFact
      disPrimeFact.add(i);
 
      // Update N
      N /= i;
    }
  }
 
  // If N is not equal to 1
  if (N != 1)
  {
    // Insert N into
    // disPrimeFact
    disPrimeFact.add(N);
  }
 
  // If N contains a single
  // distinct prime factor
  if (disPrimeFact.size() == 1)
  {
    // Return single distinct
    // prime factor of N
    for(int i : disPrimeFact)
      return i;
  }
 
  // If N contains more than
  // one distinct prime factor   
  return -1;
}
 
 
// Function to count pairs in
// the array whose product
// contains only single distinct
// prime factor
static int cntsingleFactorPair(int arr[],
                               int N)
{  
  // Stores count of 1s
  // in the array
  int countOf1 = 0;
 
  // mp[i]: Stores count of array
  // elements whose distinct prime
  // factor is only i
  HashMap<Integer,
          Integer> mp = new HashMap<Integer,
                                    Integer>();
 
  // Traverse the array arr[]
  for (int i = 0; i < N; i++)
  {
    // If current element is 1
    if(arr[i] == 1)
    {
      countOf1++;
      continue;
    }
 
    // Store distinct
    // prime factor of arr[i]
    int factorValue =
        singlePrimeFactor(arr[i]);
 
    // If arr[i] contains more
    // than one prime factor
    if (factorValue == -1)
    {
      continue;
    }
 
    // If arr[i] contains
    // a single prime factor
    else
    {
      if(mp.containsKey(factorValue))
        mp.put(factorValue,
        mp.get(factorValue) + 1);
      else
        mp.put(factorValue, 1);
    }
  }
 
  // Stores the count of pairs whose
  // product of elements contains only
  // a single distinct prime factor
  int res = 0;
 
  // Traverse the map mp[]
  for (Map.Entry<Integer,
                 Integer> it :
       mp.entrySet())
  {
    // Stores count of array
    // elements whose prime
    // factor is (it.first)
    int X = it.getValue();
 
    // Update res
    res += countOf1 * X +
           (X * (X - 1) ) / 2;
  }
 
  return res;
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {1, 2, 3, 4};
  int N = arr.length;
  System.out.print(
         cntsingleFactorPair(arr, N));
}
}
 
// This code is contributed by gauravrajput1
Python3



# Python3 program to implement
# the above approach
 
# Function to find a single
# distinct prime factor of N
def singlePrimeFactor(N):
     
    # Stores distinct
    # prime factors of N
    disPrimeFact = {}
     
    # Calculate prime factor of N
    for i in range(2, N + 1):
        if i * i > N:
            break
         
        # Calculate distinct
        # prime factor
        while (N % i == 0):
             
            # Insert i into
            # disPrimeFact
            disPrimeFact[i] = 1
             
            # Update N
            N //= i
 
    # If N is not equal to 1
    if (N != 1):
         
        # Insert N into
        # disPrimeFact
        disPrimeFact[N] = 1
         
    # If N contains a single
    # distinct prime factor
    if (len(disPrimeFact) == 1):
         
        # Return single distinct
        # prime factor of N
        return list(disPrimeFact.keys())[0]
         
    # If N contains more than one
    # distinct prime factor
    return -1
 
# Function to count pairs in the array
# whose product contains only
# single distinct prime factor
def cntsingleFactorPair(arr, N):
     
    # Stores count of 1s
    # in the array
    countOf1 = 0
 
    # mp[i]: Stores count of array elements
    # whose distinct prime factor is only i
    mp = {}
 
    # Traverse the array arr[]
    for i in range(N):
         
        # If current element is 1
        if (arr[i] == 1):
            countOf1 += 1
            continue
 
        # Store distinct
        # prime factor of arr[i]
        factorValue = singlePrimeFactor(arr[i])
 
        # If arr[i] contains more
        # than one prime factor
        if (factorValue == -1):
            continue
         
        # If arr[i] contains
        # a single prime factor
        else:
            mp[factorValue] = mp.get(factorValue, 0) + 1
 
    # Stores the count of pairs whose
    # product of elements contains only
    # a single distinct prime factor
    res = 0
 
    # Traverse the map mp[]
    for it in mp:
         
        # Stores count of array elements
        # whose prime factor is (it.first)
        X = mp[it]
 
        # Update res
        res += countOf1 * X + (X * (X - 1) ) // 2
 
    return res
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 1, 2, 3, 4 ]
    N = len(arr)
     
    print(cntsingleFactorPair(arr, N))
 
# This code is contributed by mohit kumar 29
C#



// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to find a single
// distinct prime factor of N
static int singlePrimeFactor(int N)
{
  // Stores distinct
  // prime factors of N
  HashSet<int> disPrimeFact =
          new HashSet<int>();
 
  // Calculate prime factor of N
  for (int i = 2;
           i * i <= N; ++i)
  {
    // Calculate distinct
    // prime factor
    while (N % i == 0)
    {
      // Insert i into
      // disPrimeFact
      disPrimeFact.Add(i);
 
      // Update N
      N /= i;
    }
  }
 
  // If N is not equal to 1
  if(N != 1)
  {
    // Insert N into
    // disPrimeFact
    disPrimeFact.Add(N);
  }
 
  // If N contains a single
  // distinct prime factor
  if (disPrimeFact.Count == 1)
  {
    // Return single distinct
    // prime factor of N
    foreach(int i in disPrimeFact)
      return i;
  }
 
  // If N contains more than
  // one distinct prime factor   
  return -1;
}
 
 
// Function to count pairs in
// the array whose product
// contains only single distinct
// prime factor
static int cntsingleFactorPair(int []arr,
                               int N)
{  
  // Stores count of 1s
  // in the array
  int countOf1 = 0;
 
  // mp[i]: Stores count of array
  // elements whose distinct prime
  // factor is only i
  Dictionary<int,
             int> mp =
             new Dictionary<int,
                            int>();
 
  // Traverse the array arr[]
  for (int i = 0; i < N; i++)
  {
    // If current element is 1
    if(arr[i] == 1)
    {
      countOf1++;
      continue;
    }
 
    // Store distinct
    // prime factor of arr[i]
    int factorValue =
        singlePrimeFactor(arr[i]);
 
    // If arr[i] contains more
    // than one prime factor
    if (factorValue == -1)
    {
      continue;
    }
 
    // If arr[i] contains
    // a single prime factor
    else
    {
      if(mp.ContainsKey(factorValue))
        mp[factorValue] = mp[factorValue] + 1;
      else
        mp.Add(factorValue, 1);
    }
  }
 
  // Stores the count of pairs whose
  // product of elements contains only
  // a single distinct prime factor
  int res = 0;
 
  // Traverse the map mp[]
  foreach(KeyValuePair<int,
                       int> ele1 in mp)
  {
    // Stores count of array
    // elements whose prime
    // factor is (it.first)
    int X = ele1.Value;
 
    // Update res
    res += countOf1 * X +
           (X * (X - 1) ) / 2;
  }
 
  return res;
}
 
// Driver Code
public static void Main()
{
  int []arr = {1, 2, 3, 4};
  int N = arr.Length;
  Console.WriteLine(
         cntsingleFactorPair(arr, N));
}
}
 
// This code is contributed by bgangwar59
Javascript



<script>
 
// JavaScript program to implement
// the above approach
 
// Function to find a single
// distinct prime factor of N
function singlePrimeFactor(N)
{
     
    // Stores distinct
    // prime factors of N
    var disPrimeFact = {};
     
    // Calculate prime factor of N
    for(var i = 2; i * i <= N; ++i)
    {
         
        // Calculate distinct
        // prime factor
        while (N % i === 0)
        {
             
            // Insert i into
            // disPrimeFact
            disPrimeFact[i] = 1;
             
            // Update N
            N = parseInt(N / i);
        }
    }
     
    // If N is not equal to 1
    if (N !== 1)
    {
         
        // Insert N into
        // disPrimeFact
        disPrimeFact[N] = 1;
    }
     
    // If N contains a single
    // distinct prime factor
    if (Object.keys(disPrimeFact).length === 1)
    {
         
        // Return single distinct
        // prime factor of N
        for(const [key, value] of Object.entries(
            disPrimeFact))
        {
            return key;
        }
    }
     
    // If N contains more than
    // one distinct prime factor
    return -1;
}
 
// Function to count pairs in
// the array whose product
// contains only single distinct
// prime factor
function cntsingleFactorPair(arr, N)
{
     
    // Stores count of 1s
    // in the array
    var countOf1 = 0;
     
    // mp[i]: Stores count of array
    // elements whose distinct prime
    // factor is only i
    var mp = {};
     
    // Traverse the array arr[]
    for(var i = 0; i < N; i++)
    {
         
        // If current element is 1
        if (arr[i] === 1)
        {
            countOf1++;
            continue;
        }
         
        // Store distinct
        // prime factor of arr[i]
        var factorValue = singlePrimeFactor(arr[i]);
         
        // If arr[i] contains more
        // than one prime factor
        if (factorValue === -1)
        {
            continue;
        }
     
        // If arr[i] contains
        // a single prime factor
        else
        {
            if (mp.hasOwnProperty(factorValue))
                mp[factorValue] = mp[factorValue] + 1;
            else
                mp[factorValue] = 1;
        }
    }
     
    // Stores the count of pairs whose
    // product of elements contains only
    // a single distinct prime factor
    var res = 0;
     
    // Traverse the map mp[]
    for(const [key, value] of Object.entries(mp))
    {
         
        // Stores count of array
        // elements whose prime
        // factor is (it.first)
        var X = value;
         
        // Update res
        res = parseInt(res + countOf1 * X +
                        (X * (X - 1)) / 2);
    }
    return res;
}
 
// Driver Code
var arr = [ 1, 2, 3, 4 ];
var N = arr.length;
 
document.write(cntsingleFactorPair(arr, N));
 
// This code is contributed by rdtank
 
</script>
Output: 
4
 
Time Complexity: O(N√X), where X is the maximum element of the given 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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer DSA Live Classes



My Personal Notes
arrow_drop_up
Previous
Possible arrangement of persons waiting to sit in a hall
Next

Check if given point lies in range of any of the given towers
Recommended Articles
Page :
Count pairs from an array with even product of count of distinct prime factors
22, Feb 21
Count of distinct power of prime factor of N
25, Jun 20
Count all distinct pairs with product equal to K
26, Mar 20
Exactly n distinct prime factor numbers from a to b
04, Nov 16
Count all the numbers less than 10^6 whose minimum prime factor is N
23, Oct 18
Count of numbers up to N having at least one prime factor common with N
29, Apr 21
Count of pairs (i, j) in the array such that arr[i] is a factor of arr[j]
21, May 20
Count of subarrays whose products don't have any repeating prime factor
04, Jul 17
Count distinct prime triplets up to N such that sum of two primes is equal to the third prime
09, Feb 21
Find two distinct prime numbers with given product
16, Oct 18
Distinct Prime Factors of Array Product
23, Sep 18
All possible co-prime distinct element pairs within a range [L, R]
30, Oct 18
Number of Co-prime pairs from 1 to N with product equals to N
15, Oct 18
Count substrings made up of a single distinct character
22, Feb 21
Count prime pairs whose difference is also a Prime Number
05, Nov 20
Count subarrays having a single distinct element that can be obtained from a given array
22, Jan 21
Count minimum substring removals required to reduce string to a single distinct character
07, Dec 20
Count distinct pairs with given sum
11, Dec 20
Count pairs having distinct sum from a given range
09, Feb 21
Count distinct sum of pairs possible from a given range
08, Mar 21
Check whether count of distinct characters in a string is Prime or not
22, Nov 18
Count ways to split N! into two distinct co-prime factors
09, Oct 20
Count distinct prime factors for each element of an array
09, Feb 21
Count pairs with product of indices equal to the product of elements present at those indices
18, Mar 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
math_lover
@math_lover
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox