Minimum Absolute Difference - Practice Coding Problems

Minimum Absolute Difference - Problem

Array Sorting Easy

Imagine you have an array of distinct integers and you need to find all pairs of numbers that have the smallest possible difference between them. This is like finding the closest neighbors in a line of numbers!

Given an array arr of distinct integers, your task is to:

Find the minimum absolute difference between any two elements in the array
Return all pairs of elements that have exactly this minimum difference
Each pair [a, b] should satisfy: a < b and b - a equals the minimum absolute difference
Return the pairs in ascending order

Example: For array [4, 2, 1, 3], the minimum difference is 1, and the pairs with difference 1 are: [[1,2], [2,3], [3,4]]

Input & Output

example_1.py — Basic case with consecutive differences

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

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

💡 Note: After sorting: [1,2,3,4]. Adjacent differences are all 1, which is minimum. So all adjacent pairs are returned.

example_2.py — Multiple minimum differences

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

› Output: [[1,3]]

💡 Note: After sorting: [1,3,6,10,15]. Differences are 2,3,4,5. Minimum is 2, only pair [1,3] has this difference.

example_3.py — Minimum case with two elements

$ Input: arr = [40,20]

› Output: [[20,40]]

💡 Note: Only two elements, so only one pair possible: [20,40] with difference 20.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Sort the Array

Arrange elements in ascending order: [4,2,1,3] → [1,2,3,4]

Find Minimum Adjacent Difference

Compare only adjacent elements: 2-1=1, 3-2=1, 4-3=1. Minimum is 1.

Collect Pairs

All adjacent pairs with difference 1: [1,2], [2,3], [3,4]

Key Takeaway

🎯 Key Insight: After sorting the array, the minimum absolute difference will always be between adjacent elements, eliminating the need to check all pairs!

Asked in

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

The optimal solution is to sort the array first, then find the minimum difference between adjacent elements. This works because after sorting, the minimum absolute difference will always be between consecutive elements. The approach takes O(n log n) time due to sorting and O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Array)	O(n log n)	O(1)	Sort array then find minimum difference between adjacent elements
Brute Force (Nested Loops)	O(n²)	O(k)	Check all possible pairs to find minimum difference

Two Pointers (Sorted Array) — Algorithm Steps

Sort the array in ascending order
Find minimum difference by comparing adjacent elements
Iterate through sorted array again to collect all adjacent pairs with minimum difference
Return the collected pairs (already in ascending order due to sorting)

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Transform [4,2,1,3] to [1,2,3,4]

Compare Adjacent

Check differences: |2-1|=1, |3-2|=1, |4-3|=1

Find Minimum

All adjacent differences are 1, so min_diff = 1

Collect Pairs

All adjacent pairs have min difference: [1,2], [2,3], [3,4]

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

int** minimumAbsDifference(int* arr, int arrSize, int* returnSize, int** returnColumnSizes) {
    // Sort the array
    qsort(arr, arrSize, sizeof(int), compare);
    
    // Find minimum difference between adjacent elements
    int minDiff = INT_MAX;
    for (int i = 0; i < arrSize - 1; i++) {
        if (arr[i + 1] - arr[i] < minDiff) {
            minDiff = arr[i + 1] - arr[i];
        }
    }
    
    // Count pairs with minimum difference
    int count = 0;
    for (int i = 0; i < arrSize - 1; i++) {
        if (arr[i + 1] - arr[i] == minDiff) {
            count++;
        }
    }
    
    // Allocate result array
    int** result = malloc(count * sizeof(int*));
    *returnColumnSizes = malloc(count * sizeof(int));
    *returnSize = 0;
    
    // Collect all adjacent pairs with minimum difference
    for (int i = 0; i < arrSize - 1; i++) {
        if (arr[i + 1] - arr[i] == minDiff) {
            result[*returnSize] = malloc(2 * sizeof(int));
            result[*returnSize][0] = arr[i];
            result[*returnSize][1] = arr[i + 1];
            (*returnColumnSizes)[*returnSize] = 2;
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    int arr[] = {4, 2, 1, 3};
    int arrSize = 4;
    int returnSize;
    int* returnColumnSizes;
    int** result = minimumAbsDifference(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(",");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting, O(n) for two linear passes to find minimum and collect pairs

⚡ Linearithmic

Space Complexity

O(1)

Constant extra space if we sort in-place, O(n) for result storage

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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

Two Pointers (Sorted Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler