Median of difference of all pairs from an Array

Given an array arr[] of length N, the task is to find the median of the differences of all pairs of the array elements.

Example:

Input: arr[] = {1, 2, 3, 4} 
Output:
Explanation: 
The difference of all pairs from the given array are {2 – 1, 3 – 2, 4 – 3, 3 – 1, 4 – 2, 4 – 1} = {1, 1, 1, 2, 2, 3}. 
Since the array contains 6 elements, the median is the element at index 3 of the difference array. 
Therefore, the answer is 1.

Input: arr[] = {1, 3, 5} 
Output:
Explanation: The difference array is {2, 2, 4}. Therefore, the median is 2. 
 

Naive Approach: The task is to generate all possible pairs from the given array and calculate the difference of every pair in the array arr[] and store them in the array diff[]. Sort diff[] and find the middle element. 



Time Complexity: O(N2*log(N2)) 
Auxiliary Space: O(N2)

Efficient Approach: The above approach can be optimized using Binary Search and Sorting. Follow the below steps to solve the problem:

  • Sort the given array.
  • Initialize low=0 and high=arr[N-1]-arr[0].
  • Calculate mid equal to (low + high) / 2.
  • Calculate the number of differences less than mid. If it exceeds the median index of the difference array, [ceil(N * (N – 1) / 2)], then update high as mid – 1. Otherwise, update low as mid + 1.
  • Repeat the above steps until low and high becomes equal.

Below is the implementation above approach: 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement 
// the above approach 
#include <bits/stdc++.h> 
#define ll long long 
using namespace std; 
  
// Function check if mid can be median 
// index of the difference array 
bool possible(ll mid, vector<ll>& a) 
  
    // Size of the array 
    ll n = a.size(); 
  
    // Total possible no of pair 
    // possible 
    ll total = (n * (n - 1)) / 2; 
  
    // The index of the element in the 
    // differece of all pairs 
    // from the array 
    ll need = (total + 1) / 2; 
  
    ll count = 0; 
    ll start = 0, end = 1; 
  
    // Count the number of pairs 
    // having difference <= mid 
    while (end < n) { 
  
        if (a[end] - a[start] <= mid) { 
            end++; 
        
        else
            count += (end - start - 1); 
            start++; 
        
    
  
    // If the difference between end 
    // and first element is less then 
    // or equal to mid 
    if (end == n && start < end 
        && a[end - 1] - a[start] <= mid) { 
  
        ll t = end - start - 1; 
  
        count += (t * (t + 1) / 2); 
    
  
    // Checking for the no of element less than 
    // or equal to mid is greater than median or 
    // not 
    if (count >= need) 
        return true
    else
        return false
  
// Function to calculate the median 
// of differences of all pairs 
// from the array 
ll findMedian(vector<ll>& a) 
  
    // Size of the array 
    ll n = a.size(); 
  
    // Initialising the low and high 
    ll low = 0, high = a[n - 1] - a[0]; 
  
    // Binary search 
    while (low <= high) { 
  
        // Calculate mid 
        ll mid = (low + high) / 2; 
  
        // If mid can be the median 
        // of the array 
        if (possible(mid, a)) 
            high = mid - 1; 
        else
            low = mid + 1; 
    
  
    // Returning the median of the 
    // differences of pairs from 
    // the array 
    return high + 1; 
  
// Driver Code 
int main() 
  
    vector<ll> a = { 1, 7, 5, 2 }; 
  
    sort(a.begin(), a.end()); 
  
    cout << findMedian(a) << endl; 

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement 
// the above approach 
import java.util.*;
  
class GFG{
  
// Function check if mid can be median 
// index of the difference array 
static boolean possible(long mid, int[] a) 
  
    // Size of the array 
    long n = a.length; 
  
    // Total possible no of pair 
    // possible 
    long total = (n * (n - 1)) / 2
  
    // The index of the element in the 
    // differece of all pairs 
    // from the array 
    long need = (total + 1) / 2
  
    long count = 0
    long start = 0, end = 1
  
    // Count the number of pairs 
    // having difference <= mid 
    while (end < n)
    
        if (a[(int)end] - a[(int)start] <= mid)
        
            end++; 
        
        else 
        
            count += (end - start - 1); 
            start++; 
        
    
  
    // If the difference between end 
    // and first element is less then 
    // or equal to mid 
    if (end == n && start < end &&
        a[(int)end - 1] - a[(int)start] <= mid) 
    
        long t = end - start - 1
        count += (t * (t + 1) / 2); 
    
  
    // Checking for the no of element less than 
    // or equal to mid is greater than median or 
    // not 
    if (count >= need) 
        return true
    else
        return false
  
// Function to calculate the median 
// of differences of all pairs 
// from the array 
static long findMedian(int[] a) 
  
    // Size of the array 
    long n = a.length; 
  
    // Initialising the low and high 
    long low = 0, high = a[(int)n - 1] - a[0]; 
  
    // Binary search 
    while (low <= high)
    
  
        // Calculate mid 
        long mid = (low + high) / 2
  
        // If mid can be the median 
        // of the array 
        if (possible(mid, a)) 
            high = mid - 1
        else
            low = mid + 1
    
  
    // Returning the median of the 
    // differences of pairs from 
    // the array 
    return high + 1
  
}
  
// Driver code
public static void main (String[] args)
{
    int[] a = { 1, 7, 5, 2 }; 
      
    Arrays.sort(a); 
      
    System.out.println(findMedian(a));
}
}
  
// This code is contributed by offbeat

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement 
# the above approach 
  
# Function check if mid can be median 
# index of the difference array 
def possible(mid, a): 
  
    # Size of the array 
    n = len(a); 
  
    # Total possible no of pair 
    # possible 
    total = (n * (n - 1)) // 2
  
    # The index of the element in the 
    # differece of all pairs 
    # from the array 
    need = (total + 1) // 2
  
    count = 0
    start = 0; end = 1
  
    # Count the number of pairs 
    # having difference <= mid 
    while (end < n):
        if (a[end] - a[start] <= mid):
            end += 1
          
        else:
            count += (end - start - 1); 
            start += 1
  
    # If the difference between end 
    # and first element is less then 
    # or equal to mid 
    if (end == n and start < end and 
      a[end - 1] - a[start] <= mid):
        t = end - start - 1
  
        count += (t * (t + 1) // 2); 
  
    # Checking for the no of element 
    # less than or equal to mid is 
    # greater than median or not 
    if (count >= need):
        return True
    else:
        return False
  
# Function to calculate the median 
# of differences of all pairs 
# from the array 
def findMedian(a): 
  
    # Size of the array 
    n = len(a); 
  
    # Initialising the low and high 
    low = 0; high = a[n - 1] - a[0]; 
  
    # Binary search 
    while (low <= high):
  
        # Calculate mid 
        mid = (low + high) // 2
  
        # If mid can be the median 
        # of the array 
        if (possible(mid, a)):
            high = mid - 1
        else :
            low = mid + 1
  
    # Returning the median of the 
    # differences of pairs from 
    # the array 
    return high + 1
  
# Driver Code 
if __name__ == "__main__"
  
    a = [ 1, 7, 5, 2 ]; 
      
    a.sort()
      
    print(findMedian(a));
      
# This code is contributed by AnkitRai01

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement 
// the above approach 
using System;
  
class GFG{
  
// Function check if mid can be median 
// index of the difference array 
static bool possible(long mid, int[] a) 
  
    // Size of the array 
    long n = a.Length; 
  
    // Total possible no of pair 
    // possible 
    long total = (n * (n - 1)) / 2; 
  
    // The index of the element in the 
    // differece of all pairs 
    // from the array 
    long need = (total + 1) / 2; 
  
    long count = 0; 
    long start = 0, end = 1; 
  
    // Count the number of pairs 
    // having difference <= mid 
    while (end < n)
    
        if (a[(int)end] - a[(int)start] <= mid)
        
            end++; 
        
        else
        
            count += (end - start - 1); 
            start++; 
        
    
  
    // If the difference between end 
    // and first element is less then 
    // or equal to mid 
    if (end == n && start < end &&
          a[(int)end - 1] - a[(int)start] <= mid) 
    
        long t = end - start - 1; 
        count += (t * (t + 1) / 2); 
    
  
    // Checking for the no of element less than 
    // or equal to mid is greater than median or 
    // not 
    if (count >= need) 
        return true
    else
        return false
  
// Function to calculate the median 
// of differences of all pairs 
// from the array 
static long findMedian(int[] a) 
  
    // Size of the array 
    long n = a.Length; 
  
    // Initialising the low and high 
    long low = 0, high = a[(int)n - 1] - a[0]; 
  
    // Binary search 
    while (low <= high)
    
  
        // Calculate mid 
        long mid = (low + high) / 2; 
  
        // If mid can be the median 
        // of the array 
        if (possible(mid, a)) 
            high = mid - 1; 
        else
            low = mid + 1; 
    
  
    // Returning the median of the 
    // differences of pairs from 
    // the array 
    return high + 1; 
}
  
// Driver code
public static void Main (string[] args)
{
    int[] a = { 1, 7, 5, 2 }; 
      
    Array.Sort(a); 
      
    Console.Write(findMedian(a));
}
}
  
// This code is contributed by rutvik_56

chevron_right


Output: 

3

Time Complexity: O(N*log(M)), where N is the number of elements and M is the maximum difference among pairs of elements of array. 
Auxiliary Space: O(1)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : AnkitRai01, offbeat, rutvik_56