Find all pairs in an Array in sorted order with minimum absolute difference
Last Updated :
11 Dec, 2024
Given an integer array arr[] of size N, the task is to find all distinct pairs having minimum absolute difference and print them in ascending order.
Examples:
Input: arr[] = {4, 2, 1, 3}
Output: {1, 2}, {2, 3}, {3, 4}
Explanation: The minimum absolute difference between pairs is 1.
Input: arr[] = {1, 3, 8, 10, 15}
Output: {1, 3}, {8, 10}
Explanation: The minimum absolute difference between the pairs {1, 3}, {8, 10} is 2.
Approach (Using Nested Loop):
The basic idea is to compare each pair of elements in the array and find the pair(s) with the minimum absolute difference.
- Sort the array arr in non-decreasing order.
- Initialize a variable min_diff to store the minimum absolute difference between pairs. Set min_diff to a very large value (e.g., INT_MAX).
- Initialize a vector pairs to store all pairs having the minimum absolute difference.
- Iterate through the array arr using a nested loop. For each pair of elements (arr[i], arr[j]) such that i < j, compute the absolute difference diff = abs(arr[i] – arr[j]). If diff < min_diff, update min_diff with diff and clear the vector pairs. Add the pair (arr[i], arr[j]) to the vector pairs.
- If diff == min_diff, add the pair (arr[i], arr[j]) to the vector pairs.
- Return the vector pairs containing all pairs having the minimum absolute difference.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
// Function to return all
// pairs having minimal absolute difference
vector<vector<int>> minAbsDiffPairs(vector<int>& arr) {
// Sort the array in non-decreasing order
sort(arr.begin(), arr.end());
// Find the minimum absolute difference between pairs
int min_diff = INT_MAX;
vector<vector<int>> pairs;
for (int i = 0; i < arr.size(); i++) {
for (int j = i+1; j < arr.size(); j++) {
int diff = abs(arr[i] - arr[j]);
if (diff < min_diff) {
min_diff = diff;
pairs.clear();
pairs.push_back({arr[i], arr[j]});
}
else if (diff == min_diff) {
pairs.push_back({arr[i], arr[j]});
}
}
}
return pairs;
}
// Driver Code
int main() {
vector<int> arr = { 4, 2, 1, 3 };
vector<vector<int>> pairs = minAbsDiffPairs(arr);
// Print all pairs
for (auto v : pairs) {
cout << v[0] << " " << v[1] << endl;
}
return 0;
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
// Function to return all pairs having minimal absolute difference
public static List<List<Integer>> minAbsDiffPairs(int[] arr) {
// Sort the array in non-decreasing order
Arrays.sort(arr);
// Find the minimum absolute difference between pairs
int minDiff = Integer.MAX_VALUE;
List<List<Integer>> pairs = new ArrayList<>();
for (int i = 0; i < arr.length - 1; i++) {
int diff = Math.abs(arr[i] - arr[i + 1]);
// If the current difference is smaller than the minimum difference so far
if (diff < minDiff) {
minDiff = diff;
pairs.clear();
pairs.add(Arrays.asList(arr[i], arr[i + 1]));
}
// If the current difference is equal to the minimum difference so far
else if (diff == minDiff) {
pairs.add(Arrays.asList(arr[i], arr[i + 1]));
}
}
return pairs;
}
public static void main(String[] args) {
int[] arr = { 4, 2, 1, 3 };
List<List<Integer>> pairs = minAbsDiffPairs(arr);
// Print all pairs
for (List<Integer> pair : pairs) {
System.out.println(pair.get(0) + " " + pair.get(1));
}
}
}
def min_abs_diff_pairs(arr):
# Sort the array in non-decreasing order
arr.sort()
# Find the minimum absolute difference between pairs
min_diff = float('inf')
pairs = []
for i in range(len(arr)):
for j in range(i + 1, len(arr)):
diff = abs(arr[i] - arr[j])
if diff < min_diff:
min_diff = diff
pairs = [[arr[i], arr[j]]]
elif diff == min_diff:
pairs.append([arr[i], arr[j]])
return pairs
# Driver Code
if __name__ == "__main__":
arr = [4, 2, 1, 3]
pairs = min_abs_diff_pairs(arr)
# Print all pairs
for v in pairs:
print(v[0], v[1])
using System;
using System.Collections.Generic;
using System.Linq;
public class GFG {
// Function to return all pairs having minimal absolute
// difference
public static List<List<int> >
MinAbsDiffPairs(List<int> arr)
{
// Sort the array in non-decreasing order
arr.Sort();
// Find the minimum absolute difference between
// pairs
int min_diff = int.MaxValue;
List<List<int> > pairs = new List<List<int> >();
for (int i = 0; i < arr.Count; i++) {
for (int j = i + 1; j < arr.Count; j++) {
int diff = Math.Abs(arr[i] - arr[j]);
if (diff < min_diff) {
min_diff = diff;
pairs.Clear();
pairs.Add(
new List<int>{ arr[i], arr[j] });
}
else if (diff == min_diff) {
pairs.Add(
new List<int>{ arr[i], arr[j] });
}
}
}
return pairs;
}
public static void Main()
{
List<int> arr = new List<int>{ 4, 2, 1, 3 };
List<List<int> > pairs = MinAbsDiffPairs(arr);
// Print all pairs
foreach(var v in pairs)
{
Console.WriteLine(v[0] + " " + v[1]);
}
}
}
// Function to return all
// pairs having minimal absolute difference
function minAbsDiffPairs(arr) {
// Sort the array in non-decreasing order
arr.sort((a, b) => a - b);
// Find the minimum absolute difference between pairs
let min_diff = Number.MAX_VALUE;
let pairs=[];
for (let i = 0; i < arr.length; i++) {
for (let j = i+1; j < arr.length; j++) {
let diff = Math.abs(arr[i] - arr[j]);
if (diff < min_diff) {
min_diff = diff;
pairs=[[arr[i], arr[j]]];
}
else if (diff == min_diff) {
pairs.push([arr[i], arr[j]]);
}
}
}
return pairs;
}
// Driver Code
let arr = [ 4, 2, 1, 3 ];
let pairs = minAbsDiffPairs(arr);
// Print all pairs
for (let v of pairs) {
console.log(v[0]+ " "+ v[1]);
}
Output:
1 2
2 3
3 4
Time Complexity: O(n log n), where n is the size of the input array.
Auxiliary Space: O(k), where k is the number of pairs having the minimum absolute difference.
Approach: The idea is to consider the absolute difference of the adjacent elements of the sorted array. Follow the steps below to solve the problem:
- Sort the given array arr[].
- Compare all adjacent pairs in the sorted array and find the minimum absolute difference between all adjacent pairs.
- Finally, print all the adjacent pairs having differences equal to the minimum absolute difference.
Below is the implementation of the above code:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to return all
// pairs having minimal absolute difference
vector<vector<int> > minAbsDiffPairs(vector<int>& arr)
{
vector<vector<int> > ans;
int n = arr.size();
// Sort the array
sort(arr.begin(), arr.end());
// Stores the minimal absolute difference
int minDiff = INT_MAX;
for (int i = 0; i < n - 1; i++)
minDiff = min(minDiff, abs(arr[i] - arr[i + 1]));
for (int i = 0; i < n - 1; i++) {
vector<int> pair;
if (abs(arr[i] - arr[i + 1]) == minDiff) {
pair.push_back(min(arr[i], arr[i + 1]));
pair.push_back(max(arr[i], arr[i + 1]));
ans.push_back(pair);
}
}
return ans;
}
// Driver Code
int main()
{
vector<int> arr = { 4, 2, 1, 3 };
int N = (sizeof arr) / (sizeof arr[0]);
vector<vector<int> > pairs = minAbsDiffPairs(arr);
// Print all pairs
for (auto v : pairs)
cout << v[0] << " " << v[1] << endl;
return 0;
}
// Java program for the above approach
import java.util.ArrayList;
import java.util.Collections;
class GFG
{
// Function to return all
// pairs having minimal absolute difference
static ArrayList<ArrayList<Integer>> minAbsDiffPairs(ArrayList<Integer> arr) {
ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();
int n = arr.size();
// Sort the array
Collections.sort(arr);
// Stores the minimal absolute difference
int minDiff = Integer.MAX_VALUE;
for (int i = 0; i < n - 1; i++)
minDiff = Math.min(minDiff, Math.abs(arr.get(i) - arr.get(i + 1)));
for (int i = 0; i < n - 1; i++) {
ArrayList<Integer> pair = new ArrayList<Integer>();
if (Math.abs(arr.get(i) - arr.get(i + 1)) == minDiff) {
pair.add(Math.min(arr.get(i), arr.get(i + 1)));
pair.add(Math.max(arr.get(i), arr.get(i + 1)));
ans.add(pair);
}
}
return ans;
}
// Driver Code
public static void main(String args[]) {
ArrayList<Integer> arr = new ArrayList<Integer>();
arr.add(4);
arr.add(2);
arr.add(1);
arr.add(3);
ArrayList<ArrayList<Integer>> pairs = minAbsDiffPairs(arr);
// Print all pairs
// System.out.println(pairs);
for (ArrayList<Integer> v : pairs) {
for (int w : v)
System.out.print(w + " ");
System.out.println("");
}
}
}
// This code is contributed by saurabh_jaiswal.
# Python3 program for the above approach
import math as Math
# Function to return all pairs having
# minimal absolute difference
def minAbsDiffPairs(arr):
ans = []
n = len(arr)
# Sort the array
arr.sort()
# Stores the minimal absolute difference
minDiff = 10 ** 9
for i in range(n - 1):
minDiff = min(minDiff, Math.fabs(arr[i] -
arr[i + 1]))
for i in range(n - 1):
pair = []
if (Math.fabs(arr[i] - arr[i + 1]) == minDiff):
pair.append(min(arr[i], arr[i + 1]))
pair.append(max(arr[i], arr[i + 1]))
ans.append(pair)
return ans
# Driver Code
arr = [ 4, 2, 1, 3 ]
N = len(arr)
pairs = minAbsDiffPairs(arr)
# Print all pairs
for v in pairs:
print(f"{v[0]} {v[1]}")
# This code is contributed by gfgking
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
// Function to return all
// pairs having minimal Absolute difference
static List<List<int>> minAbsDiffPairs(List<int> arr) {
List<List<int>> ans = new List<List<int>>();
int n = arr.Count;
// Sort the array
arr.Sort();
// Stores the minimal Absolute difference
int minDiff = int.MaxValue;
for (int i = 0; i < n - 1; i++)
minDiff = Math.Min(minDiff, Math.Abs(arr[i] - arr[i + 1]));
for (int i = 0; i < n - 1; i++) {
List<int> pair = new List<int>();
if (Math.Abs(arr[i] - arr[i + 1]) == minDiff) {
pair.Add(Math.Min(arr[i], arr[i + 1]));
pair.Add(Math.Max(arr[i], arr[i + 1]));
ans.Add(pair);
}
}
return ans;
}
// Driver Code
public static void Main()
{
List<int> arr = new List<int>();
arr.Add(4);
arr.Add(2);
arr.Add(1);
arr.Add(3);
List<List<int>> pairs = minAbsDiffPairs(arr);
// Print all pairs
// System.out.println(pairs);
foreach (List<int> v in pairs)
{
foreach (int w in v)
Console.Write(w + " ");
Console.WriteLine("");
}
}
}
// This code is contributed by saurabh_jaiswal.
<script>
// JavaScript code for the above approach
// Function to return all
// pairs having minimal absolute difference
function minAbsDiffPairs(arr)
{
let ans = [];
let n = arr.length;
// Sort the array
arr.sort(function (a, b) { return a - b })
// Stores the minimal absolute difference
let minDiff = Number.MAX_VALUE;
for (let i = 0; i < n - 1; i++)
minDiff = Math.min(minDiff, Math.abs(arr[i] - arr[i + 1]));
for (let i = 0; i < n - 1; i++) {
let pair = [];
if (Math.abs(arr[i] - arr[i + 1]) == minDiff) {
pair.push(Math.min(arr[i], arr[i + 1]));
pair.push(Math.max(arr[i], arr[i + 1]));
ans.push(pair);
}
}
return ans;
}
// Driver Code
let arr = [4, 2, 1, 3];
let N = arr.length;
let pairs = minAbsDiffPairs(arr);
// Print all pairs
for (let v of pairs)
document.write(v[0] + " " + v[1] + '<br>')
// This code is contributed by Potta Lokesh
</script>
Time Complexity: O(NlogN)
Auxiliary Space: O(N), since N extra space has been taken.
Similar Reads
Count of all pairs in an Array with minimum absolute difference
Given an integer array arr[] of size N, the task is to count the total number of distinct pairs having minimum absolute difference. Examples: Input: arr[] = {4, 2, 1, 3} Output: 3 Explanation: The minimum absolute difference between the pairs {1, 2}, {2, 3}, {3, 4} is 1.Input: arr[] = {1, 3, 8, 10,
5 min read
Find maximum absolute difference with min sum of ratios in an Array
Given an array of positive integers arr[], the task is to find the maximum absolute difference between the pairs from the array such that the sum of their ratios is minimum. Examples: Input: arr[] = {2, 6, 3, 4, 8, 9}Output: 4Explanation: In the above example, the ratios of every pair are calculated
7 min read
Find a pair with sum N having minimum absolute difference
Given an integer N, the task is to find a distinct pair of X and Y such that X + Y = N and abs(X - Y) is minimum. Examples: Input: N = 11Output: 5 6 Explanation:X = 5 and Y = 6 satisfy the given equation. Therefore, the minimum absolute value of abs(X - Y) = 1. Input: N = 12 Output: 5 7 Naive Approa
6 min read
Minimum value of maximum absolute difference of all adjacent pairs in an Array
Given an array arr, containing non-negative integers and (-1)s, of size N, the task is to replace those (-1)s with a common non-negative integer such that the maximum absolute difference of all adjacent pairs is minimum. Print this minimum possible value of the maximum absolute difference. Examples:
9 min read
Find the array element having minimum sum of absolute differences with all other array elements
Given an array arr[] of size N, the task is to find the minimum sum of absolute differences of an array element with all elements of another array. Input: arr[ ] = {1, 2, 3, 4, 5}, N = 5Output: 3Explanation: For arr[0](= 1): Sum = abs(2 - 1) + abs(3 - 1) + abs(4 - 1) + abs(5 - 1) = 10.For arr[1](= 2
4 min read
Minimum sum of absolute differences of pairs in a triplet from three arrays
Given three arrays a[], b[] and c[] of sizes A, B and C respectively, the task is to find the minimum possible value of abs(a[i] - b[j]) + abs(b[j] - c[k]) where 0 ? i ? A, 0 ? j ? B and 0 ? k ? C. Examples: Input: A = 3, B = 2, C = 2, a[] = {1, 8, 5}, b[] = {2, 9}, c[] = {5, 4}Output: 3Explanation:
11 min read
Pair of fibonacci numbers with a given sum and minimum absolute difference
Given an integer N(less than 10^6), the task is to find a pair of Fibonacci numbers whose sum is equal to the given N, and the absolute difference between the chosen pair is minimum. Print -1 if there is no solution. Examples: Input: N = 199 Output: 55 144 Explanation 199 can be represented as sum 5
8 min read
Sum of absolute differences of all pairs in a given array
Given a sorted array of distinct elements, the task is to find the summation of absolute differences of all pairs in the given array. Examples: Input : arr[] = {1, 2, 3, 4} Output: 10 Sum of |2-1| + |3-1| + |4-1| + |3-2| + |4-2| + |4-3| = 10 Input : arr[] = {1, 8, 9, 15, 16} Output: 74 Input : arr[]
11 min read
Queries to find minimum absolute difference between adjacent array elements in given ranges
Given an array arr[] consisting of N integers and an array query[] consisting of queries of the form {L, R}, the task for each query is to find the minimum of the absolute difference between adjacent elements over the range [L, R]. Examples: Input: arr[] = {2, 6, 1, 8, 3, 4}, query[] = {{0, 3}, {1,
15+ min read
Minimum possible sum of absolute difference of pairs from given arrays
Given two arrays a[] and b[] of size N and M respectively (N < M), the task is to find the minimum possible sum of absolute difference of pairs formed by pairing each element of array a[] with an element of array b[] Note: Each element of each array can be considered only once. Examples: Input: a
8 min read