# Median of difference of all pairs from an Array

• Last Updated : 29 May, 2021

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.
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.
• 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++

 `// C++ Program to implement ` `// the above approach ` `#include ` `#define ll long long ` `using` `namespace` `std; `   `// Function check if mid can be median ` `// index of the difference array ` `bool` `possible(ll mid, vector& 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 ` `    ``// difference 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& a) ` `{ `   `    ``// Size of the array ` `    ``ll n = a.size(); `   `    ``// Initialising the low and high ` `    ``ll low = 0, high = a[n - 1] - a; `   `    ``// 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 a = { 1, 7, 5, 2 }; `   `    ``sort(a.begin(), a.end()); `   `    ``cout << findMedian(a) << endl; ` `} `

## Java

 `// 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 ` `    ``// difference 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`

## Python3

 `# 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 ` `    ``# difference 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`

## C#

 `// 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 ` `    ``// difference 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; `   `    ``// 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`

## Javascript

 ``

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 an array.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :