Mithril·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

May 2026

Summary

Interviewed for a Software Engineer role at Mithril and got hit with a parsing problem that was way more involved than I expected. Had to build a mini compiler basically, tokenizing a small language and spitting out operation triads. Not your typical leetcode grind.

Questions Asked (1)

Given a list of lines from a small line-based programming language that supports assignment statements and non-nested if-else blocks, parse the input and produce a deterministic intermediate representation in operation triad form, using temporaries and labels as needed.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

This one took me a minute to even understand what they were asking.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the language syntax and the expected triad format, then outline a two-pass approach: first parse lines into an AST, then traverse the AST to emit triads with temporaries and labels. Emphasize determinism by fixing temporary and label naming conventions and handling if-else control flow with explicit jumps.

Pro tip: Mention that you would write a few test cases (e.g., nested if-else, multiple assignments) to validate the output, and discuss how you'd handle edge cases like empty lines or comments. This shows attention to correctness and testing.

1. Clarify requirements and assumptions

Ask about the exact syntax (e.g., assignment operator, if-else structure, variable naming) and the expected triad format (e.g., op, arg1, arg2). Confirm whether temporaries and labels should follow a specific naming scheme.

2. Design the parsing strategy

Propose a line-by-line parser that builds an abstract syntax tree (AST) or a list of statements. For if-else, identify the condition, then-block, and else-block, ensuring proper nesting handling (even if non-nested, the structure must be captured).

3. Generate triads with temporaries and labels

Traverse the AST and emit triads for each operation. Use temporaries for intermediate results (e.g., t1, t2) and labels for control flow (e.g., L1, L2). For if-else, emit conditional jumps and unconditional jumps to skip the else block.

4. Ensure determinism and handle edge cases

Define a consistent numbering scheme for temporaries and labels (e.g., increment counters). Handle edge cases like empty lines, comments, or multiple statements per line if allowed. Discuss how to avoid ambiguity in triad references.

5. Validate and discuss trade-offs

Walk through a simple example to verify the output. Discuss trade-offs: e.g., single-pass vs. two-pass parsing, memory usage, and whether to optimize the triad sequence. Mention potential extensions like nested if-else or loops.

Key Points to Mention

Deterministic naming for temporaries and labels (e.g., t1, t2, L1, L2) to ensure reproducible output.
Two-pass approach: parsing to AST then code generation, which separates concerns and simplifies handling of control flow.
Control flow translation for if-else: conditional jump for the condition, unconditional jump to skip the else block, and labels for branch targets.
Handling of assignment statements: evaluate right-hand side into a temporary, then assign to the variable.
Edge cases: empty lines, comments, multiple assignments, and potential syntax errors.
Trade-offs: single-pass vs. two-pass, memory vs. simplicity, and whether to optimize the triad sequence.

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