给定数组的arr [i]％arr [j]的最大值

给定数组arr [] ，任务是找到所有可能对的arr [i]％arr [j]的最大值。

例子：

Input: arr[] = { 2, 3 }
Output: 2
2 % 3 = 2
3 % 2 = 1

Input: arr[] = { 2, 2, 2, 2 }
Output: 0

天真的方法：运行两个嵌套循环，并为每对计算arr [i]％arr [j]的值。根据计算出的值更新答案。

下面是上述方法的实现：

C++

// C++ implementation of the above approach
#include 
using namespace std;
  
// Function to return maximum value of
// arr[i] % arr[j]
int computeMaxValue(const int* arr, int n)
{
    int ans = 0;
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
  
            // Check pair (x, y) as well as 
            // (y, x) for maximum value
            int val = max(arr[i] % arr[j], 
                          arr[j] % arr[i]);
  
            // Update the answer
            ans = max(ans, val);
        }
    }
    return ans;
}
  
// Driver code
int main()
{
    int arr[] = { 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << computeMaxValue(arr, n);
    return 0;
}

Java

// Java implementation of the above approach
  
import java.util.*;
class GFG
{
      
    // Function to return maximum value of
    // arr[i] % arr[j]
    static int computeMaxValue(int []arr, int n)
    {
        int ans = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
      
                // Check pair (x, y) as well as 
                // (y, x) for maximum value
                int val = Math.max(arr[i] % arr[j], 
                            arr[j] % arr[i]);
      
                // Update the answer
                ans = Math.max(ans, val);
            }
        }
        return ans;
    }
      
    // Driver code
    public static void main(String []args)
    {
        int []arr = { 2, 3 };
        int n = arr.length;
        System.out.println(computeMaxValue(arr, n));
          
    }
  
}
  
// This code is contributed
// by ihritik

Python3

# Python3  implementation of the above approach
  
# Function to return maximum value of
# arr[i] % arr[j]
def computeMaxValue(arr, n):
  
    ans = 0
    for i in range(0, n-1):
        for j in range( i+1, n):
  
            # Check pair (x, y) as well as 
            # (y, x) for maximum value
            val = max(arr[i] % arr[j], arr[j] % arr[i])
  
            # Update the answer
            ans = max(ans, val)
          
      
    return ans
  
  
# Driver code
arr = [ 2, 3 ]
n = len(arr)
print(computeMaxValue(arr, n))
          
# This code is contributed
# by ihritik

C#

// C# implementation of the above approach
  
using System;
class GFG
{
      
    // Function to return maximum value of
    // arr[i] % arr[j]
    static int computeMaxValue(int []arr, int n)
    {
        int ans = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
      
                // Check pair (x, y) as well as 
                // (y, x) for maximum value
                int val = Math.Max(arr[i] % arr[j], 
                            arr[j] % arr[i]);
      
                // Update the answer
                ans = Math.Max(ans, val);
            }
        }
        return ans;
    }
      
    // Driver code
    public static void Main()
    {
        int []arr = { 2, 3 };
        int n = arr.Length;
        Console.WriteLine(computeMaxValue(arr, n));
          
    }
  
}
  
// This code is contributed
// by ihritik

输出：

2

高效方法：当A 且A和B为最大可能值时，将产生A％ B的最大值。换句话说，结果将是数组中第二大的元素，但当数组的所有元素都相同时(在这种情况下，结果将为0 )。

A = second largest element of the array.
B = largest element of the array and A < B.
Maximum value of A % B = A.

Corner case: If all the elements of the array are same say arr[] = {x, x, x, x} then the result will be x % x = 0.

下面是上述方法的实现：

C++

// C++ implementation of the above approach
#include 
using namespace std;
  
// Function to return maximum value of
// arr[i] % arr[j]
int computeMaxValue(const int* arr, int n)
{
    bool allSame = true;
    int i = 1;
    while (i < n) {
  
        // If current element is different
        // from the previous element
        if (arr[i] != arr[i - 1]) {
            allSame = false;
            break;
        }
        i++;
    }
  
    // If all the elements of the array are equal
    if (allSame)
        return 0;
  
    // Maximum element from the array
    int max = *std::max_element(arr, arr + n);
    int secondMax = 0;
    for (i = 0; i < n; i++) {
        if (arr[i] < max && arr[i] > secondMax)
            secondMax = arr[i];
    }
  
    // Return the second maximum element
    // from the array
    return secondMax;
}
  
// Driver code
int main()
{
    int arr[] = { 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << computeMaxValue(arr, n);
    return 0;
}

Java

// Java implementation of the above approach
class GFG
{
  
// Function to return maximum value of
// arr[i] % arr[j]
static int computeMaxValue(int arr[], int n)
{
    boolean allSame = true;
    int i = 1;
    while (i < n) 
    {
  
        // If current element is different
        // from the previous element
        if (arr[i] != arr[i - 1]) 
        {
            allSame = false;
            break;
        }
        i++;
    }
  
    // If all the elements of the 
    // array are equal
    if (allSame)
        return 0;
  
    // Maximum element from the array
    int max = -1;
    for(i = 0; i < n; i++)
    {
        if(max < arr[i])
        max = arr[i];
    }
    int secondMax = 0;
    for (i = 0; i < n; i++)
    {
        if (arr[i] < max && arr[i] > secondMax)
            secondMax = arr[i];
    }
  
    // Return the second maximum element
    // from the array
    return secondMax;
}
  
// Driver code
public static void main(String[] args)
{
    int []arr = { 2, 3 };
    int n = arr.length;
    System.out.println(computeMaxValue(arr, n));
}
}
  
// This code is contributed
// by 29AjayKumar

Python3

# Python3 implementation of the 
# above approach 
  
# Function to return maximum value 
# of arr[i] % arr[j] 
def computeMaxValue(arr, n) :
      
    allSame = True; 
    i = 1; 
    while (i < n) : 
  
        # If current element is different 
        # from the previous element 
        if (arr[i] != arr[i - 1]) :
            allSame = False
            break
          
        i += 1
      
    # If all the elements of the 
    # array are equal 
    if (allSame) :
        return 0
  
    # Maximum element from the array 
    max_element = max(arr) 
      
    secondMax = 0
    for i in range(n) :
        if (arr[i] < max_element and 
            arr[i] > secondMax) :
            secondMax = arr[i] 
      
    # Return the second maximum element 
    # from the array 
    return secondMax
  
# Driver code 
if __name__ == "__main__" :
    arr = [ 2, 3 ] 
    n = len(arr)
      
    print(computeMaxValue(arr, n))
  
# This code is contributed by Ryuga

C＃

// C# implementation of the above approach
using System;
  
class GFG
{
  
// Function to return maximum value of
// arr[i] % arr[j]
static int computeMaxValue(int[] arr, int n)
{
    bool allSame = true;
    int i = 1;
    while (i < n) 
    {
  
        // If current element is different
        // from the previous element
        if (arr[i] != arr[i - 1]) 
        {
            allSame = false;
            break;
        }
        i++;
    }
  
    // If all the elements of the 
    // array are equal
    if (allSame)
        return 0;
  
    // Maximum element from the array
    int max = -1;
    for(i = 0; i < n; i++)
    {
        if(max < arr[i])
        max = arr[i];
    }
    int secondMax = 0;
    for (i = 0; i < n; i++)
    {
        if (arr[i] < max && arr[i] > secondMax)
            secondMax = arr[i];
    }
  
    // Return the second maximum element
    // from the array
    return secondMax;
}
  
// Driver code
public static void Main()
{
    int[] arr = { 2, 3 };
    int n = arr.Length;
    Console.Write(computeMaxValue(arr, n));
}
}
  
// This code is contributed by Ita_c.

的PHP

 $secondMax)
            $secondMax = $arr[$i];
    }
  
    // Return the second maximum 
    // element from the array
    return $secondMax;
}
  
// Driver code
$arr = array(2, 3);
$n = sizeof($arr);
echo computeMaxValue($arr, $n);
  
// This code is contributed by ajit.
?>

输出：

2