Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Count of distinct pairs having one element as K times the other

  • Last Updated : 31 Aug, 2021

Given an array arr[] and an integer K, find the maximum number of pairs that can be made such that one element is K times the other i.e, arr[i]=K*arr[j].

Examples:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 2, 1, 2, 4} K = 2
Output: 2
Explanation: There are two possible ways to construct pairs: ({1, 2}, {1, 2}) and ({1, 2}, {2, 4}).



Input: a = {5, 4, 3, 2, 1} K = 2
Output: 1
Explanation: We can construct either set {1, 2} or set {2, 4}.

Approach: Sort the given array arr[] and check all the possible pairs of the array arr[] and check if a given (i, j) arr[i]=2*arr[j]. Follow the steps below to solve the problem:

  • Sort the array arr[] using the sort function in C++ STL.
  • Initialize a vector used to keep the count of already used elements.
  • Initialize the variable ans as 0 to store the count of all possible pairs.
  • Iterate over the range [0, N-1] using the variable i  and perform the following steps: 
    • Iterate over the range [l, N-1] using the variable j and do the following:
      • If the value of used[j] and used[i] are false and arr[j]=K*arr[i], then, set the value of used[i] and used[j] to true and increase the value of ans by 1 and break the loop.
  • Finally, after completing the above steps, print the value of ans.

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 maximum number
// of pairs.
int maxPairs(vector<int> a, int k)
{
    // Sort the array.
    sort(a.begin(), a.end());
    int n = a.size(), ans = 0;
 
    // mark as used
    vector<bool> used(n);
 
    // iterate over all elements
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // if condition is satisfied,
            // pair the elements
            if (!used[j]
                && a[j] == k * a[i]
                && !used[i]) {
                used[j] = used[i] = true;
                ans++;
                break;
            }
        }
    }
 
    return ans;
}
 
// Driver Code
int32_t main()
{
    vector<int> a{ 1, 2, 1, 2, 4 };
    int k = 2;
    cout << maxPairs(a, k);
    return 0;
}

Java




// Java program for the above approach.
 
 
import java.util.Arrays;
 
class GFG {
 
    // Function to find the maximum number
    // of pairs.
public static int maxPairs(int[] a, int k)
{
    // Sort the array.
    Arrays.sort(a);
    int n = a.length, ans = 0;
 
    // mark as used
    boolean[] used = new boolean[n];
 
 
    // iterate over all elements
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // if condition is satisfied,
            // pair the elements
            if (!used[j]
                && a[j] == k * a[i]
                && !used[i]) {
                used[i] =  true;
                used[j] = used[i];
                ans++;
                break;
            }
        }
    }
 
    return ans;
}
 
    // Driver Code
    public static void main(String args[])
    {
        int[] a = {1, 2, 1, 2, 4};
        int k = 2;
        System.out.println(maxPairs(a, k));
    }
}
 
// This code is contributed by _saurabh_jaiswal.

Python3




# Python Program for the above approach
 
# Function to find the maximum number
# of pairs.
def maxPairs(a, k):
 
    # Sort the array.
    a.sort()
    n = len(a)
    ans = 0
 
    # mark as used
    used = [False] * n
 
    # iterate over all elements
    for i in range(0, n):
        for j in range(i + 1, n):
 
            # if condition is satisfied,
            # pair the elements
            if (used[j] == False and a[j] == k * a[i] and used[i] == False):
                used[j] = used[j] = True
                ans += 1
                break
 
    return ans
 
# Driver Code
a = [1, 2, 1, 2, 4]
k = 2
print(maxPairs(a, k))
 
# This code is contributed by _saurabh_jaiswal

C#




// C# program for the above approach.
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find the maximum number
// of pairs.
static int maxPairs(List<int> a, int k)
{
   
    // Sort the array.
    a.Sort();
    int n = a.Count, ans = 0;
 
    // mark as used
    int [] Ar = new int[n];
    List<int> used = new List<int>(Ar);
 
    // iterate over all elements
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // if condition is satisfied,
            // pair the elements
            if (used[j]==0
                && a[j] == k * a[i]
                && used[i]==0) {
                used[j] = used[i] = 1;
                ans++;
                break;
            }
        }
    }
 
    return ans;
}
 
// Driver Code
  public static void Main(){
    List<int> a = new List<int>(){ 1, 2, 1, 2, 4 };
    int k = 2;
    Console.Write(maxPairs(a, k));
  }
}
 
// This code is contributed by SURENDRA_GANGWAR.

Javascript




<script>
        // JavaScript Program for the above approach
 
        // Function to find the maximum number
        // of pairs.
        function maxPairs(a, k)
        {
         
            // Sort the array.
            a.sort(function (x, y) { return x - y });
            let n = a.length, ans = 0;
 
            // mark as used
            let used = new Array(n).fill(false);
 
            // iterate over all elements
            for (let i = 0; i < n; i++) {
                for (let j = i + 1; j < n; j++) {
 
                    // if condition is satisfied,
                    // pair the elements
                    if (used[j] == false && a[j] == k * a[i] && used[i] == false) {
                        used[j] = used[j] = true;
                        ans++;
                        break;
                    }
                }
            }
 
            return ans;
        }
 
        // Driver Code
        let a = [1, 2, 1, 2, 4];
        let k = 2;
        document.write(maxPairs(a, k));
         
    // This code is contributed by Potta Lokesh
    </script>
Output
2

Time Complexity: O(N^2)
Space Complexity: O(N)




My Personal Notes arrow_drop_up
Recommended Articles
Page :