Find Indices With Index and Value Difference I

Find Indices With Index and Value Difference I - 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, and
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 = [4,1,2,3], indexDifference = 1, valueDifference = 1

› Output: [2,3]

💡 Note: At indices 2 and 3: abs(2-3) = 1 >= 1 (index diff), abs(2-3) = 1 >= 1 (value diff). Both conditions satisfied.

Example 2 — No Valid Pair

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

› Output: [-1,-1]

💡 Note: Only valid index pairs are (0,2) with values (1,3). Value difference is |1-3| = 2 < 4, so no solution exists.

Example 3 — Same Index

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

› Output: [0,0]

💡 Note: With single element and both differences = 0, we can return the same index twice: abs(0-0) = 0 >= 0, abs(5-5) = 0 >= 0.

Constraints

1 ≤ nums.length ≤ 100
0 ≤ indexDifference ≤ nums.length - 1
0 ≤ valueDifference ≤ 50
0 ≤ nums[i] ≤ 50

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is to check both index distance and value difference conditions systematically. The brute force approach checks all pairs in O(n²) time. An optimized version can skip pairs that don't meet the index difference requirement first. Time: O(n²), Space: O(1)

Common Approaches

✓ Dfs

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

Brute Force

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

Iterate through all pairs of indices (i, j) and check if both the index difference and value difference conditions are satisfied. Return the first valid pair found.

Optimized Two Pointers

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

Instead of checking all pairs, we only check pairs where the index difference condition is already satisfied. For each index i, we only check indices j where abs(i-j) >= indexDifference.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int abs_diff(int a, int b) {
    return a > b ? a - b : b - a;
}

int* parseArray(char* str, int* size) {
    *size = 0;
    int* arr = (int*)malloc(1000 * sizeof(int));
    
    char* ptr = str;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++; // skip '['
    
    if (*ptr == ']') {
        return arr;
    }
    
    while (*ptr) {
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr == ']') break;
        
        int num = 0;
        int negative = 0;
        if (*ptr == '-') {
            negative = 1;
            ptr++;
        }
        
        while (*ptr >= '0' && *ptr <= '9') {
            num = num * 10 + (*ptr - '0');
            ptr++;
        }
        
        if (negative) num = -num;
        arr[(*size)++] = num;
    }
    
    return arr;
}

int main() {
    char buffer[10000];
    
    // Read array
    fgets(buffer, sizeof(buffer), stdin);
    buffer[strcspn(buffer, "\n")] = 0;
    int numsSize;
    int* nums = parseArray(buffer, &numsSize);
    
    // Read indexDifference
    fgets(buffer, sizeof(buffer), stdin);
    int indexDifference = atoi(buffer);
    
    // Read valueDifference
    fgets(buffer, sizeof(buffer), stdin);
    int valueDifference = atoi(buffer);
    
    // Find valid indices
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < numsSize; j++) {
            if (abs_diff(i, j) >= indexDifference && 
                abs_diff(nums[i], nums[j]) >= valueDifference) {
                printf("[%d,%d]\n", i, j);
                free(nums);
                return 0;
            }
        }
    }
    
    printf("[-1,-1]\n");
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

234 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