Related Articles
Maximum modulo of all the pairs of array where arr[i] >= arr[j]
• Difficulty Level : Hard
• Last Updated : 08 Apr, 2019

Given an array of n integers. Find the maximum value of arr[i] mod arr[j] where arr[i] >= arr[j] and 1 <= i, j <= n
Examples:

```Input: arr[] = {3, 4, 7}
Output: 3
Explanation:
There are 3 pairs which satisfies arr[i] >= arr[j] are:-
4, 3 => 4 % 3 = 1
7, 3 => 7 % 3 = 1
7, 4 => 7 % 4 = 3
Hence Maximum value among all is 3.

Input: arr[] = {3, 7, 4, 11}
Output: 4

Input: arr[] = {4, 4, 4}
Output: 0
```

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

A Naive approach is to run two nested for loops and select the maximum of every possible pairs after taking modulo of them. Time complexity of this approach will be O(n2) which will not be sufficient for large value of n.

An efficient approach (when elements are from small range) is to use sorting and binary search method. Firstly we will sort the array so that we would able to apply binary search on it. Since we need to maximize the value of arr[i] mod arr[j] so we iterate through each x(such x divisible by arr[j]) in range from 2*arr[j] to M+arr[j], where M is Maximum value of sequence. For each value of x we need to find maximum value of arr[i] such that arr[i] < x.
By doing this we would assure that we have chosen only those values of arr[i] that will give the maximum value of arr[i] mod arr[j]. After that we just need to repeat the above process for other values of arr[j] and update the answer by value a[i] mod arr[j]. For example:-

```If arr[] = {4, 6, 7, 8, 10, 12, 15} then for
first element, i.e., arr[j] = 4 we iterate
through x = {8, 12, 16}.
Therefore for each value of x, a[i] will be:-
x = 8, arr[i] = 7 (7 < 8)
ans = 7 mod 4 = 3
x = 12, arr[i] = 10 (10 < 12)
ans = 10 mod 4 = 2 (Since 2 < 3,
No update)
x = 16, arr[i] = 15 (15 < 16)
ans  = 15 mod 4 = 3 (Since 3 == 3,
No need to update)
```

## C++

 `// C++ program to find Maximum modulo value``#include ``using` `namespace` `std;`` ` `int` `maxModValue(``int` `arr[], ``int` `n)``{``    ``int` `ans = 0;``    ``// Sort the array[] by using inbuilt sort function``    ``sort(arr, arr + n);`` ` `    ``for` `(``int` `j = n - 2; j >= 0; --j) {``        ``// Break loop if answer is greater or equals to``        ``// the arr[j] as any number modulo with arr[j]``        ``// can only give maximum value up-to arr[j]-1``        ``if` `(ans >= arr[j])``            ``break``;`` ` `        ``// If both elements are same then skip the next``        ``// loop as it would be worthless to repeat the``        ``// rest process for same value``        ``if` `(arr[j] == arr[j + 1])``            ``continue``;`` ` `        ``for` `(``int` `i = 2 * arr[j]; i <= arr[n - 1] + arr[j]; i += arr[j]) {``            ``// Fetch the index which is greater than or``            ``// equals to arr[i] by using binary search``            ``// inbuilt lower_bound() function of C++``            ``int` `ind = lower_bound(arr, arr + n, i) - arr;`` ` `            ``// Update the answer``            ``ans = max(ans, arr[ind - 1] % arr[j]);``        ``}``    ``}``    ``return` `ans;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 3, 4, 5, 9, 11 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << maxModValue(arr, n);``}`

## Java

 `// Java program to find Maximum modulo value`` ` `import` `java.util.Arrays;`` ` `class` `Test {``    ``static` `int` `maxModValue(``int` `arr[], ``int` `n)``    ``{``        ``int` `ans = ``0``;`` ` `        ``// Sort the array[] by using inbuilt sort function``        ``Arrays.sort(arr);`` ` `        ``for` `(``int` `j = n - ``2``; j >= ``0``; --j) {``            ``// Break loop if answer is greater or equals to``            ``// the arr[j] as any number modulo with arr[j]``            ``// can only give maximum value up-to arr[j]-1``            ``if` `(ans >= arr[j])``                ``break``;`` ` `            ``// If both elements are same then skip the next``            ``// loop as it would be worthless to repeat the``            ``// rest process for same value``            ``if` `(arr[j] == arr[j + ``1``])``                ``continue``;`` ` `            ``for` `(``int` `i = ``2` `* arr[j]; i <= arr[n - ``1``] + arr[j]; i += arr[j]) {``                ``// Fetch the index which is greater than or``                ``// equals to arr[i] by using binary search`` ` `                ``int` `ind = Arrays.binarySearch(arr, i);`` ` `                ``if` `(ind < ``0``)``                    ``ind = Math.abs(ind + ``1``);`` ` `                ``else` `{``                    ``while` `(arr[ind] == i) {``                        ``ind--;`` ` `                        ``if` `(ind == ``0``) {``                            ``ind = -``1``;``                            ``break``;``                        ``}``                    ``}``                    ``ind++;``                ``}`` ` `                ``// Update the answer``                ``ans = Math.max(ans, arr[ind - ``1``] % arr[j]);``            ``}``        ``}``        ``return` `ans;``    ``}`` ` `    ``// Driver method``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``3``, ``4``, ``5``, ``9``, ``11` `};``        ``System.out.println(maxModValue(arr, arr.length));``    ``}``}`

## Python3

 `# Python3 program to find Maximum modulo value `` ` `def` `maxModValue(arr, n): `` ` `    ``ans ``=` `0``     ` `    ``# Sort the array[] by using inbuilt``    ``# sort function ``    ``arr ``=` `sorted``(arr) `` ` `    ``for` `j ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``): ``         ` `        ``# Break loop if answer is greater or equals to ``        ``# the arr[j] as any number modulo with arr[j] ``        ``# can only give maximum value up-to arr[j]-1 ``        ``if` `(ans >``=` `arr[j]):``            ``break`` ` `        ``# If both elements are same then skip the next ``        ``# loop as it would be worthless to repeat the ``        ``# rest process for same value ``        ``if` `(arr[j] ``=``=` `arr[j ``+` `1``]) :``            ``continue``        ``i ``=` `2` `*` `arr[j]``        ``while``(i <``=` `arr[n ``-` `1``] ``+` `arr[j]):``             ` `            ``# Fetch the index which is greater than or ``            ``# equals to arr[i] by using binary search ``            ``# inbuilt lower_bound() function of C++ ``            ``ind ``=` `0``            ``for` `k ``in` `arr:``                ``if` `k >``=` `i:``                    ``ind ``=` `arr.index(k)`` ` `            ``# Update the answer ``            ``ans ``=` `max``(ans, arr[ind ``-` `1``] ``%` `arr[j])``            ``i ``+``=` `arr[j]`` ` `    ``return` `ans `` ` `# Driver Code``arr ``=` `[``3``, ``4``, ``5``, ``9``, ``11` `]``n ``=` `5``print``(maxModValue(arr, n))`` ` `# This code is contributed by``# Shubham Singh(SHUBHAMSINGH10)`

## C#

 `// C# program to find Maximum modulo value``using` `System;`` ` `public` `class` `GFG {``     ` `    ``static` `int` `maxModValue(``int``[] arr, ``int` `n)``    ``{``         ` `        ``int` `ans = 0;`` ` `        ``// Sort the array[] by using inbuilt``        ``// sort function``        ``Array.Sort(arr);`` ` `        ``for` `(``int` `j = n - 2; j >= 0; --j)``        ``{``             ` `            ``// Break loop if answer is greater``            ``// or equals to the arr[j] as any``            ``// number modulo with arr[j] can ``            ``// only give maximum value up-to``            ``// arr[j]-1``            ``if` `(ans >= arr[j])``                ``break``;`` ` `            ``// If both elements are same then``            ``// skip the next loop as it would``            ``// be worthless to repeat the``            ``// rest process for same value``            ``if` `(arr[j] == arr[j + 1])``                ``continue``;`` ` `            ``for` `(``int` `i = 2 * arr[j]; ``                      ``i <= arr[n - 1] + arr[j];``                                   ``i += arr[j])``            ``{``                 ` `                ``// Fetch the index which is ``                ``// greater than or equals to``                ``// arr[i] by using binary search`` ` `                ``int` `ind = Array.BinarySearch(arr, i);`` ` `                ``if` `(ind < 0)``                    ``ind = Math.Abs(ind + 1);`` ` `                ``else` `{``                    ``while` `(arr[ind] == i) {``                        ``ind--;`` ` `                        ``if` `(ind == 0) {``                            ``ind = -1;``                            ``break``;``                        ``}``                    ``}``                    ``ind++;``                ``}`` ` `                ``// Update the answer``                ``ans = Math.Max(ans, arr[ind - 1]``                                       ``% arr[j]);``            ``}``        ``}``         ` `        ``return` `ans;``    ``}`` ` `    ``// Driver method``    ``public` `static` `void` `Main()``    ``{``         ` `        ``int``[] arr = { 3, 4, 5, 9, 11 };``         ` `        ``Console.WriteLine(``                 ``maxModValue(arr, arr.Length));``    ``}``}`` ` `// This code is contributed by Sam007.`
```Output:
4
```

Time complexity: O(nlog(n) + Mlog(M)) where n is total number of elements and M is maximum value of all the elements.
Auxiliary space: O(1)

This blog is contributed by Shubham Bansal. 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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up