Minimum Absolute Difference Queries - Practice Coding Problems

Minimum Absolute Difference Queries - Problem

Imagine you're analyzing data patterns across different segments of a dataset. You need to find the minimum absolute difference between any two distinct values within specific ranges.

The minimum absolute difference of an array is the smallest value of |a[i] - a[j]| where 0 <= i < j < a.length and a[i] != a[j]. If all elements are identical, return -1.

Example: For array [5, 2, 3, 7, 2], the minimum absolute difference is |2 - 3| = 1. Note that we can't use |2 - 2| = 0 because the elements must be different values.

Given an integer array nums and multiple queries where queries[i] = [li, ri], you need to compute the minimum absolute difference for each subarray nums[li...ri] (inclusive).

Goal: Return an array where each element is the answer to the corresponding query.

Input & Output

example_1.py — Basic Query

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

› Output: [1]

💡 Note: The subarray [1,3,4] has unique values. The minimum absolute differences are |1-3|=2, |1-4|=3, |3-4|=1. The minimum is 1.

example_2.py — Multiple Queries

$ Input: nums = [4,5,2,2,7,10], queries = [[2,3],[0,2],[0,5]]

› Output: [1,1,1]

💡 Note: Query [2,3]: subarray [2,2] has only one unique value, but since we need different elements, we get -1. Wait, that's wrong. Let me recalculate: [2,2] only has identical elements, so the answer should be -1. Actually, looking at constraints, this should return [0,1,1].

example_3.py — Edge Case

$ Input: nums = [1,1,1], queries = [[0,2]]

› Output: [-1]

💡 Note: The subarray [1,1,1] contains only identical elements. Since we need different values to calculate absolute difference, the answer is -1.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 100
1 ≤ queries.length ≤ 2 × 10⁴
0 ≤ l_i < r_i < nums.length
Key constraint: Values bounded to 1-100 enables frequency counting optimization

Visualization

Tap to expand

Understanding the Visualization

Preprocessing Phase

Build cumulative frequency tables for each value 1-100

Query Phase

Use prefix sums to get frequencies in any range instantly

Optimization

Only check consecutive existing values instead of all pairs

Key Takeaway

🎯 Key Insight: When values are bounded (1-100), we can use frequency arrays and prefix sums to convert expensive per-query computations into cheap table lookups, achieving massive performance gains for multiple queries.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses 2D prefix sums to preprocess frequency counts for all values (1-100) at each position. This enables O(1) range frequency queries, and we only need to check consecutive pairs of existing values to find the minimum difference. Time complexity: O(n × 100 + q × 100), which is effectively O(n + q) since 100 is constant.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Prefix Sum with Frequency Array	O(n * 100 + q * 100)	O(n * 100)	Use 2D prefix sums to count frequencies in any range, then find minimum difference
Frequency Count + Sorted Search	O(q * n log n)	O(n)	Count frequencies of unique values, then find minimum difference between consecutive sorted unique values
Brute Force (Nested Loops)	O(q * n²)	O(1)	For each query, check all pairs in the subarray to find minimum difference

Optimal: Prefix Sum with Frequency Array — Algorithm Steps

Build 2D prefix sum array: prefix[i][v] = count of value v in nums[0...i-1]
For each query [l,r], get frequency of each value 1-100 in O(100) = O(1)
Find which values exist (frequency > 0)
Check consecutive pairs of existing values for minimum difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sums

Create 2D array tracking cumulative frequency of each value

Range Query

Get frequency in [l,r] using prefix[r+1][v] - prefix[l][v]

Find Existing Values

Identify which values have frequency > 0 in range

Minimum Difference

Check consecutive existing values for minimum gap

Code -

solution.c — C

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

int* minimumDifferenceQueries(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    const int MAX_VAL = 100;
    
    // Build 2D prefix sum
    int** prefix = (int**)malloc((numsSize + 1) * sizeof(int*));
    for (int i = 0; i <= numsSize; i++) {
        prefix[i] = (int*)calloc(MAX_VAL + 1, sizeof(int));
    }
    
    for (int i = 0; i < numsSize; i++) {
        for (int v = 1; v <= MAX_VAL; v++) {
            prefix[i + 1][v] = prefix[i][v];
        }
        prefix[i + 1][nums[i]]++;
    }
    
    for (int q = 0; q < queriesSize; q++) {
        int l = queries[q][0], r = queries[q][1];
        
        // Get existing values in range
        int existing[MAX_VAL + 1];
        int existingCount = 0;
        
        for (int v = 1; v <= MAX_VAL; v++) {
            int count = prefix[r + 1][v] - prefix[l][v];
            if (count > 0) {
                existing[existingCount++] = v;
            }
        }
        
        if (existingCount < 2) {
            result[q] = -1;
        } else {
            int minDiff = INT_MAX;
            for (int i = 0; i < existingCount - 1; i++) {
                int diff = existing[i + 1] - existing[i];
                if (diff < minDiff) {
                    minDiff = diff;
                }
            }
            result[q] = minDiff;
        }
    }
    
    // Free memory
    for (int i = 0; i <= numsSize; i++) {
        free(prefix[i]);
    }
    free(prefix);
    
    return result;
}

int main() {
    int nums[] = {1, 3, 4};
    int* query1 = (int*)malloc(2 * sizeof(int));
    query1[0] = 0; query1[1] = 2;
    int** queries = &query1;
    int queriesColSize[] = {2};
    int returnSize;
    
    int* result = minimumDifferenceQueries(nums, 3, queries, 1, queriesColSize, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    
    free(result);
    free(query1);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 100 + q * 100)

O(n) preprocessing with 100 values tracked, then O(100) = O(1) per query

✓ Linear Growth

Space Complexity

O(n * 100)

2D prefix sum array of size n × 100

⚡ Linearithmic Space

31.5K Views

Medium-High Frequency

~25 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

Optimal: Prefix Sum with Frequency Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler