FastPrepRich Text Parser Part 3 (Depth Tokens)

Rich Text Parser Part 3 (Depth Tokens)

Figma logoFigma● MediumFULLTIMEPHONE SCREENONSITE INTERVIEW
Learn

Problem statement

🐝 Hi there! The description you are currently reading is one part of a 3-part Figma interview set. It is highly recommended to read ALL THE PARTS before coding as parts build on top of each other 🐳

At Figma, documents are stored as nested structures: a paragraph can contain text runs and nested groups, which can themselves contain more groups. You are working with a small text format that describes structures like this. This set reconstructs a real ~45-minute Figma coding screen, part by part.

Part 3. This was the final twist of the real interview. After the Part 2 parser passed, the interviewer swapped the tokenizer for a different implementation and asked for the same result. The new tokenizer returns a flat list in which every word is preceded by its nesting depth: tokenize("(a,(b),c)") now returns [1, 'a', 2, 'b', 1, 'c']. There are no bracket tokens anymore.

Implement readRichText(tokens) that produces the same serialized nested structure that Part 2 produced, from this new token format. On FastPrep the flat list arrives as string tokens: depths appear as strings such as "1", each followed by its word.

Rules of the depth encoding.

  • depths are positive integers; the first depth may be greater than 1
  • between consecutive words the depth may rise or fall by more than 1: each unit of rise opens one new group, each unit of fall closes one
  • consecutive words at the same depth are siblings in the same group, and a word that returns to a still-open depth joins that open group
  • this encoding cannot represent empty groups, so none appear

Output format. Return the parsed document as a Python-style list string:

  • a group serializes as [ … ] with children joined by a comma and a single space
  • words are wrapped in single quotes
  • the return value is the serialization of the document: the list of all top-level items. A document that consists of one group therefore starts with two brackets, e.g. [['a', 'b', 'c']]

In Python, str(nested_list) produces exactly this format.

Function

readRichText(tokens: String[]) → String

Examples

Example 1

tokens = ["1", "a", "1", "b", "1", "c"]return = "[['a', 'b', 'c']]"

All words have depth 1, so they belong to the same top-level group: ['a', 'b', 'c']. The full parsed document is [['a', 'b', 'c']].

Example 2

tokens = ["1", "a", "2", "b", "1", "c"]return = "[['a', ['b'], 'c']]"

This is the Part 3 source example for tokenize("(a,(b),c)"). The word b has depth 2, so it becomes a nested group between a and c.

Example 3

tokens = ["3", "a", "2", "b", "1", "c"]return = "[[[['a'], 'b'], 'c']]"

This corresponds to the source example read_rich_text(tokenize("(((a)b)c)")) from Part 2. The first depth is 3, so a sits inside three groups; the depths then fall to 2 and 1, closing one level each time. Together with the outer document list the answer has four leading brackets.

Example 4

tokens = ["1", "a", "3", "b"]return = "[['a', [['b']]]]"

Only words carry depth labels, so the depth can jump from 1 straight to 3: two new groups open at once and b lands inside both.

Constraints

  • 0 <= tokens.length <= 5000, always an even number: alternating depth and word
  • depths are decimal strings between 1 and 50
  • words are lowercase alphanumeric with at most 10 characters

More Figma problems

See Figma hiring insights
public String readRichText(String[] tokens) {
  // write your code here
}
tokens["1", "a", "1", "b", "1", "c"]
expected"[['a', 'b', 'c']]"
Checking account…