Find all pairs in an Array in sorted order with minimum absolute difference
Last Updated :
08 Oct, 2023
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;
vector<vector< int >> minAbsDiffPairs(vector< int >& arr) {
sort(arr.begin(), arr.end());
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;
}
int main() {
vector< int > arr = { 4, 2, 1, 3 };
vector<vector< int >> pairs = minAbsDiffPairs(arr);
for ( auto v : pairs) {
cout << v[0] << " " << v[1] << endl;
}
return 0;
}
|
Java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
public static List<List<Integer>> minAbsDiffPairs( int [] arr) {
Arrays.sort(arr);
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 (diff < minDiff) {
minDiff = diff;
pairs.clear();
pairs.add(Arrays.asList(arr[i], arr[i + 1 ]));
}
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);
for (List<Integer> pair : pairs) {
System.out.println(pair.get( 0 ) + " " + pair.get( 1 ));
}
}
}
|
Python
def min_abs_diff_pairs(arr):
arr.sort()
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
if __name__ = = "__main__" :
arr = [ 4 , 2 , 1 , 3 ]
pairs = min_abs_diff_pairs(arr)
for v in pairs:
print (v[ 0 ], v[ 1 ])
|
C#
using System;
using System.Collections.Generic;
using System.Linq;
public class GFG {
public static List<List< int > >
MinAbsDiffPairs(List< int > arr)
{
arr.Sort();
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);
foreach ( var v in pairs)
{
Console.WriteLine(v[0] + " " + v[1]);
}
}
}
|
Javascript
function minAbsDiffPairs(arr) {
arr.sort((a, b) => a - b);
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;
}
let arr = [ 4, 2, 1, 3 ];
let pairs = minAbsDiffPairs(arr);
for (let v of pairs) {
console.log(v[0]+ " " + v[1]);
}
|
Output:
1 2
2 3
3 4
Time Complexity: O(n^2 log n), where n is the size of the input array. This is because we are using a nested loop to compare each pair of elements in the array, and the sorting operation inside the outer loop has a time complexity of O(n log n).
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++
#include <bits/stdc++.h>
using namespace std;
vector<vector< int > > minAbsDiffPairs(vector< int >& arr)
{
vector<vector< int > > ans;
int n = arr.size();
sort(arr.begin(), arr.end());
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;
}
int main()
{
vector< int > arr = { 4, 2, 1, 3 };
int N = ( sizeof arr) / ( sizeof arr[0]);
vector<vector< int > > pairs = minAbsDiffPairs(arr);
for ( auto v : pairs)
cout << v[0] << " " << v[1] << endl;
return 0;
}
|
Java
import java.util.ArrayList;
import java.util.Collections;
class GFG
{
static ArrayList<ArrayList<Integer>> minAbsDiffPairs(ArrayList<Integer> arr) {
ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();
int n = arr.size();
Collections.sort(arr);
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;
}
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);
for (ArrayList<Integer> v : pairs) {
for ( int w : v)
System.out.print(w + " " );
System.out.println( "" );
}
}
}
|
Python3
import math as Math
def minAbsDiffPairs(arr):
ans = []
n = len (arr)
arr.sort()
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
arr = [ 4 , 2 , 1 , 3 ]
N = len (arr)
pairs = minAbsDiffPairs(arr)
for v in pairs:
print (f "{v[0]} {v[1]}" )
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static List<List< int >> minAbsDiffPairs(List< int > arr) {
List<List< int >> ans = new List<List< int >>();
int n = arr.Count;
arr.Sort();
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;
}
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);
foreach (List< int > v in pairs)
{
foreach ( int w in v)
Console.Write(w + " " );
Console.WriteLine( "" );
}
}
}
|
Javascript
<script>
function minAbsDiffPairs(arr)
{
let ans = [];
let n = arr.length;
arr.sort( function (a, b) { return a - b })
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;
}
let arr = [4, 2, 1, 3];
let N = arr.length;
let pairs = minAbsDiffPairs(arr);
for (let v of pairs)
document.write(v[0] + " " + v[1] + '<br>' )
</script>
|
Time Complexity: O(NlogN)
Auxiliary Space: O(N), since N extra space has been taken.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...