Skip to content
Related Articles

Related Articles

Maximum number of elements from an array B[] that are present in ranges [A[i] + K, A[i] – K]

Improve Article
Save Article
  • Last Updated : 23 Jul, 2021
Improve Article
Save Article

Given two arrays A[] of size N and B[] of size M and an integer K, the task is to select at most one element from array B[] for every element A[i] such that the element lies in the range [A[i] – K, A[i] + K] ( for 0 <= i <= N – 1 ). Print the maximum number of elements that can be selected from the array B[]. 

Examples:

Input: N = 4, A[] = {60, 45, 80, 60}, M = 3, B[] = {30, 60, 75}, K= 5 
Output: 2
Explanation :
B[0] (= 30): Not present in any of the ranges [A[i] + K, A[i] – K].
B[1] (= 60): B[1] lies in the range [A[0] – K, A[0] + K], i.e. [55, 65]. 
B[2] (= 75): B[2] lies in the range [A[2] – K, A[2] + K], i.e. [75, 85].

Input: N = 3 A[] = {10, 20, 30}, M = 3, B[] = {5, 10, 15}, K = 10
Output: 2

Naive Approach: The simplest approach to solve the problem is to traverse the array A[], search linearly in the array B[] and mark visited if the value of the array B[] is selected. Finally, print the maximum number of elements from the array B[] that can be selected.

Time Complexity: O(N * M)
Auxiliary Space: O(M)

Efficient Approach: Sort both the arrays A[] and B[] and try to assign the element of B[] that is in a range [A[i] – K, A[i] + K]. Follow the steps below to solve the problem:

  • Sort the arrays A[] and B[].
  • Initialize a variable, say j as 0, to keep track in the array B[] and count as 0 to store the answer.
  • Iterate in a range [0, N – 1] and perform the following steps:
    • Iterate in a while loop till j < M and B[j]< A[i] – K, then increase the value of j by 1.
    • If the value of j is less than M and B[j] is greater than equal to A[i] – K and B[j] is less than equal to A[i] + K then increase the value of count and j by 1.
  • After completing the above steps, print the value of count as the final value of the answer.

Below is the implementation of the above approach.

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the maximum number of
// elements that can be selected from array
// B[] lying in the range [A[i] - K, A[i] + K]
int selectMaximumEle(int n, int m, int k,
                     int A[], int B[])
{
    // Sort both arrays
    sort(A, A + n);
    sort(B, B + m);
 
    int j = 0, count = 0;
 
    // Iterate in the range[0, N-1]
    for (int i = 0; i < n; i++) {
         
        // Increase the value of j till
        // B[j] is smaller than A[i]
        while (j < m && B[j] < A[i] - k) {
            j++;
        }
 
        // Increasing count variable when B[j]
        // lies in the range [A[i]-K, A[i]+K]
        if (j < m && B[j] >= A[i] - k
            && B[j] <= A[i] + k) {
           
            count++;
            j++;
        }
    }
     
    // Finally, return the answer
    return count;
}
 
// Driver Code
int main()
{
    // Given Input
    int N = 3, M = 3, K = 10;
    int A[] = { 10, 20, 30 };
    int B[] = { 5, 10, 15 };
     
    // Function Call
    cout << selectMaximumEle(N, M, K, A, B) << endl;
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.util.Arrays;
 
class GFG
{
   
    // Function to count the maximum number of
    // elements that can be selected from array
    // B[] lying in the range [A[i] - K, A[i] + K]
    static int selectMaximumEle(int n, int m, int k,
                                int A[], int B[])
    {
        // Sort both arrays
        Arrays.sort(A);
        Arrays.sort(B);
 
        int j = 0, count = 0;
 
        // Iterate in the range[0, N-1]
        for (int i = 0; i < n; i++) {
 
            // Increase the value of j till
            // B[j] is smaller than A[i]
            while (j < m && B[j] < A[i] - k) {
                j++;
            }
 
            // Increasing count variable when B[j]
            // lies in the range [A[i]-K, A[i]+K]
            if (j < m && B[j] >= A[i] - k
                && B[j] <= A[i] + k) {
 
                count++;
                j++;
            }
        }
 
        // Finally, return the answer
        return count;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given Input
        int N = 3, M = 3, K = 10;
        int A[] = { 10, 20, 30 };
        int B[] = { 5, 10, 15 };
 
        // Function Call
        System.out.println(selectMaximumEle(N, M, K, A, B));
    }
}
 
// This code is contributed by Potta Lokesh

Python3




# Python3 program for the above approach
 
# Function to count the maximum number of
# elements that can be selected from array
# B[] lying in the range [A[i] - K, A[i] + K]
def selectMaximumEle(n, m, k, A, B):
     
    # Sort both arrays
    A.sort()
    B.sort()
 
    j = 0
    count = 0
 
    # Iterate in the range[0, N-1]
    for i in range(n):
 
        # Increase the value of j till
        # B[j] is smaller than A[i]
        while (j < m and B[j] < A[i] - k):
            j += 1
 
        # Increasing count variable when B[j]
        # lies in the range [A[i]-K, A[i]+K]
        if (j < m and B[j] >= A[i] - k
                and B[j] <= A[i] + k):
 
            count += 1
            j += 1
 
    # Finally, return the answer
    return count
 
# Driver Code
 
# Given Input
N = 3
M = 3
K = 10
A = [ 10, 20, 30 ]
B = [ 5, 10, 15 ]
 
# Function Call
print(selectMaximumEle(N, M, K, A, B))
 
# This code is contributed by gfgking

C#




// C# program for the above approach
using System;
 
class GFG{
     
// Function to count the maximum number of
// elements that can be selected from array
// B[] lying in the range [A[i] - K, A[i] + K]
static int selectMaximumEle(int n, int m, int k,
                            int[] A, int[] B)
{
     
    // Sort both arrays
    Array.Sort(A);
    Array.Sort(B);
 
    int j = 0, count = 0;
 
    // Iterate in the range[0, N-1]
    for(int i = 0; i < n; i++)
    {
         
        // Increase the value of j till
        // B[j] is smaller than A[i]
        while (j < m && B[j] < A[i] - k)
        {
            j++;
        }
 
        // Increasing count variable when B[j]
        // lies in the range [A[i]-K, A[i]+K]
        if (j < m && B[j] >= A[i] - k &&
                     B[j] <= A[i] + k)
        {
            count++;
            j++;
        }
    }
 
    // Finally, return the answer
    return count;
}
 
// Driver code
public static void Main()
{
     
    // Given Input
    int N = 3, M = 3, K = 10;
    int[] A = { 10, 20, 30 };
    int[] B = { 5, 10, 15 };
 
    // Function Call
    Console.WriteLine(selectMaximumEle(N, M, K, A, B));
}
}
 
// This code is contributed by avijitmondal1998

Javascript




<script>
    // Javascript program for the above approach
 
// Function to count the maximum number of
// elements that can be selected from array
// B[] lying in the range [A[i] - K, A[i] + K]
function selectMaximumEle(n, m, k, A, B) {
    // Sort both arrays
    A.sort((a, b) => a - b);
    B.sort((a, b) => a - b);
 
 
    let j = 0, count = 0;
 
    // Iterate in the range[0, N-1]
    for (let i = 0; i < n; i++) {
 
        // Increase the value of j till
        // B[j] is smaller than A[i]
        while (j < m && B[j] < A[i] - k) {
            j++;
        }
 
        // Increasing count variable when B[j]
        // lies in the range [A[i]-K, A[i]+K]
        if (j < m && B[j] >= A[i] - k
            && B[j] <= A[i] + k) {
 
            count++;
            j++;
        }
    }
 
    // Finally, return the answer
    return count;
}
 
// Driver Code
 
// Given Input
let N = 3, M = 3, K = 10;
let A = [10, 20, 30];
let B = [5, 10, 15];
 
// Function Call
document.write(selectMaximumEle(N, M, K, A, B) + "<br>");
 
// This code is contributed by _saurabh_jaiswal.
</script>

Output: 

2

 

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)

 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!