Find Indices With Index and Value Difference II

Find Indices With Index and Value Difference II - Problem

🎯 Find Indices With Index and Value Difference II

You're given a 0-indexed integer array nums of length n, along with two constraints: indexDifference and valueDifference.

Your mission: Find two indices i and j (both in range [0, n-1]) that satisfy both conditions:

📏 Index constraint: abs(i - j) >= indexDifference
📊 Value constraint: abs(nums[i] - nums[j]) >= valueDifference

Return: An array [i, j] if such indices exist, otherwise [-1, -1]. If multiple valid pairs exist, return any one of them.

Note: Indices i and j can be equal if they satisfy both constraints.

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,1,2,3], indexDifference = 1, valueDifference = 1

› Output: [0,2]

💡 Note: Indices 0 and 2 satisfy both constraints: |0-2| = 2 ≥ 1 and |4-2| = 2 ≥ 1. Other valid pairs exist like [0,1] but we return the first found.

example_2.py — No Solution

$ Input: nums = [1,2,3], indexDifference = 2, valueDifference = 4

› Output: [-1,-1]

💡 Note: No pair of indices satisfies both constraints. The maximum index difference is 2 (indices 0,2) but |1-3| = 2 < 4, so the value difference constraint fails.

example_3.py — Same Index Valid

$ Input: nums = [5], indexDifference = 0, valueDifference = 0

› Output: [0,0]

💡 Note: Single element array where i=j=0 satisfies both constraints: |0-0| = 0 ≥ 0 and |5-5| = 0 ≥ 0.

Visualization

Tap to expand

Understanding the Visualization

Setup Window

Start checking from positions that satisfy minimum distance

Track Extremes

Keep track of minimum and maximum activity levels from valid previous positions

Compare Current

Check if current position has sufficient activity difference with tracked extremes

Found Solution

Return the first valid pair that satisfies both distance and activity constraints

Key Takeaway

🎯 Key Insight: Instead of checking all pairs (O(n²)), we use sliding window technique to track min/max values from valid previous positions, achieving optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each operation is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track min/max values and indices

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 5 × 10⁴
0 ≤ indexDifference ≤ nums.length
0 ≤ valueDifference ≤ 5 × 10⁴

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a sliding window approach with min/max tracking in O(n) time. Instead of checking all pairs, we maintain the minimum and maximum values from positions that satisfy the index difference constraint, enabling constant-time comparisons as we iterate through the array.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Min/Max Tracking (Optimal)	O(n)	O(1)	Use sliding window technique to track minimum and maximum values from valid previous positions
Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible pairs of indices that satisfy the index difference constraint

Two Pointers with Min/Max Tracking (Optimal) — Algorithm Steps

Initialize variables to track min/max values and their indices
Iterate through array starting from index indexDifference
For each position i, update min/max from position i-indexDifference
Check if current value has sufficient difference with tracked min or max
Return indices if valid pair found, otherwise continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start from index equal to indexDifference

Track Min/Max

Update min/max from valid previous positions

Compare

Check current value against tracked min/max

Continue

Slide window and repeat until valid pair found

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int* findIndices(int* nums, int n, int indexDifference, int valueDifference) {
    int* result = (int*)malloc(2 * sizeof(int));
    int minVal = INT_MAX, maxVal = INT_MIN;
    int minIdx = -1, maxIdx = -1;
    
    for (int i = indexDifference; i < n; i++) {
        // Update min and max from valid previous positions
        int prevIdx = i - indexDifference;
        if (nums[prevIdx] < minVal) {
            minVal = nums[prevIdx];
            minIdx = prevIdx;
        }
        if (nums[prevIdx] > maxVal) {
            maxVal = nums[prevIdx];
            maxIdx = prevIdx;
        }
        
        // Check if current position forms valid pair with min or max
        if (abs_val(nums[i] - minVal) >= valueDifference) {
            result[0] = minIdx;
            result[1] = i;
            return result;
        }
        if (abs_val(nums[i] - maxVal) >= valueDifference) {
            result[0] = maxIdx;
            result[1] = i;
            return result;
        }
    }
    
    result[0] = -1;
    result[1] = -1;
    return result;
}

int main() {
    int nums[] = {4, 1, 2, 3};
    int* result = findIndices(nums, 4, 1, 1);
    printf("[%d, %d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each operation is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track min/max values and indices

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 5 × 10⁴
0 ≤ indexDifference ≤ nums.length
0 ≤ valueDifference ≤ 5 × 10⁴

28.4K Views

Medium Frequency

~15 min Avg. Time

847 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

🎯 Find Indices With Index and Value Difference II

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers with Min/Max Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler