 Open in App
Not now

# Minimize maximum difference between adjacent elements possible by removing a single array element

• Difficulty Level : Medium
• Last Updated : 05 May, 2021

Given an sorted array arr[] consisting of N elements, the task is to find the minimum of all maximum differences between adjacent elements of all arrays obtained by removal of any single array element.

Examples:

Input: arr[ ] = { 1, 3, 7, 8}
Output: 5
Explanation:
All possible arrays after removing a single element are as follows:
{3, 7, 8}: Difference between adjacent elements are { 4, 1}. Maximum = 4.
{ 1, 7, 8}: Difference between adjacent elements are { 6, 1}. Maximum = 6.
{ 1, 3, 8}: Difference between adjacent elements are { 2, 5}. Maximum = 5.
Finally, minimum of (4, 6, 5) is 4, which is the required output.

Input: arr[ ] = { 1, 2, 3, 4, 5}
Output: 1
Explanation:
All possible arrays after removing a single element are as follows:
{ 2, 3, 4, 5}: Difference between adjacent elements are { 1, 1, 1}. Maximum = 1.
{ 1, 3, 4, 5}: Difference between adjacent elements are { 2, 1, 1}. Maximum = 2.
{ 1, 2, 4, 5}: Difference between adjacent elements are { 1, 2, 1}. Maximum = 2.
{ 1, 2, 3, 5}: Difference between adjacent elements are { 1, 1, 2}. Maximum = 2.
Finally, minimum of (1, 2, 2, 2) is 1, which is the required output.

Approach: Follow the steps to solve the problem

• Declare a variable MinValue = INT_MAX to store the final answer.
• Traverse the array, for i in range [0, N – 1]
• Declare a vector new_arr which is a copy of arr[] except element arr[i]
• Store the maximum adjacent difference of new_arr in a variable diff
• Update MinValue = min(MinValue, diff)
• Return MinValue as the final answer.

Below is the implementation of above approach.

## C++

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find maximum difference``// between adjacent array elements``int` `maxAdjacentDifference(vector<``int``> A)``{``    ``// Store the maximum difference``    ``int` `diff = 0;` `// Traverse the array``    ``for` `(``int` `i = 1; i < (``int``)A.size(); i++) {` `        ``// Update maximum difference``        ``diff = max(diff, A[i] - A[i - 1]);``    ``}` `    ``return` `diff;``}` `// Function to calculate the minimum``// of maximum difference between``// adjacent array elements possible``// by removing a single array element``int` `MinimumValue(``int` `arr[], ``int` `N)``{``    ``// Stores the required minimum``    ``int` `MinValue = INT_MAX;` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Stores the updated array``        ``vector<``int``> new_arr;` `        ``for` `(``int` `j = 0; j < N; j++) {` `            ``// Skip the i-th element``            ``if` `(i == j)``                ``continue``;` `            ``new_arr.push_back(arr[j]);``        ``}` `        ``// Update MinValue``        ``MinValue``            ``= min(MinValue,``                  ``maxAdjacentDifference(new_arr));``    ``}` `    ``// return MinValue``    ``return` `MinValue;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 3, 7, 8 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);``    ``cout << MinimumValue(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG``{` `// Function to find maximum difference``// between adjacent array elements``static` `int` `maxAdjacentDifference(ArrayList A)``{``  ` `    ``// Store the maximum difference``    ``int` `diff = ``0``;` `// Traverse the array``    ``for` `(``int` `i = ``1``; i < (``int``)A.size(); i++)``    ``{` `        ``// Update maximum difference``        ``diff = Math.max(diff, A.get(i) - A.get(i - ``1``));``    ``}` `    ``return` `diff;``}` `// Function to calculate the minimum``// of maximum difference between``// adjacent array elements possible``// by removing a single array element``static` `int` `MinimumValue(``int` `arr[], ``int` `N)``{``  ` `    ``// Stores the required minimum``    ``int` `MinValue = Integer.MAX_VALUE;` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``// Stores the updated array``        ``ArrayList new_arr=``new` `ArrayList<>();` `        ``for` `(``int` `j = ``0``; j < N; j++) {` `            ``// Skip the i-th element``            ``if` `(i == j)``                ``continue``;` `            ``new_arr.add(arr[j]);``        ``}` `        ``// Update MinValue``        ``MinValue``            ``= Math.min(MinValue,``                  ``maxAdjacentDifference(new_arr));``    ``}` `    ``// return MinValue``    ``return` `MinValue;` `}` `  ``// Driver code``    ``public` `static` `void` `main (String[] args) {``     ``int` `arr[] = { ``1``, ``3``, ``7``, ``8` `};``    ``int` `N = arr.length;``   ``System.out.print(MinimumValue(arr, N));` `    ``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement``# the above approach``import` `sys` `# Function to find maximum difference``# between adjacent array elements``def` `maxAdjacentDifference(A):``    ` `    ``# Store the maximum difference``    ``diff ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(``1``, ``len``(A), ``1``):``        ` `        ``# Update maximum difference``        ``diff ``=` `max``(diff, A[i] ``-` `A[i ``-` `1``])` `    ``return` `diff` `# Function to calculate the minimum``# of maximum difference between``# adjacent array elements possible``# by removing a single array element``def` `MinimumValue(arr, N):``    ` `    ``# Stores the required minimum``    ``MinValue ``=` `sys.maxsize` `    ``for` `i ``in` `range``(N):``        ` `        ``# Stores the updated array``        ``new_arr ``=` `[]` `        ``for` `j ``in` `range``(N):``            ` `            ``# Skip the i-th element``            ``if` `(i ``=``=` `j):``                ``continue` `            ``new_arr.append(arr[j])` `        ``# Update MinValue``        ``MinValue ``=` `min``(MinValue,``                       ``maxAdjacentDifference(new_arr))` `    ``# return MinValue``    ``return` `MinValue` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=`  `[ ``1``, ``3``, ``7``, ``8` `]``    ``N ``=` `len``(arr)``    ` `    ``print``(MinimumValue(arr, N))` `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find maximum difference``// between adjacent array elements``static` `int` `maxAdjacentDifference(List<``int``> A)``{``    ` `    ``// Store the maximum difference``    ``int` `diff = 0;` `    ``// Traverse the array``    ``for``(``int` `i = 1; i < A.Count; i++)``    ``{``        ` `        ``// Update maximum difference``        ``diff = Math.Max(diff, A[i] - A[i - 1]);``    ``}``    ``return` `diff;``}` `// Function to calculate the minimum``// of maximum difference between``// adjacent array elements possible``// by removing a single array element``static` `int` `MinimumValue(``int``[] arr, ``int` `N)``{``    ` `    ``// Stores the required minimum``    ``int` `MinValue = Int32.MaxValue;` `    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Stores the updated array``        ``List<``int``> new_arr = ``new` `List<``int``>();` `        ``for``(``int` `j = 0; j < N; j++)``        ``{``            ` `            ``// Skip the i-th element``            ``if` `(i == j)``                ``continue``;` `            ``new_arr.Add(arr[j]);``        ``}` `        ``// Update MinValue``        ``MinValue = Math.Min(MinValue,``             ``maxAdjacentDifference(new_arr));``    ``}` `    ``// Return MinValue``    ``return` `MinValue;``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = { 1, 3, 7, 8 };``    ``int` `N = arr.Length;``    ` `    ``Console.WriteLine(MinimumValue(arr, N));``}``}` `// This code is contributed by ukasp`

## Javascript

 ``

Output:

`4`

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

My Personal Notes arrow_drop_up