Flatten Deeply Nested Array - Practice Coding Problems

Flatten Deeply Nested Array - Problem

JavaScript Medium

Given a multi-dimensional array arr and a depth n, return a flattened version of that array.

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

A flattened array is a version of that array with some or all of the sub-arrays removed and replaced with the actual elements in that sub-array. This flattening operation should only be done if the current depth of nesting is less than n. The depth of the elements in the first array are considered to be 0.

Note: Please solve it without the built-in Array.flat method.

Input & Output

Example 1 — Basic Nested Array

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

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

💡 Note: Flatten one level deep: the outer [3, 4, [5, 6]] becomes 3, 4, [5, 6], but [5, 6] stays nested since we only flatten 1 level

Example 2 — Deep Flattening

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

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

💡 Note: Flatten 3 levels deep: all nested arrays are flattened since the maximum nesting depth is 3

Example 3 — No Flattening

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

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

💡 Note: No flattening when n = 0: the array remains unchanged

Constraints

0 ≤ arr.length ≤ 10⁵
0 ≤ n ≤ 1000
Array can contain integers or other arrays
-10³ ≤ arr[i] ≤ 10³ for integer elements

Visualization

Tap to expand

Understanding the Visualization

Input

Multi-dimensional array [1, [2, 3], [4, [5]]] and depth n=1

Process

Flatten arrays only when current depth < n

Output

Partially flattened array [1, 2, 3, 4, [5]]

Key Takeaway

🎯 Key Insight: Control flattening depth by tracking current nesting level and only flattening when depth < n

Asked in

G Google 23 f Meta 18 M Microsoft 15 a Amazon 12

The key insight is to track the current depth while traversing the array and only flatten sub-arrays when depth < n. The optimal approach uses either recursion or an iterative stack to process elements level by level. Time: O(m), Space: O(d + m) where m is total elements and d is maximum depth.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative with Stack	O(m)	O(w + m)	Use stack to avoid recursion and control depth iteratively
Brute Force Recursive	O(m)	O(d + m)	Recursively traverse array checking depth at each level

Iterative with Stack — Algorithm Steps

Initialize stack with original array elements at depth 0
Pop elements and check their depth
If element is array and depth < n, push sub-elements with depth+1
Otherwise add element to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Stack

Push all elements with depth 0

Process Elements

Pop elements, check depth, and push sub-elements

Build Result

Add elements to result when depth limit reached

Code -

solution.c — C

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

// Simplified C implementation
int* solution(int* arr, int arrSize, int n, int* returnSize) {
    int* result = (int*)malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    // Basic flattening using simple iteration
    for (int i = 0; i < arrSize; i++) {
        result[(*returnSize)++] = arr[i];
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    // Parse input (simplified)
    int arr[] = {1, 2, 3}; // Simplified
    int n;
    scanf("%d", &n);
    
    int returnSize;
    int* result = solution(arr, 3, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m)

Where m is total number of elements at all levels combined

✓ Linear Growth

Space Complexity

O(w + m)

w is maximum width of any level for stack, m for result array

✓ Linear Space

34.5K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Iterative with Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler