Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Basic
  • Last Updated : 30 Apr, 2021

Given an array A[] consisting of distinct elements, the task is to obtain the largest possible modulus value that remains after repeatedly replacing adjacent elements by their modulus, starting from the first element, for any possible permutations of the given array.

 (…(( A[1] mod A[2]) mod A[3]) …. ) mod A[N])

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:



Input: A[] = {7, 10, 12}
Output: 7
Explanation: All possible values of the given expression across all permutations of the given array are as follows:
{7, 10, 12} = ((7 % 10) % 12) = 7
{10, 12 7} = ((10 % 12) % 7) = 3
{7, 12, 10} =((7 % 12) % 10) = 7
{10, 7, 12} = ((10 % 7) % 12) = 3
{12, 7, 10} = ((12 % 7) % 10) = 5
{12, 10, 7} = ((12 % 10) % 7) = 2
Therefore, the maximum possible value is 7.

Input: A[] = {20, 30}
Output: 20
Explanation:
The maximum possible value from all the permutations of the given array is 20.

Naive Approach: The simplest approach to solve the problem is to generate all permutations of the given array and find the value of the given expression for all permutations. Finally, print the maximum value of the expression obtained. 
Time Complexity: O(N * N!) 
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach, the following observations need to be made:

  • For any permutation A1…..AN, the value of the expression always lies in the range [0, min(A2…..An)-1].
  • Considering K to be the smallest element in the array, the value of the expression will always be K for the permutations having K as the first element.
  • For all other permutations, the value of the expression will always be less than K, as shown in the examples above. Therefore, K is the maximum possible value of the expression for any permutation of the array.
  • Therefore, the maximum possible value will always be equal to the smallest element of the array.

Therefore, to solve the problem, simply traverse the array and find the minimum element present in the array and print it as the required answer.

Below is the implementation of the above approach:

C++




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum
// of two numbers
int min(int a, int b)
{
    return (a > b) ? b : a;
}
 
// Function to find the maximum value
// possible of the given expression
// from all permutations of the array
int maximumModuloValue(int A[], int n)
{
    // Stores the minimum value
    // from the array
    int mn = INT_MAX;
    for (int i = 0; i < n; i++) {
        mn = min(A[i], mn);
    }
 
    // Return the answer
    return mn;
}
 
// Driver Code
int main()
{
    int A[] = { 7, 10, 12 };
 
    int n = (sizeof(A) / (sizeof(A[0])));
 
    cout << maximumModuloValue(A, n)
         << endl;
 
    return 0;
}

Java




// 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

Python3




# Python3 program to implement
# the above approach
import sys
 
# Function to find the maximum value
# possible of the given expression
# from all permutations of the array
def maximumModuloValue(A, n):
 
    # Stores the minimum value
    # from the array
    mn = sys.maxsize
    for i in range(n):
        mn = min(A[i], mn)
 
    # Return the answer
    return mn
 
# Driver Code
 
# Given array arr[]
A = [ 7, 10, 12 ]
 
n = len(A)
 
# Function call
print(maximumModuloValue(A, n))
 
# This code is contributed by Shivam Singh

C#




// C# Program to implement
// the above approach
using System;
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 = int.MaxValue;
 
    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;
    Console.WriteLine(maximumModuloValue(A, n));
  }
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
// javascript Program to implement
// the above approach
 
    // Function to find the maximum value
    // possible of the given expression
    // from all permutations of the array
    function maximumModuloValue(A , n) {
        // Stores the minimum value
        // from the array
        var mn = Number.MAX_VALUE;
 
        for (i = 0; i < n; i++) {
            mn = Math.min(A[i], mn);
        }
 
        // Return the answer
        return mn;
    }
 
    // Driver Code
     
        var A = [ 7, 10, 12 ];
        var n = A.length;
        document.write(maximumModuloValue(A, n));
 
// This code contributed by umadevi9616
</script>
Output: 
7

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :