LeetCode //C - 1200. Minimum Absolute Difference

1200. Minimum Absolute Difference

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

Example 1:

Input: arr = 4,2,1,3

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

Explanation: The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.

Example 2:

Input: arr = 1,3,6,10,15

Output: \[1,3]

Example 3:

Input: arr = 3,8,-10,23,19,-4,-14,27

Output: \[-14,-10,19,23,23,27]

Constraints:

• 2 < = a r r . l e n g t h < = 10 5 2 <= arr.length <= 10^5 2<=arr.length<=105
• − 10 6 < = a r r i < = 10 6 -10^6 <= arri <= 10^6 −106<=arri<=106

From: LeetCode

Link: 1200. Minimum Absolute Difference

---

Solution:

Ideas:

Sort first, then only compare neighboring numbers.

Code:

#include <stdlib.h>

int cmpInt(const void* a, const void* b) {
    int x = *(int*)a;
    int y = *(int*)b;
    return (x > y) - (x < y);
}

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** minimumAbsDifference(int* arr, int arrSize, int* returnSize, int** returnColumnSizes) {
    qsort(arr, arrSize, sizeof(int), cmpInt);

    int minDiff = arr[1] - arr[0];
    for (int i = 1; i < arrSize - 1; i++) {
        int diff = arr[i + 1] - arr[i];
        if (diff < minDiff) {
            minDiff = diff;
        }
    }

    int count = 0;
    for (int i = 0; i < arrSize - 1; i++) {
        if (arr[i + 1] - arr[i] == minDiff) {
            count++;
        }
    }

    int** result = (int**)malloc(sizeof(int*) * count);
    *returnColumnSizes = (int*)malloc(sizeof(int) * count);
    *returnSize = count;

    int idx = 0;
    for (int i = 0; i < arrSize - 1; i++) {
        if (arr[i + 1] - arr[i] == minDiff) {
            result[idx] = (int*)malloc(sizeof(int) * 2);
            result[idx][0] = arr[i];
            result[idx][1] = arr[i + 1];
            (*returnColumnSizes)[idx] = 2;
            idx++;
        }
    }

    return result;
}