Related Articles

# For each element in 1st array count elements less than or equal to it in 2nd array | Set 2

• Difficulty Level : Medium
• Last Updated : 20 May, 2021

Given two unsorted arrays arr1[] and arr2[]. They may contain duplicates. For each element in arr1[] count elements less than or equal to it in array arr2[].
Examples

Input : arr1[] = [1, 2, 3, 4, 7, 9]
arr2[] = [0, 1, 2, 1, 1, 4]
Output : [4, 5, 5, 6, 6, 6]
Explanation: There are 4 elements less than or equal to 1 in second array, similarly there are 5 elements less than 2 in second array, calculate the values similarly for other elements.
Input : arr1[] = [5, 10, 2, 6, 1, 8, 6, 12]
arr2[] = [6, 5, 11, 4, 2, 3, 7]
Output : [4, 6, 1, 5, 0, 6, 5, 7]
Explanation: There are 4 elements less than or equal to 5 in second array, similarly there are 6 elements less than 10 in second array, calculate the values similarly for other elements.

This problem is already discussed in the previous post
Solution: In this article, a more optimized linear time solution to the above problem is discussed. The approach discussed here works for arrays with values in a small range. A range of values that can be used as an index in an array.

• Approach :
The idea is to create a prefix map up to the maximum element of the second array. The prefix array will store the maximum element up to that index, for example, prefix[i] will store the count of elements up to i. Then traverse through the first array and find the count of elements less than or equal to that element from the prefix array.
The prefix array is created by traversing through the prefix array and updating the current element by adding the precious element, i.e. prefix[i]+ =prefix[i-1].
• Algorithm:
1. Create extra space (prefix) of the size of a maximum element of the second and first array or a map.
2. Traverse the second array.
3. For every element of the second array increase the count of prefix array, i.e. prefix[arr2[i]]++
4. Traverse through the prefix array from 1 to MAX (maximum element of the second and first array and update the ith element by adding the sum of i-1th element
5. Now traverse through the first array and print the value of prefix[arr_1[i]]
• Implementation:

## C++

 `// C++ program for each element in 1st``// array count elements less than or equal to it``// in 2nd array` `#include ``using` `namespace` `std;` `#define MAX 100000` `// Function for each element in 1st``// array count elements less than or equal to it``// in 2nd array``void` `countEleLessThanOrEqual(``int` `arr1[], ``int` `m,``                                ``int` `arr2[], ``int` `n)``{``    ``// Creating hash array initially``    ``// filled with zero``    ``int` `hash[MAX] = {0};``    ` `    ``// Insert element of arr2[] to hash``    ``// such that hash[i] will give count of``    ``// element i in arr2[]``    ``for` `(``int` `i = 0; i < n; i++)``        ``hash[arr2[i]]++;` `    ``// Presum of hash array``    ``// such that hash[i] will give count of``    ``// element less than or equals to i in arr2[]``    ``for` `(``int` `i=1; i

## Java

 `// Java program for each element``// in 1st array count elements``// less than or equal to it in``// 2nd array``import` `java.io.*;` `class` `GFG``{``static` `int` `MAX = ``100000``;` `// Function for each element``// in 1st array count elements``// less than or equal to it``// in 2nd array``static` `void` `countEleLessThanOrEqual(``int` `arr1[], ``int` `m,``                                    ``int` `arr2[], ``int` `n)``{``    ``// Creating hash array initially``    ``// filled with zero``    ``int` `hash[] = ``new` `int``[MAX];``    ` `    ``// Insert element of arr2[] to``    ``// hash such that hash[i] will``    ``// give count of element i in arr2[]``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``hash[arr2[i]]++;` `    ``// Presum of hash array``    ``// such that hash[i] will``    ``// give count of element``    ``// less than or equals to``    ``// i in arr2[]``    ``for``(``int` `i = ``1``; i < MAX; i++)``    ``{``        ``hash[i] = hash[i] +``                  ``hash[i - ``1``];``    ``}``    ` `    ``// Traverse arr1[] and``    ``// print hash[arr[i]]``    ``for` `(``int` `i = ``0``; i < m; i++)``    ``{``        ``System.out.print(hash[arr1[i]] + ``" "``);``    ``}``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``int` `arr1[] = {``1``, ``2``, ``3``, ``4``, ``7``, ``9``};``    ``int` `arr2[] = {``0``, ``1``, ``2``, ``1``, ``1``, ``4``};``    ``int` `m, n;``    ` `    ``m = arr1.length;``    ``n = arr2.length;``    ` `    ``countEleLessThanOrEqual(arr1, m, arr2, n);``}``}` `// This code is contributed``// by inder_verma`

## Python3

 `# Python 3 program for each element in 1st``# array count elements less than or equal``# to it in 2nd array` `MAX` `=` `100000` `# Function for each element in 1st``# array count elements less than or``# equal to it in 2nd array``def` `countEleLessThanOrEqual(arr1, m, arr2, n):``    ` `    ``# Creating hash array initially``    ``# filled with zero``    ``hash` `=` `[``0` `for` `i ``in` `range``(``MAX``)]``    ` `    ``# Insert element of arr2[] to hash``    ``# such that hash[i] will give count``    ``# of element i in arr2[]``    ``for` `i ``in` `range``(n):``        ``hash``[arr2[i]] ``+``=` `1` `    ``# Presum of hash array such that``    ``# hash[i] will give count of element``    ``# less than or equals to i in arr2[]``    ``for` `i ``in` `range``(``1``, ``MAX``, ``1``):``        ``hash``[i] ``=` `hash``[i] ``+` `hash``[i ``-` `1``]``    ` `    ``# Traverse arr1[] and print hash[arr[i]]``    ``for` `i ``in` `range``(m):``        ``print``(``hash``[arr1[i]], end ``=` `" "``)    ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr1 ``=` `[``1``, ``2``, ``3``, ``4``, ``7``, ``9``]``    ``arr2 ``=` `[``0``, ``1``, ``2``, ``1``, ``1``, ``4``]``    ``m ``=` `len``(arr1)``    ``n ``=` `len``(arr2)``    ` `    ``countEleLessThanOrEqual(arr1, m, arr2, n)``    ` `# This code is contributed by``# Shashank_Sharma`

## C#

 `// C# program for each element``// in 1st array count elements``// less than or equal to it in``// 2nd array``using` `System;``public` `class` `GFG {` `static` `int` `MAX = 100000;` `// Function for each element``// in 1st array count elements``// less than or equal to it``// in 2nd array``static` `void` `countEleLessThanOrEqual(``int` `[]arr1, ``int` `m,``                                    ``int` `[]arr2, ``int` `n)``{``    ``// Creating hash array initially``    ``// filled with zero``    ``int` `[]hash = ``new` `int``[MAX];``    ` `    ``// Insert element of arr2[] to``    ``// hash such that hash[i] will``    ``// give count of element i in arr2[]``    ``for` `(``int` `i = 0; i < n; i++)``        ``hash[arr2[i]]++;` `    ``// Presum of hash array``    ``// such that hash[i] will``    ``// give count of element``    ``// less than or equals to``    ``// i in arr2[]``    ``for``(``int` `i = 1; i < MAX; i++)``    ``{``        ``hash[i] = hash[i] +``                ``hash[i - 1];``    ``}``    ` `    ``// Traverse arr1[] and``    ``// print hash[arr[i]]``    ``for` `(``int` `i = 0; i < m; i++)``    ``{``        ``Console.Write(hash[arr1[i]] + ``" "``);``    ``}``}` `// Driver code``public` `static` `void` `Main ()``{``    ``int` `[]arr1 = {1, 2, 3, 4, 7, 9};``    ``int` `[]arr2 = {0, 1, 2, 1, 1, 4};``    ``int` `m, n;``    ` `    ``m = arr1.Length;``    ``n = arr2.Length;``    ` `    ``countEleLessThanOrEqual(arr1, m, arr2, n);``}``}` `// This code is contributed by Shikha Singh.`

## PHP

 ``

## Javascript

 ``

Output:
`4 5 5 6 6 6`

• Implementation:

## C++

 `// C++ program for each element in 1st``// array count elements less than or equal to it``// in 2nd array``#include ``#include ``#include ` `// Function for each element in 1st``// array count elements less than or equal to it``// in 2nd array``void` `countLessThanOrEqual(``const` `std::vector<``int``>& vec1,``                        ``const` `std::vector<``int``>& vec2) {``    ``std::map<``int``, unsigned ``int``> countOfVec2;``    ``for` `(``const` `auto``& item : vec2) {``        ``++countOfVec2[item];``    ``}` `    ``unsigned ``int` `prev = 0;``    ``for` `(``auto``& pair : countOfVec2) {``        ``pair.second += prev;``        ``prev = pair.second;``    ``}``    ``// Traverse arr1[] and print result``    ``for` `(``const` `auto``& item : vec1) {``        ``unsigned ``int` `result = (--countOfVec2.upper_bound(item))->second;``        ``std::cout << result << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``std::vector<``int``> arr1 = { 1, 2, 3, 4, 7, 9 };``    ``std::vector<``int``> arr2 = { 0, 1, 2, 1, 1, 4 };` `    ``countLessThanOrEqual(arr1, arr2);` `    ``return` `0;``}`

## Java

 `// Java program for each element in 1st ``// array count elements less than or equal to it ``// in 2nd array``import` `java.util.*;``class` `GFG {` `  ``// Function for each element in 1st ``  ``// array count elements less than or equal to it ``  ``// in 2nd array ``  ``static` `void` `countLessThanOrEqual(``int` `vec1[], ``int` `vec2[])``  ``{``    ``HashMap countOfVec2 = ``new` `HashMap<>();  ``    ``for``(``int` `item : vec2)``    ``{``      ``if``(!countOfVec2.containsKey(item))``        ``countOfVec2.put(item, ``0``);``      ``countOfVec2.put(item, countOfVec2.get(item) + ``1``);``    ``}` `    ``int` `prev = ``0``;``    ``Vector li = ``new` `Vector();``    ``for` `(Map.Entry pair : countOfVec2.entrySet())``    ``{``      ``li.add(pair.getKey());``    ``}``    ``for``(``int` `pair : li)``    ``{``      ``countOfVec2.put(pair, countOfVec2.get(pair) + prev);``      ``prev = countOfVec2.get(pair);``    ``}` `    ``// Traverse arr1[] and print result ``    ``for``(``int` `item : vec1)``    ``{``      ``int` `i = ``0``, v = ``0``, last = ``0``;``      ``for` `(Map.Entry pair : countOfVec2.entrySet())``      ``{``        ``last = pair.getKey();``        ``if``(item < pair.getKey())``        ``{``          ``v = i;``          ``break``;``        ``}``        ``i++;``      ``}``      ``v -= ``1``;``      ``if``(v == -``1``)``      ``{``        ``v = last;``      ``}``      ``int` `result = countOfVec2.get(v);``      ``System.out.print(result + ``" "``);``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr1[] = {``1``, ``2``, ``3``, ``4``, ``7``, ``9``};``    ``int` `arr2[] = {``0``, ``1``, ``2``, ``1``, ``1``, ``4``};` `    ``countLessThanOrEqual(arr1, arr2);``  ``}``}` `// This code is contributed by divyesh072019.`

## Python3

 `# Python3 program for each element in 1st``# array count elements less than or equal to it``# in 2nd array` `# Function for each element in 1st``# array count elements less than or equal to it``# in 2nd array``def` `countLessThanOrEqual(vec1, vec2):``    ` `    ``countOfVec2 ``=` `{}``    ``for` `item ``in` `vec2:``        ``if` `item ``not` `in` `countOfVec2:``            ``countOfVec2[item] ``=` `0``        ``countOfVec2[item] ``+``=` `1``        ` `    ``prev ``=` `0``    ``for` `pair ``in` `countOfVec2:``        ``countOfVec2[pair] ``+``=` `prev``        ``prev ``=` `countOfVec2[pair]``        ` `    ``val ``=` `list``(countOfVec2)``    ` `    ``# Traverse arr1[] and print result``    ``for` `item ``in` `vec1:``        ``i ``=` `0``        ``v ``=` `0``        ``for` `i ``in` `range``(``len``(val)):``            ``if` `item < val[i]:``                ``v ``=` `i``                ``break``        ``v ``-``=` `1``        ``if` `v ``=``=` `-``1``:``            ``v ``=` `val[``-``1``]``        ``result ``=` `countOfVec2[v]``        ``print``(result, end ``=` `" "``)` `# Driver code``arr1 ``=` `[``1``, ``2``, ``3``, ``4``, ``7``, ``9``]``arr2 ``=` `[``0``, ``1``, ``2``, ``1``, ``1``, ``4``]` `countLessThanOrEqual(arr1, arr2)` `# This code is contributed by shubhamsingh10`

## C#

 `// C# program for each element in 1st ``// array count elements less than or equal to it ``// in 2nd array ``using` `System;``using` `System.Collections.Generic;  ``class` `GFG {` `  ``// Function for each element in 1st ``  ``// array count elements less than or equal to it ``  ``// in 2nd array ``  ``static` `void` `countLessThanOrEqual(``int``[] vec1, ``int``[] vec2)``  ``{``    ``Dictionary<``int``, ``int``> countOfVec2 = ``new` `Dictionary<``int``, ``int``>(); ``    ``foreach``(``int` `item ``in` `vec2)``    ``{``      ``if``(!countOfVec2.ContainsKey(item))``        ``countOfVec2[item] = 0;``      ``countOfVec2[item] += 1;``    ``}` `    ``int` `prev = 0;``    ``List<``int``> li = ``new` `List<``int``>();``    ``foreach``(KeyValuePair<``int``, ``int``> pair ``in` `countOfVec2)``    ``{``      ``li.Add(pair.Key);``    ``}``    ``foreach``(``int` `pair ``in` `li)``    ``{``      ``countOfVec2[pair] += prev;``      ``prev = countOfVec2[pair];``    ``}` `    ``// Traverse arr1[] and print result ``    ``foreach``(``int` `item ``in` `vec1)``    ``{``      ``int` `i = 0, v = 0, last = 0;``      ``foreach``(KeyValuePair<``int``, ``int``> pair ``in` `countOfVec2)``      ``{``        ``last = pair.Key;``        ``if``(item < pair.Key)``        ``{``          ``v = i;``          ``break``;``        ``}``        ``i++;``      ``}``      ``v -= 1;``      ``if``(v == -1)``      ``{``        ``v = last;``      ``}``      ``int` `result = countOfVec2[v];``      ``Console.Write(result + ``" "``);``    ``}``  ``}` `  ``// Driver code       ``  ``static` `void` `Main()``  ``{``    ``int``[] arr1 = {1, 2, 3, 4, 7, 9};``    ``int``[] arr2 = {0, 1, 2, 1, 1, 4};` `    ``countLessThanOrEqual(arr1, arr2);``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``
Output:
`4 5 5 6 6 6`

• Complexity Analysis:
• Time Complexity: O(max + n ) where max is the maximum element of both arrays and n is the length of the array.
A single traversal of both the arrays and the prefix array is needed.
• Space Complexity: O(max) where max is the maximum element of both arrays.
A prefix array of size max is needed.

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