Minimum Difference Between Highest and Lowest of K Scores

Minimum Difference Between Highest and Lowest of K Scores - Problem

Imagine you're a teacher selecting students for a special program based on their test scores. You have a list of student scores and need to choose exactly k students such that the performance gap between the highest and lowest scoring selected students is as small as possible.

Given a 0-indexed integer array nums where nums[i] represents the score of the i-th student, and an integer k, your task is to select any k students from the array to minimize the difference between the highest and lowest scores among your selected students.

Goal: Return the minimum possible difference between the highest and lowest scores when selecting exactly k students.

Example: If scores are [90, 30, 87, 50, 20] and k = 3, selecting students with scores [87, 90, 50] gives a difference of 90 - 50 = 40, but selecting [30, 20, 50] gives 50 - 20 = 30, which is better!

Input & Output

example_1.py — Basic Case

$ Input: nums = [90,30,87,50,20], k = 3

› Output: 30

💡 Note: We can select scores [30,50,20] which gives us a difference of 50-20=30. This is optimal because after sorting [20,30,50,87,90], the minimum range window of size 3 is [20,30,50].

example_2.py — Small Array

$ Input: nums = [9,4,1,7], k = 2

› Output: 2

💡 Note: After sorting: [1,4,7,9]. We can pick [7,9] with difference 9-7=2, or [1,4] with difference 4-1=3, or [4,7] with difference 7-4=3. The minimum is 2.

example_3.py — Edge Case k=1

$ Input: nums = [87,30,12,99], k = 1

› Output: 0

💡 Note: When k=1, we only select one student, so the difference between highest and lowest is always 0 (they are the same element).

Constraints

1 ≤ k ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 10⁵
k represents the exact number of students to select

Visualization

Tap to expand

Understanding the Visualization

Line Up Players

Arrange all players by their skill rating from lowest to highest

Selection Window

Consider groups of k consecutive players in the lineup

Calculate Team Balance

For each group, check the skill gap between the best and worst player

Find Optimal Team

The group with the smallest skill gap is your most balanced team

Key Takeaway

🎯 Key Insight: Just like selecting consecutive players from a skill-sorted lineup minimizes team imbalance, selecting consecutive elements from a sorted array minimizes the range between max and min values!

Asked in

a Amazon 15 G Google 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses sorting + sliding window technique. After sorting the array, we slide a window of size k across it. The key insight is that to minimize the range (max - min), we should always select consecutive elements from the sorted array. This gives us O(n log n) time complexity, which is much better than the brute force O(2^n) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Sliding Window (Optimal)	O(n log n)	O(1)	Sort array and slide a window of size k to find minimum range
Brute Force (Try All Combinations)	O(C(n,k) * k)	O(k)	Generate all possible combinations of k students and find the minimum difference

Sorting + Sliding Window (Optimal) — Algorithm Steps

Sort the input array in ascending order
Initialize a sliding window of size k starting from index 0
Calculate the difference between the last and first elements in the current window
Slide the window one position to the right and repeat
Return the minimum difference found across all windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort the scores to group similar values together

Place Window

Start with a window of size k at the beginning

Calculate Difference

Find difference between max and min in current window

Slide Window

Move window one position right and repeat

Track Minimum

Keep track of the smallest difference found

Code -

solution.c — C

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

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

int minimumDifference(int* nums, int numsSize, int k) {
    if (k == 1) return 0;
    
    // Sort the array to group similar scores together
    qsort(nums, numsSize, sizeof(int), compare);
    
    int minDiff = INT_MAX;
    
    // Slide a window of size k across the sorted array
    for (int i = 0; i <= numsSize - k; i++) {
        // Current window: nums[i] to nums[i + k - 1]
        int currentDiff = nums[i + k - 1] - nums[i];
        if (currentDiff < minDiff) {
            minDiff = currentDiff;
        }
    }
    
    return minDiff;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the array. The sliding window part is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables (assuming in-place sorting)

✓ Linear Space

18.5K Views

Medium Frequency

~12 min Avg. Time

850 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 + Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler