Given an array arr[] consisting of N integers, the task is to count all disjoint pairs having absolute difference of at least K.
Note: The pair (arr[i], arr[j]) and (arr[j], arr[i]) are considered as the same pair.
Examples:
Input: arr[] = {1, 3, 3, 5}, K = 2
Output: 2
Explanation:
The following two pairs satisfy the necessary conditions:
- {arr[0], arr[1]} = (1, 3) whose absolute difference is |1 – 3| = 2
- {arr[2], arr[3]} = (3, 5) whose absolute difference is |3 – 5| = 2
Input: arr[] = {1, 2, 3, 4}, K = 3
Output: 1
Explanation:
The only pair satisfying the necessary conditions is {arr[0], arr[3]} = (1, 4), since |1 – 4| = 3.
Naive Approach: The simplest approach is to generate all possible pairs of the given array and count those pairs whose absolute difference is at least K and to keep track of elements that have already been taken into pairs, using an auxiliary array visited[] to mark the paired elements.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to count distinct pairs // with absolute difference atleast K void countPairsWithDiffK( int arr[],
int N, int K)
{ // Track the element that
// have been paired
int vis[N];
memset (vis, 0, sizeof (vis));
// Stores count of distinct pairs
int count = 0;
// Pick all elements one by one
for ( int i = 0; i < N; i++) {
// If already visited
if (vis[i] == 1)
continue ;
for ( int j = i + 1; j < N; j++) {
// If already visited
if (vis[j] == 1)
continue ;
// If difference is at least K
if ( abs (arr[i] - arr[j]) >= K) {
// Mark element as visited and
// increment the count
count++;
vis[i] = 1;
vis[j] = 1;
break ;
}
}
}
// Print the final count
cout << count << ' ' ;
} // Driver Code int main()
{ // Given arr[]
int arr[] = { 1, 3, 3, 5 };
// Size of array
int N = sizeof (arr) / sizeof (arr[0]);
// Given difference K
int K = 2;
// Function Call
countPairsWithDiffK(arr, N, K);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG{
// Function to count distinct pairs // with absolute difference atleast K static void countPairsWithDiffK( int arr[],
int N, int K)
{ // Track the element that
// have been paired
int []vis = new int [N];
Arrays.fill(vis, 0 );
// Stores count of distinct pairs
int count = 0 ;
// Pick all elements one by one
for ( int i = 0 ; i < N; i++)
{
// If already visited
if (vis[i] == 1 )
continue ;
for ( int j = i + 1 ; j < N; j++)
{
// If already visited
if (vis[j] == 1 )
continue ;
// If difference is at least K
if (Math.abs(arr[i] - arr[j]) >= K)
{
// Mark element as visited and
// increment the count
count++;
vis[i] = 1 ;
vis[j] = 1 ;
break ;
}
}
}
// Print the final count
System.out.print(count);
} // Driver Code public static void main(String args[])
{ // Given arr[]
int arr[] = { 1 , 3 , 3 , 5 };
// Size of array
int N = arr.length;
// Given difference K
int K = 2 ;
// Function Call
countPairsWithDiffK(arr, N, K);
} } // This code is contributed by bgangwar59 |
// C# program for the above approach using System;
class GFG{
// Function to count distinct pairs // with absolute difference atleast K static void countPairsWithDiffK( int [] arr, int N,
int K)
{ // Track the element that
// have been paired
int [] vis = new int [N];
// Stores count of distinct pairs
int count = 0;
// Pick all elements one by one
for ( int i = 0; i < N; i++)
{
// If already visited
if (vis[i] == 1)
continue ;
for ( int j = i + 1; j < N; j++)
{
// If already visited
if (vis[j] == 1)
continue ;
// If difference is at least K
if (Math.Abs(arr[i] - arr[j]) >= K)
{
// Mark element as visited and
// increment the count
count++;
vis[i] = 1;
vis[j] = 1;
break ;
}
}
}
// Print the final count
Console.Write(count);
} // Driver Code public static void Main()
{ // Given arr[]
int [] arr = { 1, 3, 3, 5 };
// Size of array
int N = arr.Length;
// Given difference K
int K = 2;
// Function Call
countPairsWithDiffK(arr, N, K);
} } // This code is contributed by chitranayal |
<script> // JavaScript implementation // for above approach // Function to count distinct pairs // with absolute difference atleast K function countPairsWithDiffK(arr, N, K)
{ // Track the element that
// have been paired
var vis = new Array(N);
vis.fill(0);
// Stores count of distinct pairs
var count = 0;
// Pick all elements one by one
for ( var i = 0; i < N; i++) {
// If already visited
if (vis[i] == 1)
continue ;
for ( var j = i + 1; j < N; j++) {
// If already visited
if (vis[j] == 1)
continue ;
// If difference is at least K
if (Math.abs(arr[i] - arr[j]) >= K) {
// Mark element as visited and
// increment the count
count++;
vis[i] = 1;
vis[j] = 1;
break ;
}
}
}
// Print the final count
document.write( count + " " );
} var arr = [ 1, 3, 3, 5 ];
// Size of array
var N = arr.length;
// Given difference K
var K = 2;
// Function Call
countPairsWithDiffK(arr, N, K);
// This code is contributed by SoumikMondal </script> |
# Python3 program for the above approach # Function to count distinct pairs # with absolute difference atleast K def countPairsWithDiffK(arr, N, K):
# Track the element that
# have been paired
vis = [ 0 ] * N
# Stores count of distinct pairs
count = 0
# Pick all elements one by one
for i in range (N):
# If already visited
if (vis[i] = = 1 ):
continue
for j in range (i + 1 , N):
# If already visited
if (vis[j] = = 1 ):
continue
# If difference is at least K
if ( abs (arr[i] - arr[j]) > = K):
# Mark element as visited and
# increment the count
count + = 1
vis[i] = 1
vis[j] = 1
break
# Print the final count
print (count)
# Driver Code if __name__ = = '__main__' :
# Given arr[]
arr = [ 1 , 3 , 3 , 5 ]
# Size of array
N = len (arr)
# Given difference K
K = 2
# Function Call
countPairsWithDiffK(arr, N, K)
# This code is contributed by mohit kumar 29 |
2
Time Complexity: O(N2)
Auxiliary Space: O(N)
Efficient Approach: The efficient idea is to use Binary Search to find the first occurrence having a difference of at least K. Below are the steps:
- Sort the given array in increasing order.
- Initialize cnt to 0 which will store the count of all possible pairs.
-
Perform the Binary Search as per the following:
- Initialize left as 0 and right as N/2 + 1.
- Find the value of mid as (left + right) / 2.
- Check if mid number of pairs can be formed by pairing leftmost M elements with rightmost M elements
- In the above steps, traverse the array over the range [0, M] and if there exists an index whose abs(arr[N – M + i] – arr[i]) is less than K then update right as (mid – 1).
- Otherwise, update left as mid + 1 and cnt as mid.
- After the above step, print the value of cnt as all possible count of pairs.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to check if it is possible to // form M pairs with abs diff at least K bool isValid( int arr[], int n, int m, int d)
{ // Traverse the array over [0, M]
for ( int i = 0; i < m; i++) {
// If valid index
if ( abs (arr[n - m + i] - arr[i]) < d) {
return 0;
}
}
// Return 1
return 1;
} // Function to count distinct pairs // with absolute difference atleast K int countPairs( int arr[], int N, int K)
{ // Stores the count of all
// possible pairs
int ans = 0;
// Initialize left and right
int left = 0, right = N / 2 + 1;
// Sort the array
sort(arr, arr + N);
// Perform Binary Search
while (left <= right) {
// Find the value of mid
int mid = (left + right) / 2;
// Check valid index
if (isValid(arr, N, mid, K)) {
// Update ans
ans = mid;
left = mid + 1;
}
else
right = mid - 1;
}
// Print the answer
cout << ans << ' ' ;
} // Driver Code int main()
{ // Given array arr[]
int arr[] = { 1, 3, 3, 5 };
// Given difference K
int K = 2;
// Size of the array
int N = sizeof (arr) / sizeof (arr[0]);
// Function call
countPairs(arr, N, K);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG{
// Function to check if it is possible to // form M pairs with abs diff at least K static int isValid( int arr[], int n, int m,
int d)
{ // Traverse the array over [0, M]
for ( int i = 0 ; i < m; i++)
{
// If valid index
if (Math.abs(arr[n - m + i] - arr[i]) < d)
{
return 0 ;
}
}
// Return 1
return 1 ;
} // Function to count distinct pairs // with absolute difference atleast K static void countPairs( int arr[], int N, int K)
{ // Stores the count of all
// possible pairs
int ans = 0 ;
// Initialize left and right
int left = 0 , right = N / 2 + 1 ;
// Sort the array
Arrays.sort(arr);
// Perform Binary Search
while (left <= right)
{
// Find the value of mid
int mid = (left + right) / 2 ;
// Check valid index
if (isValid(arr, N, mid, K) == 1 )
{
// Update ans
ans = mid;
left = mid + 1 ;
}
else
right = mid - 1 ;
}
// Print the answer
System.out.print(ans);
} // Driver Code public static void main(String args[])
{ // Given array arr[]
int arr[] = { 1 , 3 , 3 , 5 };
// Given difference K
int K = 2 ;
// Size of the array
int N = arr.length;
// Function call
countPairs(arr, N, K);
} } // This code is contributed by bgangwar59 |
// C# program for the // above approach using System;
class GFG{
// Function to check if it // is possible to form M // pairs with abs diff at // least K static int isValid( int []arr, int n,
int m, int d)
{ // Traverse the array over
// [0, M]
for ( int i = 0; i < m; i++)
{
// If valid index
if (Math.Abs(arr[n - m + i] -
arr[i]) < d)
{
return 0;
}
}
// Return 1
return 1;
} // Function to count distinct // pairs with absolute difference // atleast K static void countPairs( int []arr,
int N, int K)
{ // Stores the count of all
// possible pairs
int ans = 0;
// Initialize left
// and right
int left = 0,
right = N / 2 + 1;
// Sort the array
Array.Sort(arr);
// Perform Binary Search
while (left <= right)
{
// Find the value of mid
int mid = (left +
right) / 2;
// Check valid index
if (isValid(arr, N,
mid, K) == 1)
{
// Update ans
ans = mid;
left = mid + 1;
}
else
right = mid - 1;
}
// Print the answer
Console.WriteLine(ans);
} // Driver Code public static void Main()
{ // Given array arr[]
int []arr = {1, 3, 3, 5};
// Given difference K
int K = 2;
// Size of the array
int N = arr.Length;
// Function call
countPairs(arr, N, K);
} } // This code is contributed by surendra_gangwar |
<script> // javascript program for the above approach // Function to check if it is possible to
// form M pairs with abs diff at least K
function isValid(arr , n , m , d) {
// Traverse the array over [0, M]
for (i = 0; i < m; i++) {
// If valid index
if (Math.abs(arr[n - m + i] - arr[i]) < d) {
return 0;
}
}
// Return 1
return 1;
}
// Function to count distinct pairs
// with absolute difference atleast K
function countPairs(arr , N , K) {
// Stores the count of all
// possible pairs
var ans = 0;
// Initialize left and right
var left = 0, right = N / 2 + 1;
// Sort the array
arr.sort();
// Perform Binary Search
while (left <= right) {
// Find the value of mid
var mid = parseInt((left + right) / 2);
// Check valid index
if (isValid(arr, N, mid, K) == 1) {
// Update ans
ans = mid;
left = mid + 1;
} else
right = mid - 1;
}
// Print the answer
document.write(ans);
}
// Driver Code
// Given array arr
var arr = [ 1, 3, 3, 5 ];
// Given difference K
var K = 2;
// Size of the array
var N = arr.length;
// Function call
countPairs(arr, N, K);
// This code contributed by gauravrajput1 </script> |
# Python3 program for the above approach # Function to check if it is possible to # form M pairs with abs diff at least K def isValid(arr, n, m, d):
# Traverse the array over [0, M]
for i in range (m):
# If valid index
if ( abs (arr[n - m + i] - arr[i]) < d):
return 0
# Return 1
return 1
# Function to count distinct pairs # with absolute difference atleast K def countPairs(arr, N, K):
# Stores the count of all
# possible pairs
ans = 0
# Initialize left and right
left = 0
right = N / / 2 + 1
# Sort the array
arr.sort(reverse = False )
# Perform Binary Search
while (left < = right):
# Find the value of mid
mid = (left + right) / / 2
# Check valid index
if (isValid(arr, N, mid, K)):
# Update ans
ans = mid
left = mid + 1
else :
right = mid - 1
# Print the answer
print (ans, end = "")
# Driver Code if __name__ = = '__main__' :
# Given array arr[]
arr = [ 1 , 3 , 3 , 5 ]
# Given difference K
K = 2
# Size of the array
N = len (arr)
# Function call
countPairs(arr, N, K)
# This code is contributed by bgangwar59 |
2
Time Complexity: O(N*log N)
Auxiliary Space: O(1)