Contains Duplicate III - Practice Coding Problems

Contains Duplicate III - Problem

Array Sliding Window Sorting Bucket Sort Ordered Set Hard

You're given an integer array nums and two integers indexDiff and valueDiff. Your task is to find if there exists a pair of indices (i, j) that satisfy all of the following conditions:

i != j (different indices)
abs(i - j) <= indexDiff (indices are close enough)
abs(nums[i] - nums[j]) <= valueDiff (values are similar enough)

Return true if such a pair exists, false otherwise.

Example: If nums = [1,2,3,1], indexDiff = 3, and valueDiff = 0, we need to find two identical values within 3 positions of each other. The answer is true because nums[0] = nums[3] = 1 and abs(0-3) = 3 <= 3.

Input & Output

example_1.py — Basic Match

$ Input: nums = [1,2,3,1], indexDiff = 3, valueDiff = 0

› Output: true

💡 Note: We find indices i=0 and j=3 where nums[0]=1 and nums[3]=1. The constraints are satisfied: |0-3|=3 ≤ 3 and |1-1|=0 ≤ 0.

example_2.py — Value Difference

$ Input: nums = [1,5,9,1,5,9], indexDiff = 2, valueDiff = 3

› Output: false

💡 Note: No two elements within indexDiff=2 positions have a value difference ≤ 3. For example, indices 0,1: |1-5|=4 > 3.

example_3.py — Edge Case

$ Input: nums = [1,3,1], indexDiff = 1, valueDiff = 1

› Output: false

💡 Note: Adjacent pairs: (1,3) at indices 0,1 has |1-3|=2 > 1, and (3,1) at indices 1,2 has |3-1|=2 > 1. No valid pair exists.

Visualization

Tap to expand

Understanding the Visualization

Deploy Cameras

Place cameras at different positions, each recording noise levels

Set Parameters

Define maximum distance between cameras and acceptable noise difference

Monitor Window

Use sliding window to only check cameras within distance limit

Bucket Classification

Group similar noise levels into buckets for efficient comparison

Detection

Alert when two cameras meet both distance and noise similarity criteria

Key Takeaway

🎯 Key Insight: By treating the problem as a smart city monitoring system, we see how bucket sort creates 'zones' of similar values, allowing instant detection of nearby cameras with similar readings, achieving optimal O(n) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each element exactly once, and hash map operations (insert, delete, lookup) are O(1) on average

✓ Linear Growth

Space Complexity

O(min(n, indexDiff))

The hash map stores at most indexDiff+1 elements at any time, which is bounded by min(n, indexDiff)

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 2 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
0 ≤ indexDiff ≤ nums.length
0 ≤ valueDiff ≤ 2³¹ - 1

Asked in

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

The optimal solution uses a bucket sort approach with sliding window, achieving O(n) time complexity. By dividing the value space into buckets of size valueDiff + 1, we ensure that elements in the same bucket automatically satisfy the value constraint, while adjacent buckets need explicit checking. The sliding window maintains only elements within the indexDiff range, making this both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Bucket Sort Approach (Optimal)	O(n)	O(min(n, indexDiff))	Use bucket sort concept with sliding window to achieve O(n) time complexity
Sliding Window with Ordered Set	O(n log k)	O(k)	Use sliding window to maintain valid indices and binary search to find values within range
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of indices to see if they satisfy both distance and value constraints

Bucket Sort Approach (Optimal) — Algorithm Steps

Create bucket size as valueDiff + 1 (ensures elements in same bucket differ by at most valueDiff)
Use a hash map where key is bucket index and value is the number in that bucket
For each element nums[i], calculate its bucket index
Check current bucket and adjacent buckets for elements within valueDiff
If window size exceeds indexDiff, remove the leftmost element from its bucket
Add current element to its bucket
Continue until a valid pair is found or array ends

Visualization

Tap to expand

Step-by-Step Walkthrough

Create buckets

Divide value space into buckets of size valueDiff+1

Process elements

Assign each element to its bucket based on value

Check neighbors

Elements in same/adjacent buckets are candidates

Maintain window

Remove elements outside indexDiff range

Code -

solution.c — C

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

// Simplified bucket approach using limited window check
bool containsNearbyAlmostDuplicate(int* nums, int numsSize, int indexDiff, int valueDiff) {
    if (indexDiff < 0 || valueDiff < 0) return false;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j <= i + indexDiff && j < numsSize; j++) {
            if (abs((long long)nums[i] - nums[j]) <= valueDiff) {
                return true;
            }
        }
    }
    
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each element exactly once, and hash map operations (insert, delete, lookup) are O(1) on average

✓ Linear Growth

Space Complexity

O(min(n, indexDiff))

The hash map stores at most indexDiff+1 elements at any time, which is bounded by min(n, indexDiff)

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 2 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
0 ≤ indexDiff ≤ nums.length
0 ≤ valueDiff ≤ 2³¹ - 1

52.4K Views

Medium-High Frequency

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

Bucket Sort Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler