Minimum Absolute Difference

Minimum Absolute Difference - Problem

Array Sorting Easy

Given an array of distinct integers arr, find all pairs of elements with the minimum absolute difference of any two elements.

Return a list of pairs in ascending order (with respect to pairs), each pair [a, b] follows:

a, b are from arr
a < b
b - a equals to the minimum absolute difference of any two elements in arr

Input & Output

Example 1 — Basic Case

$ Input: arr = [4,2,1,3]

› Output: [[1,2],[2,3],[3,4]]

💡 Note: After sorting: [1,2,3,4]. Adjacent differences: |2-1|=1, |3-2|=1, |4-3|=1. Minimum difference is 1, so all adjacent pairs qualify.

Example 2 — Single Pair

$ Input: arr = [1,3,6,10,15]

› Output: [[1,3]]

💡 Note: After sorting: [1,3,6,10,15]. Adjacent differences: |3-1|=2, |6-3|=3, |10-6|=4, |15-10|=5. Minimum difference is 2, only pair [1,3] qualifies.

Example 3 — Multiple Minimum Pairs

$ Input: arr = [1,1,3,3]

› Output: [[1,3],[1,3]]

💡 Note: After sorting: [1,1,3,3]. Adjacent differences: |1-1|=0, |3-1|=2, |3-3|=0. Wait, this violates distinct constraint. Let's use [1,5,3,4]: sorted [1,3,4,5], differences [2,1,1], min=1, pairs [[3,4],[4,5]].

Constraints

2 ≤ arr.length ≤ 10⁵
-10⁶ ≤ arr[i] ≤ 10⁶
All integers in arr are distinct

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 M Microsoft 6

The key insight is that after sorting the array, the minimum absolute difference can only occur between adjacent elements. The optimal approach sorts first in O(n log n), then finds minimum difference in O(n). Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Compare All Pairs

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

Compare all pairs of elements to find the minimum absolute difference. Then iterate through all pairs again to collect those with the minimum difference.

Sort First - Optimal Solution

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

After sorting, the minimum absolute difference can only occur between adjacent elements. This reduces the problem to a single pass through sorted array.

Brute Force - Compare All Pairs — Algorithm Steps

Step 1: Find minimum absolute difference by checking all pairs
Step 2: Collect all pairs that have this minimum difference
Step 3: Sort pairs and return result

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare All Pairs

Check difference between every pair of elements

Find Minimum

Track the smallest absolute difference found

Collect Results

Gather all pairs that have the minimum difference

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *pairA = (int*)a;
    int *pairB = (int*)b;
    if (pairA[0] != pairB[0]) {
        return pairA[0] - pairB[0];
    }
    return pairA[1] - pairB[1];
}

int** solution(int* arr, int arrSize, int* returnSize, int** returnColumnSizes) {
    int n = arrSize;
    int minDiff = INT_MAX;
    
    // Find minimum absolute difference
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int diff = abs(arr[i] - arr[j]);
            if (diff < minDiff) {
                minDiff = diff;
            }
        }
    }
    
    // Collect all pairs with minimum difference
    int** result = (int**)malloc(n * n * sizeof(int*));
    *returnColumnSizes = (int*)malloc(n * n * sizeof(int));
    int resultSize = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (abs(arr[i] - arr[j]) == minDiff) {
                int a = arr[i] < arr[j] ? arr[i] : arr[j];
                int b = arr[i] > arr[j] ? arr[i] : arr[j];
                result[resultSize] = (int*)malloc(2 * sizeof(int));
                result[resultSize][0] = a;
                result[resultSize][1] = b;
                (*returnColumnSizes)[resultSize] = 2;
                resultSize++;
            }
        }
    }
    
    // Sort pairs
    qsort(result, resultSize, sizeof(int*), compare);
    
    *returnSize = resultSize;
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array
    int arr[1000];
    int arrSize = 0;
    parseArray(line, arr, &arrSize);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(arr, arrSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops to compare all pairs, done twice

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track minimum difference

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

894 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 - Compare All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler