Open In App

Minimize the difference between minimum and maximum elements

Last Updated : 05 May, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given an array of N     integers and an integer k     . It is allowed to modify an element either by increasing or decreasing them by k (only once).
The task is to minimize and print the maximum difference between the shortest and longest towers.

Examples: 

Input: arr[] = {1, 10, 8, 5}, k = 2
Output : Max height difference = 5
Explanation:
modified arr[]={3, 8, 6, 7}
max difference: 5

Input: arr[] = {3, 16, 12, 9, 20}, k = 3
Output : Max height difference: 11

Approach: 

  1. Find the max and min elements present in the array.
  2. Check whether the difference between the max and min element is less than or equal to k or not: 
    • If yes, then return the difference between the max and min element.
    • otherwise, go to step 3.
  3. Calculate the average of the max and min elements of the array.
  4. Traverse the array and do the following operations: 
    • If the array element is greater than the average then decrease it by k.
    • If the array element is smaller than the average then increase it by k.
  5. Return the difference between the max and min elements of the modified array.

Below is the implementation of above approach: 

C++ 
// C++ program to minimize the difference between
// minimum and maximum elements

#include <bits/stdc++.h>
using namespace std;

// Function to minimize the difference between
// minimum and maximum elements
int minimizeDiff(int* arr, int n, int k)
{
    // Find max and min elements of the array
    int max = *(max_element(arr, arr + n));
    int min = *(min_element(arr, arr + n));

    // Check whether the difference between
    // the max and min element is less than
    // or equal to k or not
    if ((max - min) <= k) {
        return (max - min);
    }

    // Calculate average of max and min
    int avg = (max + min) / 2;

    for (int i = 0; i < n; i++) {
        // If the array element is greater than the
        // average then decrease it by k
        if (arr[i] > avg)
            arr[i] -= k;
        // If the array element is smaller than the
        // average then increase it by k
        else
            arr[i] += k;
    }

    // Find max and min of the modified array
    max = *(max_element(arr, arr + n));
    min = *(min_element(arr, arr + n));

    // return the new difference
    return (max - min);
}

// Driver code
int main()
{
    int arr[] = { 3, 16, 12, 9, 20 };
    int n = 5;
    int k = 3;

    cout << "Max height difference = "
         << minimizeDiff(arr, n, k) << endl;

    return 0;
}
Java 
// Java program to minimize the difference between 
// minimum and maximum elements 
import java.util.*;

class GFG 
{

    // Function to minimize the difference between 
    // minimum and maximum elements 
    static int minimizeDiff(int[] arr, int n, int k)
    {
        // Find max and min elements of the array 
        int max = Arrays.stream(arr).max().getAsInt();
        int min = Arrays.stream(arr).min().getAsInt();

        // Check whether the difference between 
        // the max and min element is less than 
        // or equal to k or not 
        if ((max - min) <= k)
        {
            return (max - min);
        }

        // Calculate average of max and min 
        int avg = (max + min) / 2;

        for (int i = 0; i < n; i++) 
        {
            // If the array element is greater than the 
            // average then decrease it by k 
            if (arr[i] > avg) 
            {
                arr[i] -= k;
            } 
            
            // If the array element is smaller than the 
            // average then increase it by k 
            else 
            {
                arr[i] += k;
            }
        }

        // Find max and min of the modified array 
        max = Arrays.stream(arr).max().getAsInt();
        min = Arrays.stream(arr).min().getAsInt();

        // return the new difference 
        return (max - min);
    }

    // Driver code
    public static void main(String[] args) 
    {
        int arr[] = {3, 16, 12, 9, 20};
        int n = 5;
        int k = 3;

        System.out.println("Max height difference = "
                + minimizeDiff(arr, n, k));
    }
}

// This code has been contributed by 29AjayKumar
Python3 
# Python 3 program to minimize the 
# difference between minimum and
# maximum elements 

# Function to minimize the difference 
# between minimum and maximum elements 
def minimizeDiff(arr, n, k) :

    # Find max and min elements 
    # of the array 
    max_element = max(arr)
    min_element = min(arr)

    # Check whether the difference between 
    # the max and min element is less than 
    # or equal to k or not 
    if ((max_element - min_element) <= k) : 
        return (max_element - min_element) 
    
    # Calculate average of max and min 
    avg = (max_element + min_element) // 2

    for i in range(n): 
        
        # If the array element is greater than 
        # the average then decrease it by k 
        if (arr[i] > avg) :
            arr[i] -= k 
            
        # If the array element is smaller than  
        # the average then increase it by k 
        else :
            arr[i] += k 

    # Find max and min of the 
    # modified array 
    max_element = max(arr) 
    min_element = min(arr) 

    # return the new difference 
    return (max_element - min_element); 

# Driver code 
if __name__ == "__main__" :
    
    arr = [ 3, 16, 12, 9, 20 ]
    n = 5
    k = 3
    
    print("Max height difference =", 
            minimizeDiff(arr, n, k))

# This code is contributed by Ryuga
C# 
// C# program to minimize the difference between 
// minimum and maximum elements 
using System;
using System.Linq;

class GFG 
{

    // Function to minimize the difference between 
    // minimum and maximum elements 
    static int minimizeDiff(int[] arr, int n, int k)
    {
        // Find max and min elements of the array 
        int max = arr.Max();
        int min = arr.Min();

        // Check whether the difference between 
        // the max and min element is less than 
        // or equal to k or not 
        if ((max - min) <= k)
        {
            return (max - min);
        }

        // Calculate average of max and min 
        int avg = (max + min) / 2;

        for (int i = 0; i < n; i++) 
        {
            // If the array element is greater than the 
            // average then decrease it by k 
            if (arr[i] > avg) 
            {
                arr[i] -= k;
            } 
            
            // If the array element is smaller than the 
            // average then increase it by k 
            else
            {
                arr[i] += k;
            }
        }

        // Find max and min of the modified array 
        max = arr.Max();
        min = arr.Min();

        // return the new difference 
        return (max - min);
    }

    // Driver code
    public static void Main() 
    {
        int []arr = {3, 16, 12, 9, 20};
        int n = 5;
        int k = 3;

        Console.WriteLine("Max height difference = "
                + minimizeDiff(arr, n, k));
    }
}

/* This code contributed by PrinciRaj1992 */
JavaScript 
<script>

// Javascript program to minimize
// the difference between 
// minimum and maximum elements 
    
    // Function to minimize the difference between 
    // minimum and maximum elements 
    function minimizeDiff(arr,n,k)
    {
        // Find max and min elements of the array 
        let max = Math.max(...arr);
        let min = Math.min(...arr);
  
        // Check whether the difference between 
        // the max and min element is less than 
        // or equal to k or not 
        if ((max - min) <= k)
        {
            return (max - min);
        }
  
        // Calculate average of max and min 
           let avg = Math.floor((max + min) / 2);
  
        for (let i = 0; i < n; i++) 
        {
            // If the array element is greater than the 
            // average then decrease it by k 
            if (arr[i] > avg) 
            {
                arr[i] -= k;
            } 
              
            // If the array element is smaller than the 
            // average then increase it by k 
            else 
            {
                arr[i] += k;
            }
        }
  
        // Find max and min of the modified array 
       max = Math.max(...arr);
        min = Math.min(...arr);
  
        // return the new difference 
        return (max - min);
    }
    
    // Driver code
    let arr=[3, 16, 12, 9, 20];
    let n = 5;
    let k = 3;
    document.write("Max height difference = "
                + minimizeDiff(arr, n, k));
    
    
    
// This code is contributed by avanitrachhadiya2155

</script>
PHP 
<?php 
// PHP program to minimize the difference 
// between minimum and maximum elements

// Function to minimize the difference 
// between minimum and maximum elements
function minimizeDiff(&$arr, $n, $k)
{
    // Find max and min elements 
    // of the array
    $max = max($arr);
    $min = min($arr);

    // Check whether the difference between
    // the max and min element is less than
    // or equal to k or not
    if (($max - $min) <= $k)
    {
        return ($max - $min);
    }

    // Calculate average of max and min
    $avg = ($max + $min) / 2;

    for ($i = 0; $i < $n; $i++) 
    {
        // If the array element is greater than 
        // the average then decrease it by k
        if ($arr[$i] > $avg)
            $arr[$i] -= $k;
            
        // If the array element is smaller than 
        // the average then increase it by k
        else
            $arr[$i] += $k;
    }

    // Find max and min of the 
    // modified array
    $max = max($arr);
    $min = min($arr);

    // return the new difference
    return ($max - $min);
}

// Driver code
$arr = array( 3, 16, 12, 9, 20 );
$n = 5;
$k = 3;

echo "Max height difference = " . 
      minimizeDiff($arr, $n, $k). "\n";

// This code is contributed by ita_c
?>

Output
Max height difference = 11

Time Complexity: O( N )

Space Complexity: O( 1 )


Next Article
Analysis of Algorithms

D
Dhirendra121
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox