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

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:0Explanation:

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(N^{2})

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

`// C++ program to find the number of indices pair` `// such that pair sum from first Array` `// is greater than second Array` ` ` `#include <bits/stdc++.h>` `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

`// 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<Integer> A, Vector<Integer> 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<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));` `}` `}` ` ` `// This code is contributed by 29AjayKumar` |

## 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):` ` ` ` ` `# 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#

`// 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))**.