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++
// 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)
{
//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
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 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));
}
}
# 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# 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)
// 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 <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)
{
// 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 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)
{
// 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<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 Udit Mehta
# 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# 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
<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)
{
// Initializing 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 (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;
}
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))
</script>
// This code is contributed by Udit Mehta
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)).
Similar Reads
Number of pairs in an array such that product is greater than sum
Given a array a[] of non-negative integers. Count the number of pairs (i, j) in the array such that a[i] + a[j] < a[i]*a[j]. (the pair (i, j) and (j, i) are considered same and i should not be equal to j) Examples: Input : a[] = {3, 4, 5} Output : 3 Pairs are (3, 4) , (4, 5) and (3,5) Input : a[]
8 min read
Count of distinct index pair (i, j) such that element sum of First Array is greater
Given two arrays a[] and b[], both of size N. The task is to count the number of distinct pairs such that (a[i] + a[j] ) > ( b[i] + b[j] ) subject to condition that (j > i). Examples: Input: N = 5, a[] = {1, 2, 3, 4, 5}, b[] = {2, 5, 6, 1, 9} Output: 1 Explanation: Only one such pair exists an
13 min read
Check if all K-length subset sums of first array greater than that of the second array
Given two arrays A[] and B[] of size N and an integer K, the task is to check if all possible subset-sums of subsets of size K of the array A[] are greater than that of the array B[] or not. If found to be true, then print "YES". Otherwise, print "NO". Examples: Input: A[] = {12, 11, 10, 13}, B[] =
7 min read
Count of pairs from arrays A and B such that element in A is greater than element in B at that index
Given two arrays A[] and B[] of size N, the task is to count the maximum number of pairs, where each pair contains one from each array, such that A[i] > B[i]. Also the array A can be rearranged any number of times. Examples: Input: A[] = {20, 30, 50}, B[]= {60, 40, 25} Output: 2 Explanation: Init
7 min read
Choose two elements from the given array such that their sum is not present in any of the arrays
Given two arrays A[] and B[], the task is to choose two elements X and Y such that X belongs to A[] and Y belongs to B[] and (X + Y) must not be present in any of the array.Examples: Input: A[] = {3, 2, 2}, B[] = {1, 5, 7, 7, 9} Output: 3 9 3 + 9 = 12 and 12 is not present in any of the given arrays
5 min read
Minimize swap of elements such that one Array has greater sum than other
Given two arrays A[] and B[] with size N and M, the task is to find the minimum number of swaps between two arrays (can be any two element of two arrays) required to make the sum of array A[] strictly greater than array B[]. Examples: Input: N = 5, A[] = {1, 5, 4, 6, 2}, M = 7, B[] = {0, 1, 17, 4, 6
15+ min read
Minimum sum of two elements from two arrays such that indexes are not same
Given two arrays a[] and b[] of same size. Task is to find minimum sum of two elements such that they belong to different arrays and are not at same index in their arrays. Examples: Input : a[] = {5, 4, 13, 2, 1} b[] = {2, 3, 4, 6, 5}Output : 3We take 1 from a[] and 2 from b[]Sum is 1 + 2 = 3.Input
15+ min read
Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
Given two unsorted arrays arr1[] and arr2[], the task is to find the sum of elements of arr1[] such that the number of elements less than or equal to them in arr2[] is maximum. Examples: Input: arr1[] = {1, 2, 3, 4, 7, 9}, arr2[] = {0, 1, 2, 1, 1, 4} Output: 20 Below table shows the count of element
15 min read
Sum of all array elements less than X and greater than Y for Q queries
Given a sorted array arr[], and a set Q having M queries, where each query has values X and Y, the task is to find the sum of all integers less than X and greater than Y present in the array. Note: X and Y may or may not be present in the array. Examples: Input: arr[] = [3 5 8 12 15], Q = {{5, 12},
9 min read
Find pairs with given sum such that elements of pair are in different rows
Given a matrix of distinct values and a sum. The task is to find all the pairs in a given matrix whose summation is equal to the given sum. Each element of a pair must be from different rows i.e; the pair must not lie in the same row.Examples: Input : mat[][] = {{1, 3, 2, 4}, {5, 8, 7, 6}, {9, 10, 1
15+ min read