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:
#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^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++ 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>
|
1 2 2 3 3 4
Time Complexity: O(NlogN)
Auxiliary Space: O(N), since N extra space has been taken.