# Minimize the maximum difference between the heights

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 5.
Explanation : We change 1 to 6, 15 to
9 and 10 to 4. Maximum difference is 5
(between 4 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}
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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 ` `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; ` ` `  `    ``// Handle corner elements ` `    ``int` `small = arr + 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); ` `    ``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; ` ` `  `    ``// Handle corner elements ` `    ``int` `small = arr + 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

 ` ``\$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 ` `?> `

Output :

```Maximum difference is 2
```

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

Improved By : chitranayal, ihritik

Article Tags :
Practice Tags :

95

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