Number of indices pair such that element pair sum from first Array is greater than second Array
Last Updated :
23 Nov, 2023
Given two integer arrays A[] and B[] of equal sizes, the task is to find the number of pairs of indices {i, j} in the arrays such that A[i] + A[j] > B[i] + B[j] and i < j.
Examples:
Input: A[] = {4, 8, 2, 6, 2}, B[] = {4, 5, 4, 1, 3}
Output: 7
Explanation:
There are a total of 7 pairs of indices {i, j} in the array following the condition. They are:
{0, 1}: A[0] + A[1] > B[0] + B[1]
{0, 3}: A[0] + A[3] > B[0] + B[3]
{1, 2}: A[1] + A[2] > B[1] + B[2]
{1, 3}: A[1] + A[3] > B[1] + B[3]
{1, 4}: A[1] + A[4] > B[1] + B[4]
{2, 3}: A[2] + A[3] > B[2] + B[3]
{3, 4}: A[3] + A[4] > B[3] + B[4]
Input: A[] = {1, 3, 2, 4}, B[] = {1, 3, 2, 4}
Output: 0
Explanation:
No such possible pairs of {i, j} can be found that satisfies the given condition
Naive Approach: The naive approach is to consider all the possible pairs of {i, j} in the given arrays and check if A[i] + A[j] > B[i] + B[j]. This can be done by using the concept of nested loops.
Time Complexity: O(N2)
Implementation:-
C++
#include <bits/stdc++.h>
using namespace std;
int getPairs(vector< int > A, vector< int > B, int n)
{
int ans=0;
for ( int i=0;i<n-1;i++)
{
for ( int j=i+1;j<n;j++)
{
if (A[i]+A[j]>B[i]+B[j])ans++;
}
}
return ans;
}
int main()
{
int n = 5;
vector< int > A;
vector< int > B;
A.push_back(4);
A.push_back(8);
A.push_back(2);
A.push_back(6);
A.push_back(2);
B.push_back(4);
B.push_back(5);
B.push_back(4);
B.push_back(1);
B.push_back(3);
cout << getPairs(A, B, n);
return 0;
}
|
Java
import java.util.*;
public class Main {
public static int getPairs( int [] A, int [] B, int n)
{
int ans = 0 ;
for ( int i = 0 ; i < n - 1 ; i++)
{
for ( int j = i + 1 ; j < n; j++) {
if (A[i] + A[j] > B[i] + B[j])
ans++;
}
}
return ans;
}
public static void main(String[] args)
{
int n = 5 ;
int [] A = { 4 , 8 , 2 , 6 , 2 };
int [] B = { 4 , 5 , 4 , 1 , 3 };
System.out.println(getPairs(A, B, n));
}
}
|
Python3
def getPairs(A, B, n):
ans = 0
for i in range (n - 1 ):
for j in range (i + 1 , n):
if A[i] + A[j] > B[i] + B[j]:
ans + = 1
return ans
n = 5
A = []
A.append( 4 )
A.append( 8 )
A.append( 2 )
A.append( 6 )
A.append( 2 )
B = []
B.append( 4 )
B.append( 5 )
B.append( 4 )
B.append( 1 )
B.append( 3 )
print (getPairs(A, B, n))
|
C#
using System;
using System.Collections.Generic;
public class GFG {
static int GetPairs(List< int > A, List< int > B, int n)
{
int ans = 0;
for ( int i = 0; i < n - 1; i++) {
for ( int j = i + 1; j < n; j++) {
if (A[i] + A[j] > B[i] + B[j]) {
ans++;
}
}
}
return ans;
}
static public void Main( string [] args)
{
int n = 5;
List< int > A = new List< int >{ 4, 8, 2, 6, 2 };
List< int > B = new List< int >{ 4, 5, 4, 1, 3 };
Console.WriteLine(GetPairs(A, B, n));
}
}
|
Javascript
function getPairs(A, B, n)
{
let ans = 0;
for (let i = 0; i < n - 1; i++) {
for (let j = i + 1; j < n; j++) {
if (A[i] + A[j] > B[i] + B[j])
ans++;
}
}
return ans;
}
function main()
{
let n = 5;
let A = [ 4, 8, 2, 6, 2 ];
let B = [ 4, 5, 4, 1, 3 ];
console.log(getPairs(A, B, n));
}
main();
|
Output:- 7
Time Complexity:- O(N^2)
Space Complexity:- O(1)
Efficient Approach: The key observation from the problem is that the given condition can also be visualised as (ai-bi) + (aj-bj)> 0 so we can make another array to store the difference of both arrays. let this array be D . Therefore, the problem reduces to finding pairs with Di+Dj>0. Now we can sort D array and for each corresponding element Di we will find the no of good pairs that Di can make and add this no of pairs to a count variable.For each element Di to find the no of good pairs it can make we can use the upper_bound function of the standard template library to find the upper bound of -Di. since the array is sorted so all elements present after -Di will also make good pair with Di .thus,if upper bound of -Di is x and n be the total size of array then total pairs corresponding to Di will be n-x. This approach takes O(NlogN) time.
- The given condition in the question can be rewritten as:
A[i] + A[j] > B[i] + B[j]
A[i] + A[j] - B[i] - B[j] > 0
(A[i] - B[i]) + (A[j] - B[j]) > 0
- Create another array, say D, to store the difference between elements at the corresponding index in both array, i.e.
- If we carefully look at the last condition ( (A[i] – B[i]) + (A[j] – B[j]) > 0 ) then it is quite obvious that the given condition i<j is trivial and non significant. Therefore, now we only have to find pairs in D such that their sum is > 0.
D[i] = A[i] - B[i]
- Now to make sure that the constraint i < j is satisfied, sort the difference array D, so that each element i is smaller than elements to its right.
- If at some index i, the value in the difference array D is negative, then we only need to find the nearest position ‘j’ at which the value is just greater than -D[i], so that on summation the value becomes > 0.
Inorder to find such index ‘j’, upper_bound() function or Binary Search can be used, since the array is sorted.
- If at some index i, the value in array D is positive, then that means all the values after it will be positive as well. Therefore total no. of pair from index i to n-1 will be equal to n-i-1.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int getPairs(vector< int > A, vector< int > B, int n)
{
vector< int > D(n);
for ( int i = 0; i < n; i++) {
D[i] = A[i] - B[i];
}
sort(D.begin(), D.end());
long long total = 0;
for ( int i = 0; i < n; ++i) {
if (D[i] <= 0) {
int k = upper_bound(D.begin(), D.end(), -D[i])
- D.begin();
total += n - k;
}
else {
total += n-i-1;
}
}
return total;
}
int main()
{
int n = 5;
vector< int > A;
vector< int > B;
A.push_back(4);
A.push_back(8);
A.push_back(2);
A.push_back(6);
A.push_back(2);
B.push_back(4);
B.push_back(5);
B.push_back(4);
B.push_back(1);
B.push_back(3);
cout << getPairs(A, B, n);
}
|
Java
import java.util.*;
class GFG{
static long getPairs(Vector<Integer> A, Vector<Integer> B, int n)
{
int []D = new int [n];
for ( int i = 0 ; i < n; i++)
{
D[i] = A.get(i) - B.get(i);
}
Arrays.sort(D);
long total = 0 ;
for ( int i = 0 ; i < n; ++i) {
if (D[i] <= 0 ) {
int k = upper_bound(D, 0 ,D.length, -D[i]);
total += n - k;
}
else {
total += n-i- 1 ;
}
}
return total;
}
static int upper_bound( int [] a, int low,
int high, int element)
{
while (low < high){
int middle = low + (high - low)/ 2 ;
if (a[middle] > element)
high = middle;
else
low = middle + 1 ;
}
return low;
}
public static void main(String[] args)
{
int n = 5 ;
Vector<Integer> A = new Vector<Integer>();
Vector<Integer> B= new Vector<Integer>();
A.add( 4 );
A.add( 8 );
A.add( 2 );
A.add( 6 );
A.add( 2 );
B.add( 4 );
B.add( 5 );
B.add( 4 );
B.add( 1 );
B.add( 3 );
System.out.print(getPairs(A, B, n));
}
}
|
Python3
import bisect
def getPairs(A, B, n):
D = [ 0 ] * (n)
for i in range (n):
D[i] = A[i] - B[i]
D.sort()
total = 0
for i in range ( 0 ,n):
if (D[i] < = 0 ):
k = bisect.bisect_right(D, - D[i], 0 , len (D))
total + = n - k
else :
total + = n - i - 1
return total
if __name__ = = "__main__" :
n = 5
A = []
B = []
A.append( 4 );
A.append( 8 );
A.append( 2 );
A.append( 6 );
A.append( 2 );
B.append( 4 );
B.append( 5 );
B.append( 4 );
B.append( 1 );
B.append( 3 );
print (getPairs(A, B, n))
|
C#
using System;
using System.Collections.Generic;
class GFG{
static long getPairs(List< int > A, List< int > B, int n)
{
int []D = new int [n];
for ( int i = 0; i < n; i++)
{
D[i] = A[i] - B[i];
}
Array.Sort(D);
long total = 0;
for ( int i = 0; i < n; ++i) {
if (D[i] <= 0) {
int k = upper_bound(D,0,D.Length, -D[i]);
total += n - k;
}
else {
total += n-i-1;
}
}
return total;
}
static int upper_bound( int [] a, int low,
int high, int element)
{
while (low < high){
int middle = low + (high - low)/2;
if (a[middle] > element)
high = middle;
else
low = middle + 1;
}
return low;
}
public static void Main(String[] args)
{
int n = 5;
List< int > A = new List< int >();
List< int > B= new List< int >();
A.Add(4);
A.Add(8);
A.Add(2);
A.Add(6);
A.Add(2);
B.Add(4);
B.Add(5);
B.Add(4);
B.Add(1);
B.Add(3);
Console.Write(getPairs(A, B, n));
}
}
|
Javascript
<script>
function getPairs(A, B, n)
{
let D = new Array(n);
for (let i = 0; i < n; i++) {
D[i] = A[i] - B[i];
}
D.sort((a, b) => a - b);
let total = 0;
for (int i = 0; i < n; ++i) {
if (D[i] <= 0) {
int k = upper_bound(D,0,D.length, -D[i]);
total += n - k;
}
else {
total += n-i-1;
}
}
return total;
}
function upper_bound(a, low, high, element)
{
while (low < high){
let middle = low + Math.floor((high - low)/2);
if (a[middle] > element)
high = middle;
else
low = middle + 1;
}
return low;
}
let n = 5;
let A = new Array();
let B = new Array();
A.push(4);
A.push(8);
A.push(2);
A.push(6);
A.push(2);
B.push(4);
B.push(5);
B.push(4);
B.push(1);
B.push(3);
document.write(getPairs(A, B, n))
</script>
|
Time Complexity Analysis:
- The sorting of the array takes O(N * log(N)) time.
- The time taken to find the index which is just greater than a specific value is O(Log(N)). Since in the worst case, this can be executed for N elements in the array, the overall time complexity for this is O(N * log(N)).
- Therefore, the overall time complexity is O(N * log(N)).
Share your thoughts in the comments
Please Login to comment...