Dynamic Batch Completion Times

All generation sequences are waiting at time 0 in input order. A dynamic batch has batchSize identical slots. A sequence of length L occupies one slot for L time units.
Whenever a slot becomes free, immediately assign the next waiting sequence. If several slots become free together, use the smaller slot index first. Return each sequence's completion time in input order.

Function
dynamicBatchCompletionTimes(sequenceLengths: int[], batchSize: int) → int[]

Examples
Example 1
sequenceLengths = [2,1,3]
batchSize = 2
return = [2,1,4]
The length-1 sequence finishes first; the third sequence immediately takes that slot.
Example 2
sequenceLengths = [3,3,3]
batchSize = 1
return = [3,6,9]
One slot processes every sequence serially.
Example 3
sequenceLengths = [1,1,1,1]
batchSize = 2
return = [1,1,2,2]
Two sequences finish at each time step.

Constraints
1 <= sequenceLengths.length <= 100000.
1 <= batchSize <= sequenceLengths.length.
1 <= sequenceLengths[i] <= 100000.

The trick: track when each slot becomes free in a min-heap. Seed it with batchSize slots, each as (freeTime 0, slotIndex). For each sequence in input order, pop the smallest (freeTime, index), compute finish = freeTime + length, store finish in the answer at that sequence's position, then push (finish, index) back. The tuple ordering handles the tie rule, since equal free times fall back to the smaller slot index. The common pitfall is sorting sequences or reordering by length. Don't. Assignment order is fixed by input, only slot choice is dynamic. Another pitfall is forgetting the tiebreak, which matters for correctness in the spec even if the output times look the same. Complexity is O(n log k) with n up to 100000, so a naive scan of all slots per sequence is risky when batchSize is large. If the heap logic slips under pressure, StealthCoder works as the safety net during the live OA.

StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.