Find Indices With Index and Value Difference I

Find Indices With Index and Value Difference I - Problem

Imagine you're a data analyst looking for two specific data points in a dataset that satisfy both positional and value-based criteria!

Given a 0-indexed integer array nums of length n, along with two threshold values:

indexDifference - minimum distance between positions
valueDifference - minimum difference between values

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

Position 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]

Note: Multiple valid pairs may exist - return any one of them. The indices i and j can be equal.

Input & Output

example_1.py — Basic Case

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

› Output: [0,3]

💡 Note: Indices 0 and 3 satisfy both conditions: |0-3| = 3 ≥ 2 (index difference) and |5-1| = 4 ≥ 4 (value difference)

example_2.py — No Valid Pair

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

› Output: [-1,-1]

💡 Note: No pair of indices satisfies the value difference requirement: |2-1| = 1 < 2, and |1-2| = 1 < 2

example_3.py — Same Index Valid

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

› Output: [0,0]

💡 Note: Since both differences can be 0, any index paired with itself works. Index 0 with itself: |0-0| = 0 ≥ 0 and |1-1| = 0 ≥ 0

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Setup

Place cameras along a hallway at positions 0, 1, 2, 3... with sensor readings

Distance Rule

Cameras must be at least 'indexDifference' positions apart

Reading Rule

Camera readings must differ by at least 'valueDifference'

Find Pair

Locate any two cameras satisfying both distance and reading requirements

Key Takeaway

🎯 Key Insight: By tracking extremes (min/max) in valid ranges, we avoid checking all pairs and achieve optimal O(n) time complexity.

Asked in

⊞ Microsoft 25 a Amazon 18 G Google 12 f Meta 8

The optimal approach uses a sliding window technique to track the minimum and maximum values from indices that satisfy the index difference constraint. This reduces the time complexity from O(n²) to O(n) by avoiding redundant comparisons and leveraging the insight that we only need to find any valid pair.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Sliding Window	O(n)	O(1)	Use sliding window to track min/max values from valid index ranges
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of indices to find one that satisfies both constraints

Optimized Sliding Window — Algorithm Steps

For each index j, consider all valid indices i where abs(i-j) >= indexDifference
Maintain minVal and maxVal from all positions [0, j-indexDifference]
Check if abs(nums[j] - minVal) >= valueDifference or abs(nums[j] - maxVal) >= valueDifference
If satisfied, find and return the corresponding indices
Update minVal and maxVal for the next iteration

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first element as min/max

Slide window

For each j, update min/max from valid i range

Check constraints

Compare current element with tracked extremes

Code -

solution.c — C

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

int* findIndices(int* nums, int numsSize, int indexDifference, int valueDifference) {
    int* result = (int*)malloc(2 * sizeof(int));
    
    int minVal = nums[0], maxVal = nums[0];
    int minIdx = 0, maxIdx = 0;
    
    for (int j = indexDifference; j < numsSize; j++) {
        // Update min and max from valid range
        int i = j - indexDifference;
        if (nums[i] < minVal) {
            minVal = nums[i];
            minIdx = i;
        }
        if (nums[i] > maxVal) {
            maxVal = nums[i];
            maxIdx = i;
        }
        
        // Check if current j can form valid pair
        if (abs(nums[j] - minVal) >= valueDifference) {
            result[0] = minIdx;
            result[1] = j;
            return result;
        }
        if (abs(nums[j] - maxVal) >= valueDifference) {
            result[0] = maxIdx;
            result[1] = j;
            return result;
        }
    }
    
    result[0] = -1;
    result[1] = -1;
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for tracking min/max values and indices

✓ Linear Space

26.8K Views

Medium Frequency

~15 min Avg. Time

892 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

Optimized Sliding Window — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler