Smallest Range II - Practice Coding Problems

Smallest Range II - Problem

Imagine you have an array of numbers and you're given a magical power to transform each element! For every number in the array, you must choose to either add k or subtract k from it - no exceptions, no staying the same.

Your goal is to minimize the range (difference between maximum and minimum values) of the transformed array. This is like trying to bring all the numbers as close together as possible after applying your transformations.

Example: If you have [1, 3, 6] and k = 3, you could transform it to [4, 0, 9] (adding 3, subtracting 3, adding 3) giving a range of 9, or [4, 6, 3] (adding 3, adding 3, subtracting 3) giving a range of 3. The second choice is better!

Input: An integer array nums and an integer k
Output: The minimum possible range after transforming all elements

Input & Output

example_1.py — Basic Case

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

› Output: 0

💡 Note: Single element array always has range 0, regardless of operations

example_2.py — Simple Transformation

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

› Output: 6

💡 Note: We can transform to [2, 8] (both +2) giving range 6, which is better than [2, 12] or [-2, 8]

example_3.py — Multiple Elements

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

› Output: 3

💡 Note: Transform to [4, 6, 3] by doing +3, +3, -3. This gives range 6-3=3, which is optimal

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁴
0 ≤ k ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

We have people of different heights who must either stand on platform (+k) or crouch (-k)

Sort by Height

Arrange people from shortest to tallest

Try Split Points

Test each boundary where people to the left stand up, people to the right crouch down

Find Minimum Range

Choose the split that minimizes height difference between tallest and shortest

Key Takeaway

🎯 Key Insight: Sorting enables us to efficiently find the optimal split point where elements are divided into two groups with opposite operations, minimizing the overall range.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses sorting + split point technique in O(n log n) time. After sorting, we try each possible split point where elements before get +k and elements after get -k, finding the minimum range across all possibilities.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Two Pointers (Optimal)	O(n log n)	O(1)	Sort array and find optimal split point between +k and -k operations
Brute Force (Try All Combinations)	O(n * 2^n)	O(n)	Try every possible combination of +k and -k for each element

Sorting + Two Pointers (Optimal) — Algorithm Steps

Sort the array to organize elements by value
Try each possible split point from index 0 to n-1
For each split, calculate range when left side gets +k, right side gets -k
Also try the opposite: left side gets -k, right side gets +k
Return the minimum range found across all splits

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Arrange elements in ascending order

Try Split Points

Test each position as boundary between +k and -k operations

Calculate Range

For each split, find the resulting min and max values

Find Minimum

Return the split that gives the smallest range

Code -

solution.c — C

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

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

int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }

int smallestRangeII(int* nums, int numsSize, int k) {
    if (numsSize <= 1) return 0;
    
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Initial range if we do all +k or all -k
    int result = nums[numsSize - 1] - nums[0];
    
    // Try each possible split point
    for (int i = 0; i < numsSize - 1; i++) {
        // Left part: +k, Right part: -k
        int high = max(nums[i] + k, nums[numsSize - 1] - k);
        int low = min(nums[0] + k, nums[i + 1] - k);
        result = min(result, high - low);
    }
    
    return result;
}

int main() {
    int nums[] = {1, 3, 6};
    int k = 3;
    printf("%d\n", smallestRangeII(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting, then O(n) to try all split points

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

19.7K Views

Medium Frequency

~25 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

Sorting + Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler