Skip to content
Related Articles

Related Articles

Improve Article
Count pairs in an array such that LCM(arr[i], arr[j]) > min(arr[i],arr[j])
  • Difficulty Level : Easy
  • Last Updated : 21 May, 2021

Given an array arr[], the task is to find the count of pairs in the array such that LCM(arr[i], arr[j]) > min(arr[i], arr[j]) 
Note: Pairs (arr[i], arr[j]) and (arr[j], arr[i]) are considered identical and will be counted only once.

Examples:  

Input: arr[] = {1, 1, 4, 9} 
Output:
All valid pairs are (1, 4), (1, 9), (1, 4), (1, 9) and (4, 9).

Input: arr[] = {2, 4, 5, 2, 5, 7, 2, 8} 
Output: 24 

Approach: It is observed that only the pairs of the form (arr[i], arr[j]) where arr[i] = arr[j] won’t satisfy the given condition. So, the problem now gets reduced to finding the number of pairs (arr[i], arr[j]) such that arr[i] != arr[j].



Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of valid pairs
int count_pairs(int n, int a[])
{
    // Store frequencies of array elements
    unordered_map<int, int> frequency;
    for (int i = 0; i < n; i++) {
        frequency[a[i]]++;
    }
 
    int count = 0;
 
    // Count of pairs (arr[i], arr[j])
    // where arr[i] = arr[j]
    for (auto x : frequency) {
        int f = x.second;
        count += f * (f - 1) / 2;
    }
 
    // Count of pairs (arr[i], arr[j]) where
    // arr[i] != arr[j], i.e. Total pairs - pairs
    // where arr[i] = arr[j]
    return ((n * (n - 1)) / 2) - count;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 4, 5, 2, 5, 7, 2, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << count_pairs(n, arr);
    return 0;
}

Java




// Java implementation of the approach
import java.util.HashMap;
import java.util.Map;
 
class GfG
{
 
    // Function to return the count of valid pairs
    static int count_pairs(int n, int a[])
    {
        // Store frequencies of array elements
        HashMap<Integer, Integer> frequency = new HashMap<>();
        for (int i = 0; i < n; i++)
        {
             
            if (!frequency.containsKey(a[i]))
                frequency.put(a[i], 0);
            frequency.put(a[i], frequency.get(a[i])+1);
        }
     
        int count = 0;
     
        // Count of pairs (arr[i], arr[j])
        // where arr[i] = arr[j]
        for (Map.Entry<Integer, Integer> x: frequency.entrySet())
        {
            int f = x.getValue();
            count += f * (f - 1) / 2;
        }
     
        // Count of pairs (arr[i], arr[j]) where
        // arr[i] != arr[j], i.e. Total pairs - pairs
        // where arr[i] = arr[j]
        return ((n * (n - 1)) / 2) - count;
    }
 
    // Driver code
    public static void main(String []args)
    {
         
        int arr[] = { 2, 4, 5, 2, 5, 7, 2, 8 };
        int n = arr.length;
        System.out.println(count_pairs(n, arr));
    }
}
     
// This code is contributed by Rituraj Jain

Python3




# Python3 implementation of the approach
 
# Function to return the count
# of valid pairs
def count_pairs(n, a) :
 
    # Store frequencies of array elements
    frequency = dict.fromkeys(a, 0)
    for i in range(n) :
        frequency[a[i]] += 1
 
    count = 0
 
    # Count of pairs (arr[i], arr[j])
    # where arr[i] = arr[j]
    for f in frequency.values() :
        count += f * (f - 1) // 2
     
    # Count of pairs (arr[i], arr[j]) where
    # arr[i] != arr[j], i.e. Total pairs - pairs
    # where arr[i] = arr[j]
    return ((n * (n - 1)) // 2) - count
 
# Driver Code
if __name__ == "__main__" :
     
    arr = [ 2, 4, 5, 2,
            5, 7, 2, 8 ]
    n = len(arr)
    print(count_pairs(n, arr))
 
# This code is contributed by Ryuga

C#




// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GfG
{
 
    // Function to return the count of valid pairs
    static int count_pairs(int n, int []arr)
    {
        // Store frequencies of array elements
        Dictionary<int,int> mp = new Dictionary<int,int>();
        for (int i = 0 ; i < n; i++)
        {
            if(mp.ContainsKey(arr[i]))
            {
                var val = mp[arr[i]];
                mp.Remove(arr[i]);
                mp.Add(arr[i], val + 1);
            }
            else
            {
                mp.Add(arr[i], 1);
            }
        }
        int count = 0;
     
        // Count of pairs (arr[i], arr[j])
        // where arr[i] = arr[j]
        foreach(KeyValuePair<int, int> x in mp)
        {
            int f = x.Value;
            count += f * (f - 1) / 2;
        }
     
        // Count of pairs (arr[i], arr[j]) where
        // arr[i] != arr[j], i.e. Total pairs - pairs
        // where arr[i] = arr[j]
        return ((n * (n - 1)) / 2) - count;
    }
 
    // Driver code
    public static void Main(String []args)
    {
         
        int []arr = { 2, 4, 5, 2, 5, 7, 2, 8 };
        int n = arr.Length;
        Console.WriteLine(count_pairs(n, arr));
    }
}
 
// This code is contributed by Rajput-Ji

Javascript




<script>
 
// Javascript implementation of the approach
 
// Function to return the count of valid pairs
function count_pairs(n, a)
{
    // Store frequencies of array elements
    var frequency = new Map();
    for (var i = 0; i < n; i++) {
        if(frequency.has(a[i]))
            frequency.set(a[i], frequency.get(a[i])+1)
        else
            frequency.set(a[i], 1)
    }
 
    var count = 0;
 
    // Count of pairs (arr[i], arr[j])
    // where arr[i] = arr[j]
    frequency.forEach((value, key) => {
         
        var f = value;
        count += f * (f - 1) / 2;
    });
 
    // Count of pairs (arr[i], arr[j]) where
    // arr[i] != arr[j], i.e. Total pairs - pairs
    // where arr[i] = arr[j]
    return ((n * (n - 1)) / 2) - count;
}
 
// Driver Code
var arr = [2, 4, 5, 2, 5, 7, 2, 8];
var n = arr.length;
document.write( count_pairs(n, arr));
 
 
</script>
Output: 
24

 

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 Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :