Minimum Difference Between Highest and Lowest of K Scores solution and explanation

def min_difference(nums, k):
    nums.sort()
    return min(nums[i + k - 1] - nums[i] for i in range(len(nums) - k + 1))

nums = [9, 4, 1, 7]
k = 2
print(min_difference(nums, k))

import java.util.Arrays;

public class Solution {
    public int minDifference(int[] nums, int k) {
        Arrays.sort(nums);
        int minDiff = Integer.MAX_VALUE;
        for (int i = 0; i <= nums.length - k; i++) {
            minDiff = Math.min(minDiff, nums[i + k - 1] - nums[i]);
        }
        return minDiff;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] nums = {9, 4, 1, 7};
        int k = 2;
        System.out.println(sol.minDifference(nums, k));
    }
}

#include <iostream>
#include <vector>
#include <algorithm>

int minDifference(std::vector<int>& nums, int k) {
    if (k == 1) return 0;
    std::sort(nums.begin(), nums.end());
    int minDiff = INT_MAX;
    for (int i = 0; i <= nums.size() - k; i++) {
        minDiff = std::min(minDiff, nums[i + k - 1] - nums[i]);
    }
    return minDiff;
}

int main() {
    std::vector<int> nums = {9, 4, 1, 7};
    int k = 2;
    std::cout << minDifference(nums, k) << std::endl;
    return 0;
}

function minDifference(nums, k) {
    nums.sort((a, b) => a - b);
    let minDiff = Infinity;
    for (let i = 0; i <= nums.length - k; i++) {
        minDiff = Math.min(minDiff, nums[i + k - 1] - nums[i]);
    }
    return minDiff;
}

const nums = [9, 4, 1, 7];
const k = 2;
console.log(minDifference(nums, k));

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

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

int minDifference(int* nums, int numsSize, int k) {
    qsort(nums, numsSize, sizeof(int), compare);
    int minDiff = 1000000;
    for (int i = 0; i <= numsSize - k; i++) {
        int diff = nums[i + k - 1] - nums[i];
        if (diff < minDiff) {
            minDiff = diff;
        }
    }
    return minDiff;
}

int main() {
    int nums[] = {9, 4, 1, 7};
    int k = 2;
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", minDifference(nums, size, k));
    return 0;
}

using System;

public class Solution {
    public int MinDifference(int[] nums, int k) {
        Array.Sort(nums);
        int minDiff = int.MaxValue;
        for (int i = 0; i <= nums.Length - k; i++) {
            minDiff = Math.Min(minDiff, nums[i + k - 1] - nums[i]);
        }
        return minDiff;
    }

    public static void Main(string[] args) {
        Solution sol = new Solution();
        int[] nums = {9, 4, 1, 7};
        int k = 2;
        Console.WriteLine(sol.MinDifference(nums, k));
    }
}

def min_difference_dp(nums, k):
    max_value = max(nums)
    min_value = min(nums)
    freq = [0] * (max_value + 1)
    for num in nums:
        freq[num] += 1
    start, sum_k, min_diff = min_value, 0, float('inf')
    for end in range(min_value, max_value + 1):
        if freq[end] > 0:
            sum_k += freq[end]
            while sum_k >= k:
                min_diff = min(min_diff, end - start)
                sum_k -= freq[start]
                start += 1
    return min_diff

nums = [9, 4, 1, 7]
k = 2
print(min_difference_dp(nums, k))

function minimumDifference(nums: number[], k: number): number {
    nums.sort((a, b) => a - b);
    const n = nums.length;
    let ans = nums[n - 1] - nums[0];
    for (let i = 0; i + k - 1 < n; i++) {
        ans = Math.min(nums[i + k - 1] - nums[i], ans);
    }
    return ans;
}

func minimumDifference(nums []int, k int) int {
	sort.Ints(nums)
	ans := 100000
	for i := 0; i < len(nums)-k+1; i++ {
		ans = min(ans, nums[i+k-1]-nums[i])
	}
	return ans
}

impl Solution {
    pub fn minimum_difference(mut nums: Vec<i32>, k: i32) -> i32 {
        nums.sort();
        let k = k as usize;
        let mut res = i32::MAX;
        for i in 0..=nums.len() - k {
            res = res.min(nums[i + k - 1] - nums[i]);
        }
        res
    }
}

class Solution {
    /**
     * @param Integer[] $nums
     * @param Integer $k
     * @return Integer
     */
    function minimumDifference($nums, $k) {
        sort($nums);
        $ans = 10 ** 5;
        for ($i = 0; $i < count($nums) - $k + 1; $i++) {
            $ans = min($ans, $nums[$i + $k - 1] - $nums[$i]);
        }
        return $ans;
    }
}