Find Indices With Index and Value Difference II

Find Indices With Index and Value Difference II - Problem

You are given a 0-indexed integer array nums having length n, an integer indexDifference, and an integer valueDifference.

Your task is to find two indices i and j, both in the range [0, n - 1], that satisfy the following conditions:

abs(i - j) >= indexDifference
abs(nums[i] - nums[j]) >= valueDifference

Return an integer array answer, where answer = [i, j] if there are two such indices, and answer = [-1, -1] otherwise.

If there are multiple choices for the two indices, return any of them.

Note: i and j may be equal.

Input & Output

Example 1 — Basic Case

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

› Output: [0,3]

💡 Note: Index difference: |0-3| = 3 ≥ 2 ✓, Value difference: |5-1| = 4 ≥ 4 ✓

Example 2 — No Valid Pair

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

› Output: [0,0]

💡 Note: Index difference: |0-0| = 0 ≥ 0 ✓, Value difference: |2-2| = 0 ≥ 0 ✓

Example 3 — Large Differences Required

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

› Output: [-1,-1]

💡 Note: No pair satisfies both constraints: max value difference is |1-3| = 2 < 4

Constraints

2 ≤ nums.length ≤ 5 × 10⁵
0 ≤ indexDifference < nums.length
0 ≤ valueDifference ≤ 10⁹
0 ≤ nums[i] ≤ 5 × 10⁸

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 m Microsoft 6

The key insight is to track minimum and maximum values efficiently while maintaining the index difference constraint. The optimized approach uses a single pass with min/max tracking to achieve O(n) time and O(1) space complexity.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Math

⏱️ Time: N/A Space: N/A

Brute Force - Check All Pairs

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

For each pair of indices (i, j), check if the absolute difference of indices is at least indexDifference and the absolute difference of values is at least valueDifference. Return the first valid pair found.

Optimized with Min/Max Tracking

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

Maintain running minimum and maximum values along with their indices. For each position i, check elements that are at least indexDifference away and see if any tracked min/max satisfies the value difference constraint.

Two Pointers with Sliding Window

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

Maintain a sliding window where the distance between left and right pointers is at least indexDifference. Track minimum and maximum values in the valid range to quickly check value difference constraint.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int nums[1000];
static int result[2];

void solution(int* nums, int n, int indexDifference, int valueDifference, int* result) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int idxDiff = i - j;
            if (idxDiff < 0) idxDiff = -idxDiff;
            int valDiff = nums[i] - nums[j];
            if (valDiff < 0) valDiff = -valDiff;
            
            if (idxDiff >= indexDifference && valDiff >= valueDifference) {
                result[0] = i;
                result[1] = j;
                return;
            }
        }
    }
    result[0] = -1;
    result[1] = -1;
}

int parseArray(const char* s, int* nums) {
    int n = 0;
    int len = strlen(s);
    
    if (len <= 2) return 0; // Empty array "[]"
    
    int i = 1; // Skip '['
    while (i < len - 1) { // Stop before ']'
        // Skip whitespace and commas
        while (i < len - 1 && (s[i] == ' ' || s[i] == ',')) i++;
        if (i >= len - 1) break;
        
        // Parse number
        char* endptr;
        nums[n] = (int)strtol(s + i, &endptr, 10);
        i = endptr - s;
        n++;
    }
    return n;
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0; // Remove newline
    int n = parseArray(line, nums);
    
    fgets(line, sizeof(line), stdin);
    int indexDifference = (int)strtol(line, NULL, 10);
    
    fgets(line, sizeof(line), stdin);
    int valueDifference = (int)strtol(line, NULL, 10);
    
    solution(nums, n, indexDifference, valueDifference, result);
    printf("[%d,%d]\n", result[0], result[1]);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.4K Views

Medium Frequency

~25 min Avg. Time

289 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