Maximize modulus by replacing adjacent pairs with their modulus for any permutation of given Array

// Java Program to implement
// the above approach
import java.io.*;
class GFG{

    // Function to find the maximum value
    // possible of the given expression
    // from all permutations of the array
    static int maximumModuloValue(int A[], int n)
    {
        // Stores the minimum value
        // from the array
        int mn = Integer.MAX_VALUE;

        for (int i = 0; i < n; i++) 
        {
            mn = Math.min(A[i], mn);
        }

        // Return the answer
        return mn;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int A[] = {7, 10, 12};
        int n = A.length;
        System.out.println(maximumModuloValue(A, n));
    }
}

// This code is contributed by AnkitRai01

import java.util.Arrays;

public class NikunjSonigara {

    // Function to find the maximum modulus value among all permutations of the array
    static int maximizeModulus(int[] arr) {
        // Initialize max value to the smallest possible integer value
        int maxValue = Integer.MIN_VALUE;

        // Generate permutations and calculate modulus for each permutation
        do {
            // Initialize value with the first element of the permutation
            int value = arr[0];

            // Calculate modulus for the rest of the elements in the permutation
            for (int i = 1; i < arr.length; ++i) {
                value = value % arr[i];
            }

            // Update max value if the current permutation has a higher modulus
            if (value > maxValue) {
                maxValue = value;
            }

        } while (nextPermutation(arr)); // Generate the next permutation

        // Return the maximum modulus value found
        return maxValue;
    }

    // Helper function to generate the next permutation
    static boolean nextPermutation(int[] arr) {
        int i = arr.length - 2;
        while (i >= 0 && arr[i] >= arr[i + 1]) {
            i--;
        }
        if (i < 0) {
            return false; // No more permutations
        }

        int j = arr.length - 1;
        while (arr[j] <= arr[i]) {
            j--;
        }

        // Swap arr[i] and arr[j]
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;

        // Reverse the remaining part of the array
        reverse(arr, i + 1, arr.length - 1);

        return true;
    }

    // Helper function to reverse the elements in a range of the array
    static void reverse(int[] arr, int start, int end) {
        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }

    public static void main(String[] args) {
        // Test with the given inputs
        int[] arr1 = {7, 10, 12};
        int[] arr2 = {20, 30};

        // Output the results of the function for each test case
        System.out.println(maximizeModulus(arr1)); // Output: 7
        System.out.println(maximizeModulus(arr2)); // Output: 20
    }
}