# Maximize the number of sum pairs which are divisible by K

Given an array of N integers and an integer K. The task is to print the maximum number of pairs(a[i]+a[j]) possible which are divisible by K.

Note: A particular index number cannot be considered in more than one pair.

Examples:

Input: a[] = {1, 2, 2, 3, 2, 4, 10}, k =2
Output: 3
The pairs are: (1, 2), (4, 5), (0, 3)

Input: a[] = {1, 2, 2, 3, 2, 4, 5}, k = 3
Output: 2

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: A naive approach is to iterate using two loops and calculate the total number of pairs whose sum is divisible by K. Time Complexity of this approach is O(N^2).

Efficient Approach: An efficient approach will be to use a hashing technique to solve the problem. The following steps can be followed to solve the above problem.

• Initially increase the hash[a[i]%k] by one for every array element.
• Iterate in the map and get every possible hash values.
• If the hash value is 0, then the number of pairs will be hash/2.
• After that for every hash value x, we can use the minimum of (hash[x], hash[k-x]) and use them to create pairs.
• Subtract the number of pairs used from the hash value accordingly.

Below is the implementation of the above approach.

## C++

 `// C++ program to implement the above ` `// approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to maximize the number of pairs ` `int` `findMaximumPairs(``int` `a[], ``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Hash-table ` `    ``unordered_map<``int``, ``int``> hash; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``hash[a[i] % k]++; ` ` `  `    ``int` `count = 0; ` ` `  `    ``// Iterate for all numbers less than hash values ` `    ``for` `(``auto` `it : hash) { ` ` `  `        ``// If the number is 0 ` `        ``if` `(it.first == 0) { ` ` `  `            ``// We take half since same number ` `            ``count += it.second / 2; ` `            ``if` `(it.first % 2 == 0) ` `                ``hash[it.first] = 0; ` `            ``else` `                ``hash[it.first] = 1; ` `        ``} ` `        ``else` `{ ` ` `  `            ``int` `first = it.first; ` `            ``int` `second = k - it.first; ` ` `  `            ``// Check for minimal occurrence ` `            ``if` `(hash[first] < hash[second]) { ` `                ``// Take the minimal ` `                ``count += hash[first]; ` ` `  `                ``// Subtract the pairs used ` `                ``hash[second] -= hash[first]; ` `                ``hash[first] = 0; ` `            ``} ` `            ``else` `if` `(hash[first] > hash[second]) { ` `                ``// Take the minimal ` `                ``count += hash[second]; ` ` `  `                ``// Subtract the pairs used ` `                ``hash[first] -= hash[second]; ` `                ``hash[second] = 0; ` `            ``} ` `            ``else` `{ ` `                ``// Check if numbers are same ` `                ``if` `(first == second) { ` ` `  `                    ``// If same then number of pairs will be half ` `                    ``count += it.second / 2; ` ` `  `                    ``// Check for remaining ` `                    ``if` `(it.first % 2 == 0) ` `                        ``hash[it.first] = 0; ` `                    ``else` `                        ``hash[it.first] = 1; ` `                ``} ` `                ``else` `{ ` ` `  `                    ``// Store the number of pairs ` `                    ``count += hash[first]; ` `                    ``hash[first] = 0; ` `                    ``hash[second] = 0; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 1, 2, 2, 3, 2, 4, 10 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` `    ``int` `k = 2; ` `    ``cout << findMaximumPairs(a, n, k); ` ` `  `    ``return` `0; ` `} `

## Python3

 `# Python3 program to implement  ` `# the above approach  ` ` `  `# Function to maximize the ` `# number of pairs  ` `def` `findMaximumPairs(a, n, k) :  ` ` `  `    ``# Hash-table  ` `    ``hash` `=` `{};  ` `    ``for` `i ``in` `range``(n) : ` `        ``if` `a[i] ``%` `k ``not` `in` `hash` `: ` `            ``hash``[a[i] ``%` `k] ``=` `0` `         `  `        ``hash``[a[i] ``%` `k] ``+``=` `1` ` `  `    ``count ``=` `0``;  ` ` `  `    ``# Iterate for all numbers less  ` `    ``# than hash values  ` `    ``for` `keys,values ``in` `hash``.items() : ` ` `  `        ``# If the number is 0  ` `        ``if` `(keys ``=``=` `0``) : ` ` `  `            ``# We take half since same number  ` `            ``count ``+``=` `values ``/``/` `2``;  ` `            ``if` `(keys ``%` `2` `=``=` `0``) : ` `                ``hash``[keys] ``=` `0``;  ` `            ``else` `: ` `                ``hash``[keys] ``=` `1``;  ` `                 `  `        ``else` `: ` ` `  `            ``first ``=` `keys;  ` `            ``second ``=` `k ``-``keys;  ` ` `  `            ``# Check for minimal occurrence  ` `            ``if` `(``hash``[first] < ``hash``[second]) : ` `                 `  `                ``# Take the minimal  ` `                ``count ``+``=` `hash``[first];  ` ` `  `                ``# Subtract the pairs used  ` `                ``hash``[second] ``-``=` `hash``[first];  ` `                ``hash``[first] ``=` `0``;  ` `             `  `            ``elif` `(``hash``[first] > ``hash``[second]) :  ` `                 `  `                ``# Take the minimal  ` `                ``count ``+``=` `hash``[second];  ` ` `  `                ``# Subtract the pairs used  ` `                ``hash``[first] ``-``=` `hash``[second];  ` `                ``hash``[second] ``=` `0``;  ` `             `  `            ``else` `: ` `                 `  `                ``# Check if numbers are same  ` `                ``if` `(first ``=``=` `second) : ` ` `  `                    ``# If same then number of pairs  ` `                    ``# will be half  ` `                    ``count ``+``=` `values ``/``/` `2``;  ` ` `  `                    ``# Check for remaining  ` `                    ``if` `(keys ``%` `2` `=``=` `0``) : ` `                        ``hash``[keys] ``=` `0``;  ` `                    ``else` `: ` `                        ``hash``[keys] ``=` `1``;  ` `                 `  `                ``else` `: ` ` `  `                    ``# Store the number of pairs  ` `                    ``count ``+``=` `hash``[first];  ` `                    ``hash``[first] ``=` `0``;  ` `                    ``hash``[second] ``=` `0``;  ` `                     `  `    ``return` `count;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``a ``=` `[ ``1``, ``2``, ``2``, ``3``, ``2``, ``4``, ``10` `];  ` `    ``n ``=` `len``(a) ` `    ``k ``=` `2``;  ` `    ``print``(findMaximumPairs(a, n, k));  ` ` `  `# This code is contributed by Ryuga `

Output:

```3
```

Time Complexity: O(max(N, K))

My Personal Notes arrow_drop_up Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : AnkitRai01, ManasChhabra2

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.