GFG App
Open App
Browser
Continue

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

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.

Implementation:

## 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[0]);` `    ``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

 ``

## Javascript

 ``

Output

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

Time Complexity : O(n2)
Auxiliary Space: O(1)

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 k, we use the 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 the array, we use hashing.

Implementation:

## C++

 `// C++ program to find all pairs such that` `// a % b = k.` `#include ` `using` `namespace` `std;`   `// Utility 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[0]);` `    ``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.` ` `  `# Utility 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 print that 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`

## Javascript

 ``

Output

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

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

This article is contributed by Aarti_Rathi and Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up