No of pairs (a[j] >= a[i]) with k numbers in range (a[i], a[j]) that are divisible by x
Given an array and two numbers x and k. Find the number of different ordered pairs of indexes (i, j) such that a[j] >= a[i] and there are exactly k integers num such that num is divisible by x and num is in range a[i]-a[j].
Examples:
Input : arr[] = {1, 3, 5, 7}
x = 2, k = 1
Output : 3
Explanation: The pairs (1, 3), (3, 5) and (5, 7)
have k (which is 1) integers i.e., 2, 4, 6
respectively for every pair in between them.
Input : arr[] = {5, 3, 1, 7}
x = 2, k = 0
Output : 4
Explanation: The pairs with indexes (1, 1), (2, 2),
(3, 3), (4, 4) have k = 0 integers that are
divisible by 2 in between them.
A naive approach is to traverse through all pairs possible and count the number of pairs that have k integers in between them which are divisible by x.
Time complexity: O(n^2), as we will be using nested loops for traversing n*n times.
An efficient approach is to sort the array and use binary search to find out the right and left boundaries of numbers(use lower_bound function inbuilt function to do it) which satisfy the condition and which do not. We have to sort the array as it is given every pair should be a[j] >= a[i] irrespective of value of i and j. After sorting we traverse through n elements, and find the number with whose multiplication with x gives a[i]-1, so that we can find k number by adding k to d = a[i]-1/x. So we binary search for the value (d+k)*x to get the multiple with which we can make a pair of a[i] as it will have exactly k integers in between a[i] and a[j]. In this way we get the left boundary for a[j] using binary search in O(log n), and for all other pairs possible with a[i], we need to find out the right-most boundary by searching the number equal to or greater than (d+k+1)*x where we will get k+1 multiples and we get the no of pairs as (right-left) boundary [index-wise].
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int countPairs( int a[], int n, int x, int k)
{
sort(a, a + n);
int ans = 0;
for ( int i = 0; i < n; i++) {
int d = (a[i] - 1) / x;
int it1 = lower_bound(a, a + n,
max((d + k) * x, a[i])) - a;
int it2 = lower_bound(a, a + n,
max((d + k + 1) * x, a[i])) - a;
ans += it2 - it1;
}
return ans;
}
int main()
{
int a[] = { 1, 3, 5, 7 };
int n = sizeof (a) / sizeof (a[0]);
int x = 2, k = 1;
cout << countPairs(a, n, x, k);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int countPairs( int a[], int n, int x, int k)
{
Arrays.sort(a);
int ans = 0 ;
for ( int i = 0 ; i < n; i++)
{
int d = (a[i] - 1 ) / x;
int it1 = Arrays.binarySearch(a,
Math.max((d + k) * x, a[i]));
int it2 = Arrays.binarySearch(a,
Math.max((d + k + 1 ) * x, a[i])) ;
ans += it1 - it2;
}
return ans;
}
public static void main(String[] args)
{
int []a = { 1 , 3 , 5 , 7 };
int n = a.length;
int x = 2 , k = 1 ;
System.out.println(countPairs(a, n, x, k));
}
}
|
Python3
import bisect
def countPairs(a, n, x, k):
a.sort()
ans = 0
for i in range (n):
d = (a[i] - 1 ) / / x
it1 = bisect.bisect_left(a, max ((d + k) * x, a[i]))
it2 = bisect.bisect_left(a, max ((d + k + 1 ) * x, a[i]))
ans + = it2 - it1
return ans
if __name__ = = "__main__" :
a = [ 1 , 3 , 5 , 7 ]
n = len (a)
x = 2
k = 1
print (countPairs(a, n, x, k))
|
C#
using System;
class GFG{
static int countPairs( int [] a, int n,
int x, int k)
{
Array.Sort(a);
int ans = 0;
for ( int i = 0; i < n; i++)
{
int d = (a[i] - 1) / x;
int a1 = Math.Max((d + k) * x, a[i]);
int it1 = Array.BinarySearch(a, a1);
int a2 = Math.Max((d + k + 1) * x, a[i]);
int it2 = Array.BinarySearch(a, a2);
ans += Math.Abs(it2 - it1);
}
return ans;
}
static void Main()
{
int [] a = { 1, 3, 5, 7 };
int n = a.Length;
int x = 2, k = 1;
Console.Write(countPairs(a, n, x, k));
}
}
|
Javascript
function lower_bound(arr, N, X)
{
let mid;
let low = 0;
let high = N;
while (low < high) {
mid = low + (high - low) / 2;
if (X <= arr[mid]) {
high = mid;
}
else {
low = mid + 1;
}
}
if (low < N && arr[low] < X) {
low++;
}
return low;
}
function countPairs(a, n, x, k)
{
a.sort();
let ans = 0;
for (let i = 0; i < n; i++) {
let d = (a[i] - 1) / x;
let it1 = lower_bound(a, n,
Math.max((d + k) * x, a[i]));
let it2 = lower_bound(
a, n, Math.max((d + k + 1) * x, a[i]));
ans += it2 - it1;
}
return ans;
}
let a = [ 1, 3, 5, 7 ];
let n = 4;
let x = 2, k = 1;
console.log(countPairs(a, n, x, k));
|
Time Complexity: O(N*logN), as we are using sort function which will cost N*logN.
Auxiliary Space: O(1), as we are not using any extra space.
Last Updated :
03 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...