Count Picked Items Less Than Queries

A warehouse has items represented by an array items, where items[i] is the value of the i-th item.
There are several orders. The i-th order picks every item in the inclusive index range startIndex[i] through endIndex[i]. Across all orders, this creates one combined multiset of picked item values.
For each value query[i], return how many picked items have value strictly less than query[i].

Function
countPickedItemsLessThan(items: int[], startIndex: int[], endIndex: int[], query: int[]) → int[]

Examples
Example 1
items = [1,2,5,4,5]
startIndex = [0,0,1]
endIndex = [1,2,2]
query = [2,4]
return = [2,5]
The orders pick values [1,2], [1,2,5], and [2,5]. Two picked values are less than 2, and five are less than 4.

Constraints
1 <= items.length
startIndex.length == endIndex.length
0 <= startIndex[i] <= endIndex[i] < items.length

Step one: don't expand the orders. Build a difference array over indices. For each order, add 1 at startIndex and subtract 1 at endIndex+1. A prefix sum gives cnt[i], the number of times items[i] was picked. Step two: pair each value with its count, sort by value, and build a prefix sum of counts over the sorted order. Step three: for each query, binary search for the first sorted value that is >= query, then return the prefix count before it. That's strictly less than. The classic pitfall is using upper bound instead of lower bound, which counts equal values. Another is forgetting the endIndex+1 slot, so size the array n+1. Duplicate values are fine, since the sorted prefix handles them. Total cost is O((n + m) log n). If the binary search details slip under pressure, StealthCoder can hand you the clean version during the live OA.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.