Smallest Range I - Practice Coding Problems

Smallest Range I - Problem

Array Math Easy

You are given an integer array nums and an integer k. Your goal is to minimize the score of the array, where the score is defined as the difference between the maximum and minimum elements.

You can perform at most one operation on each element: change nums[i] to nums[i] + x, where x is any integer in the range [-k, k].

What's the strategy? To minimize the range, we want to bring all numbers as close together as possible. The optimal approach is to:

Increase smaller numbers (add up to +k)
Decrease larger numbers (add up to -k)
Move everything toward the middle of the original range

Return the minimum possible score after applying the operations optimally.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1], k = 0

› Output: 0

💡 Note: With only one element and k=0, we can't make any changes. The score is max - min = 1 - 1 = 0.

example_2.py — Can Eliminate Range

$ Input: nums = [0, 10], k = 2

› Output: 6

💡 Note: Original range is 10-0=10. We can increase 0 by 2 to get 2, and decrease 10 by 2 to get 8. New range is 8-2=6.

example_3.py — Ranges Overlap

$ Input: nums = [1, 3, 6], k = 3

› Output: 0

💡 Note: Min=1 can become 4 (add 3), Max=6 can become 3 (subtract 3). Since 4 > 3, we can make all values equal, so minimum score is 0.

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁴
0 ≤ k ≤ 10⁴
Follow-up: Can you solve this in O(n) time?

Visualization

Tap to expand

Understanding the Visualization

Find the Extremes

Locate the minimum and maximum values in the array - these define our current range

Apply Optimal Moves

Move the minimum value as far right as possible (+k) and maximum as far left as possible (-k)

Check for Overlap

If the adjusted ranges overlap (min+k ≥ max-k), all numbers can meet at the same point!

Calculate Result

If ranges overlap, return 0. Otherwise, return the remaining gap: (max-k) - (min+k)

Key Takeaway

🎯 Key Insight: This problem transforms from a complex optimization into simple arithmetic once we realize the optimal strategy is always to maximize adjustments toward the center!

Asked in

G Google 35 a Amazon 28 Apple 22 ⊞ Microsoft 18

The optimal solution uses mathematical insight to solve this in O(n) time. Key insight: to minimize the range, increase the minimum by k and decrease the maximum by k. The answer is max(0, max_val - min_val - 2k). If the original range is ≤ 2k, we can make all elements equal (score = 0)!

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O((2k+1)^n)	O(n)	Try every possible adjustment value for each element and find minimum range
Mathematical Insight (Optimal)	O(n)	O(1)	Use mathematical insight: answer is max(0, max_val - min_val - 2k)

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible combinations of adjustments for each element
For each combination, apply the adjustments to create a new array
Calculate the score (max - min) for each adjusted array
Return the minimum score found across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

For array [1,3,6] with k=3, we try all possible adjustments from -3 to +3 for each element

Calculate Each Score

For each combination like [1+3, 3+0, 6-3] = [4,3,3], calculate max-min = 4-3 = 1

Find Minimum

Compare all scores and return the minimum value found

Code -

solution.c — C

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

int findMax(int* arr, int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) max = arr[i];
    }
    return max;
}

int findMin(int* arr, int size) {
    int min = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) min = arr[i];
    }
    return min;
}

int backtrack(int index, int* currentNums, int size, int k) {
    if (index == size) {
        return findMax(currentNums, size) - findMin(currentNums, size);
    }
    
    int minScore = INT_MAX;
    int original = currentNums[index];
    
    for (int adjustment = -k; adjustment <= k; adjustment++) {
        currentNums[index] = original + adjustment;
        int score = backtrack(index + 1, currentNums, size, k);
        if (score < minScore) minScore = score;
    }
    
    currentNums[index] = original;
    return minScore;
}

int smallestRangeI(int* nums, int numsSize, int k) {
    int* copy = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        copy[i] = nums[i];
    }
    
    int result = backtrack(0, copy, numsSize, k);
    free(copy);
    return result;
}

int main() {
    int nums[1000], numsSize = 0, k;
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    printf("%d\n", smallestRangeI(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((2k+1)^n)

For each of n elements, we try 2k+1 possible adjustments, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

We need space to store the current combination and calculate scores

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~12 min Avg. Time

892 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