Mini Parser

Mini Parser - Problem

Given a string s that represents the serialization of a nested list, implement a parser to deserialize it and return the deserialized NestedInteger.

Each element is either an integer or a list whose elements may also be integers or other lists.

The format follows these rules:

An integer is just a number (positive, negative, or zero)
A list starts with [ and ends with ]
Elements in a list are separated by commas
Lists can be nested to any depth

Examples:

"324" → single integer 324
"[123,456]" → list containing two integers
"[123,[456,789]]" → list containing an integer and a nested list

Input & Output

Example 1 — Single Integer

$ Input: s = "324"

› Output: 324

💡 Note: The input represents a single integer, so we parse and return the number 324.

Example 2 — Simple List

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

› Output: [123,456]

💡 Note: The input represents a list with two integers. We parse the brackets and comma-separated values to return [123,456].

Example 3 — Nested List

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

› Output: [123,[456,789]]

💡 Note: The input has a nested structure: a list containing an integer (123) and another list ([456,789]). We parse recursively to maintain the nesting.

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s consists of digits, square brackets "[]", minus sign "-", and commas ","
s is the valid serialization of a NestedInteger
All integers in s are in the range [-10⁶, 10⁶]

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22 M Microsoft 18

The key insight is to use either recursion or a stack to handle the nested structure systematically. The stack approach is most intuitive: push new lists when encountering '[', parse numbers between delimiters, and pop completed lists when encountering ']'. Time: O(n), Space: O(d) where d is the maximum nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Parser	O(n)	O(d)	Use a stack to track current parsing context and build nested structure
Recursive Descent Parser	O(n)	O(d)	Parse recursively by identifying integers vs lists and handling each case

Stack-Based Parser — Algorithm Steps

Initialize stack with empty list
For '[': push new list to stack
For numbers: parse and add to current list
For ']': pop completed list and add to parent

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty list on stack

Process Characters

Push/pop lists, parse numbers

Complete

Stack contains final parsed structure

Code -

solution.c — C

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

typedef struct NestedInteger {
    int isInteger;
    int intVal;
    struct NestedInteger** list;
    int listSize;
} NestedInteger;

typedef struct {
    NestedInteger** items;
    int size;
    int capacity;
} Stack;

Stack* createStack() {
    Stack* s = malloc(sizeof(Stack));
    s->capacity = 100;
    s->items = malloc(s->capacity * sizeof(NestedInteger*));
    s->size = 0;
    return s;
}

void push(Stack* s, NestedInteger* item) {
    s->items[s->size++] = item;
}

NestedInteger* pop(Stack* s) {
    return s->items[--s->size];
}

NestedInteger* top(Stack* s) {
    return s->items[s->size - 1];
}

NestedInteger* createInteger(int val) {
    NestedInteger* ni = malloc(sizeof(NestedInteger));
    ni->isInteger = 1;
    ni->intVal = val;
    ni->list = NULL;
    ni->listSize = 0;
    return ni;
}

NestedInteger* createList() {
    NestedInteger* ni = malloc(sizeof(NestedInteger));
    ni->isInteger = 0;
    ni->intVal = 0;
    ni->list = NULL;
    ni->listSize = 0;
    return ni;
}

void addToList(NestedInteger* list, NestedInteger* element) {
    list->list = realloc(list->list, (list->listSize + 1) * sizeof(NestedInteger*));
    list->list[list->listSize] = element;
    list->listSize++;
}

void printNested(NestedInteger* ni) {
    if (ni->isInteger) {
        printf("%d", ni->intVal);
    } else {
        printf("[");
        for (int i = 0; i < ni->listSize; i++) {
            if (i > 0) printf(",");
            printNested(ni->list[i]);
        }
        printf("]");
    }
}

NestedInteger* solution(char* s) {
    if (s[0] != '[') {
        return createInteger(atoi(s));
    }
    
    Stack* stack = createStack();
    push(stack, createList());
    char num[20] = "";
    int numLen = 0;
    int negative = 0;
    
    for (int i = 0; i < strlen(s); i++) {
        char ch = s[i];
        if (ch == '[') {
            if (i > 0) { // Not the first '['
                push(stack, createList());
            }
        } else if (ch == ']') {
            if (numLen > 0) {
                int val = atoi(num);
                if (negative) val = -val;
                addToList(top(stack), createInteger(val));
                numLen = 0;
                negative = 0;
                memset(num, 0, sizeof(num));
            }
            if (stack->size > 1) {
                NestedInteger* completed = pop(stack);
                addToList(top(stack), completed);
            }
        } else if (ch == ',') {
            if (numLen > 0) {
                int val = atoi(num);
                if (negative) val = -val;
                addToList(top(stack), createInteger(val));
                numLen = 0;
                negative = 0;
                memset(num, 0, sizeof(num));
            }
        } else if (ch == '-') {
            negative = 1;
        } else if (isdigit(ch)) {
            num[numLen++] = ch;
        }
    }
    
    return stack->items[0];
}

int main() {
    char s[10000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    NestedInteger* result = solution(s);
    printNested(result);
    printf("\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, each character processed once

✓ Linear Growth

Space Complexity

O(d)

Stack depth d equals maximum nesting level of lists

✓ Linear Space

32.2K Views

Medium Frequency

~25 min Avg. Time

896 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

Constraints

Visualization

Related Problems

Common Approaches

Stack-Based Parser — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler