Skip to content
Related Articles

Related Articles

Improve Article

Count pairs from two arrays with difference exceeding K

  • Last Updated : 23 Jun, 2021

Given two integer arrays arr[] and brr[] consisting of distinct elements of size N and M respectively and an integer K, the task is to find the count of pairs(arr[i], brr[j]) such that (brr[j] – arr[i]) > K.

Examples:

Input: arr[] = {5, 9, 1, 8}, brr[] {10, 12, 7, 4, 2, 3}, K = 3 
Output:
Explanation: 
Possible pairs that satisfy the given conditions are: { (5, 10), (5, 12), (1, 10), (1, 12), (1, 7), (8, 12) }. 
Therefore, the required output is 6.

Input: arr[] = {2, 10}, brr[] = {5, 7}, K = 2 
Output:
Explanation: 
Possible pairs that satisfy the given conditions are: { (2, 5), (2, 7) }. 
Therefore, the required output is 2.

Naive approach: The simplest approach to solve this problem is to traverse the array and generate all possible pairs of the given array and for each pair, check if (brr[j] – arr[i]) > K or not. If found to be true then increment the counter. Finally, print the value of the counter.



Time Complexity: O(N × M)
Auxiliary Space: O(1)

Efficient approach: To optimize the above approach the idea is to first sort the array and then use two pointer techniques. Follow the steps below to solve the problem:

  • Initialize a variable, say cntPairs to store the count of pairs that satisfy the given conditions.
  • Sort the given array.
  • Initialize two variables, say i = 0 and j = 0 to store the index of left and right pointers respectively.
  • Traverse both the array and check if (brr[j] – arr[i]) > K or not. If found to be true then update the value of cntPairs += (M – j) and increment the value of i pointer variable.
  • Otherwise, increment the value of j pointer variable.
  • Finally, print the value of cntPrint.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count pairs that satisfy
// the given conditions
int count_pairs(int arr[], int brr[],
                int N, int M, int K)
{
    // Stores index of
    // the left pointer.
    int i = 0;
 
    // Stores index of
    // the right pointer
    int j = 0;
 
    // Stores count of total pairs
    // that satisfy the conditions
    int cntPairs = 0;
 
    // Sort arr[] array
    sort(arr, arr + N);
 
    // Sort brr[] array
    sort(brr, brr + M);
 
    // Traverse both the array
    // and count then pairs
    while (i < N && j < M) {
 
        // If the value of
        // (brr[j] - arr[i]) exceeds K
        if (brr[j] - arr[i] > K) {
 
            // Update cntPairs
            cntPairs += (M - j);
 
            // Update
            i++;
        }
        else {
 
            // Update j
            j++;
        }
    }
 
    return cntPairs;
}
 
// Driver Code
int main()
{
    int arr[] = { 5, 9, 1, 8 };
    int brr[] = { 10, 12, 7, 4, 2, 3 };
    int K = 3;
    int N = sizeof(arr) / sizeof(arr[0]);
    int M = sizeof(brr) / sizeof(brr[0]);
    cout << count_pairs(arr, brr, N, M, K);
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
   
// Function to count pairs that satisfy
// the given conditions
static int count_pairs(int arr[], int brr[],
                       int N, int M, int K)
{
     
    // Stores index of
    // the left pointer.
    int i = 0;
 
    // Stores index of
    // the right pointer
    int j = 0;
 
    // Stores count of total pairs
    // that satisfy the conditions
    int cntPairs = 0;
 
    // Sort arr[] array
    Arrays.sort(arr);
 
    // Sort brr[] array
    Arrays.sort(brr);
 
    // Traverse both the array
    // and count then pairs
    while (i < N && j < M)
    {
         
        // If the value of
        // (brr[j] - arr[i]) exceeds K
        if (brr[j] - arr[i] > K)
        {
             
            // Update cntPairs
            cntPairs += (M - j);
             
            // Update
            i++;
        }
        else
        {
             
            // Update j
            j++;
        }
    }
    return cntPairs;
}
 
// Driver Code
public static void main(String args[])
{
    int arr[] = { 5, 9, 1, 8 };
    int brr[] = { 10, 12, 7, 4, 2, 3 };
    int K = 3;
     
    int N = arr.length;
    int M = brr.length;
     
    System.out.println(count_pairs(arr, brr, N, M, K));
}
}
 
// This code is contributed by SURENDRA_GANGWAR

Python3




# Python3 program to implement
# the above approach
 
# Function to count pairs that satisfy
# the given conditions
def count_pairs(arr, brr, N, M, K):
     
    # Stores index of
    # the left pointer.
    i = 0
 
    # Stores index of
    # the right pointer
    j = 0
 
    # Stores count of total pairs
    # that satisfy the conditions
    cntPairs = 0
 
    # Sort arr[] array
    arr = sorted(arr)
 
    # Sort brr[] array
    brr = sorted(brr)
 
    # Traverse both the array
    # and count then pairs
    while (i < N and j < M):
 
        # If the value of
        # (brr[j] - arr[i]) exceeds K
        if (brr[j] - arr[i] > K):
 
            # Update cntPairs
            cntPairs += (M - j)
 
            # Update
            i += 1
        else:
 
            # Update j
            j += 1
 
    return cntPairs
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 5, 9, 1, 8 ]
    brr = [ 10, 12, 7, 4, 2, 3 ]
    K = 3
     
    N = len(arr)
    M = len(brr)
     
    print(count_pairs(arr, brr, N, M, K))
 
# This code is contributed by mohit kumar 29

C#




// C# program to implement
// the above approach
using System;
class GFG{
     
// Function to count pairs
// that satisfy the given
// conditions
static int count_pairs(int[] arr, int[] brr,
                       int N, int M, int K)
{
  // Stores index of
  // the left pointer.
  int i = 0;
 
  // Stores index of
  // the right pointer
  int j = 0;
 
  // Stores count of total pairs
  // that satisfy the conditions
  int cntPairs = 0;
 
  // Sort arr[] array
  Array.Sort(arr);
 
  // Sort brr[] array
  Array.Sort(brr);
 
  // Traverse both the array
  // and count then pairs
  while (i < N && j < M)
  {
    // If the value of
    // (brr[j] - arr[i])
    // exceeds K
    if (brr[j] - arr[i] > K)
    {
      // Update cntPairs
      cntPairs += (M - j);
 
      // Update
      i++;
    }
    else
    {
      // Update j
      j++;
    }
  }
  return cntPairs;
}
     
// Driver code 
static void Main()
{
  int[] arr = {5, 9, 1, 8};
  int[] brr = {10, 12,
               7, 4, 2, 3};
  int K = 3;
  int N = arr.Length;
  int M = brr.Length;
  Console.WriteLine(
  count_pairs(arr, brr,
              N, M, K));
}
}
 
// This code is contributed by divyeshrabadiya07

Javascript




<script>
// Javascript program to implement
// the above approach
    
// Function to count pairs that satisfy
// the given conditions
function count_pairs(arr, brr, N, M, K)
{
 
    // Stores index of
    // the left pointer.
    let i = 0;
  
    // Stores index of
    // the right pointer
    let j = 0;
  
    // Stores count of total pairs
    // that satisfy the conditions
    let cntPairs = 0;
  
    // Sort arr[] array
    (arr).sort(function(a,b){return a-b;});
  
    // Sort brr[] array
    (brr).sort(function(a,b){return a-b;});
  
    // Traverse both the array
    // and count then pairs
    while (i < N && j < M)
    {
          
        // If the value of
        // (brr[j] - arr[i]) exceeds K
        if (brr[j] - arr[i] > K)
        {
              
            // Update cntPairs
            cntPairs += (M - j);
              
            // Update
            i++;
        }
        else
        {
              
            // Update j
            j++;
        }
    }
    return cntPairs;
}
 
// Driver Code
let arr = [5, 9, 1, 8];
let brr = [ 10, 12, 7, 4, 2, 3];
let K = 3;
let N = arr.length;
let M = brr.length;
document.write(count_pairs(arr, brr, N, M, K));
 
// This code is contributed by unknown2108
</script>
Output: 
6

 

Time Complexity: O(N * log(N) + M * log(M)) 
Auxiliary Space: O(1)

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :