Contains Duplicate II - Practice Coding Problems

Contains Duplicate II - Problem

You are given an integer array nums and a distance threshold k. Your task is to determine if there are any duplicate elements within a specific range.

More specifically, return true if there exist two distinct indices i and j in the array such that:

nums[i] == nums[j] (the elements are equal)
abs(i - j) <= k (the indices are at most k positions apart)

Otherwise, return false.

Example: In array [1,2,3,1] with k=3, we find that nums[0] = nums[3] = 1 and abs(0-3) = 3 <= 3, so we return true.

Input & Output

example_1.py — Basic Case

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

› Output: true

💡 Note: The value 1 appears at indices 0 and 3. The distance between these indices is |3-0| = 3, which is exactly equal to k=3, so we return true.

example_2.py — No Valid Duplicates

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

› Output: true

💡 Note: The value 1 appears at indices 0, 2, and 3. The distance between indices 2 and 3 is |3-2| = 1, which equals k=1, so we return true.

example_3.py — Distance Too Large

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

› Output: false

💡 Note: Although there are duplicates (1 appears at indices 0,3 and 2 appears at indices 1,4), all duplicate pairs have distances greater than k=2, so we return false.

Visualization

Tap to expand

Understanding the Visualization

Book Registry

Keep a record of when each book was last checked out (hash map)

New Checkout

When someone wants to check out a book, look up the last checkout date

Time Check

If the same book was checked out within k days, flag it as a violation

Update Record

Update the registry with the new checkout date

Key Takeaway

🎯 Key Insight: We only need to remember the most recent occurrence of each element, not all historical positions. This reduces both time and space complexity significantly!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, hash map operations are O(1) average case

✓ Linear Growth

Space Complexity

O(min(n,k))

Hash map stores at most min(n,k) elements since we only need recent indices

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁵
Note: Two distinct indices means i ≠ j

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 Apple 28 f Meta 25

The optimal solution uses a one-pass hash table approach with O(n) time complexity. As we iterate through the array, we maintain a hash map that stores the most recent index of each element. For each element, we check if it was seen before within distance k. This eliminates the need for nested loops and provides an efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(min(n,k))	Track most recent index of each element and check distance on the fly
Brute Force (Nested Loops)	O(n*k)	O(1)	Check every pair of elements to find duplicates within distance k

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize an empty hash map to store element -> most recent index
Iterate through the array with current index i
For each element, check if it exists in hash map
If exists and current_index - stored_index <= k, return true
Update hash map with current element and index
If loop completes without finding duplicates, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Process nums[0]=1

Add 1->0 to hash map

Process nums[1]=2

Add 2->1 to hash map

Process nums[2]=3

Add 3->2 to hash map

Process nums[3]=1

Found 1 in map at index 0, distance = 3-0 = 3 ≤ k

Code -

solution.c — C

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

#define HASH_SIZE 10007

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

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

void insert(HashNode** table, int key, int value) {
    int index = hash(key);
    HashNode* node = table[index];
    
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = table[index];
    table[index] = newNode;
}

int find(HashNode** table, int key) {
    int index = hash(key);
    HashNode* node = table[index];
    
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return -1;
}

bool containsNearbyDuplicate(int* nums, int numsSize, int k) {
    HashNode* table[HASH_SIZE] = {NULL};
    
    for (int i = 0; i < numsSize; i++) {
        int lastIndex = find(table, nums[i]);
        if (lastIndex != -1 && i - lastIndex <= k) {
            return true;
        }
        insert(table, nums[i], i);
    }
    
    return false;
}

int main() {
    int nums[] = {1, 2, 3, 1};
    int k = 3;
    printf("%s\n", containsNearbyDuplicate(nums, 4, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, hash map operations are O(1) average case

✓ Linear Growth

Space Complexity

O(min(n,k))

Hash map stores at most min(n,k) elements since we only need recent indices

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁵
Note: Two distinct indices means i ≠ j

58.5K Views

High Frequency

~15 min Avg. Time

2.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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler