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:
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:
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++

 `// C++ program to find the number of indices pair` `// such that pair sum from first Array` `// is greater than second Array`   `#include ` `using` `namespace` `std;`   `// Function to get the number of pairs of indices` `// {i, j} in the given two arrays A and B such that` `// A[i] + A[j] > B[i] + B[j]` `int` `getPairs(vector<``int``> A, vector<``int``> B, ``int` `n)` `{` `      ``//variable to store answer` `      ``int` `ans=0;` `      `  `      ``//iterating over array` `      ``for``(``int` `i=0;iB[i]+B[j])ans++;` `        ``}` `    ``}` `      ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `      ``//size of array A and B` `    ``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;` `}` `//code contributed by shubhamrajput6156`

Java

 `// Java program to find the number of indices pair such that` `// pair sum from first Array is greater than second Array`   `import` `java.util.*;`   `public` `class` `Main {`   `    ``// Function to get the number of pairs of indices` `    ``// {i, j} in the given two arrays A and B such that` `    ``// A[i] + A[j] > B[i] + B[j]` `    ``public` `static` `int` `getPairs(``int``[] A, ``int``[] B, ``int` `n)` `    ``{` `        ``// variable to store answer` `        ``int` `ans = ``0``;`   `            ``// iterating over array` `            ``for` `(``int` `i = ``0``; i < n - ``1``; i++)` `        ``{` `            ``for` `(``int` `j = i + ``1``; j < n; j++) {` `                ``// if found such element then increase` `                ``// answer` `                ``if` `(A[i] + A[j] > B[i] + B[j])` `                    ``ans++;` `            ``}` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// size of array A and B` `        ``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

 `# Python 3 program to find the number of indices pair` `# such that pair sum from first Array` `# is greater than second Array`   `# Function to get the number of pairs of indices` `# {i, j} in the given two arrays A and B such that` `# A[i] + A[j] > B[i] + B[j]` `def` `getPairs(A, B, n):` `  `  `      ``# variable to store answer` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(n ``-` `1``):` `        ``for` `j ``in` `range``(i ``+` `1``, n):` `          `  `            ``# if found such element then increase answer` `            ``if` `A[i] ``+` `A[j] > B[i] ``+` `B[j]:` `                ``ans ``+``=` `1` `    ``return` `ans`   `  ``#driver code` `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))`   `# This code is contributed by redmoonz.`

C#

 `// C# program to find the number of indices pair such that` `// pair sum from first Array is greater than second Array` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``// Function to get the number of pairs of indices` `  ``// {i, j} in the given two arrays A and B such that` `  ``// A[i] + A[j] > B[i] + B[j]` `  ``static` `int` `GetPairs(List<``int``> A, List<``int``> B, ``int` `n)` `  ``{`   `    ``// variable to store answer` `    ``int` `ans = 0;`   `    ``// iterating over array` `    ``for` `(``int` `i = 0; i < n - 1; i++) {` `      ``for` `(``int` `j = i + 1; j < n; j++) {`   `        ``// if found such element then increase` `        ``// answer` `        ``if` `(A[i] + A[j] > B[i] + B[j]) {` `          ``ans++;` `        ``}` `      ``}` `    ``}`   `    ``return` `ans;` `  ``}`   `  ``// Driver code` `  ``static` `public` `void` `Main(``string``[] args)` `  ``{`   `    ``// size of array A and B` `    ``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));` `  ``}` `}`   `// This Code is Contributed by Prasad Kandekar(prasad264)`

Javascript

 `// Function to get the number of pairs of indices` `// {i, j} in the given two arrays A and B such that` `// A[i] + A[j] > B[i] + B[j]`   `function` `getPairs(A, B, n)` `{` `    ``// variable to store answer` `    ``let ans = 0;`   `    ``// iterating over array` `    ``for` `(let i = 0; i < n - 1; i++) {` `        ``for` `(let j = i + 1; j < n; j++) {` `            ``// if found such element then increase answer` `            ``if` `(A[i] + A[j] > B[i] + B[j])` `                ``ans++;` `        ``}` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `function` `main()` `{` `    ``// size of array A and B` `    ``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++

 `// C++ program to find the number of indices pair` `// such that pair sum from first Array` `// is greater than second Array`   `#include ` `using` `namespace` `std;`   `// Function to get the number of pairs of indices` `// {i, j} in the given two arrays A and B such that` `// A[i] + A[j] > B[i] + B[j]` `int` `getPairs(vector<``int``> A, vector<``int``> B, ``int` `n)` `{` `    ``// Initializing the difference array D` `    ``vector<``int``> D(n);`   `    ``// Computing the difference between the` `    ``// elements at every index and storing` `    ``// it in the array D` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``D[i] = A[i] - B[i];` `    ``}`   `    ``// Sort the array D` `    ``sort(D.begin(), D.end());`   `    ``// Variable to store the total` `    ``// number of pairs that satisfy` `    ``// the given condition` `    ``long` `long` `total = 0;`   `    ``// Loop to iterate through the difference` `    ``// array D and find the total number` `    ``// of pairs of indices that follow the` `    ``// given condition` `    ``for` `(``int` `i = 0; i < n; ++i) {`   `        ``// If the value at that index is negative or zero` `        ``// then we need to find the index of the` `        ``// value just greater than -D[i]` `        ``if` `(D[i] <= 0) {` `            ``int` `k = upper_bound(D.begin(), D.end(), -D[i])` `                    ``- D.begin();` `            ``total += n - k;` `        ``}`   `        ``// If the value at the index is positive` `        ``// then we need to find the number of indexes after i-th index` `      `  `        ``else` `{` `            ``total += n-i-1;` `        ``}` `    ``}` `    ``return` `total;` `}`   `// Driver code` `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);` `}`   `// This code is contributed by Udit Mehta`

Java

 `// Java program to find the number of indices pair` `// such that pair sum from first Array` `// is greater than second Array` `import` `java.util.*;`   `class` `GFG{`   `// Function to get the number of pairs of indices` `// {i, j} in the given two arrays A and B such that` `// A[i] + A[j] > B[i] + B[j]` `static` `long` `getPairs(Vector A, Vector B, ``int` `n)` `{` `    ``// Initializing the difference array D` `    ``int` `[]D = ``new` `int``[n];`   `    ``// Computing the difference between the` `    ``// elements at every index and storing` `    ``// it in the array D` `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``D[i] = A.get(i) - B.get(i);` `    ``}`   `    ``// Sort the array D` `    ``Arrays.sort(D);`   `    ``// Variable to store the total` `    ``// number of pairs that satisfy` `    ``// the given condition` `    ``long` `total = ``0``;`   `    ``// Loop to iterate through the difference` `    ``// array D and find the total number` `    ``// of pairs of indices that follow the` `    ``// given condition` `    ``for` `(``int` `i = ``0``; i < n; ++i) {`   `        ``// If the value at that index is negative or zero` `        ``// then we need to find the index of the` `        ``// value just greater than -D[i]` `        ``if` `(D[i] <= ``0``) {` `            ``int` `k = upper_bound(D,``0``,D.length, -D[i]);` `            ``total += n - k;` `        ``}`   `        ``// If the value at the index is positive` `        ``// then we need to find the number of indexes after i-th index` `      `  `        ``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;` `} `   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``5``;` `    ``Vector A = ``new` `Vector();` `    ``Vector B= ``new` `Vector();`   `    ``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));` `}` `}`   `// This code is contributed by Udit Mehta`

Python3

 `# Python 3 program to find the number of indices pair` `# such that pair sum from first Array` `# is greater than second Array` `import` `bisect `   `# Function to get the number of pairs of indices` `# {i, j} in the given two arrays A and B such that` `# A[i] + A[j] > B[i] + B[j]` `def` `getPairs(A,  B, n):`   `    ``# Initializing the difference array D` `    ``D ``=` `[``0``]``*``(n)` ` `  `    ``# Computing the difference between the` `    ``# elements at every index and storing` `    ``# it in the array D` `    ``for` `i ``in` `range``(n):` `        ``D[i] ``=` `A[i] ``-` `B[i]` ` `  `    ``# Sort the array D` `    ``D.sort()` ` `  `    ``# Variable to store the total` `    ``# number of pairs that satisfy` `    ``# the given condition` `    ``total ``=` `0` ` `  `    ``# Loop to iterate through the difference` `    ``# array D and find the total number` `    ``# of pairs of indices that follow the` `    ``# given condition` `    ``for` `i ``in` `range``(``0``,n):` ` `  `        ``# If the value at that index is negative` `        ``# then we need to find the index of the` `        ``# value just greater than -D[i]` `       ``if``(D[i] <``=`  `0``):` `            ``k ``=` `bisect.bisect_right(D, ``-``D[i], ``0``, ``len``(D))` `            ``total ``+``=` `n ``-` `k` `            `  `        ``# If the value at the index i is positive,` `        ``# then we need to find the number of indexes after i-th index` `        `  `       ``else``:` `            ``total ``+``=` `n``-``i``-``1` ` `  `        `  `    ``return` `total` ` `  `# Driver code` `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))`   `# This code is contributed by Udit Mehta`

C#

 `// C# program to find the number of indices pair` `// such that pair sum from first Array` `// is greater than second Array` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{` ` `  `// Function to get the number of pairs of indices` `// {i, j} in the given two arrays A and B such that` `// A[i] + A[j] > B[i] + B[j]` `static` `long` `getPairs(List<``int``> A, List<``int``> B, ``int` `n)` `{` `    ``// Initializing the difference array D` `    ``int` `[]D = ``new` `int``[n];` ` `  `    ``// Computing the difference between the` `    ``// elements at every index and storing` `    ``// it in the array D` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``{` `        ``D[i] = A[i] - B[i];` `    ``}` ` `  `    ``// Sort the array D` `    ``Array.Sort(D);` ` `  `    ``// Variable to store the total` `    ``// number of pairs that satisfy` `    ``// the given condition` `    ``long` `total = 0;` ` `  `    ``// Loop to iterate through the difference` `    ``// array D and find the total number` `    ``// of pairs of indices that follow the` `    ``// given condition` `    ``for` `(``int` `i = 0; i < n; ++i) {`   `        ``// If the value at that index is negative or zero` `        ``// then we need to find the index of the` `        ``// value just greater than -D[i]` `        ``if` `(D[i] <= 0) {` `            ``int` `k = upper_bound(D,0,D.Length, -D[i]);` `            ``total += n - k;` `        ``}`   `        ``// If the value at the index is positive` `        ``// then we need to find the number of indexes after i-th index` `        ``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;` `} ` ` `  `// Driver code` `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));` `}` `}`   `// This code is contributed by Udit Mehta`

Javascript

 ``   `// This code is contributed by Udit Mehta`

Output

```7

```

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)).