Asana·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

Jul 2026

Summary

Coding round at Asana for a software engineer role. The problem was an ASCII art renderer, which sounds straightforward but has enough edge cases to keep you busy for a while.

Questions Asked (1)

Implement an ASCII art printer that renders an input string using a given font, where each character is defined as a fixed-height glyph. Characters are concatenated horizontally row by row, with a single blank column between them. Newlines in the input start a new glyph block. Spaces render as blank glyphs. Unsupported characters should either error or use a placeholder. The solution must run in O(S) time where S is the total size of the rendered output, and must return a string rather than printing to stdout.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

I went straight to the horizontal concatenation logic and got that working pretty quickly.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify requirements and edge cases first, then outline a solution that processes the input line by line, building each output row by concatenating glyph rows with a space separator. Emphasize achieving O(S) time by avoiding unnecessary string concatenations and using efficient data structures like a list of strings or a StringBuilder.

Pro tip: Proactively discuss trade-offs between erroring on unsupported characters versus using a placeholder, and mention how you'd handle memory efficiently for large outputs, showing you think about real-world constraints.

1. Clarify requirements and edge cases

Ask about the font format, handling of unsupported characters, newlines, spaces, and whether the output should include trailing spaces. Confirm the expected time complexity and return type.

2. Design the algorithm

Process the input line by line. For each line, initialize an array of strings for each row of the output block. For each character, append its glyph row to the corresponding output row, adding a space separator between glyphs.

3. Implement efficiently

Use a list of strings or a StringBuilder for each output row to avoid O(n^2) concatenation. Ensure that the total time is proportional to the output size by only doing constant work per output character.

4. Handle edge cases and validate

Test with empty input, spaces, unsupported characters, and multiple newlines. Verify that the output matches the expected format and that the time complexity holds.

5. Discuss trade-offs and optimizations

Mention alternative approaches (e.g., precomputing glyph widths) and trade-offs between erroring and placeholder for unsupported characters. Consider memory usage and potential optimizations for very large inputs.

Key Points to Mention

Time complexity O(S) where S is the total output size, achieved by processing each character once and using efficient string building.
Handling of newlines by starting a new block of glyph rows, and spaces as blank glyphs.
Strategy for unsupported characters: either raise an error or substitute a placeholder, with justification.
Use of a list of strings or StringBuilder to avoid quadratic string concatenation.
Edge cases: empty input, leading/trailing spaces, multiple consecutive newlines.
Memory considerations and potential optimizations for large outputs.

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