Minimum Difference Between Largest and Smallest Value in Three Moves

Minimum Difference Between Largest and Smallest Value in Three Moves - Problem

You're given an integer array nums and have the power to transform it strategically. In each move, you can change any element to any value you want - there are no restrictions!

Your mission is to minimize the difference between the largest and smallest values in the array after making at most 3 moves.

Key insight: Since you can change elements to any value, the optimal strategy is to either remove the largest elements or the smallest elements (or a combination) to minimize the range.

Input: An integer array nums
Output: The minimum possible difference between max and min values after at most 3 moves

Example: For [5,3,2,4], you can change 5 to 3, making the array [3,3,2,4]. The difference becomes 4-2=2.

Input & Output

example_1.py — Basic Case

$ Input: [5, 3, 2, 4]

› Output: 0

💡 Note: We can change one element to 3, making the array [3,3,2,4] with difference 2. But optimally, we can make all elements equal: [3,3,3,3] using 3 moves, resulting in difference 0.

example_2.py — Large Range

$ Input: [1, 5, 0, 10, 14]

› Output: 1

💡 Note: After sorting: [0,1,5,10,14]. We can remove the 3 largest elements (5,10,14) leaving [0,1] with difference 1. Or remove 2 largest + 1 smallest leaving [1,5] with difference 4. The minimum is 1.

example_3.py — Small Array Edge Case

$ Input: [3, 100, 20]

› Output: 0

💡 Note: With only 3 elements, we can change all of them in 3 moves to make them equal, resulting in difference 0.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
You have exactly 3 moves maximum
Each move allows changing any element to any value

Visualization

Tap to expand

Understanding the Visualization

Survey the Range

Sort the mountains by height to identify the extreme peaks

Strategic Planning

Consider 4 strategies: level 3 tallest, 3 shortest, or mixed approaches

Execute Optimal Plan

Choose the strategy that results in the smallest height difference

Measure Success

Calculate the final range after leveling

Key Takeaway

🎯 Key Insight: Focus on extreme values! Since we can set any height, we only need to consider removing the tallest or shortest peaks to minimize the range efficiently.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy strategy after sorting: since we can change any element to any value, we should focus on removing extreme values that contribute to the largest differences. There are only 4 strategic scenarios to consider: remove 3 largest, 2 largest + 1 smallest, 1 largest + 2 smallest, or 3 smallest elements. Time complexity: O(n log n) for sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n³ × k³)	O(1)	Try every possible combination of 3 elements to change with all possible values
Greedy with Sorting (Optimal)	O(n log n)	O(1)	Sort array and try 4 strategic scenarios: remove 0-3 largest or 0-3 smallest elements

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of 3 positions from the array
For each combination, try different values for those positions
Calculate min-max difference for each scenario
Return the minimum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Select 3 Positions

Choose 3 positions from the array to modify

Try All Values

For each combination, try different values

Calculate Difference

Compute max - min for each scenario

Track Minimum

Keep track of the smallest difference found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int minDifference(int* nums, int numsSize) {
    if (numsSize <= 4) return 0;
    
    int minDiff = INT_MAX;
    
    // Try all combinations of 3 positions (simplified approach)
    for (int i = 0; i < numsSize - 2; i++) {
        for (int j = i + 1; j < numsSize - 1; j++) {
            for (int k = j + 1; k < numsSize; k++) {
                // Try setting these positions to min/max values
                int* temp = malloc(numsSize * sizeof(int));
                memcpy(temp, nums, numsSize * sizeof(int));
                
                // Find current min and max
                int currentMin = nums[0], currentMax = nums[0];
                for (int l = 0; l < numsSize; l++) {
                    if (nums[l] < currentMin) currentMin = nums[l];
                    if (nums[l] > currentMax) currentMax = nums[l];
                }
                
                // Try setting to min value
                temp[i] = temp[j] = temp[k] = currentMin;
                
                int min = temp[0], max = temp[0];
                for (int l = 0; l < numsSize; l++) {
                    if (temp[l] < min) min = temp[l];
                    if (temp[l] > max) max = temp[l];
                }
                
                if (max - min < minDiff) {
                    minDiff = max - min;
                }
                
                free(temp);
            }
        }
    }
    
    return minDiff;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int sign = 1;
    int readingNum = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            readingNum = 1;
        } else if (c == '-') {
            sign = -1;
            readingNum = 1;
        } else if ((c == ',' || c == ']') && readingNum) {
            nums[size++] = num * sign;
            num = 0;
            sign = 1;
            readingNum = 0;
        }
    }
    
    printf("%d\n", minDifference(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × k³)

C(n,3) combinations × trying different values for each position

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

41.2K Views

Medium-High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler