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

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