Mini Parser - Practice Coding Problems

Mini Parser - Problem

Mini Parser is a fascinating string parsing challenge that simulates deserializing nested data structures! 🏗️

You're given a string s that represents a serialized nested list. Your task is to implement a parser that can deserialize this string and return the corresponding NestedInteger object.

Each element in the nested structure can be:
• An integer (like 123 or -456)
• A list containing other integers or lists (like [123,[456,789]])

The challenge lies in correctly parsing nested brackets, handling negative numbers, and maintaining the proper structure hierarchy. Think of it as building a tree from a flattened representation!

Example: The string "[123,[456,[789]]]" represents a list containing the integer 123 and another list, which contains 456 and yet another nested list with 789.

Input & Output

example_1.py — Simple Integer

$ Input: s = "324"

› Output: NestedInteger(324)

💡 Note: The string represents a single integer, so we return a NestedInteger containing that integer value.

example_2.py — Simple List

$ Input: s = "[123,456]"

› Output: NestedInteger([NestedInteger(123), NestedInteger(456)])

💡 Note: The string represents a list with two integers. We create a NestedInteger list containing two NestedInteger integers.

example_3.py — Nested Structure

$ Input: s = "[123,[456,[789]]]"

› Output: NestedInteger([NestedInteger(123), NestedInteger([NestedInteger(456), NestedInteger([NestedInteger(789)])])])

💡 Note: This is a complex nested structure. The outer list contains integer 123 and another list, which contains 456 and a deeply nested list with 789.

Visualization

Tap to expand

Understanding the Visualization

Initialize Workspace

Set up the main assembly table (root NestedInteger on stack)

Handle Opening Brackets

Each '[' creates a new assembly level - push new workspace onto stack

Process Elements

Numbers and nested structures are added to the current workspace (stack top)

Handle Closing Brackets

Each ']' completes the current level - pop workspace and item goes to parent automatically

Key Takeaway

🎯 Key Insight: The stack naturally mirrors the nested structure - each nesting level gets its own context, and closing brackets automatically merge completed structures with their parents.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Stack depth proportional to nesting level, result structure size is O(n)

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s consists of digits, square brackets "[]", minus sign "-", and commas ","
s is the serialization of valid NestedInteger
Numbers can be negative and multi-digit

Asked in

G Google 12 a Amazon 8 Apple 6 ⊞ Microsoft 4

The optimal solution uses a stack-based approach to parse the string in a single pass. Each '[' pushes a new NestedInteger list onto the stack, numbers are parsed and added to the current list, and each ']' pops the completed list. This achieves O(n) time complexity with clean, intuitive code that mirrors the natural nesting structure.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Parsing)	O(n²)	O(n²)	Recursively parse each character with multiple passes over substrings
One-Pass Stack Parsing (Optimal)	O(n)	O(n)	Use a stack to track nesting levels while parsing string in single pass

Brute Force (Recursive Parsing) — Algorithm Steps

Start parsing from the beginning of string
If character is '[', find the matching ']' by counting brackets
Extract substring and recursively parse each element
If character is digit/negative sign, extract the complete number
Create NestedInteger objects for each parsed element

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Parse

Start parsing from beginning, identify first structure

Bracket Matching

Find matching bracket by counting, creating substring

Recursive Call

Make new recursive call on extracted substring

Repeat Process

Continue recursively for each nested element

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct NestedInteger {
    int val;
    struct NestedInteger** lst;
    int lst_size;
    int lst_capacity;
    int is_int;
} NestedInteger;

NestedInteger* createNestedInteger() {
    NestedInteger* ni = malloc(sizeof(NestedInteger));
    ni->lst = malloc(sizeof(NestedInteger*) * 10);
    ni->lst_size = 0;
    ni->lst_capacity = 10;
    ni->is_int = 0;
    return ni;
}

NestedInteger* createNestedIntegerWithValue(int val) {
    NestedInteger* ni = malloc(sizeof(NestedInteger));
    ni->val = val;
    ni->is_int = 1;
    ni->lst = NULL;
    ni->lst_size = 0;
    return ni;
}

void addToNestedInteger(NestedInteger* ni, NestedInteger* elem) {
    if (ni->lst_size >= ni->lst_capacity) {
        ni->lst_capacity *= 2;
        ni->lst = realloc(ni->lst, sizeof(NestedInteger*) * ni->lst_capacity);
    }
    ni->lst[ni->lst_size++] = elem;
}

NestedInteger* parseHelper(const char* s, int* pos) {
    if (s[*pos] != '[') {
        int start = *pos;
        if (s[*pos] == '-') (*pos)++;
        while (*pos < strlen(s) && isdigit(s[*pos])) (*pos)++;
        
        char num_str[32];
        strncpy(num_str, s + start, *pos - start);
        num_str[*pos - start] = '\0';
        
        return createNestedIntegerWithValue(atoi(num_str));
    }
    
    NestedInteger* list = createNestedInteger();
    (*pos)++; // skip '['
    
    while (*pos < strlen(s) && s[*pos] != ']') {
        if (s[*pos] == ',') {
            (*pos)++;
            continue;
        }
        
        NestedInteger* nested = parseHelper(s, pos);
        addToNestedInteger(list, nested);
    }
    
    (*pos)++; // skip ']'
    return list;
}

NestedInteger* deserialize(char* s) {
    int pos = 0;
    return parseHelper(s, &pos);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case with deep nesting, we may reparse the same characters multiple times

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursive calls plus substring creation can lead to quadratic space usage

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s consists of digits, square brackets "[]", minus sign "-", and commas ","
s is the serialization of valid NestedInteger
Numbers can be negative and multi-digit

24.0K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Recursive Parsing) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler