Robinhood·Software Engineer·Technical Phone Screen·Senior

Senior

May 2026

Summary

Robinhood software engineer screen, one question, very technical and specific. They wanted working code plus correctness under edge cases, and the O(1) space constraint was the part that tripped me up most.

Questions Asked (1)

Write a function that parses a string of OHLC candlestick records (semicolon-separated, comma-separated fields) and returns a classification string where each character is 'B' (bullish), 'S' (bearish), 'D' (doji), or 'X' (invalid record). Constraints: up to 200k records, single-pass O(total input length) time, O(1) extra space beyond the output, no converting the input to arrays.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

The classification logic itself is fine, close vs open comparison is trivial.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the exact format of the OHLC records and the classification rules (e.g., what constitutes a doji). Then outline a single-pass algorithm that scans the string character by character, parsing fields on the fly without splitting into arrays, and appends the classification character to a result string. Emphasize O(1) extra space and O(n) time, and discuss edge cases like empty records, missing fields, or non-numeric values.

Pro tip: Mention that you would use a state machine or index-based parsing to avoid creating intermediate strings, and that you'd validate numeric fields using a custom parser to handle potential overflow or malformed input. Also, note that you'd test with a large input to ensure performance and memory constraints are met.

1. Clarify requirements and edge cases

Ask about the exact format: are there always 4 fields? What defines a doji (e.g., open == close)? How to handle whitespace, empty fields, or non-numeric values? Confirm that invalid records should produce 'X'.

2. Design a single-pass parsing strategy

Plan to iterate over the string once, using indices to delimit records (semicolon) and fields (comma). Parse each field as a number without creating substrings, and track the current field index.

3. Implement classification logic

After parsing all four fields, compare open and close: if open < close, append 'B'; if open > close, append 'S'; if equal, append 'D'. If any field is invalid or missing, append 'X'.

4. Handle invalid records and edge cases

During parsing, if a field is empty, non-numeric, or if there are not exactly 4 fields, mark the record as invalid and skip to the next semicolon. Ensure the output string is built efficiently (e.g., using a byte buffer or strings.Builder).

5. Analyze complexity and test

Confirm O(n) time and O(1) extra space (excluding output). Discuss testing with large inputs, malformed records, and performance benchmarks.

Key Points to Mention

Single-pass parsing without splitting into arrays or creating intermediate strings.
O(1) extra space beyond the output string (e.g., using indices and a fixed-size buffer for numeric parsing).
Handling of invalid records: missing fields, non-numeric values, extra fields, or empty records.
Definition of doji: typically open == close, but confirm with interviewer if a threshold is needed.
Efficient output construction: using a byte slice or strings.Builder to avoid O(n^2) concatenation.
Edge cases: empty input, trailing semicolon, whitespace around fields, and very large numbers.

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