# Number of indices pair such that element pair sum from first Array is greater than second Array

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 + A > B + B
{0, 3}: A + A > B + B
{1, 2}: A + A > B + B
{1, 3}: A + A > B + B
{1, 4}: A + A > B + B
{2, 3}: A + A > B + B
{3, 4}: A + A > B + B

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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)

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

Below is the implementation of the above approach:

 `// 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) ` `{ ` `    ``// Intitializing 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 = n - 1; i >= 0; i--) { ` ` `  `        ``// If the value at the index i is positive, ` `        ``// then it remains positive for any pairs ` `        ``// with j such that j > i. ` `        ``if` `(D[i] > 0) { ` `            ``total += n - i - 1; ` `        ``} ` ` `  `        ``// If the value at that index is negative ` `        ``// then we need to find the index of the ` `        ``// value just greater than -D[i] ` `        ``else` `{ ` `            ``int` `k = upper_bound(D.begin(), ` `                                ``D.end(), -D[i]) ` `                    ``- D.begin(); ` `            ``total += n - k; ` `        ``} ` `    ``} ` `    ``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); ` `} `

 `// 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) ` `{ ` `    ``// Intitializing 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 = n - ``1``; i >= ``0``; i--) { ` ` `  `        ``// If the value at the index i is positive, ` `        ``// then it remains positive for any pairs ` `        ``// with j such that j > i. ` `        ``if` `(D[i] > ``0``) { ` `            ``total += n - i - ``1``; ` `        ``} ` ` `  `        ``// If the value at that index is negative ` `        ``// then we need to find the index of the ` `        ``// value just greater than -D[i] ` `        ``else` `{ ` `            ``int` `k = upper_bound(D,``0``, D.length, -D[i]); ` `            ``total += n - k; ` `        ``} ` `    ``} ` `    ``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 29AjayKumar `

 `# 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): ` ` `  `    ``# Intitializing 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``(n ``-` `1``, ``-``1``, ``-``1``): ` `  `  `        ``# If the value at the index i is positive, ` `        ``# then it remains positive for any pairs ` `        ``# with j such that j > i. ` `        ``if` `(D[i] > ``0``): ` `            ``total ``+``=` `n ``-` `i ``-` `1` `  `  `        ``# If the value at that index is negative ` `        ``# then we need to find the index of the ` `        ``# value just greater than -D[i] ` `        ``else``: ` `            ``k ``=` `bisect.bisect_right(D, ``-``D[i], ``0``, ``len``(D)) ` `            ``total ``+``=` `n ``-` `k ` `    ``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 chitranayal `

 `// 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) ` `{ ` `    ``// Intitializing 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 = n - 1; i >= 0; i--) { ` `  `  `        ``// If the value at the index i is positive, ` `        ``// then it remains positive for any pairs ` `        ``// with j such that j > i. ` `        ``if` `(D[i] > 0) { ` `            ``total += n - i - 1; ` `        ``} ` `  `  `        ``// If the value at that index is negative ` `        ``// then we need to find the index of the ` `        ``// value just greater than -D[i] ` `        ``else` `{ ` `            ``int` `k = upper_bound(D,0, D.Length, -D[i]); ` `            ``total += n - k; ` `        ``} ` `    ``} ` `    ``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 sapnasingh4991 `

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

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.

Article Tags :
Practice Tags :