Count pairs whose products exist in array
Last Updated :
16 Oct, 2023
Given an array, count those pair whose product value is present in array.
Examples:
Input : arr[] = {6, 2, 4, 12, 5, 3}
Output : 3
All pairs whose product exist in array
(6 , 2) (2, 3) (4, 3)
Input : arr[] = {3, 5, 2, 4, 15, 8}
Output : 2
A Simple solution is to generate all pairs of given array and check if product exists in the array. If exists, then increment count. Finally return count.
Below is implementation of above idea
C++
#include<bits/stdc++.h>
using namespace std;
int countPairs( int arr[] , int n)
{
int result = 0;
for ( int i = 0; i < n ; i++)
{
for ( int j = i+1 ; j < n ; j++)
{
int product = arr[i] * arr[j] ;
for ( int k = 0; k < n; k++)
{
if (arr[k] == product)
{
result++;
break ;
}
}
}
}
return result;
}
int main()
{
int arr[] = {6 ,2 ,4 ,12 ,5 ,3} ;
int n = sizeof (arr)/ sizeof (arr[0]);
cout << countPairs(arr, n);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int countPairs( int arr[],
int n)
{
int result = 0 ;
for ( int i = 0 ; i < n ; i++)
{
for ( int j = i + 1 ; j < n ; j++)
{
int product = arr[i] * arr[j] ;
for ( int k = 0 ; k < n; k++)
{
if (arr[k] == product)
{
result++;
break ;
}
}
}
}
return result;
}
public static void main (String[] args)
{
int arr[] = { 6 , 2 , 4 , 12 , 5 , 3 } ;
int n = arr.length;
System.out.println(countPairs(arr, n));
}
}
|
Python 3
def countPairs(arr, n):
result = 0 ;
for i in range ( 0 , n):
for j in range (i + 1 , n):
product = arr[i] * arr[j] ;
for k in range ( 0 , n):
if (arr[k] = = product):
result = result + 1 ;
break ;
return result;
arr = [ 6 , 2 , 4 , 12 , 5 , 3 ] ;
n = len (arr);
print (countPairs(arr, n));
|
C#
using System;
class GFG
{
public static int countPairs( int [] arr,
int n)
{
int result = 0;
for ( int i = 0; i < n ; i++)
{
for ( int j = i + 1 ; j < n ; j++)
{
int product = arr[i] * arr[j];
for ( int k = 0; k < n; k++)
{
if (arr[k] == product)
{
result++;
break ;
}
}
}
}
return result;
}
public static void Main( string [] args)
{
int [] arr = new int [] {6, 2, 4, 12, 5, 3};
int n = arr.Length;
Console.WriteLine(countPairs(arr, n));
}
}
|
Javascript
<script>
function countPairs(arr, n)
{
var result = 0;
for (i = 0; i < n; i++)
{
for (j = i + 1; j < n; j++)
{
var product = arr[i] * arr[j];
for (k = 0; k < n; k++)
{
if (arr[k] == product)
{
result++;
break ;
}
}
}
}
return result;
}
var arr = [ 6, 2, 4, 12, 5, 3 ];
var n = arr.length;
document.write(countPairs(arr, n));
</script>
|
PHP
<?php
function countPairs( $arr , $n )
{
$result = 0;
for ( $i = 0; $i < $n ; $i ++)
{
for ( $j = $i + 1 ; $j < $n ; $j ++)
{
$product = $arr [ $i ] * $arr [ $j ] ;
for ( $k = 0; $k < $n ; $k ++)
{
if ( $arr [ $k ] == $product )
{
$result ++;
break ;
}
}
}
}
return $result ;
}
$arr = array (6, 2, 4, 12, 5, 3);
$n = sizeof( $arr );
echo countPairs( $arr , $n );
|
Output:
3
Time complexity: O(n3)
Auxiliary Space: O(1)
An Efficient solution is to use ‘hash’ that stores all array element. Generate all possible pair of given array ‘arr’ and check product of each pair is in ‘hash’. If exists, then increment count. Finally return count.
Below is implementation of above idea
C++
#include<bits/stdc++.h>
using namespace std;
int countPairs( int arr[] , int n)
{
int result = 0;
set< int > Hash;
for ( int i = 0 ; i < n; i++)
Hash.insert(arr[i]);
for ( int i = 0 ; i < n; i++)
{
for ( int j = i + 1; j<n ; j++)
{
int product = arr[i]*arr[j];
if (Hash.find(product) != Hash.end())
result++;
}
}
return result;
}
int main()
{
int arr[] = {6 ,2 ,4 ,12 ,5 ,3};
int n = sizeof (arr)/ sizeof (arr[0]);
cout << countPairs(arr, n) ;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int countPairs( int arr[], int n) {
int result = 0 ;
HashSet< Integer> Hash = new HashSet<>();
for ( int i = 0 ; i < n; i++)
{
Hash.add(arr[i]);
}
for ( int i = 0 ; i < n; i++)
{
for ( int j = i + 1 ; j < n; j++)
{
int product = arr[i] * arr[j];
if (Hash.contains(product))
{
result++;
}
}
}
return result;
}
public static void main(String[] args)
{
int arr[] = { 6 , 2 , 4 , 12 , 5 , 3 };
int n = arr.length;
System.out.println(countPairs(arr, n));
}
}
|
Python3
def countPairs(arr, n):
result = 0
Hash = set ()
for i in range (n):
Hash .add(arr[i])
for i in range (n):
for j in range (i + 1 , n):
product = arr[i] * arr[j]
if product in ( Hash ):
result + = 1
return result
if __name__ = = '__main__' :
arr = [ 6 , 2 , 4 , 12 , 5 , 3 ]
n = len (arr)
print (countPairs(arr, n))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int countPairs( int []arr, int n)
{
int result = 0;
HashSet< int > Hash = new HashSet< int >();
for ( int i = 0; i < n; i++)
{
Hash.Add(arr[i]);
}
for ( int i = 0; i < n; i++)
{
for ( int j = i + 1; j < n; j++)
{
int product = arr[i] * arr[j];
if (Hash.Contains(product))
{
result++;
}
}
}
return result;
}
public static void Main(String[] args)
{
int []arr = {6, 2, 4, 12, 5, 3};
int n = arr.Length;
Console.WriteLine(countPairs(arr, n));
}
}
|
Javascript
<script>
function countPairs(arr , n) {
var result = 0;
var Hash = new Set();
for (i = 0; i < n; i++) {
Hash.add(arr[i]);
}
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
var product = arr[i] * arr[j];
if (Hash.has(product)) {
result++;
}
}
}
return result;
}
var arr = [ 6, 2, 4, 12, 5, 3 ];
var n = arr.length;
document.write(countPairs(arr, n));
</script>
|
Output:
3
Time complexity : O(n2) ‘Under the assumption insert, find operation take O(1) Time ‘
Auxiliary Space: O(n)
Method 3:Using Unordered Map
Approach:
1.Create an empty map to store the elements of the array and their frequencies.
2.Traverse the array and insert each element into the map along with its frequency.
3.Initialize a count variable to 0 to keep track of the number of pairs.
4.Traverse the array again and for each element, check if it has any factor (other than itself) that is present in the map.
5.If both factors are present in the map, then increment the count of pairs.
6.Return the count of pairs.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int count_Pairs( int arr[], int n) {
map< int , int > mp;
for ( int i = 0; i < n; i++) {
mp[arr[i]]++;
}
int count = 0;
for ( int i = 0; i < n; i++) {
for ( int j = 1; j*j <= arr[i]; j++) {
if (arr[i] % j == 0) {
int factor1 = j;
int factor2 = arr[i] / j;
if (mp.count(factor1) && mp.count(factor2)) {
if (factor1 == factor2 && mp[factor1] < 2) {
continue ;
}
count++;
}
}
}
}
return count;
}
int main() {
int arr[] = {6, 2, 4, 12, 5, 3};
int n = sizeof (arr) / sizeof (arr[0]);
int count = count_Pairs(arr, n);
cout << count << endl;
return 0;
}
|
Java
import java.util.HashMap;
import java.util.Map;
public class Main {
static int countPairs( int [] arr)
{
Map<Integer, Integer> frequencyMap
= new HashMap<>();
for ( int num : arr) {
frequencyMap.put(
num, frequencyMap.getOrDefault(num, 0 ) + 1 );
}
int count
= 0 ;
for ( int num : arr) {
for ( int j = 1 ; j * j <= num; j++) {
if (num % j == 0 ) {
int factor1 = j;
int factor2 = num / j;
if (frequencyMap.containsKey(factor1)
&& frequencyMap.containsKey(
factor2)) {
if (factor1 == factor2
&& frequencyMap.get(factor1)
< 2 ) {
continue ;
}
count++;
}
}
}
}
return count;
}
public static void main(String[] args)
{
int [] arr = { 6 , 2 , 4 , 12 , 5 , 3 };
int count = countPairs(arr);
System.out.println(count);
}
}
|
Python
def count_pairs(arr):
mp = {}
for num in arr:
if num in mp:
mp[num] + = 1
else :
mp[num] = 1
count = 0
for num in arr:
for j in range ( 1 , int (num * * 0.5 ) + 1 ):
if num % j = = 0 :
factor1 = j
factor2 = num / / j
if factor1 in mp and factor2 in mp:
if factor1 = = factor2 and mp[factor1] < 2 :
continue
count + = 1
return count
if __name__ = = "__main__" :
arr = [ 6 , 2 , 4 , 12 , 5 , 3 ]
count = count_pairs(arr)
print (count)
|
C#
using System;
using System.Collections.Generic;
class GFG {
static int CountPairs( int [] arr, int n)
{
Dictionary< int , int > mp = new Dictionary<
int , int >();
for ( int i = 0; i < n; i++) {
if (!mp.ContainsKey(arr[i]))
mp[arr[i]] = 1;
else
mp[arr[i]]++;
}
int count
= 0;
for ( int i = 0; i < n; i++) {
for ( int j = 1; j * j <= arr[i]; j++) {
if (arr[i] % j == 0) {
int factor1 = j;
int factor2 = arr[i] / j;
if (mp.ContainsKey(factor1)
&& mp.ContainsKey(factor2)) {
if (factor1 == factor2
&& mp[factor1] < 2) {
continue ;
}
count++;
}
}
}
}
return count;
}
static void Main( string [] args)
{
int [] arr = { 6, 2, 4, 12, 5, 3 };
int n = arr.Length;
int count = CountPairs(arr, n);
Console.WriteLine(count);
}
}
|
Javascript
function GFG(arr) {
const mp = new Map();
for (let i = 0; i < arr.length; i++) {
if (!mp.has(arr[i])) {
mp.set(arr[i], 0);
}
mp.set(arr[i], mp.get(arr[i]) + 1);
}
let count = 0;
for (let i = 0; i < arr.length; i++) {
for (let j = 1; j * j <= arr[i]; j++) {
if (arr[i] % j === 0) {
const factor1 = j;
const factor2 = arr[i] / j;
if (mp.has(factor1) && mp.has(factor2)) {
if (factor1 === factor2 && mp.get(factor1) < 2) {
continue ;
}
count++;
}
}
}
}
return count;
}
function main() {
const arr = [6, 2, 4, 12, 5, 3];
const count = GFG(arr);
console.log(count);
}
main();
|
Output:
3
Time complexity :O(n log n)
Auxiliary Space: O(n)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...