# Maximize count of persons receiving a chocolate

• Difficulty Level : Medium
• Last Updated : 14 Dec, 2020

Given two arrays A[], consisting of N integers, and B[], consisting of taste values of M chocolates and an integer X, the task is to find the maximum number of people who can receive a chocolate based on the condition that one person can have only one chocolate and with taste value in the range [A[i] – X, A[i] + X]
Note: Once a chocolate is given to a person, it cannot be given to any other person.

Examples:

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.

Input: A[] = {90, 49, 20, 39, 60}, B[] = {14, 24, 82}, X = 15
Output: 3
Explanation:
1st person can pick the 3rd chocolate as the value of the 3rd chocolate ( = 82 ) lies in the range [75 ( = 90 – 15 ), 105 ( = 90 + 15)].
2nd person can’t pick any chocolate because there is no chocolate with value in the range [34 ( = 49 – 15 ), 64 ( = 49 + 15).
3rd person can pick the 1st chocolate as the value of the 1st chocolate lies in the range [5 ( = 20 – 15), 35 ( = 20 – 15)].
4th person can pick the 2nd chocolate because value of the 2nd chocolate lies in the range [ 24 ( = 39 – 15) and 54 ( = 39 – 15)].
5th person can’t pick any chocolate because there is no chocolate with value in the range [45 ( = 60 – 15), 75 ( = 60 – 15)].
Therefore, the total number of people receiving a chocolate is 3, which is the maximum possible.

Input: A[] = {2, 4, 6, 40, 50}, B[] = {38, 36}, X=13
Output: 2

Approach: This problem can be solved using Greedy Technique/a> and Searching. The key observation here is for any ith person, assign the chocolate with smallest possible value that lies in the range, if possible. Otherwise, exclude that person from the result. Follow the steps below:

• Sort the given arrays A[] and B[] in non-decreasing order.
• Initialize a multiset to store the elements of the array B[].
• Initialize a variable count = 0, to store the count of persons receiving a chocolate.
• Traverse the array A[] and find the smallest possible chocolate value that can be assigned to every ith person using Binary Search or lower_bound(). Check if that value lies in the range [ai – X, ai + X] or not.
• If found to be true, then increment count and remove the value of this chocolate from the multiset.
• After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the maximum number``// of persons receiving a chocolate``int` `countMaxPersons(``int``* A, ``int` `n, ``int``* B,``                    ``int` `m, ``int` `x)``{` `    ``// Initialize count as 0``    ``int` `count = 0;` `    ``// Sort the given arrays``    ``sort(A, A + n);``    ``sort(B, B + m);` `    ``// Initialize a multiset``    ``multiset<``int``> s;` `    ``// Insert B[] array values into``    ``// the multiset``    ``for` `(``int` `i = 0; i < m; i++)``        ``s.insert(B[i]);` `    ``// Traverse elements in array A[]``    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `val = A[i] - x;` `        ``// Search for the lowest value in B[]``        ``auto` `it = s.lower_bound(val);` `        ``// If found, increment count,``        ``// and delete from set``        ``if` `(it != s.end()``            ``&& *it <= A[i] + x) {``            ``count++;``            ``s.erase(it);``        ``}``    ``}` `    ``// Return the number of people``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 90, 49, 20, 39, 49 };``    ``int` `B[] = { 14, 24, 82 };``    ``int` `X = 15;``    ``int` `N = ``sizeof``(A) / ``sizeof``(A);``    ``int` `M = ``sizeof``(B) / ``sizeof``(B);` `    ``// Function Call``    ``cout << countMaxPersons(A, N, B, M, X);``}`

## Python3

 `# Python3 program for the above approach``from` `bisect ``import` `bisect_left` `# Function to count the maximum number``# of persons receiving a chocolate``def` `countMaxPersons(A, n, B, m, x):` `    ``# Initialize count as 0``    ``count ``=` `0` `    ``# Sort the given arrays``    ``A ``=` `sorted``(A)``    ``B ``=` `sorted``(B)` `    ``# Initialize a multiset``    ``s ``=` `[]` `    ``# Insert B[] array values into``    ``# the multiset``    ``for` `i ``in` `range``(m):``        ``s.append(B[i])` `    ``# Traverse elements in array A[]``    ``for` `i ``in` `range``(n):``        ``val ``=` `A[i] ``-` `x` `        ``# Search for the lowest value in B[]``        ``it ``=` `bisect_left(s,val)` `        ``# If found, increment count,``        ``# and delete from set``        ``if` `(it !``=` `len``(s) ``and` `it <``=` `A[i] ``+` `x):``            ``count ``+``=` `1``            ``del` `s[it]` `    ``# Return the number of people``    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``A ``=` `[``90``, ``49``, ``20``, ``39``, ``49``]``    ``B ``=` `[``14``, ``24``, ``82``]``    ``X ``=` `15``    ``N ``=` `len``(A)``    ``M ``=` `len``(B)` `    ``# Function Call``    ``print``(countMaxPersons(A, N, B, M, X))` `    ``# This code is contributed by mohit kumar 29`
Output:
`3`

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

My Personal Notes arrow_drop_up