BlackRock·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

BlackRock software engineer interview with two back-to-back coding problems and a tight two-minute verbal explanation window after each one. Pretty focused on fundamentals but the submission constraint made it stressful.

Questions Asked (2)

Implement a sorting function from scratch (no built-in sort) that returns a list of integers in non-decreasing order. After coding, explain your choice of algorithm along with its time and space complexity and whether it's stable.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

I went with merge sort because I could at least explain stability confidently.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then choose a sorting algorithm that balances simplicity, efficiency, and stability. Implement the algorithm with clean code, test edge cases, and clearly explain your choice with time/space complexity and stability.

Pro tip: Mention that you would use a stable sort like merge sort for financial data to preserve the original order of equal elements, which can be crucial for audit trails and reporting.

1. Clarify Requirements

Ask about input size, data characteristics (e.g., nearly sorted, duplicates), memory constraints, and whether stability is required. This shows you consider practical constraints before coding.

2. Choose Algorithm

Select an algorithm based on requirements. For general purposes, merge sort (stable, O(n log n)) or quicksort (in-place, average O(n log n)) are good choices. Justify your selection.

3. Implement and Test

Write clean, modular code with comments. Test with edge cases: empty list, single element, duplicates, already sorted, reverse sorted, and large random input.

4. Analyze Complexity

State the time complexity (best, average, worst) and space complexity. Explain how the algorithm behaves with different inputs.

5. Discuss Stability

Define stability and state whether your chosen algorithm is stable. If not, explain why stability might or might not matter for the given context.

Key Points to Mention

Time complexity: O(n log n) for merge sort and quicksort (average), O(n^2) for bubble/insertion sort.
Space complexity: O(n) for merge sort, O(log n) for quicksort (due to recursion stack), O(1) for in-place sorts like heapsort.
Stability: Merge sort is stable; quicksort and heapsort are not stable by default.
Trade-offs: Quicksort is often faster in practice but has worst-case O(n^2); merge sort guarantees O(n log n) but uses extra space.
Edge cases: Handle empty lists, single elements, duplicates, and already sorted data efficiently.
Real-world considerations: For financial data, stability can be important to maintain order of equal elements (e.g., transactions with same timestamp).

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

Write a function that takes two iterables of integers and returns a sorted list of unique elements appearing in both. You need to handle input parsing yourself, cover edge cases like empty inputs and duplicates, and explain time and space complexity. Only one submission allowed.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

The single submission rule is what made this annoying.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the problem and edge cases first, then propose an efficient algorithm using sets for intersection, followed by sorting the result. Implement the solution with clear input parsing, and analyze time and space complexity.

Pro tip: Mention that you would use a set for O(1) lookups and handle duplicates naturally, but also discuss the trade-off between sorting the intersection versus using a sorted data structure from the start.

1. Clarify requirements and edge cases

Ask clarifying questions about input format (e.g., strings, lists), expected output (sorted list), and edge cases like empty inputs, duplicates, and non-integer inputs. Confirm that the function should handle any iterable of integers.

2. Design the algorithm

Propose using sets to find the intersection of the two iterables, which automatically handles duplicates and provides O(1) average lookup. Then sort the resulting set to produce the final list.

3. Implement the solution

Write the function with proper input parsing (e.g., converting strings to integers if needed). Use set intersection and sorted() to return the sorted list. Include handling for empty inputs.

4. Analyze complexity

Explain that time complexity is O(n + m + k log k) where n and m are input sizes and k is the size of the intersection, due to set construction and sorting. Space complexity is O(n + m) for the sets.

5. Test and validate

Walk through test cases: empty inputs, no common elements, all common elements, duplicates in inputs. Verify that the output is sorted and unique.

Key Points to Mention

Use of sets for efficient intersection and duplicate handling
Time complexity: O(n + m + k log k) and space complexity: O(n + m)
Edge cases: empty inputs, duplicates, no intersection
Input parsing: converting strings to integers if necessary
Trade-offs: sorting after intersection vs. using sorted containers
Only one submission: emphasize testing and validation before finalizing

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