# Find all pairs (a, b) in an array such that a % b = k

Given an array with distinct elements, the task is to find the pairs in the array such that a % b = k, where k is a given integer.

Examples :

```Input  :  arr[] = {2, 3, 5, 4, 7}
k = 3
Output :  (7, 4), (3, 4), (3, 5), (3, 7)
7 % 4 = 3
3 % 4 = 3
3 % 5 = 3
3 % 7 = 3
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

A Naive Solution is to make all pairs one by one and check their modulo is equal to k or not. If equals to k, then print that pair.

## C++

 `// C++ implementation to find such pairs ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find pair such that (a % b = k) ` `bool` `printPairs(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``bool` `isPairFound = ``true``; ` ` `  `    ``// Consider each and every pair ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``for` `(``int` `j = 0; j < n; j++) { ` `            ``// Print if their modulo equals to k ` `            ``if` `(i != j && arr[i] % arr[j] == k) { ` `                ``cout << ``"("` `<< arr[i] << ``", "` `                     ``<< arr[j] << ``")"` `                     ``<< ``" "``; ` `                ``isPairFound = ``true``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `isPairFound; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 3, 5, 4, 7 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `k = 3; ` ` `  `    ``if` `(printPairs(arr, n, k) == ``false``) ` `        ``cout << ``"No such pair exists"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to find such pairs ` ` `  `class` `Test { ` `    ``// method to find pair such that (a % b = k) ` `    ``static` `boolean` `printPairs(``int` `arr[], ``int` `n, ``int` `k) ` `    ``{ ` `        ``boolean` `isPairFound = ``true``; ` ` `  `        ``// Consider each and every pair ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``for` `(``int` `j = ``0``; j < n; j++) { ` `                ``// Print if their modulo equals to k ` `                ``if` `(i != j && arr[i] % arr[j] == k) { ` `                    ``System.out.print(``"("` `+ arr[i] + ``", "` `+ arr[j] + ``")"` `                                     ``+ ``" "``); ` `                    ``isPairFound = ``true``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``return` `isPairFound; ` `    ``} ` ` `  `    ``// Driver method ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr[] = { ``2``, ``3``, ``5``, ``4``, ``7` `}; ` `        ``int` `k = ``3``; ` ` `  `        ``if` `(printPairs(arr, arr.length, k) == ``false``) ` `            ``System.out.println(``"No such pair exists"``); ` `    ``} ` `} `

## Python3

 `# Python3 implementation to find such pairs ` ` `  `# Function to find pair such that (a % b = k) ` `def` `printPairs(arr, n, k): ` ` `  `    ``isPairFound ``=` `True` ` `  `    ``# Consider each and every pair ` `    ``for` `i ``in` `range``(``0``, n): ` `     `  `        ``for` `j ``in` `range``(``0``, n): ` `         `  `            ``# Print if their modulo equals to k ` `            ``if` `(i !``=` `j ``and` `arr[i] ``%` `arr[j] ``=``=` `k): ` `             `  `                ``print``(``"("``, arr[i], ``", "``, arr[j], ``")"``, ` `                                 ``sep ``=` `"``", end = "` `") ` `                ``isPairFound ``=` `True` `             `  `    ``return` `isPairFound ` ` `  `# Driver Code ` `arr ``=` `[``2``, ``3``, ``5``, ``4``, ``7``] ` `n ``=` `len``(arr)  ` `k ``=` `3` `if` `(printPairs(arr, n, k) ``=``=` `False``): ` `    ``print``(``"No such pair exists"``) ` ` `  `# This article is contributed by Smitha Dinesh Semwal. `

## C#

 `// C# implementation to find such pair ` `using` `System; ` ` `  `public` `class` `GFG { ` `     `  `    ``// method to find pair such that (a % b = k) ` `    ``static` `bool` `printPairs(``int``[] arr, ``int` `n, ``int` `k) ` `    ``{ ` `        ``bool` `isPairFound = ``true``; ` ` `  `        ``// Consider each and every pair ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``for` `(``int` `j = 0; j < n; j++)  ` `            ``{ ` `                ``// Print if their modulo equals to k ` `                ``if` `(i != j && arr[i] % arr[j] == k) ` `                ``{ ` `                    ``Console.Write(``"("` `+ arr[i] + ``", "`  `                                ``+ arr[j] + ``")"` `+ ``" "``); ` `                    ``isPairFound = ``true``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``return` `isPairFound; ` `    ``} ` ` `  `    ``// Driver method ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr = { 2, 3, 5, 4, 7 }; ` `        ``int` `k = 3; ` ` `  `        ``if` `(printPairs(arr, arr.Length, k) == ``false``) ` `            ``Console.WriteLine(``"No such pair exists"``); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007 `

## PHP

 ` `

Output :

```(3, 5) (3, 4) (3, 7) (7, 4)
```

Time Complexity : O(n2)

An Efficient solution is based on below observations :

1. If k itself is present in arr[], then k forms a pair with all elements arr[i] where k < arr[i]. For all such arr[i], we have k % arr[i] = k.
2. For all elements greater than or equal to arr[i], we use following fact.
```   If arr[i] % arr[j] = k,
==> arr[i] = x * arr[j] + k
==> (arr[i] - k) = x * arr[j]
We find all divisors of (arr[i] - k)
and see if they are present in arr[].```

To quickly check if an element is present in array, we use hashing.

## C++

 `// C++ program to find all pairs such that ` `// a % b = k. ` `#include ` `using` `namespace` `std; ` ` `  `// Utiltity function to find the divisors of ` `// n and store in vector v[] ` `vector<``int``> findDivisors(``int` `n) ` `{ ` `    ``vector<``int``> v; ` ` `  `    ``// Vector is used to store  the divisors ` `    ``for` `(``int` `i = 1; i <= ``sqrt``(n); i++) { ` `        ``if` `(n % i == 0) { ` `            ``// If n is a square number, push ` `            ``// only one occurrence ` `            ``if` `(n / i == i) ` `                ``v.push_back(i); ` `            ``else` `{ ` `                ``v.push_back(i); ` `                ``v.push_back(n / i); ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `v; ` `} ` ` `  `// Function to find pairs such that (a%b = k) ` `bool` `printPairs(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``// Store all the elements in the map ` `    ``// to use map as hash for finding elements ` `    ``// in O(1) time. ` `    ``unordered_map<``int``, ``bool``> occ; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``occ[arr[i]] = ``true``; ` ` `  `    ``bool` `isPairFound = ``false``; ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``// Print all the pairs with (a, b) as ` `        ``// (k, numbers greater than k) as ` `        ``// k % (num (> k)) = k i.e. 2%4 = 2 ` `        ``if` `(occ[k] && k < arr[i]) { ` `            ``cout << ``"("` `<< k << ``", "` `<< arr[i] << ``") "``; ` `            ``isPairFound = ``true``; ` `        ``} ` ` `  `        ``// Now check for the current element as 'a' ` `        ``// how many b exists such that a%b = k ` `        ``if` `(arr[i] >= k) { ` `            ``// find all the divisors of (arr[i]-k) ` `            ``vector<``int``> v = findDivisors(arr[i] - k); ` ` `  `            ``// Check for each divisor i.e. arr[i] % b = k ` `            ``// or not, if yes then print that pair. ` `            ``for` `(``int` `j = 0; j < v.size(); j++) { ` `                ``if` `(arr[i] % v[j] == k && arr[i] != v[j] && occ[v[j]]) { ` `                    ``cout << ``"("` `<< arr[i] << ``", "` `                         ``<< v[j] << ``") "``; ` `                    ``isPairFound = ``true``; ` `                ``} ` `            ``} ` ` `  `            ``// Clear vector ` `            ``v.clear(); ` `        ``} ` `    ``} ` ` `  `    ``return` `isPairFound; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``int` `arr[] = { 3, 1, 2, 5, 4 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `k = 2; ` ` `  `    ``if` `(printPairs(arr, n, k) == ``false``) ` `        ``cout << ``"No such pair exists"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find all pairs such that ` `// a % b = k. ` ` `  `import` `java.util.HashMap; ` `import` `java.util.Vector; ` ` `  `class` `Test { ` `    ``// Utility method to find the divisors of ` `    ``// n and store in vector v[] ` `    ``static` `Vector findDivisors(``int` `n) ` `    ``{ ` `        ``Vector v = ``new` `Vector<>(); ` ` `  `        ``// Vector is used to store  the divisors ` `        ``for` `(``int` `i = ``1``; i <= Math.sqrt(n); i++) { ` `            ``if` `(n % i == ``0``) { ` `                ``// If n is a square number, push ` `                ``// only one occurrence ` `                ``if` `(n / i == i) ` `                    ``v.add(i); ` `                ``else` `{ ` `                    ``v.add(i); ` `                    ``v.add(n / i); ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `v; ` `    ``} ` ` `  `    ``// method to find pairs such that (a%b = k) ` `    ``static` `boolean` `printPairs(``int` `arr[], ``int` `n, ``int` `k) ` `    ``{ ` `        ``// Store all the elements in the map ` `        ``// to use map as hash for finding elements ` `        ``// in O(1) time. ` `        ``HashMap occ = ``new` `HashMap<>(); ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``occ.put(arr[i], ``true``); ` ` `  `        ``boolean` `isPairFound = ``false``; ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``// Print all the pairs with (a, b) as ` `            ``// (k, numbers greater than k) as ` `            ``// k % (num (> k)) = k i.e. 2%4 = 2 ` `            ``if` `(occ.get(k) && k < arr[i]) { ` `                ``System.out.print(``"("` `+ k + ``", "` `+ arr[i] + ``") "``); ` `                ``isPairFound = ``true``; ` `            ``} ` ` `  `            ``// Now check for the current element as 'a' ` `            ``// how many b exists such that a%b = k ` `            ``if` `(arr[i] >= k) { ` `                ``// find all the divisors of (arr[i]-k) ` `                ``Vector v = findDivisors(arr[i] - k); ` ` `  `                ``// Check for each divisor i.e. arr[i] % b = k ` `                ``// or not, if yes then print that pair. ` `                ``for` `(``int` `j = ``0``; j < v.size(); j++) { ` `                    ``if` `(arr[i] % v.get(j) == k && arr[i] != v.get(j) && occ.get(v.get(j))) { ` `                        ``System.out.print(``"("` `+ arr[i] + ``", "` `                                         ``+ v.get(j) + ``") "``); ` `                        ``isPairFound = ``true``; ` `                    ``} ` `                ``} ` ` `  `                ``// Clear vector ` `                ``v.clear(); ` `            ``} ` `        ``} ` ` `  `        ``return` `isPairFound; ` `    ``} ` ` `  `    ``// Driver method ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr[] = { ``3``, ``1``, ``2``, ``5``, ``4` `}; ` `        ``int` `k = ``2``; ` ` `  `        ``if` `(printPairs(arr, arr.length, k) == ``false``) ` `            ``System.out.println(``"No such pair exists"``); ` `    ``} ` `} `

## Python3

 `# Python3 program to find all pairs  ` `# such that a % b = k. ` `  `  `# Utiltity function to find the divisors  ` `# of n and store in vector v[] ` `import` `math as mt ` ` `  `def` `findDivisors(n): ` ` `  `    ``v ``=` `[] ` ` `  `    ``# Vector is used to store the divisors ` `    ``for` `i ``in` `range``(``1``, mt.floor(n``*``*``(.``5``)) ``+` `1``): ` `        ``if` `(n ``%` `i ``=``=` `0``): ` `             `  `            ``# If n is a square number, push ` `            ``# only one occurrence ` `            ``if` `(n ``/` `i ``=``=` `i): ` `                ``v.append(i) ` `            ``else``: ` `                ``v.append(i) ` `                ``v.append(n ``/``/` `i) ` `                 `  `    ``return` `v ` ` `  `# Function to find pairs such that (a%b = k) ` `def` `printPairs(arr, n, k): ` ` `  `    ``# Store all the elements in the map ` `    ``# to use map as hash for finding elements ` `    ``# in O(1) time. ` `    ``occ ``=` `dict``() ` `    ``for` `i ``in` `range``(n): ` `        ``occ[arr[i]] ``=` `True` ` `  `    ``isPairFound ``=` `False` ` `  `    ``for` `i ``in` `range``(n): ` `         `  `        ``# Print all the pairs with (a, b) as ` `        ``# (k, numbers greater than k) as ` `        ``# k % (num (> k)) = k i.e. 2%4 = 2 ` `        ``if` `(occ[k] ``and` `k < arr[i]): ` `            ``print``(``"("``, k, ``","``, arr[i], ``")"``, end ``=` `" "``) ` `            ``isPairFound ``=` `True` ` `  `        ``# Now check for the current element as 'a' ` `        ``# how many b exists such that a%b = k ` `        ``if` `(arr[i] >``=` `k): ` `             `  `            ``# find all the divisors of (arr[i]-k) ` `            ``v ``=` `findDivisors(arr[i] ``-` `k) ` ` `  `            ``# Check for each divisor i.e. arr[i] % b = k ` `            ``# or not, if yes then prthat pair. ` `            ``for` `j ``in` `range``(``len``(v)): ` `                ``if` `(arr[i] ``%` `v[j] ``=``=` `k ``and`  `                    ``arr[i] !``=` `v[j] ``and`  `                    ``occ[v[j]]): ` `                    ``print``(``"("``, arr[i], ``","``, v[j],  ` `                                       ``")"``, end ``=` `" "``) ` `                    ``isPairFound ``=` `True` ` `  `    ``return` `isPairFound ` ` `  `# Driver Code ` `arr ``=` `[``3``, ``1``, ``2``, ``5``, ``4``] ` `n ``=` `len``(arr) ` `k ``=` `2` ` `  `if` `(printPairs(arr, n, k) ``=``=` `False``): ` `    ``print``(``"No such pair exists"``) ` ` `  `# This code is contributed by mohit kumar `

## C#

 `// C# program to find all pairs  ` `// such that a % b = k.  ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `// Utility method to find the divisors  ` `// of n and store in vector v[]  ` `public` `static` `List<``int``> findDivisors(``int` `n) ` `{ ` `    ``List<``int``> v = ``new` `List<``int``>(); ` ` `  `    ``// Vector is used to store  ` `    ``// the divisors  ` `    ``for` `(``int` `i = 1;  ` `             ``i <= Math.Sqrt(n); i++) ` `    ``{ ` `        ``if` `(n % i == 0) ` `        ``{ ` `            ``// If n is a square number,  ` `            ``// push only one occurrence  ` `            ``if` `(n / i == i) ` `            ``{ ` `                ``v.Add(i); ` `            ``} ` `            ``else` `            ``{ ` `                ``v.Add(i); ` `                ``v.Add(n / i); ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `v; ` `} ` ` `  `// method to find pairs such ` `// that (a%b = k)  ` `public` `static` `bool` `printPairs(``int``[] arr, ` `                              ``int` `n, ``int` `k) ` `{ ` `    ``// Store all the elements in the  ` `    ``// map to use map as hash for  ` `    ``// finding elements in O(1) time.  ` `    ``Dictionary<``int``,  ` `               ``bool``> occ = ``new` `Dictionary<``int``,  ` `                                          ``bool``>(); ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``occ[arr[i]] = ``true``; ` `    ``} ` ` `  `    ``bool` `isPairFound = ``false``; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``// Print all the pairs with (a, b) as  ` `        ``// (k, numbers greater than k) as  ` `        ``// k % (num (> k)) = k i.e. 2%4 = 2  ` `        ``if` `(occ[k] && k < arr[i]) ` `        ``{ ` `            ``Console.Write(``"("` `+ k + ``", "` `+  ` `                           ``arr[i] + ``") "``); ` `            ``isPairFound = ``true``; ` `        ``} ` ` `  `        ``// Now check for the current element ` `        ``// as 'a' how many b exists such that  ` `        ``// a%b = k  ` `        ``if` `(arr[i] >= k) ` `        ``{ ` `            ``// find all the divisors of (arr[i]-k)  ` `            ``List<``int``> v = findDivisors(arr[i] - k); ` ` `  `            ``// Check for each divisor i.e.  ` `            ``// arr[i] % b = k or not, if ` `            ``// yes then print that pair.  ` `            ``for` `(``int` `j = 0; j < v.Count; j++) ` `            ``{ ` `                ``if` `(arr[i] % v[j] == k &&  ` `                    ``arr[i] != v[j] && occ[v[j]]) ` `                ``{ ` `                    ``Console.Write(``"("` `+ arr[i] + ` `                                  ``", "` `+ v[j] + ``") "``); ` `                    ``isPairFound = ``true``; ` `                ``} ` `            ``} ` ` `  `            ``// Clear vector  ` `            ``v.Clear(); ` `        ``} ` `    ``} ` ` `  `    ``return` `isPairFound; ` `} ` ` `  `// Driver Code  ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``int``[] arr = ``new` `int``[] {3, 1, 2, 5, 4}; ` `    ``int` `k = 2; ` ` `  `    ``if` `(printPairs(arr, arr.Length, k) == ``false``) ` `    ``{ ` `        ``Console.WriteLine(``"No such pair exists"``); ` `    ``} ` `} ` `} ` ` `  `// This code is contributed by Shrikant13 `

Output:

```(2, 3) (2, 5) (5, 3) (2, 4)
```

Time Complexity: O(n* sqrt(max)) where max is the maximum element in the array.

This article is contributed by Sahil Chhabra. 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.