Bytedance·Software Engineer·Onsite - Coding / Algorithms·Senior

Senior

May 2026

Summary

Bytedance SRE coding round with three array problems back to back. Nothing too wild but the carry propagation one tripped me up more than I expected.

Questions Asked (3)

Given a sorted integer array and a target value, return the index of the target using an O(log n) algorithm. Return -1 if not found.

Algorithms & Data Structures

Author's notes

Binary search, pretty standard.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Recognize that the sorted array and O(log n) requirement point to binary search. Clearly explain the algorithm, walk through an example, and then implement it with careful attention to boundary conditions and edge cases.

Pro tip: Demonstrate awareness of common pitfalls like integer overflow in mid calculation and off-by-one errors, and mention that you'd test with edge cases such as empty array, single element, and target at extremes.

1. Clarify and Confirm

Ask clarifying questions: Is the array sorted ascending? Are there duplicates? Should we return any index or the first/last occurrence? Confirm the expected return type.

2. Explain the Algorithm

Describe binary search: maintain low and high pointers, compute mid, compare with target, and adjust pointers accordingly. Emphasize the O(log n) time complexity.

3. Walk Through an Example

Choose a small sorted array (e.g., [-1,0,3,5,9,12], target=9) and trace the steps, showing how low, high, and mid change until the target is found or the search space is exhausted.

4. Implement the Code

Write clean code with correct loop condition (low <= high) and mid calculation (low + (high - low) // 2) to avoid overflow. Handle the not-found case by returning -1.

5. Test and Discuss Edge Cases

Mention testing with empty array, single element, target smaller/larger than all elements, and duplicates. Discuss time and space complexity.

Key Points to Mention

Binary search requires a sorted array and achieves O(log n) time complexity.
Use low + (high - low) // 2 to prevent integer overflow in languages like Java/C++.
Loop condition should be low <= high to ensure all elements are checked.
Return -1 immediately when the search space is empty (low > high).
Edge cases: empty array, single element, target not present, duplicates.
Space complexity is O(1) for iterative implementation.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

You're given an array of digits representing a nonnegative integer. Add 1 to it and return the result as a digit array, without converting the whole thing to a native integer type.

Algorithms & Data Structures

Author's notes

The [9,9,9] case is where I briefly froze.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Traverse the array from the least significant digit (rightmost) to the most significant, adding 1 and propagating any carry. If a digit becomes 10, set it to 0 and carry 1 to the next digit; if the carry propagates beyond the most significant digit, prepend a 1 to the array. This handles all cases in O(n) time and O(1) extra space (or O(n) if a new array is needed).

Pro tip: Clarify whether the input array can be modified in place or if a new array should be returned, and mention that you'll handle edge cases like all 9s (e.g., [9,9,9] -> [1,0,0,0]) and single-digit arrays. This shows attention to detail and avoids assumptions.

1. Clarify requirements and edge cases

Ask if the input can be modified in place, if leading zeros are allowed, and confirm the expected output for cases like [9,9,9] and [0].

2. Traverse from right to left

Start at the last index and move left, adding 1 to the current digit and handling carry propagation.

3. Handle carry propagation

If a digit becomes 10, set it to 0 and carry 1 to the next digit; if the carry reaches the front, insert 1 at the beginning.

4. Return the result

If no carry remains, return the modified array; if a new digit was added, return the new array with 1 prepended.

5. Analyze complexity

State that the time complexity is O(n) and space complexity is O(1) if in-place, or O(n) if a new array is created.

Key Points to Mention

Traverse from least significant digit (rightmost) to most significant.
Carry propagation: when a digit is 9, it becomes 0 and carry continues; otherwise, increment and stop.
Edge case: all digits are 9, requiring an extra digit at the front (e.g., [9,9,9] -> [1,0,0,0]).
In-place modification vs. creating a new array, and how that affects space complexity.
Time complexity O(n) and space complexity O(1) (or O(n) if new array).
Avoid converting the entire array to an integer to prevent overflow for large inputs.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Rearrange an integer array in place so all nonzero elements come first in their original order, with zeros pushed to the end. O(1) extra space required.

Algorithms & Data Structures

Author's notes

Two-pointer approach, wrote it pretty quickly.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Use a two-pointer technique: one pointer (write) tracks the position for the next nonzero element, and the other (read) scans through the array. When a nonzero is found, swap it with the element at the write pointer and increment write. This preserves the relative order of nonzero elements and moves zeros to the end in O(n) time and O(1) space.

Pro tip: After presenting the solution, mention that this is a stable partition and that if stability weren't required, a simpler two-pointer swap from both ends would work but would not preserve order. This shows you understand the trade-offs and can adapt to variations.

1. Clarify requirements and constraints

Confirm that the array is modified in place, relative order of nonzero elements must be preserved, and only O(1) extra space is allowed. Ask if the array can contain negative numbers or if 'nonzero' means strictly positive.

2. Explain the two-pointer approach

Describe maintaining a write index (starting at 0) and iterating a read index through the array. When a nonzero is encountered, swap it with the element at the write index and increment write.

3. Walk through an example

Trace the algorithm on a small array like [0, 1, 0, 3, 12] to demonstrate how elements are moved and zeros end up at the end while preserving order.

4. Analyze complexity and edge cases

State that time complexity is O(n) and space is O(1). Discuss edge cases: all zeros, no zeros, single element, and arrays with negative numbers.

5. Implement and test

Write clean code with meaningful variable names (e.g., writeIndex, readIndex). After coding, mentally test with edge cases and offer to run through a few examples.

Key Points to Mention

Two-pointer technique with a write index and a read index
In-place modification with O(1) extra space
Preservation of relative order of nonzero elements (stable partition)
Time complexity O(n) and space complexity O(1)
Edge cases: all zeros, no zeros, single element, negative numbers
Comparison with alternative approaches (e.g., non-stable partition using two pointers from both ends)

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.