The first approach involves sorting the array and then iterating through it to find the pairs with the minimum absolute difference. By sorting, the smallest differences can only occur between consecutive elements. Hence, we sort the array and compute differences between adjacent elements to find the minimum difference.
Steps:
Time Complexity: O(n log n), due to sorting the array. Space Complexity: O(1), not considering the output space.
1var minimumAbsDifference = function(arr) {
2 arr.sort((a, b) => a - b);
3 let minDiff = Infinity;
4 let result = [];
5 for (let i = 1; i < arr.length; i++) {
6 let diff = arr[i] - arr[i - 1];
7 if (diff < minDiff) {
8 minDiff = diff;
9 result = [[arr[i - 1], arr[i]]];
10 } else if (diff === minDiff) {
11 result.push([arr[i - 1], arr[i]]);
12 }
13 }
14 return result;
15};
16This JavaScript approach involves sorting the array and checking consecutive differences. It stores pairs with the minimum found difference into the result array.
The second approach compares all pairs of elements to determine their absolute differences. This method ensures that all possible pairs are considered, and the pairs with the minimum difference are identified. Although not as efficient as the first approach, it explicitly checks every possible pair.
Steps:
Time Complexity: O(n^2), considering all pair combinations. Space Complexity: O(1), excluding result space.
1#include <vector>
2#include <algorithm>
3
4std::vector<std::vector<int>> minimumAbsDifference(std::vector<int>& arr) {
5 int minDiff = INT_MAX;
6 std::vector<std::vector<int>> result;
7 for (size_t i = 0; i < arr.size(); ++i) {
8 for (size_t j = i + 1; j < arr.size(); ++j) {
9 int diff = std::abs(arr[i] - arr[j]);
10 if (diff < minDiff) {
11 minDiff = diff;
12 result.clear();
13 result.push_back({arr[i], arr[j]});
14 } else if (diff == minDiff) {
15 result.push_back({arr[i], arr[j]});
16 }
17 }
18 }
19 return result;
20}
21This C++ solution systematically checks every element pair, calculating their disparity and updating the recorded minimal difference before accumulating the appropriate pairs in the result array that is ultimately returned.