AI Coding Interview Questions: Examples and Practice

Knowing algorithm names can still leave you unsure how to approach a new problem. These practice questions connect concrete inputs to solution choices, complexity bounds, and edge cases you should explain aloud.

• Two Sum: return two distinct indices whose values total a target. For [3, 3] and target 6, the answer uses both positions. Scan with a hash map of previously seen values, checking for the complement before storing the current value. This prevents reusing one index. Expected time is O(n), with O(n) extra space. Clarify what to return if no pair exists.
• Find the longest substring without repeated characters. For 'abba', the length is 2. Track each character's last position and maintain a window with no duplicates. The left boundary must never move backward when an old occurrence lies outside the current window. Expected time is O(n) with hash-map lookups. Clarify what counts as a character.
• Merge overlapping closed intervals. For [1, 3], [3, 5], and [8, 10], return [1, 5] and [8, 10]. Sort by start, then extend the current interval or begin another. Sorting gives O(n log n) time. Closed intervals that share an endpoint overlap; ask whether that matches the problem's definition.
• Reverse an acyclic singly linked list. Save the next node before changing the current node's next pointer. An iterative solution takes O(n) time and O(1) extra space. Trace an empty list, one node, and two nodes. Explain which part of the list is already reversed after each iteration.
• Return a binary tree's values level by level. Use a queue and process the current level's node count before starting the next level. Time is O(n); auxiliary queue space is O(w), where w is the maximum level width, excluding the returned output. Test an empty tree and a tree with only one child at each level.
• Decide whether every course can be completed given prerequisites. Model prerequisites as a directed graph and use topological sorting. If fewer than V vertices are processed, a directed cycle remains. Time is O(V + E). Test disconnected components, an isolated course, and a self-dependency.
• Find the fewest coins needed to reach an amount. Assume unlimited coins with positive integer denominations. For [1, 3, 4] and amount 6, choosing the largest coin first uses three coins; 3 + 3 uses two. Define a dynamic programming state as the minimum coins for each amount, starting with zero coins for amount zero. With target A and c denominations, the standard approach takes O(Ac) time and O(A) space. Handle unreachable amounts explicitly.

For related practice organized by role and topic, explore the interview question library.

Consider this prompt: Count nonempty contiguous subarrays whose sum equals a target, allowing negative values. For [1, -1, 1] and target 1, the answer is 3: either single-element [1] subarray, or the entire array.

Start with a baseline: choose each starting position and extend the ending position while maintaining a running sum. That takes O(n²) time and O(1) extra space. A usual shrinking-window approach is unreliable here because negative values break the assumption that extending a window increases its sum.

The faster approach uses prefix sums and a frequency map. If the current prefix sum is s, every earlier prefix equal to s - target identifies a subarray with the required sum. Initialize the map with one occurrence of prefix sum zero, representing the empty prefix before the array begins.

• Processing order: Add the current value to the prefix sum, count matching earlier prefixes, then record the current prefix. Recording it first would incorrectly count an empty subarray when the target is zero.
• Invariant: Before recording the current prefix, the map contains frequencies of all prefixes ending before the current position.
• Complexity: Each element performs a constant number of map operations. Expected time is O(n), assuming expected constant-time hash operations; extra space is O(n).
• Checks: An empty array returns 0. For [0, 0] and target 0, return 3. With fixed-width integer types, consider overflow in both the cumulative sum and the answer count.

A useful follow-up is whether the task asks for a count or the actual subarrays. Returning every matching subarray introduces output costs: an all-zero array has n(n + 1)/2 matching nonempty subarrays when the target is zero.

Make your own attempt before requesting help, then ask for the smallest intervention that lets you continue. The following prompts turn an AI conversation into practice you can check.

• Request one hint: Give me one hint about what information to store. Do not provide code or name the full algorithm yet.
• Challenge the reasoning: Here is my loop invariant. Find an input where my implementation violates it, or explain why each update preserves it. Check the response yourself; agreement from a model is not a correctness proof.
• Audit complexity: Count the work performed by slicing, sorting, container operations, and recursive calls in this implementation. A familiar algorithm name does not establish the complexity of your actual code.
• Generate tests: Suggest cases for empty input, duplicates, boundary values, and impossible results. Explain the expected answer for each. Derive those answers independently before using them as a test oracle.
• Change one constraint: How does the solution change if the input is sorted, cannot be modified, or arrives as a stream? Explain the new tradeoff before rewriting the code.

Consider a backend engineer preparing for a senior role at a cloud provider. After solving a prerequisite-graph problem, she asks an AI practice partner for a disconnected graph containing a cycle. She then traces the queue and explains why the processed-vertex count exposes the cycle, without consulting the hint.

After reading a full solution, close it and reconstruct the algorithm, invariant, and tests from memory. Being able to reproduce code is less useful than being able to explain why it works and adapt it to a changed constraint.

To rehearse explaining your reasoning in conversation, visit the mock interview page.

SubcueAI offers two live-assistance surfaces. Its flagship native app for macOS and Windows captures system audio and your microphone, with assistance displayed in a floating local overlay. It works with desktop meeting clients, including Zoom and Microsoft Teams.

The browser extension also provides live assistance through its Side Panel on Chromium browsers, including Chrome and Edge. It captures only the meeting tab's audio, covering browser-tab calls such as Google Meet. It hears the interviewer through that tab, never captures your microphone, and does not transcribe the candidate. The Firefox build is for mock practice only.

Neither surface adds a meeting bot to the call or injects a content script into the meeting page. For coding questions, distinguish spoken context from written context: audio capture alone does not supply a problem statement or code shown only in an editor. Check any suggestion against the exact prompt, constraints, and implementation.

Confirm the interview's rules before using live assistance. SubcueAI is not universally undetectable. Screen sharing, recording, proctored assessments, and company-managed devices are outside concealment assurances. A shared or recorded screen can expose an overlay or Side Panel, and device or proctoring controls can monitor activity.

For setup guidance on the available surfaces, see the SubcueAI tutorial.