Autoregressive Token Generation
Reported by candidates from Ambience Healthcare's online assessment. Pattern, common pitfall, and the honest play if you blank under the timer.
The data structure behind this Ambience Healthcare OA, reported in September 2026, is a plain dynamic array plus a pointer into the predictions. That's it. The problem reads like an LLM question, but it's a simulation loop with three stop conditions. If you're taking it in the next day or two, expect it to be easy, and expect the points to be lost on edge cases, not on the idea. StealthCoder sits invisibly on your screen as a safety net if you blank mid-assessment, but this one you can probably write from memory once you see the loop.
The problem
An autoregressive model starts with inputTokens. Its deterministic next-token calls are represented by predictedTokens in call order. Append predictions until the sequence reaches maxTotalTokens, a generated token equals stopToken, or no supplied prediction remains. Include a generated stop token in the result. Function generateTokens(inputTokens: int[], predictedTokens: int[], maxTotalTokens: int, stopToken: int) → int[] Examples Example 1 inputTokens = [1,2] predictedTokens = [3,4,9,5] maxTotalTokens = 6 stopToken = 9 return = [1,2,3,4,9] Generation includes the stop token and ends before token 5. Example 2 inputTokens = [7] predictedTokens = [8,9,10] maxTotalTokens = 3 stopToken = 99 return = [7,8,9] The maximum total length stops generation. Example 3 inputTokens = [4,5] predictedTokens = [] maxTotalTokens = 5 stopToken = 0 return = [4,5] The supplied generator has no more predictions. Constraints 1 <= inputTokens.length <= maxTotalTokens <= 100000. 0 <= predictedTokens.length <= 100000. Tokens and stopToken are integers.
Reported by candidates. Source: FastPrep
Pattern and pitfall
Copy inputTokens into a result list. Walk through predictedTokens with an index. Before each append, check whether the result length has already hit maxTotalTokens. If so, stop. Otherwise append the next prediction, then check if it equals stopToken. If it does, stop, and keep it in the output. When predictions run out, the loop ends naturally. The common pitfall is the order of checks. Example 1 shows the stop token is included. Example 2 shows the length cap blocks any further append. Another trap is mutating the input array or running the cap check after appending, which overshoots by one. What if inputTokens already equals maxTotalTokens? Then nothing gets appended. Complexity is O(n + m) time and space, fine for 100000. If you freeze live in the OA, StealthCoder can hand you the loop, but you really only need to get the check order right.
The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.
You can drill Autoregressive Token Generation 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. Built for the candidate who saw this exact problem leak two days before his OA and wondered if anyone had a play.
Get StealthCoderRelated leaked OAs
You've seen the question.
Make sure you actually pass Ambience Healthcare's OA.
Ambience Healthcare reuses patterns across OAs. Built for the candidate who saw this exact problem leak two days before his OA and wondered if anyone had a play. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Autoregressive Token Generation FAQ
How hard is the Autoregressive Token Generation question really?+
Easy. It's a simulation with a single loop and three exit conditions. The wording sounds like machine learning, but no ML knowledge is needed. Most failures come from off-by-one errors on the length cap or forgetting to include the stop token.
What's the trick to this problem?+
Check the cap before you append, then check for the stop token right after you append. That order gives you Example 1 (stop token included) and Example 2 (cap blocks further tokens). Use an index into predictedTokens instead of popping from the front, which is slow.
What edge cases should I test?+
Test empty predictedTokens, as in Example 3. Test inputTokens already at maxTotalTokens, where nothing should be appended. Test a stop token that is the very first prediction, and a stop token that never appears. Also test when the stop token lands exactly on the cap.
What's the time complexity I should aim for?+
O(n + m) time, where n is the input length and m is the number of predictions consumed. Space is O(n + m) for the result. With limits of 100000 each, any quadratic approach, like removing from the front of a list repeatedly, is a bad idea.
How do I prep for this in 48 hours?+
Don't over-prep. Write the loop once from scratch and run all three examples. Then spend your remaining time on general array and simulation problems, since the rest of the assessment is likely harder. Practice stating your stop conditions out loud in order.