Nested Array Generator - Practice Coding Problems

Nested Array Generator - Problem

JavaScript Medium

You're given a multi-dimensional array containing integers and other nested arrays. Your task is to create a generator function that yields all integers in the same order as they appear during an inorder traversal.

A multi-dimensional array is a recursive data structure where each element can be either:

An integer value
Another multi-dimensional array

Inorder traversal means we process elements from left to right, yielding integers immediately when encountered, and recursively traversing any nested arrays we find.

For example: [1, [2, 3], 4, [5, [6, 7]]] should yield: 1, 2, 3, 4, 5, 6, 7

The key challenge is implementing this as a generator that yields values lazily, rather than creating the entire flattened array upfront.

Input & Output

example_1.py — Basic Nested Array

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

› Output: Generator yields: 1, 2, 3, 4

💡 Note: The generator traverses left to right: yields 1, enters [2,3] and yields 2 then 3, finally yields 4. Each value is produced lazily when requested.

example_2.py — Deeply Nested Structure

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

› Output: Generator yields: 1, 2, 3, 4, 5, 6

💡 Note: Deep nesting is handled recursively. The generator enters [1,2] yielding both values, then yields 3, enters [4,[5,6]] yielding 4, then recursively enters [5,6] to yield 5 and 6.

example_3.py — Single Level Array

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

› Output: Generator yields: 1, 2, 3, 4, 5

💡 Note: Edge case with no nesting - the generator simply yields each integer in order from left to right, demonstrating it works correctly for flat arrays too.

Constraints

1 ≤ nested_list.length ≤ 500
The values of the integers in the nested list are in the range [-10⁶, 10⁶]
Maximum nesting depth is 50
The generator should yield values lazily (on-demand)

Visualization

Tap to expand

Understanding the Visualization

Smart Exploration

Instead of dumping all dolls at once, explore them systematically with a stack to remember your path

Immediate Collection

When you find a coin, collect it immediately - no need to wait

Recursive Delegation

When you find nested dolls, delegate the exploration to handle that branch

Memory Efficient

Only remember your current exploration path, not all coins discovered so far

Key Takeaway

🎯 Key Insight: Recursive generators with yield delegation combine the elegance of recursion with the efficiency of lazy evaluation, processing nested structures with minimal memory overhead.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses a recursive generator with yield delegation to traverse nested arrays lazily. Key insight: use yield from in Python or yield* in JavaScript to seamlessly delegate to recursive calls, achieving O(1) amortized time per element and O(depth) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Flatten First Approach	O(n)	O(n)	Recursively flatten the entire array into a list, then create generator from list
Recursive Generator (Optimal)	O(1)	O(d)	Use recursive generator with yield delegation for true lazy evaluation

Flatten First Approach — Algorithm Steps

Define a recursive function to flatten nested arrays
Traverse the entire structure and collect all integers in a list
Create a generator that yields from the flattened list
Return the generator object

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Structure

Start with nested array [1, [2, 3], 4, [5, [6, 7]]]

Recursive Flattening

Traverse entire structure collecting all integers

Flattened Array

Create intermediate array [1, 2, 3, 4, 5, 6, 7]

Generator Creation

Create generator that yields from flattened array

Code -

solution.c — C

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

// Simplified C implementation using arrays
typedef struct {
    int* data;
    int size;
    int capacity;
    int index;
} Iterator;

Iterator* createIterator(int** nested, int* sizes, int depth) {
    Iterator* iter = malloc(sizeof(Iterator));
    iter->capacity = 100;
    iter->data = malloc(sizeof(int) * iter->capacity);
    iter->size = 0;
    iter->index = 0;
    
    // Flatten the nested structure (simplified)
    for (int i = 0; i < depth; i++) {
        for (int j = 0; j < sizes[i]; j++) {
            iter->data[iter->size++] = nested[i][j];
        }
    }
    return iter;
}

int hasNext(Iterator* iter) {
    return iter->index < iter->size;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must visit every element in the nested structure once during flattening

✓ Linear Growth

Space Complexity

O(n)

Stores all integers in a separate flattened list, plus O(d) recursion depth

⚡ Linearithmic Space

42.8K Views

Medium Frequency

~15 min Avg. Time

1.6K 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

Flatten First Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler