# Remove exactly one element from the array such that max – min is minimum

Given an array consisting of N positive integer numbers. The task is to remove exactly one element from this array to minimize max(a) – min(a) and print the minimum possible (max(a) – min(a)).

Note: max(a) means largest number in array and min(a) means smallest number in array .
There are at least 2 elements in the array.

Examples:

```Input: arr[] = {1, 3, 3, 7}
Output: 2
Remove 7, then max(a) will be 3 and min(a) will be 1.
So our answer will be 3-1 = 2.

Input: arr[] = {1, 1000}
Output: 0
Remove either 1 or 1000, then our answer will 1-1 =0 or
1000-1000=0
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Simple Approach: Here it can be seen that we always have to remove either minimum or maximum of the array. We first sort the array. After sorting, if we remove minimum element, the difference would be a[n-1] – a. And if we remove the maximum element, difference would be a[n-2] – a. We return minimum of these two differences.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// function to calculate max-min ` `int` `max_min(``int` `a[], ``int` `n) ` `{ ` `    ``sort(a, a + n); ` ` `  `    ``return` `min(a[n - 2] - a, a[n - 1] - a); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 1, 3, 3, 7 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``cout << max_min(a, n); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach ` ` `  `import` `java.util.*; ` `class` `GFG ` `{ ` `    ``// function to calculate max-min ` `    ``static` `int` `max_min(``int` `a[], ``int` `n) ` `    ``{ ` `        ``Arrays.sort(a); ` `     `  `        ``return` `Math.min(a[n - ``2``] - a[``0``], a[n - ``1``] - a[``1``]); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String []args) ` `    ``{ ` `        ``int` `a[] = { ``1``, ``3``, ``3``, ``7` `}; ` `        ``int` `n = a.length; ` `     `  `        ``System.out.println(max_min(a, n)); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed  ` `// by ihritik `

## Python3

 `# Python3 implementation of the ` `# above approach  ` ` `  `# function to calculate max-min  ` `def` `max_min(a, n): ` `    ``a.sort() ` `    ``return` `min``(a[n ``-` `2``] ``-` `a[``0``],  ` `               ``a[n ``-` `1``] ``-` `a[``1``]) ` ` `  `# Driver code  ` `a ``=` `[``1``, ``3``, ``3``, ``7``]  ` `n ``=` `len``(a) ` `print``(max_min(a, n)) ` ` `  `# This code is contributed  ` `# by sahishelangia `

## C#

 `// C# implementation of the above approach ` ` `  `using` `System; ` `class` `GFG ` `{ ` `    ``// function to calculate max-min ` `    ``static` `int` `max_min(``int` `[]a, ``int` `n) ` `    ``{ ` `        ``Array.Sort(a); ` `     `  `        ``return` `Math.Min(a[n - 2] - a, a[n - 1] - a); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]a = { 1, 3, 3, 7 }; ` `        ``int` `n = a.Length; ` `     `  `        ``Console.WriteLine(max_min(a, n)); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed  ` `// by ihritik `

## PHP

 `  `  ` `

Output:

```2
```

Time Complexity: O(n log n)

Efficient Approach:
An efficient approach is to do following.
1) Find first minimum and second minimum
2) Find first maximum and second maximum
3) Return the minimum of following two differences.
…..a) First maximum and second minimum
…..b) Second maximum and first minimum

## C++

 `// C++ implementation of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// function to calculate max-min ` `int` `max_min(``int` `a[], ``int` `n) ` `{ ` `    ``// There should be at-least two elements ` `    ``if` `(n <= 1) ` `      ``return` `INT_MAX; ` ` `  `    ``// To store first and second minimums ` `    ``int` `f_min = a, s_min = INT_MAX; ` ` `  `    ``// To store first and second maximums ` `    ``int` `f_max = a, s_max = INT_MIN; ` ` `  `    ``for` `(``int` `i = 1; i= f_max) ` `        ``{ ` `           ``s_max = f_max; ` `           ``f_max = a[i]; ` `        ``} ` `        ``else` `if` `(a[i] > s_max) ` `        ``{ ` `           ``s_max = a[i]; ` `        ``} ` `    ``} ` ` `  `    ``return` `min((f_max - s_min), (s_max - f_min)); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 1, 3, 3, 7 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``cout << max_min(a, n); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach ` ` `  `class` `GFG ` `{ ` `    ``// function to calculate max-min ` `    ``static` `int` `max_min(``int` `a[], ``int` `n) ` `    ``{ ` `        ``// There should be at-least two elements ` `        ``if` `(n <= ``1``) ` `        ``return` `Integer.MAX_VALUE; ` `     `  `        ``// To store first and second minimums ` `        ``int` `f_min = a[``0``], s_min = Integer.MAX_VALUE; ` `     `  `        ``// To store first and second maximums ` `        ``int` `f_max = a[``0``], s_max = Integer.MIN_VALUE; ` `     `  `        ``for` `(``int` `i = ``1``; i= f_max) ` `            ``{ ` `            ``s_max = f_max; ` `            ``f_max = a[i]; ` `            ``} ` `            ``else` `if` `(a[i] > s_max) ` `            ``{ ` `            ``s_max = a[i]; ` `            ``} ` `        ``} ` `     `  `        ``return` `Math.min((f_max - s_min), (s_max - f_min)); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String []args) ` `    ``{ ` `        ``int` `a[] = { ``1``, ``3``, ``3``, ``7` `}; ` `        ``int` `n = a.length; ` `     `  `        ``System.out.println(max_min(a, n)); ` `     `  `    ``} ` ` `  `} ` ` `  `// This code is contributed  ` `// by ihritik `

## Python3

 `# Python3 implementation of the  ` `# above approach  ` `import` `sys ` ` `  `# function to calculate max-min  ` `def` `max_min(a, n) :  ` `     `  `    ``# There should be at-least two elements  ` `    ``if` `(n <``=` `1``) : ` `        ``return` `sys.maxsize ` ` `  `    ``# To store first and second minimums  ` `    ``f_min ``=` `a[``0``] ` `    ``s_min ``=` `sys.maxsize  ` ` `  `    ``# To store first and second maximums  ` `    ``f_max ``=` `a[``0``] ` `    ``s_max ``=` `-``(sys.maxsize ``-` `1``) ` ` `  `    ``for` `i ``in` `range``(n) :  ` `         `  `        ``if` `(a[i] <``=` `f_min) : ` `            ``s_min ``=` `f_min ` `            ``f_min ``=` `a[i] ` `         `  `        ``elif` `(a[i] < s_min) : ` `            ``s_min ``=` `a[i] ` ` `  `        ``if` `(a[i] >``=` `f_max) : ` `            ``s_max ``=` `f_max ` `            ``f_max ``=` `a[i] ` `     `  `        ``elif` `(a[i] > s_max) : ` `            ``s_max ``=` `a[i] ` ` `  `    ``return` `min``((f_max ``-` `s_min), (s_max ``-` `f_min)) ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` `    ``a ``=` `[ ``1``, ``3``, ``3``, ``7` `] ` `    ``n ``=` `len``(a) ` ` `  `    ``print``(max_min(a, n))  ` ` `  `# This code is contributed by Ryuga `

## C#

 `// C# implementation of the above approach ` `using` `System; ` `class` `GFG ` `{ ` `    ``// function to calculate max-min ` `    ``static` `int` `max_min(``int` `[]a, ``int` `n) ` `    ``{ ` `        ``// There should be at-least two elements ` `        ``if` `(n <= 1) ` `        ``return` `Int32.MaxValue; ` `     `  `        ``// To store first and second minimums ` `        ``int` `f_min = a, s_min = Int32.MaxValue; ` `     `  `        ``// To store first and second maximums ` `        ``int` `f_max = a, s_max = Int32.MinValue; ` `     `  `        ``for` `(``int` `i = 1; i= f_max) ` `            ``{ ` `            ``s_max = f_max; ` `            ``f_max = a[i]; ` `            ``} ` `            ``else` `if` `(a[i] > s_max) ` `            ``{ ` `            ``s_max = a[i]; ` `            ``} ` `        ``} ` `     `  `        ``return` `Math.Min((f_max - s_min), (s_max - f_min)); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]a = { 1, 3, 3, 7 }; ` `        ``int` `n = a.Length; ` `     `  `        ``Console.WriteLine(max_min(a, n)); ` `     `  `    ``} ` ` `  `} ` ` `  `// This code is contributed  ` `// by ihritik `

## PHP

 `= ``\$f_max``) ` `        ``{ ` `            ``\$s_max` `= ``\$f_max``; ` `            ``\$f_max` `= ``\$a``[``\$i``]; ` `        ``} ` `        ``else` `if` `(``\$a``[``\$i``] > ``\$s_max``) ` `        ``{ ` `            ``\$s_max` `= ``\$a``[``\$i``]; ` `        ``} ` `    ``} ` ` `  `    ``return` `min((``\$f_max` `- ``\$s_min``),  ` `               ``(``\$s_max` `- ``\$f_min``)); ` `} ` ` `  `// Driver code ` `\$a` `= ``array` `( 1, 3, 3, 7 ); ` `\$n` `= sizeof(``\$a``); ` ` `  `echo``(max_min(``\$a``, ``\$n``)); ` ` `  `// This code is contributed  ` `// by Mukul Singh ` `?> `

Output:

```2
```

Time Complexity: O(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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.