Minimum Absolute Difference Between Elements With Constraint

Minimum Absolute Difference Between Elements With Constraint - Problem

Imagine you're a data analyst looking for patterns in a sequence of numbers, but with a twist - you need to maintain a minimum distance between the data points you compare!

Given a 0-indexed integer array nums and an integer x, your task is to find the minimum absolute difference between two elements that are at least x indices apart.

More formally, you need to find two indices i and j such that:

abs(i - j) >= x (they're far enough apart)
abs(nums[i] - nums[j]) is minimized (their values are as close as possible)

Goal: Return the minimum absolute difference between two elements that satisfy the distance constraint.

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,3,2,4], x = 2

› Output: 0

💡 Note: We can choose i=0 and j=3 since abs(0-3)=3 >= 2. The absolute difference is abs(4-4)=0, which is the minimum possible.

example_2.py — No Exact Match

$ Input: nums = [5,3,2,10,15], x = 1

› Output: 1

💡 Note: We can choose i=1 and j=2 since abs(1-2)=1 >= 1. The absolute difference is abs(3-2)=1. We could also choose other pairs, but 1 is the minimum.

example_3.py — Large Distance

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

› Output: 3

💡 Note: The only valid pair is i=0, j=3 since abs(0-3)=3 >= 3. The absolute difference is abs(1-4)=3.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ x < nums.length
All array elements are integers

Visualization

Tap to expand

Understanding the Visualization

Camera Placement

Each camera position has a coverage value and distance constraint

Distance Validation

Only cameras at least x positions apart can be compared due to interference

Coverage Matching

Find two valid cameras with most similar coverage ranges

Optimal Solution

Use sliding window + ordered set for efficient comparison

Key Takeaway

🎯 Key Insight: The sliding window approach with an ordered data structure allows us to efficiently maintain valid elements and use binary search to find optimal matches in O(n log n) time.

Asked in

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

The optimal approach uses a sliding window technique combined with an ordered data structure (TreeSet/multiset). As we iterate through the array, we maintain a sorted collection of elements that are far enough away to be valid comparisons. For each element, we use binary search operations (floor/ceiling) to efficiently find the closest values, achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all valid pairs of elements that are at least x indices apart
Sliding Window + Ordered Set	O(n log n)	O(n)	Use sliding window with TreeSet to efficiently find closest values

Brute Force (Nested Loops) — Algorithm Steps

Initialize minimum difference to infinity
Use outer loop for index i from 0 to n-1
Use inner loop for index j from i+x to n-1 (ensuring distance constraint)
Calculate abs(nums[i] - nums[j]) and update minimum if smaller
Also check j from 0 to i-x (if i-x >= 0) for the other direction
Return the minimum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first element and check all valid distant elements

Compare Pairs

For each element, compare with all elements at least x positions away

Track Minimum

Keep track of the smallest absolute difference found

Code -

solution.c — C

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

int minimumAbsoluteDifference(int* nums, int numsSize, int x) {
    int minDiff = INT_MAX;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + x; j < numsSize; j++) {
            int diff = abs(nums[i] - nums[j]);
            if (diff < minDiff) {
                minDiff = diff;
            }
        }
    }
    
    return minDiff;
}

int main() {
    int nums[] = {4, 3, 2, 4};
    int x = 2;
    printf("%d\n", minimumAbsoluteDifference(nums, 4, x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all pairs of indices that are at least x apart, which in worst case is O(n²) pairs

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track minimum difference and loop indices

✓ Linear Space

32.4K Views

Medium Frequency

~18 min Avg. Time

1.2K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler