Given an integer and two arrays and , the task is to count the total pairs (formed after choosing an element from and another from ) from these arrays whose modulo operation yields .

**Note:** If in a pair **(a, b)**, **a > b** then the modulo must be performed as **a % b**. Also, pairs occurring more than once will be counted only once.

**Examples:**

Input:arr1[] = {1, 3, 7}, arr2[] = {5, 3, 1}, K = 2

Output:2

(3, 5) and (7, 5) are the only possible pairs.

Since, 5 % 3 = 2 and 7 % 5 = 2

Input:arr1[] = {2, 5, 99}, arr2[] = {2, 8, 1, 4}, K = 0

Output:6

All possible pairs are (2, 2), (2, 8), (2, 4), (2, 1), (5, 1) and (99, 1).

**Approach:**

- Take one element from at a time and perform it’s modulo operation with all the other elements of one by one.
- If the result from the previous step is equal to then store the pair (a, b) in a set in order to avoid duplicates where a is the smaller element and b is the larger one.
- Total required pairs will be the size of the set in the end.

Below is the implementation of the above approach:

`// C++ implementation of above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the total pairs ` `// of elements whose modulo yield K ` `int` `totalPairs(` `int` `arr1[], ` `int` `arr2[], ` `int` `K, ` `int` `n, ` `int` `m) ` `{ ` ` ` ` ` `// set is used to avoid duplicate pairs ` ` ` `set<pair<` `int` `, ` `int` `> > s; ` ` ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `for` `(` `int` `j = 0; j < m; j++) { ` ` ` ` ` `// check which element is greater and ` ` ` `// proceed according to it ` ` ` `if` `(arr1[i] > arr2[j]) { ` ` ` ` ` `// check if modulo is equal to K ` ` ` `if` `(arr1[i] % arr2[j] == K) ` ` ` `s.insert(make_pair(arr1[i], arr2[j])); ` ` ` `} ` ` ` `else` `{ ` ` ` `if` `(arr2[j] % arr1[i] == K) ` ` ` `s.insert(make_pair(arr2[j], arr1[i])); ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `// return size of the set ` ` ` `return` `s.size(); ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `arr1[] = { 8, 3, 7, 50 }; ` ` ` `int` `arr2[] = { 5, 1, 10, 4 }; ` ` ` `int` `K = 3; ` ` ` `int` `n = ` `sizeof` `(arr1) / ` `sizeof` `(arr1[0]); ` ` ` `int` `m = ` `sizeof` `(arr2) / ` `sizeof` `(arr2[0]); ` ` ` ` ` `cout << totalPairs(arr1, arr2, K, n, m); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

3

**Note:** To print all the pairs just print the elements of set.

## Recommended Posts:

- Sort elements of array whose modulo with K yields P
- Count pairs from two arrays having sum equal to K
- Count distinct pairs from two arrays having same sum of digits
- Count pairs from two sorted arrays whose sum is equal to a given value x
- Count pairs formed by distinct element sub-arrays
- Maximum modulo of all the pairs of array where arr[i] >= arr[j]
- Check if two arrays are permutations of each other using Mathematical Operation
- Count of numbers which can be made power of 2 by given operation
- Given two unsorted arrays, find all pairs whose sum is x
- Maximizing Unique Pairs from two arrays
- Count pairs with given sum
- Count all pairs with given XOR
- Count pairs with Odd XOR
- Minimum sum of absolute difference of pairs of two arrays
- Find k pairs with smallest sums in two arrays

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.