Find K-th Smallest Pair Distance - Practice Coding Problems

Find K-th Smallest Pair Distance - Problem

Find K-th Smallest Pair Distance

Imagine you have an array of integers and need to find the k-th smallest distance between any two elements. The distance between two integers a and b is defined as the absolute difference |a - b|.

Given an integer array nums and an integer k, your task is to return the k-th smallest distance among all possible pairs nums[i] and nums[j] where 0 <= i < j < nums.length.

Example: If nums = [1, 3, 1] and k = 1, the pairs are (1,3), (1,1), and (3,1) with distances [2, 0, 2]. The 1st smallest distance is 0.

Input & Output

example_1.py — Basic case

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

› Output: 0

💡 Note: The pairs are (1,3), (1,1), and (3,1) with distances [2, 0, 2]. The 1st smallest distance is 0.

example_2.py — Multiple same distances

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

› Output: 0

💡 Note: All pairs have distance 0: (1,1), (1,1), (1,1). The 2nd smallest distance is still 0.

example_3.py — Larger array

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

› Output: 5

💡 Note: The pairs are (1,6), (1,1), (6,1) with distances [5, 0, 5]. The 3rd smallest distance is 5.

Constraints

n == nums.length
2 ≤ n ≤ 10⁴
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ n*(n-1)/2
All pairs (i,j) must satisfy i < j

Visualization

Tap to expand

Understanding the Visualization

Sort Contestants

Line up contestants by their skill level to enable efficient comparisons

Smart Estimation

Instead of calculating all scores, estimate 'how many pairs score better than X'

Binary Search

Use binary search to find the exact k-th best score

Sliding Window Count

For each candidate score, use sliding window to count qualifying pairs efficiently

Key Takeaway

🎯 Key Insight: Instead of generating all pair distances, we can binary search on the answer and count pairs efficiently using a sliding window on the sorted array.

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 24

The optimal solution uses binary search on the answer space combined with a sliding window technique. After sorting the array, we binary search on possible distance values and efficiently count pairs with distance ≤ mid using a sliding window. This achieves O(n log n + n log(max-min)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Pairs)	O(n² log n)	O(n²)	Generate all pair distances, sort them, and return the k-th element
Binary Search + Sliding Window (Optimal)	O(n log n + n log(max-min))	O(1)	Binary search on answer space with sliding window to count pairs

Brute Force (Generate All Pairs) — Algorithm Steps

Create an empty list to store all pair distances
For each pair (i,j) where i < j, calculate |nums[i] - nums[j]|
Add each distance to the list
Sort the list of distances
Return the k-th element (index k-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Pairs

Create all possible pairs (i,j) where i < j

Calculate Distances

For each pair, calculate |nums[i] - nums[j]|

Sort Distances

Sort all distances in ascending order

Return K-th

Return the element at index k-1

Code -

solution.c — C

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

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int smallestDistancePair(int* nums, int numsSize, int k) {
    int* distances = malloc(numsSize * numsSize * sizeof(int));
    int count = 0;
    
    // Generate all pair distances
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            distances[count++] = abs_val(nums[i] - nums[j]);
        }
    }
    
    // Sort and return k-th smallest
    qsort(distances, count, sizeof(int), compare);
    int result = distances[k - 1];
    free(distances);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n²) to generate all pairs + O(n² log n²) to sort all distances

⚠ Quadratic Growth

Space Complexity

O(n²)

Need to store all n*(n-1)/2 pair distances

⚠ Quadratic Space

42.0K Views

Medium Frequency

~25 min Avg. Time

1.2K 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 (Generate All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler