Minimize the maximum difference between the heights

Difficulty Level : Hard
Last Updated : 06 Apr, 2021

Given heights of n towers and a value k. We need to either increase or decrease height of every tower by k (only once) where k > 0. The task is to minimize the difference between the heights of the longest and the shortest tower after modifications, and output this difference.
Examples:

Input  : arr[] = {1, 15, 10}, k = 6
Output :  Maximum difference is 2.
Explanation : We change 1 to 7, 15 to 
9 and 10 to 4. Maximum difference is 5
(between 7 and 9). We can't get a lower
difference.

Input : arr[] = {1, 5, 15, 10} 
        k = 3   
Output : Maximum difference is 8
arr[] = {4, 8, 12, 7}

Input : arr[] = {4, 6} 
        k = 10
Output : Maximum difference is 2
arr[] = {14, 16} OR {-6, -4}

Input : arr[] = {6, 10} 
        k = 3
Output : Maximum difference is 2
arr[] = {9, 7} 

Input : arr[] = {1, 10, 14, 14, 14, 15}
        k = 6 
Output: Maximum difference is 5
arr[] = {7, 4, 8, 8, 8, 9} 

Input : arr[] = {1, 2, 3}
        k = 2 
Output: Maximum difference is 2
arr[] = {3, 4, 5}

Source : Adobe Interview Experience | Set 24 (On-Campus for MTS)

The idea is to sort all elements increasing order. And for all elements check if subtract(element-k) and add(element+k) makes any changes or not.
Below is the implementation of the above approach:

C++

// C++ program to find the minimum possible
// difference between maximum and minimum
// elements when we have to add/subtract
// every number by k
#include <bits/stdc++.h>
using namespace std;
 
// Modifies the array by subtracting/adding
// k to every element such that the difference
// between maximum and minimum is minimized
int getMinDiff(int arr[], int n, int k)
{
    if (n == 1)
       return 0;
 
    // Sort all elements
    sort(arr, arr+n);
 
    // Initialize result
    int ans = arr[n-1] - arr[0];
 
    // Handle corner elements
    int small = arr[0] + k;
    int big = arr[n-1] - k;
    if (small > big)
       swap(small, big);
 
    // Traverse middle elements
    for (int i = 1; i < n-1; i ++)
    {
        int subtract = arr[i] - k;
        int add = arr[i] + k;
 
        // If both subtraction and addition
        // do not change diff
        if (subtract >= small || add <= big)
            continue;
 
        // Either subtraction causes a smaller
        // number or addition causes a greater
        // number. Update small or big using
        // greedy approach (If big - subtract
        // causes smaller diff, update small
        // Else update big)
        if (big - subtract <= add - small)
            small = subtract;
        else
            big = add;
    }
 
    return  min(ans, big - small);
}
 
// Driver function to test the above function
int main()
{
    int arr[] = {4, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    int k = 10;
    cout << "\nMaximum difference is "
        << getMinDiff(arr, n, k);
    return 0;
}

Java

// Java program to find the minimum possible
// difference between maximum and minimum
// elements when we have to add/subtract
// every number by k
import java.util.*;
 
class GFG {
 
    // Modifies the array by subtracting/adding
    // k to every element such that the difference
    // between maximum and minimum is minimized
    static int getMinDiff(int arr[], int n, int k)
    {
        if (n == 1)
        return 0;
 
        // Sort all elements
        Arrays.sort(arr);
 
        // Initialize result
        int ans = arr[n-1] - arr[0];
 
        // Handle corner elements
        int small = arr[0] + k;
        int big = arr[n-1] - k;
        int temp = 0;
         
        if (small > big)
        {
            temp = small;
            small = big;
            big = temp;
        }
 
        // Traverse middle elements
        for (int i = 1; i < n-1; i ++)
        {
            int subtract = arr[i] - k;
            int add = arr[i] + k;
 
            // If both subtraction and addition
            // do not change diff
            if (subtract >= small || add <= big)
                continue;
 
            // Either subtraction causes a smaller
            // number or addition causes a greater
            // number. Update small or big using
            // greedy approach (If big - subtract
            // causes smaller diff, update small
            // Else update big)
            if (big - subtract <= add - small)
                small = subtract;
            else
                big = add;
        }
 
        return Math.min(ans, big - small);
    }
 
    // Driver function to test the above function
    public static void main(String[] args)
    {
        int arr[] = {4, 6};
        int n = arr.length;
        int k = 10;
        System.out.println("Maximum difference is "+
                            getMinDiff(arr, n, k));
    }
}
// This code is contributed by Prerna Saini

Python3

# Python 3 program to find the minimum
# possible difference between maximum
# and minimum elements when we have to
# add / subtract every number by k
 
# Modifies the array by subtracting /
# adding k to every element such that
# the difference between maximum and
# minimum is minimized
def getMinDiff(arr, n, k):
 
    if (n == 1):
        return 0
 
    # Sort all elements
    arr.sort()
 
    # Initialize result
    ans = arr[n-1] - arr[0]
 
    # Handle corner elements
    small = arr[0] + k
    big = arr[n-1] - k
     
    if (small > big):
        small, big = big, small
 
    # Traverse middle elements
    for i in range(1, n-1):
     
        subtract = arr[i] - k
        add = arr[i] + k
 
        # If both subtraction and addition
        # do not change diff
        if (subtract >= small or add <= big):
            continue
 
        # Either subtraction causes a smaller
        # number or addition causes a greater
        # number. Update small or big using
        # greedy approach (If big - subtract
        # causes smaller diff, update small
        # Else update big)
        if (big - subtract <= add - small):
            small = subtract
        else:
            big = add
     
 
    return min(ans, big - small)
 
 
# Driver function
arr = [ 4, 6 ]
n = len(arr)
k = 10
 
print("Maximum difference is", getMinDiff(arr, n, k))
 
# This code is contributed by
# Smitha Dinesh Semwal

C#

// C# program to find the minimum
// possible difference between
// maximum and minimum elements
// when we have to add/subtract
// every number by k
using System;
 
class GFG
{
 
// Modifies the array by subtracting/adding
// k to every element such that the difference
// between maximum and minimum is minimized
static int getMinDiff(int[] arr, int n, int k)
{
    if (n == 1)
    return 0;
 
    // Sort all elements
    Array.Sort(arr);
 
    // Initialize result
    int ans = arr[n - 1] - arr[0];
 
    // Handle corner elements
    int small = arr[0] + k;
    int big = arr[n - 1] - k;
    int temp = 0;
     
    if (small > big)
    {
        temp = small;
        small = big;
        big = temp;
    }
 
    // Traverse middle elements
    for (int i = 1; i < n - 1; i ++)
    {
        int subtract = arr[i] - k;
        int add = arr[i] + k;
 
        // If both subtraction and
        // addition do not change diff
        if (subtract >= small || add <= big)
            continue;
 
        // Either subtraction causes a smaller
        // number or addition causes a greater
        // number. Update small or big using
        // greedy approach (If big - subtract
        // causes smaller diff, update small
        // Else update big)
        if (big - subtract <= add - small)
            small = subtract;
        else
            big = add;
    }
 
    return Math.Min(ans, big - small);
}
 
// Driver Code
public static void Main()
{
    int[] arr = {4, 6};
    int n = arr.Length;
    int k = 10;
    Console.Write("Maximum difference is "+
                    getMinDiff(arr, n, k));
}
}
 
// This code is contributed
// by ChitraNayal

PHP

<?php
// PHP program to find the minimum
// possible difference between
// maximum and minimum elements when
// we have to add/subtract every
// number by k
 
// Modifies the array by subtracting
// or adding k to every element such
// that the difference between maximum
// and minimum is minimized
function getMinDiff($arr, $n, $k)
{
    if ($n == 1)
    return 0;
 
    // Sort all elements
    sort($arr);
 
    // Initialize result
    $ans = $arr[$n - 1] - $arr[0];
 
    // Handle corner elements
    $small = $arr[0] + $k;
    $big = $arr[$n - 1] - $k;
    if ($small > $big)
    {
        $temp = $small;
        $small = $big;
        $big = $temp;
    }
     
    // Traverse middle elements
    for ($i = 1; $i < $n - 1; $i ++)
    {
        $subtract = $arr[$i] - $k;
        $add = $arr[$i] + $k;
 
        // If both subtraction and
        // addition do not change diff
        if ($subtract >= $small || $add <= $big)
            continue;
 
        // Either subtraction causes a smaller
        // number or addition causes a greater
        // number. Update small or big using
        // greedy approach (If big - subtract
        // causes smaller diff, update small
        // Else update big)
        if ($big - $subtract <= $add - $small)
            $small = $subtract;
        else
            $big = $add;
    }
 
    return min($ans, $big - $small);
}
 
// Driver Code
$arr = array(4, 6);
$n = sizeof($arr);
$k = 10;
echo "Maximum difference is ";
echo getMinDiff($arr, $n, $k);
 
// This code is contributed by ihritik
?>

Javascript

<script>
 
// Javascript program to find the minimum possible
// difference between maximum and minimum
// elements when we have to add/subtract
// every number by k
     
    // Modifies the array by subtracting/adding
    // k to every element such that the difference
    // between maximum and minimum is minimized
    function getMinDiff(arr,n,k)
    {
        if (n == 1)
            return 0;
  
        // Sort all elements
        arr.sort()
  
        // Initialize result
        let ans = arr[n-1] - arr[0];
  
        // Handle corner elements
        let small = arr[0] + k;
        let big = arr[n-1] - k;
        let temp = 0;
          
        if (small > big)
        {
            temp = small;
            small = big;
            big = temp;
        }
  
        // Traverse middle elements
        for (let i = 1; i < n-1; i ++)
        {
            let subtract = arr[i] - k;
            let add = arr[i] + k;
  
            // If both subtraction and addition
            // do not change diff
            if (subtract >= small || add <= big)
                continue;
  
            // Either subtraction causes a smaller
            // number or addition causes a greater
            // number. Update small or big using
            // greedy approach (If big - subtract
            // causes smaller diff, update small
            // Else update big)
            if (big - subtract <= add - small)
                small = subtract;
            else
                big = add;
        }
  
        return Math.min(ans, big - small);
    }
     
    // Driver function to test the above function
    let arr=[4, 6];
    let n = arr.length;
    let k = 10;
    document.write("Maximum difference is "+
                            getMinDiff(arr, n, k));
     
    //  This code is contributed by avanitrachhadiya2155
     
</script>

Output :

Maximum difference is 2

Time Complexity: O(n Log n)
This article is contributed Shivam Agrawal. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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

Related Articles

C++

Java

Python3

C#

PHP

Javascript