Nested Array Generator

Nested Array Generator - Problem

JavaScript Medium

Given a multi-dimensional array of integers, return a generator object which yields integers in the same order as inorder traversal.

A multi-dimensional array is a recursive data structure that contains both integers and other multi-dimensional arrays.

Inorder traversal iterates over each array from left to right, yielding any integers it encounters or applying inorder traversal to any arrays it encounters.

Input & Output

Example 1 — Simple Nested Array

$ Input: arr = [1,[2,3],4]

› Output: [1,2,3,4]

💡 Note: First yield 1, then traverse [2,3] yielding 2 then 3, finally yield 4

Example 2 — Deeply Nested

$ Input: arr = [1,[2,[3,4]],5]

› Output: [1,2,3,4,5]

💡 Note: Traverse left-to-right: yield 1, enter [2,[3,4]], yield 2, enter [3,4], yield 3,4, then yield 5

Example 3 — Empty Nested Arrays

$ Input: arr = [1,[],2,[3,[]]]

› Output: [1,2,3]

💡 Note: Empty arrays [] are skipped, yielding only the integers 1, 2, and 3

Constraints

1 ≤ arr.length ≤ 500
0 ≤ arr[i] ≤ 1000 or arr[i] is a valid multi-dimensional array
The depth of nesting will not exceed 100

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15

The key insight is to use generators for lazy evaluation of nested arrays. The optimal approach uses recursive generators with yield from to elegantly handle arbitrary nesting levels. Time: O(n), Space: O(d) where d is nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Generator	O(n)	O(d)	Use recursive generator with yield from to elegantly handle nested structure
Stack-Based Iterative	O(n)	O(d)	Use a stack to iteratively process nested arrays without recursion
Flatten First Approach	O(n)	O(n)	Recursively flatten the entire nested array into a list, then create generator from the list

Recursive Generator — Algorithm Steps

Check each element in the array
If integer, yield it directly
If nested array, recursively yield from it
Process elements only when requested

Visualization

Tap to expand

Step-by-Step Walkthrough

Enter

Start with main array [1,[2,3],4]

Recurse

When hit nested array, recursively yield from it

Yield

Elements yielded in natural traversal order

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int data[MAX_SIZE];
    int size;
    int index;
} NestedGenerator;

void flatten_recursive(const char* json, int* pos, NestedGenerator* gen) {
    while (json[*pos] != '\0') {
        if (json[*pos] == '[') {
            (*pos)++;
            flatten_recursive(json, pos, gen);
        } else if (json[*pos] == ']') {
            (*pos)++;
            return;
        } else if (json[*pos] == ',') {
            (*pos)++;
        } else if (json[*pos] >= '0' && json[*pos] <= '9' || json[*pos] == '-') {
            int num = 0;
            int sign = 1;
            if (json[*pos] == '-') {
                sign = -1;
                (*pos)++;
            }
            while (json[*pos] >= '0' && json[*pos] <= '9') {
                num = num * 10 + (json[*pos] - '0');
                (*pos)++;
            }
            gen->data[gen->size++] = sign * num;
        } else {
            (*pos)++;
        }
    }
}

NestedGenerator* solution(const char* json_str) {
    NestedGenerator* gen = malloc(sizeof(NestedGenerator));
    gen->size = 0;
    gen->index = 0;
    int pos = 0;
    flatten_recursive(json_str, &pos, gen);
    return gen;
}

int hasNext(NestedGenerator* gen) {
    return gen->index < gen->size;
}

int next(NestedGenerator* gen) {
    return gen->data[gen->index++];
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    NestedGenerator* gen = solution(input);
    
    printf("[");
    int first = 1;
    while (hasNext(gen)) {
        if (!first) printf(",");
        printf("%d", next(gen));
        first = 0;
    }
    printf("]\n");
    
    free(gen);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is processed exactly once when yielded

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth proportional to maximum nesting depth d

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Recursive Generator — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler