Minimum Difference Between Highest and Lowest of K Scores - Problem

You are given a 0-indexed integer array nums, where nums[i] represents the score of the ith student. You are also given an integer k.

Pick the scores of any k students from the array so that the difference between the highest and the lowest of the k scores is minimized.

Return the minimum possible difference.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: After sorting: [1,4,7,9]. Check windows: [1,4,7] has difference 7-1=6, [4,7,9] has difference 9-4=5. Minimum is 5.

Example 2 — All Elements

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

› Output: 0

💡 Note: When k=1, we select only one student, so the difference between highest and lowest is 0.

Example 3 — Large Range

$ Input: nums = [41,56,58,75,88], k = 3

› Output: 17

💡 Note: Already sorted. Windows: [41,56,58] diff=17, [56,58,75] diff=19, [58,75,88] diff=30. Minimum is 17.

Constraints

1 ≤ k ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 8 G Google 5

The key insight is that the optimal k students must be consecutive in a sorted array. After sorting, we use a sliding window of size k to find the minimum difference. Best approach is sliding window on sorted array. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(C(n,k) × k) Space: O(k)

For each possible combination of k students from the array, calculate the difference between the highest and lowest scores. Keep track of the minimum difference found across all combinations.

Optimized Sliding Window

⏱️ Time: O(n log n) Space: O(1)

This is the optimal solution. After sorting, we use a single sliding window of size k. Since the array is sorted, each window represents k consecutive elements, and the difference is simply the last minus first element in each window.

Sort First - Check All Windows

⏱️ Time: O(n log n + n) Space: O(1)

After sorting, we know that the minimum difference must come from k consecutive elements in the sorted array. We check all possible windows of size k and find the one with minimum difference.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible combinations of k students from n students
For each combination, find the maximum and minimum scores
Calculate the difference and update the global minimum
Return the minimum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible groups of k students

Calculate Differences

Find max-min for each group

Find Minimum

Return the smallest difference found

Code -

solution.c — C

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

int popcount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int solution(int* nums, int numsSize, int k) {
    int minDiff = INT_MAX;
    
    // Generate all combinations using bit manipulation
    for (int mask = 0; mask < (1 << numsSize); mask++) {
        if (popcount(mask) == k) {
            int maxScore = INT_MIN;
            int minScore = INT_MAX;
            
            for (int i = 0; i < numsSize; i++) {
                if (mask & (1 << i)) {
                    if (nums[i] > maxScore) maxScore = nums[i];
                    if (nums[i] < minScore) minScore = nums[i];
                }
            }
            
            int diff = maxScore - minScore;
            if (diff < minDiff) minDiff = diff;
        }
    }
    
    return minDiff;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) × k)

C(n,k) combinations, each taking O(k) time to find min/max

✓ Linear Growth

Space Complexity

O(k)

Space to store each combination of k elements

✓ Linear Space

23.4K Views

Medium Frequency

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

Minimum Difference Between Highest and Lowest of K Scores - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler