Contains Duplicate III

Contains Duplicate III - Problem

Array Sliding Window Sorting Bucket Sort Ordered Set Hard

You are given an integer array nums and two integers indexDiff and valueDiff.

Find a pair of indices (i, j) such that:

i != j
abs(i - j) <= indexDiff
abs(nums[i] - nums[j]) <= valueDiff

Return true if such pair exists or false otherwise.

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: Indices 1 and 2: abs(1-2) = 1 ≤ 3 and abs(3-4) = 1 ≤ 2, both conditions satisfied

Example 2 — No Valid Pair

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

› Output: false

💡 Note: No pair of indices satisfies both index difference and value difference constraints

Example 3 — Edge Case

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

› Output: false

💡 Note: abs(1-2) = 1 > 0, so no valid pair exists with valueDiff = 0

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is to use bucket sort to group values that are guaranteed to be within valueDiff range. The optimal bucket sort approach achieves O(n) time complexity by avoiding expensive range queries. Time: O(n), Space: O(min(n, indexDiff)).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

For each index i, check all indices j where abs(i-j) <= indexDiff and see if abs(nums[i]-nums[j]) <= valueDiff. This ensures we examine all possible pairs that satisfy the index difference constraint.

Bucket Sort Approach

⏱️ Time: O(n) Space: O(min(n, indexDiff))

Create buckets of size valueDiff+1. Values in the same bucket are guaranteed to have difference ≤ valueDiff. For each element, check its bucket and adjacent buckets within the sliding window.

Sliding Window with Set

⏱️ Time: O(n log k) Space: O(k)

Use a sliding window approach with a balanced binary search tree (or ordered set) to maintain elements within the current window. For each new element, check if there's any element in the set within valueDiff range.

Brute Force — Algorithm Steps

Iterate through each index i
For each i, check all j where abs(i-j) <= indexDiff
Return true if abs(nums[i]-nums[j]) <= valueDiff

Visualization

Tap to expand

Step-by-Step Walkthrough

Check pairs

For each index, check all indices within indexDiff

Compare values

Check if value difference <= valueDiff

Return result

Return true if any pair satisfies both conditions

Code -

solution.c — C

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

bool solution(int* nums, int numsSize, int indexDiff, int valueDiff) {
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < i + indexDiff + 1 && j < numsSize; j++) {
            if (abs(nums[i] - nums[j]) <= valueDiff) {
                return true;
            }
        }
    }
    return false;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int indexDiff, valueDiff;
    scanf("%d", &indexDiff);
    scanf("%d", &valueDiff);
    
    bool result = solution(nums, numsSize, indexDiff, valueDiff);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops where outer loop runs n times and inner loop runs up to indexDiff times for each element

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

85.0K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler