Codestin Search App

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.

Constraints

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

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.

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
✓ 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
Bucket Sort Approach (Optimal)	O(n)	O(min(n, indexDiff))	Use bucket sort concept with sliding window to achieve O(n) time complexity
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of indices to see if they satisfy both distance and value constraints

Sliding Window with Ordered Set — Algorithm Steps

Initialize an ordered set to store values in the current window
Iterate through the array with index i
If window size exceeds indexDiff, remove the leftmost element
For current element nums[i], search for values in range [nums[i]-valueDiff, nums[i]+valueDiff]
Use binary search (lower_bound) to find the smallest value >= nums[i]-valueDiff
Check if this value is <= nums[i]+valueDiff
If such value exists, return true
Add current element to the ordered set and continue
Return false if no valid pair found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize sliding window

Create ordered set to maintain sorted values

Process each element

Add current element and search for nearby values

Binary search range

Use lower_bound to find values in [num-diff, num+diff]

Slide window

Remove elements outside indexDiff range

Code -

solution.c — C

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

// Simple implementation using array as sliding window
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;
    int indexDiff = 3, valueDiff = 0;
    printf("%s\n", containsNearbyAlmostDuplicate(nums, numsSize, indexDiff, valueDiff) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

For each of n elements, we perform set operations (insert/delete/search) which take O(log k) time, where k is the size of sliding window (at most indexDiff+1)

⚡ Linearithmic

Space Complexity

O(k)

The ordered set stores at most indexDiff+1 elements at any time

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window with Ordered Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler