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

IntermediatePrefer not to say

Jun 2026

Summary

Bytedance coding round for a software engineer role. One problem, pretty dense, involved building a mini memory allocator from scratch with alignment constraints and two operations. Left feeling like I probably missed some edge cases.

Questions Asked (1)

Implement an in-memory allocator over a binary array where 0 means free and 1 means occupied. Support an alloc operation that finds the leftmost contiguous block of the requested size starting at an 8-byte-aligned index, marks those cells with a unique ID, and returns the starting index (or -1 if none found). Also support an erase operation that frees all cells tied to a given ID and returns how many cells were freed.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

The alignment part is what got me first.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the problem constraints and assumptions, then propose a data structure that efficiently supports both allocation and deallocation. Discuss the trade-offs between time and space complexity, and outline how you would handle the 8-byte alignment requirement and unique ID tracking.

Pro tip: Mention that you would use a segment tree or a balanced BST to track free blocks, and a hash map to map IDs to their allocated ranges. This shows you understand the need for efficient search and update operations.

1. Clarify Requirements and Constraints

Ask about the expected size of the binary array, frequency of operations, and whether IDs can be reused. Confirm that allocation must be leftmost and 8-byte aligned.

2. Choose Data Structures

Propose a data structure to track free blocks (e.g., segment tree, balanced BST, or interval tree) and a hash map to map allocation IDs to their start index and size.

3. Design Allocation Algorithm

Describe how to find the leftmost aligned free block of the requested size. For a segment tree, store the maximum free block size in each node and search left-first.

4. Design Deallocation Algorithm

Explain how to use the hash map to find the allocated range for an ID, mark those cells as free, and update the free block data structure. Return the number of cells freed.

5. Analyze Complexity and Trade-offs

Discuss time and space complexity for both operations. Compare alternatives like bitmaps with linear scan vs. segment tree, and justify your choice based on expected usage.

Key Points to Mention

8-byte alignment: ensure the start index is a multiple of 8, which may require adjusting the search to only consider aligned positions.
Unique ID assignment: use an incrementing counter or a set to generate unique IDs, and store them in a hash map for O(1) lookup during erase.
Leftmost allocation: the search must prioritize the smallest index that satisfies the size and alignment, which can be done by traversing the data structure in order.
Efficient free block tracking: segment tree or balanced BST can find the first fit in O(log n) time, while a simple bitmap would be O(n).
Handling fragmentation: discuss how the data structure coalesces adjacent free blocks to maintain larger contiguous free regions.
Edge cases: allocation size larger than array, no free block, erasing non-existent ID, and alignment causing wasted space.

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