# 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 ``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

 ``
Output
`2`

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

My Personal Notes arrow_drop_up