Flatten Deeply Nested Array

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

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

✓ Brute Force Recursive

⏱️ Time: O(m) Space: O(d + m)

Use simple recursion to traverse the array. At each level, check if current depth is less than n. If so, recursively flatten sub-arrays, otherwise keep them as-is.

Iterative with Stack

⏱️ Time: O(m) Space: O(w + m)

Use an iterative approach with a stack to process elements. Each stack entry contains the element and its current depth. This avoids recursion stack overflow and gives better control over the flattening process.

Brute Force Recursive — Algorithm Steps

Check if current depth < n
If yes, recursively process each element
If element is array, flatten it; otherwise add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Depth

Compare current depth with limit n

Recursive Call

If depth < n, recursively flatten sub-arrays

Build Result

Combine flattened elements into result array

Code -

solution.c — C

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

char* solution(char* command) {
    int len = strlen(command);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int j = 0;
    int i = 0;
    
    while (i < len) {
        if (command[i] == 'G') {
            result[j++] = 'G';
            i++;
        } else if (command[i] == '(' && i + 1 < len) {
            if (command[i + 1] == ')') {
                result[j++] = 'o';
                i += 2;
            } else if (i + 3 < len && strncmp(&command[i], "(al)", 4) == 0) {
                result[j++] = 'a';
                result[j++] = 'l';
                i += 4;
            } else {
                i++;
            }
        } else {
            i++;
        }
    }
    
    result[j] = '\0';
    return result;
}

int main() {
    char command[101];
    fgets(command, sizeof(command), stdin);
    command[strcspn(command, "\n")] = 0;
    
    char* result = solution(command);
    printf("%s\n", result);
    
    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(d + m)

d is maximum depth for recursion 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

Brute Force Recursive — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler