Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Hard
  • Last Updated : 28 May, 2021

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 
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 



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




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

Javascript




<script>
// Javascript 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]
function getPairs(A, B, n)
{
    // Intitializing the difference array D
    let D = new Array(n);
 
    // Computing the difference between the
    // elements at every index and storing
    // it in the array D
    for (let i = 0; i < n; i++) {
        D[i] = A[i] - B[i];
    }
 
    // Sort the array D
    D.sort((a, b) => a - b);
 
    // Variable to store the total
    // number of pairs that satisfy
    // the given condition
    let 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 (let 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 {
            let k = upper_bound(D, 0, D.length, -D[i])
            total += n - k;
        }
    }
    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;
}
 
// Driver code
 
    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))
 
 
// This code is contributed by gfgking
</script>
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)).

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :