# Maximizing Unique Pairs from two arrays

• Difficulty Level : Medium
• Last Updated : 13 Jul, 2022

Given two arrays of equal size N, form maximum number of pairs by using their elements, one from the first array and second from the second array, such that an element from each array is used at-most-once and the absolute difference between the selected elements used for forming a pair is less than or equal to a given element K.

Examples:

```Input : a[] = {3, 4, 5, 2, 1}
b[] = {6, 5, 4, 7, 15}
k = 3
Output : 4
The maximum number of pairs that can be formed
using the above 2 arrays is 4 and the corresponding
pairs are [1, 4], [2, 5], [3, 6], [4, 7], we can't
pair the remaining elements.
Other way of pairing under given constraint is
[2, 5], [3, 6], [4, 4], but count of pairs here
is 3 which is less than the result 4.```

Simple Approach: By taking few examples, we can observe that if we sort both arrays. Then one by picking the closest feasible element for every element, we get the optimal answer.

In this approach we first sort both the arrays and then compare each element of the first array with each element of the second array for the possible pair, if it’s possible to form a pair, we form the pair and move to check for the next possible pair for the next element of the first array.

Implementation:

## C++

 `// C++ implementation of above approach``#include ``#define ll long long int``using` `namespace` `std;` `// Returns count of maximum pairs that can``// be formed from a[] and b[] under given``// constraints.``ll findMaxPairs(ll a[], ll b[], ll n, ll k)``{``    ``sort(a, a+n); ``// Sorting the first array.``    ``sort(b, b+n); ``// Sorting the second array.` `    ``// To keep track of visited elements of b[]``    ``bool` `flag[n];``    ``memset``(flag, ``false``, ``sizeof``(flag));` `    ``// For every element of a[], find a pair``    ``// for it and break as soon as a pair is``    ``// found.``    ``int` `result = 0;``    ``for` `(``int` `i=0; i

## Java

 `// Java implementation of above approach``import` `java.util.*;` `class` `solution``{` `// Returns count of maximum pairs that can``// be formed from a[] and b[] under given``// constraints.``static` `int` `findMaxPairs(``int` `a[], ``int` `b[], ``int` `n, ``int` `k)``{``    ``Arrays.sort(a); ``// Sorting the first array.``    ``Arrays.sort(b); ``// Sorting the second array.` `    ``// To keep track of visited elements of b[]``    ``boolean` `[]flag = ``new` `boolean``[n];``    ``Arrays.fill(flag,``false``);` `    ``// For every element of a[], find a pair``    ``// for it and break as soon as a pair is``    ``// found.``    ``int` `result = ``0``;``    ``for` `(``int` `i=``0``; i

## Python 3

 `# Returns count of maximum pairs``# that can be formed from a[] and``# b[] under given constraints.``def` `findMaxPairs(a, b, n, k):` `    ``a.sort() ``# Sorting the first array.``    ``b.sort() ``# Sorting the second array.` `    ``# To keep track of visited``    ``# elements of b[]``    ``flag ``=` `[``False``] ``*` `n` `    ``# For every element of a[], find``    ``# a pair for it and break as soon``    ``# as a pair is found.``    ``result ``=` `0``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):``            ``if` `(``abs``(a[i] ``-` `b[j]) <``=` `k ``and``                         ``flag[j] ``=``=` `False``):``    ` `                ``# Increasing the count if``                ``# a pair is formed.``                ``result ``+``=` `1` `                ``''' Making the corresponding flag array``                ``element as 1 indicating the element``                ``in the second array element has``                ``been used. '''``                ``flag[j] ``=` `True` `                ``# We break the loop to make sure an``                ``# element of a[] is used only once.``                ``break``    ``return` `result` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``a ``=` `[``10``, ``15``, ``20``]``    ``b ``=` `[``17``, ``12``, ``24``]``    ``n ``=` `len``(a)``    ``k ``=` `3``    ``print``(findMaxPairs(a, b, n, k))` `# This code is contributed``# by ChitraNayal`

## C#

 `// C# implementation of above approach``using` `System;` `class` `GFG``{` `    ``// Returns count of maximum pairs that can``    ``// be formed from a[] and b[] under given``    ``// constraints.``    ``static` `int` `findMaxPairs(``int` `[]a, ``int` `[]b,``                                ``int` `n, ``int` `k)``    ``{``        ``Array.Sort(a); ``// Sorting the first array.``        ``Array.Sort(b); ``// Sorting the second array.` `        ``// To keep track of visited elements of b[]``        ``bool` `[]flag = ``new` `bool``[n];``    ` `        ``//Arrays.fill(flag,false);` `        ``// For every element of a[], find a pair``        ``// for it and break as soon as a pair is``        ``// found.``        ``int` `result = 0;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``for` `(``int` `j = 0; j < n; j++)``            ``{``                ``if` `(Math.Abs(a[i] - b[j]) <= k && flag[j] == ``false``)``                ``{``                    ``// Increasing the count if a pair is formed.``                    ``result++;` `                    ``/* Making the corresponding flag array``                    ``element as 1 indicating the element``                    ``in the second array element has``                    ``been used. */``                    ``flag[j] = ``true``;` `                    ``// We break the loop to make sure an``                    ``// element of a[] is used only once.``                    ``break``;``                ``}``            ``}``        ``}``        ``return` `result;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] a = {10, 15, 20};``        ``int``[] b = {17, 12, 24};``        ``int` `n = a.Length;``        ``int` `k = 3;``        ``Console.WriteLine(findMaxPairs(a, b, n, k));``    ``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`2`

Time complexity : O(n2
Auxiliary Space : O(n)

Efficient Approach: In this approach, rather than checking all the possible combinations of pairs, we optimize our code by checking only the feasible combination of pairs using the 2 pointer approach.

Implementation:

## C++

 `#include ``#define ll long long int``using` `namespace` `std;` `// Returns count of maximum pairs that can``// be formed from a[] and b[] under given``// constraints.``ll findMaxPairs(ll a[], ll b[], ll n, ll k)``{``    ``sort(a, a+n); ``// Sorting the first array.``    ``sort(b, b+n); ``// Sorting the second array.` `    ``int` `result = 0;``    ``for` `(``int` `i=0, j=0; i b[j])``            ``j++;` `        ``// Increasing array pointer of the first array.``        ``else``            ``i++;``    ``}``    ``return` `result;``}` `// Driver code``int` `main()``{``    ``ll a[] = {10, 15, 20};``    ``ll b[] = {17, 12, 24};``    ``int` `n = ``sizeof``(a)/``sizeof``(a[0]);``    ``int` `k = 3;``    ``cout << findMaxPairs(a, b, n, k);``    ``return` `0;``}`

## Java

 `// Java program for Maximizing Unique Pairs``// from two arrays``import` `java.util.*;` `class` `GFG``{` `// Returns count of maximum pairs that can``// be formed from a[] and b[] under given``// constraints.``static` `int` `findMaxPairs(``int` `a[], ``int` `b[],``                        ``int` `n, ``int` `k)``{``    ``Arrays.sort(a); ``// Sorting the first array.``    ``Arrays.sort(b); ``// Sorting the second array.` `    ``int` `result = ``0``;``    ``for` `(``int` `i = ``0``, j = ``0``; i < n && j < n;)``    ``{``        ``if` `(Math.abs(a[i] - b[j]) <= k)``        ``{``            ``result++;` `            ``// Increasing array pointer of``            ``// both the first and the second array.``            ``i++;``            ``j++;``        ``}` `        ``// Increasing array pointer``        ``// of the second array.``        ``else` `if``(a[i] > b[j])``            ``j++;` `        ``// Increasing array pointer``        ``// of the first array.``        ``else``            ``i++;``    ``}``    ``return` `result;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``int` `a[] = {``10``, ``15``, ``20``};``    ``int` `b[] = {``17``, ``12``, ``24``};``    ``int` `n = a.length;``    ``int` `k = ``3``;``    ``System.out.println(findMaxPairs(a, b, n, k));``}``}` `// This code is contributed by``// Sanjit_Prasad`

## Python3

 `# Python3 program for``# Maximizing Unique Pairs``# from two arrays` `# Returns count of maximum pairs that can``# be formed from a[] and b[] under given``# constraints.``def` `findMaxPairs(a,b,n,k):``    ` `    ``# Sorting the first array.``    ``a.sort()``    ` `    ``# Sorting the second array.``    ``b.sort()``    ` `    ``result ``=``0``    ``j``=``0``    ``for` `i ``in` `range``(n):``        ``if` `jb[j]:``                ``j``+``=``1``    ``return` `result` `# Driver code``if` `__name__``=``=``'__main__'``:``    ``a ``=` `[``10``,``15``,``20``]``    ``b ``=` `[``17``,``12``,``24``]``    ``n ``=` `len``(a)``    ``k ``=``3``    ``print``(findMaxPairs(a,b,n,k))` `# This code is contributed by``# Shrikant13`

## C#

 `// C# program for Maximizing Unique Pairs``// from two arrays``using` `System;` `class` `GFG``{` `// Returns count of maximum pairs that can``// be formed from a[] and b[] under given``// constraints.``static` `int` `findMaxPairs(``int` `[]a, ``int` `[]b,``                        ``int` `n, ``int` `k)``{``    ``Array.Sort(a); ``// Sorting the first array.``    ``Array.Sort(b); ``// Sorting the second array.` `    ``int` `result = 0;``    ``for` `(``int` `i = 0, j = 0; i < n && j < n;)``    ``{``        ``if` `(Math.Abs(a[i] - b[j]) <= k)``        ``{``            ``result++;` `            ``// Increasing array pointer of``            ``// both the first and the second array.``            ``i++;``            ``j++;``        ``}` `        ``// Increasing array pointer``        ``// of the second array.``        ``else` `if``(a[i] > b[j])``            ``j++;` `        ``// Increasing array pointer``        ``// of the first array.``        ``else``            ``i++;``    ``}``    ``return` `result;``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `[]a = {10, 15, 20};``    ``int` `[]b = {17, 12, 24};``    ``int` `n = a.Length;``    ``int` `k = 3;``    ``Console.WriteLine(findMaxPairs(a, b, n, k));``}``}` `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output

`2`

Time complexity : O(n Log n)
Auxiliary Space : O(1)