K-diff Pairs in an Array - Practice Coding Problems

K-diff Pairs in an Array - Problem

You're given an array of integers nums and an integer k. Your task is to find the number of unique k-diff pairs in the array.

A k-diff pair is defined as a pair of integers (nums[i], nums[j]) where:

0 <= i, j < nums.length
i != j (different indices)
|nums[i] - nums[j]| == k (absolute difference equals k)

Important: We only count unique pairs - if the same pair of values appears multiple times in the array, it should only be counted once.

Example: In array [3, 1, 4, 1, 5] with k = 2, the pairs (1,3) and (3,5) both have an absolute difference of 2, so the answer is 2.

Input & Output

example_1.py — Basic case with positive k

$ Input: nums = [3,1,4,1,5], k = 2

› Output: 2

💡 Note: There are two 2-diff pairs: (1,3) and (3,5). Note that we count unique pairs, so even though 1 appears twice, we only count the pair (1,3) once.

example_2.py — Case with duplicates and k=0

$ Input: nums = [1,2,3,4,5], k = 1

› Output: 4

💡 Note: There are four 1-diff pairs: (1,2), (2,3), (3,4), and (4,5). Each consecutive pair has a difference of 1.

example_3.py — Edge case with k=0

$ Input: nums = [1,3,1,5,4], k = 0

› Output: 1

💡 Note: When k=0, we're looking for pairs with the same value. Only the number 1 appears more than once, so there's exactly 1 unique pair: (1,1).

Time & Space Complexity

Time Complexity

⏱️

O(n)

One pass to build frequency map O(n) + one pass through unique elements O(n)

✓ Linear Growth

Space Complexity

O(n)

Hash table to store frequency of all unique elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁷ ≤ nums[i] ≤ 10⁷
0 ≤ k ≤ 10⁷
Follow-up: Can you solve this in O(n) time complexity?

Asked in

The optimal solution uses a hash table to count element frequencies in O(n) time. For each unique element x, we check if x+k exists (or if x appears multiple times when k=0). This approach is more efficient than sorting-based solutions and handles all edge cases elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n log n)	O(1)	Sort array, then binary search for complement of each element
Brute Force (Nested Loops)	O(n²)	O(min(n², number of unique pairs))	Check every pair of elements to find valid k-diff pairs
Hash Table (Optimal)	O(n)	O(n)	Use hash map to count frequencies and find complement pairs efficiently
Two Pointers (Sorted Array)	O(n log n)	O(1)	Sort array and use two pointers to find pairs with difference k

Sorting + Binary Search — Algorithm Steps

Sort the array to enable binary search
Remove duplicates to get unique elements
For each unique element x:
Use binary search to find x+k in the sorted array
If found, increment the result counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort array and remove duplicates

For Each Element

Consider each unique element as potential pair start

Binary Search

Search for element + k using binary search

Count Valid Pairs

Count all successful searches

Code -

solution.c — C

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

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

int binarySearch(int* arr, int size, int target, int startIdx) {
    int left = startIdx, right = size - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
            return 1;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return 0;
}

int findPairs(int* nums, int numsSize, int k) {
    if (k < 0) return 0;
    
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Create unique array
    int uniqueNums[numsSize];
    int uniqueSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (i == 0 || nums[i] != nums[i - 1]) {
            uniqueNums[uniqueSize++] = nums[i];
        }
    }
    
    int result = 0;
    
    for (int i = 0; i < uniqueSize; i++) {
        int target = uniqueNums[i] + k;
        if (binarySearch(uniqueNums, uniqueSize, target, i + 1)) {
            result++;
        }
    }
    
    // Special case for k=0
    if (k == 0) {
        result = 0;
        int i = 0;
        while (i < numsSize) {
            int count = 1;
            while (i + count < numsSize && nums[i + count] == nums[i]) {
                count++;
            }
            if (count > 1) {
                result++;
            }
            i += count;
        }
    }
    
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then n binary searches each taking O(log n)

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space (excluding space for sorting)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁷ ≤ nums[i] ≤ 10⁷
0 ≤ k ≤ 10⁷
Follow-up: Can you solve this in O(n) time complexity?

25.0K Views

Medium Frequency

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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler