Count Number of Pairs With Absolute Difference K

Count Number of Pairs With Absolute Difference K - Problem

You're given an integer array nums and an integer k. Your task is to find how many pairs of indices (i, j) exist where i < j and the absolute difference between nums[i] and nums[j] equals exactly k.

The absolute difference |nums[i] - nums[j]| means:

If nums[i] >= nums[j], then |nums[i] - nums[j]| = nums[i] - nums[j]
If nums[i] < nums[j], then |nums[i] - nums[j]| = nums[j] - nums[i]

Example: Given nums = [1, 2, 2, 1] and k = 1, the pairs (0,1), (0,2), (1,3), and (2,3) all have absolute difference of 1, so the answer is 4.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: The pairs with absolute difference 1 are: (0,1): |1-2|=1, (0,2): |1-2|=1, (1,3): |2-1|=1, (2,3): |2-1|=1. Total: 4 pairs.

example_2.py — No Valid Pairs

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

› Output: 0

💡 Note: There's only one pair (0,1) and |1-3|=2, which is not equal to k=3. So the answer is 0.

example_3.py — All Same Elements

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

› Output: 4

💡 Note: The pairs with absolute difference 2 are: (0,1): |3-1|=2, (0,4): |3-1|=2, (2,5): |1-3|=2, (3,4): |5-3|=2. Wait, let me recalculate: (0,2): |3-1|=2, (0,4): |3-1|=2, (1,5): |2-4|=2, (2,5): |1-3|=2. Actually: (2,5): |1-3|=2, (0,2): |3-1|=2, (0,4): |3-1|=2, (1,5): |2-4|=2. Total: 4 pairs.

Visualization

Tap to expand

Understanding the Visualization

Meet Each Person

As each person arrives, check if any previous arrivals could be their dance partner

Check Height Difference

Look for people who are exactly k inches taller or shorter

Count Matches

Add the number of compatible partners to our running total

Record Arrival

Add the current person to our list for future matching

Key Takeaway

🎯 Key Insight: By checking for compatible partners as each person arrives (rather than comparing everyone with everyone), we achieve optimal O(n) performance while naturally maintaining the ordering constraint.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each hash table operation is O(1) average case

✓ Linear Growth

Space Complexity

O(n)

Hash table can store up to n unique elements in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ 100
0 ≤ k ≤ 99

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a one-pass hash table approach. For each element, we check if elements with values (current ± k) exist in our hash table, count those pairs, then add the current element to the hash table. This achieves O(n) time complexity with O(n) space, efficiently handling duplicates while ensuring we only count valid pairs where the first index is less than the second.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	Build complete frequency map first, then count all valid pairs
One-Pass Hash Table (Optimal)	O(n)	O(n)	Build frequency map while checking for complements in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair (i,j) where i < j and count those with absolute difference k

Two-Pass Hash Table — Algorithm Steps

First pass: Build frequency map of all elements
Initialize counter to 0
Second pass: For each unique element x in the map:
If x+k exists in the map, add freq[x] * freq[x+k] to counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Frequency Map

Count occurrences of each element

Find Complements

For each unique element x, check if x+k exists

Multiply Frequencies

Multiply freq[x] * freq[x+k] to get pair count

Sum All Pairs

Add up all valid pair combinations

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

int get(Node** table, int key) {
    int idx = hash(key);
    Node* curr = table[idx];
    while (curr) {
        if (curr->key == key) return curr->value;
        curr = curr->next;
    }
    return 0;
}

void put(Node** table, int key, int value) {
    int idx = hash(key);
    Node* curr = table[idx];
    while (curr) {
        if (curr->key == key) {
            curr->value = value;
            return;
        }
        curr = curr->next;
    }
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = table[idx];
    table[idx] = newNode;
}

int countKDifference(int* nums, int numsSize, int k) {
    Node* freq[HASH_SIZE] = {NULL};
    
    // First pass: build frequency map
    for (int i = 0; i < numsSize; i++) {
        put(freq, nums[i], get(freq, nums[i]) + 1);
    }
    
    int count = 0;
    // Second pass: count pairs using original array
    for (int i = 0; i < numsSize; i++) {
        int targetFreq = get(freq, nums[i] + k);
        if (targetFreq > 0) {
            count += targetFreq;
        }
    }
    
    return count / 2; // Each pair counted twice
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build frequency map + O(unique elements) to count pairs

✓ Linear Growth

Space Complexity

O(n)

Frequency map stores at most n unique elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ 100
0 ≤ k ≤ 99

42.4K Views

Medium Frequency

~12 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler