Initial Public Offering
Reported by candidates from Point 72's online assessment. Pattern, common pitfall, and the honest play if you blank under the timer.
Point 72's April 2026 OA hits you with an IPO allocation problem. You've got bids with price, quantity, and timestamp. Shares go from highest price downward until they're gone. You need to return the user IDs who got zero shares, sorted. It looks like a sorting and simulation problem, but the real trick is handling ties by timestamp and tracking partial allocations cleanly.
The problem
A company launches an initial public offering (IPO) where investors submit bids during a bidding window. Each bid is represented as [userId, numberOfShares, biddingPrice, timestamp]. After the bidding window closes, shares are allocated from the highest price downward until no shares remain. Allocation rules Return the user IDs of every bidder who receives no shares at all, sorted in ascending order. Function Description Complete getUnallottedUsers. getUnallottedUsers has the following parameters: Returns: int[] of user IDs that received no shares, sorted in ascending order. User 2 has the highest bid price and receives 7 shares first. The remaining 11 shares go to the price-7 group containing users 1 and 3, allocated one share at a time by timestamp. User 1 receives all 5 requested shares, user 3 receives the remaining 6, and user 4 receives no shares. Users 1 and 2 tie for the highest price. The two available shares are distributed round-robin by timestamp, so each receives one share. The lower-priced bid from user 3 is never reached and that user is returned.
Reported by candidates. Source: FastPrep
Pattern and pitfall
The pattern is sorting plus simulation. First, group bids by price and sort each group by timestamp. Then iterate from highest price down, allocating shares greedily until the pool empties. Track how many shares each user received. The gotcha: when price tiers have more shares available than bids requested, everyone in that tier gets their full amount. When a tier runs short, you allocate one-by-one in timestamp order and stop. Users who never get called in any tier return in the output. StealthCoder catches the edge case where you miscalculate the allocation boundary. The live OA will test tie-breaking by timestamp and partial tier exhaustion.
StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.
You can drill Initial Public Offering cold, or you can hedge it. StealthCoder runs invisibly during screen share and surfaces a working solution in under 2 seconds. The proctor sees the IDE. They don't see what's behind it. If you're reading this with an OA window open, you're who this was built for.
Get StealthCoderRelated leaked OAs
You've seen the question.
Make sure you actually pass Point 72's OA.
Point 72 reuses patterns across OAs. If you're reading this with an OA window open, you're who this was built for. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Initial Public Offering FAQ
Is this really a sorting problem?+
Yes. Sort by price descending, then by timestamp ascending within each price. Iterate through tiers and allocate shares per tier until you run out. Track each user's received count. Anyone with zero is unallotted.
What's the trap with ties?+
Multiple users bid the same price. You don't give all shares to one user. You allocate round-robin by timestamp until shares or bids run out. Forgetting the timestamp order inside a price tier will fail test cases.
Can I use a hash map to track allocations?+
Yes. Use a map to store userId to allocatedShares. After sorting and simulating allocation, iterate through all user IDs in the input and return those with zero allocation, sorted.
How do I handle the remaining shares after a partial tier?+
Once a tier runs out of shares, stop. Do not allocate to lower-priced tiers. Any user whose bid price never gets reached is unallotted. This is key to the problem.
What's the time complexity I should target?+
O(n log n) for sorting, then O(n) for allocation simulation. Total O(n log n). Avoid nested loops over the share quantity. Allocate one share per iteration efficiently.