Codestin Search App

Flatten Deeply Nested Array - Problem

JavaScript Medium

Flatten a Multi-Dimensional Array with Depth Control

Imagine you have a nested Russian doll of arrays - arrays inside arrays inside arrays! Your task is to flatten this multi-dimensional structure, but with a twist: you can only unwrap up to a certain depth n.

Given a multi-dimensional array arr and a depth limit n, return a flattened version where:
• Sub-arrays are removed and replaced with their actual elements
• Flattening only occurs if the current nesting depth is less than n
• Elements at depth 0 are the outermost array elements

Challenge: Solve this without using the built-in

Array.flat()

Example: [1, [2, [3, 4]], 5] with depth 1 becomes [1, 2, [3, 4], 5]



                        
                        
                            
                                    Input & Output
                                    
                                    
                                                                                     

                                
                            
                                
                                                                                                        
                                        
                                            
                                            
                                            
                                            example_1.py — Basic Flattening
                                        
                                        
                                                                                            
                                                
                                                    $
                                                    Input:
                                                    arr = [1, [2, [3, 4]], 5], n = 1
                                                
                                                
                                                    ›
                                                    Output:
                                                    [1, 2, [3, 4], 5]
                                                
                                                                                        
                                                                                        
                                                
                                                    💡 Note:
                                                    With depth 1, we flatten the first level of nesting. The outer array contains [2, [3, 4]] which gets flattened to 2 and [3, 4], but [3, 4] remains nested since we've reached our depth limit.
                                                
                                            
                                                                                    
                                    
                                                                        
                                        
                                            
                                            
                                            
                                            example_2.py — Deeper Flattening
                                        
                                        
                                                                                            
                                                
                                                    $
                                                    Input:
                                                    arr = [1, [2, [3, 4]], 5], n = 2
                                                
                                                
                                                    ›
                                                    Output:
                                                    [1, 2, 3, 4, 5]
                                                
                                                                                        
                                                                                        
                                                
                                                    💡 Note:
                                                    With depth 2, we can flatten two levels deep. This completely flattens the array since the deepest nesting is only 2 levels deep.
                                                
                                            
                                                                                    
                                    
                                                                        
                                        
                                            
                                            
                                            
                                            example_3.py — No Flattening
                                        
                                        
                                                                                            
                                                
                                                    $
                                                    Input:
                                                    arr = [[1, 2], [3, 4]], n = 0
                                                
                                                
                                                    ›
                                                    Output:
                                                    [[1, 2], [3, 4]]
                                                
                                                                                        
                                                                                        
                                                
                                                    💡 Note:
                                                    With depth 0, no flattening occurs. The array remains exactly as provided since we're not allowed to flatten any levels.
                                                
                                            
                                                                                    
                                    
                                                                                                
                        

                        
                        
                            
                                
                                     
                                    Constraints
                                
                                
                                    
                                
                            
                            
                                
                                                                                                                        
                                                0 ≤ n ≤ 1000                                            
                                                                                    
                                                Array can contain integers and nested arrays                                            
                                                                                    
                                                Maximum nesting depth ≤ 1000                                            
                                                                                    
                                                No built-in Array.flat() method allowed                                            
                                                                                    
                                                Array length can be from 0 to 10⁴ elements                                            
                                                                                                            
                            
                        

                        
                                                
                            
                                
                                    
                                    Visualization
                                
                                
                                    
                                
                            
                            
                                
                                     Tap to expand
                                                                    
                                
                                                                
                                    
                                        
                                        Understanding the Visualization
                                    
                                    
                                                                                    
                                                1
                                                
                                                    Start with Outer Shell
                                                    Begin with the outermost array container at depth 0
                                                
                                            
                                                                                    
                                                2
                                                
                                                    Check Depth Limit
                                                    For each nested array, verify if we can go deeper (depth < n)
                                                
                                            
                                                                                    
                                                3
                                                
                                                    Recursively Unpack
                                                    If within limit, recursively process sub-arrays with decremented depth
                                                
                                            
                                                                                    
                                                4
                                                
                                                    Preserve Deep Nesting
                                                    Arrays beyond depth limit remain intact in the final result
                                                
                                            
                                                                            
                                    
                                                                        
                                        
                                            
                                        
                                        
                                            Key Takeaway
                                            
                                            🎯 Key Insight: Recursion with depth tracking provides elegant control over flattening levels, allowing us to preserve nested structure beyond our specified limit while efficiently processing all accessible elements.                                            
                                        
                                    
                                                                    
                                                            
                        
                        
                        
                        
                            
                                
                                    
                                    Related Problems
                                
                                
                                    
                                
                            
                            
                                                                                                                                                
                                            #1
                                            Flatten Binary Tree to Linked List
                                            Medium
                                        
                                                                            
                                            #2
                                            Array Flat Method
                                            Easy
                                        
                                                                            
                                            #3
                                            Recursive Flattening
                                            Medium
                                        
                                                                            
                                            #4
                                            Tree Traversal
                                            Medium
                                        
                                                                            
                                            #5
                                            Depth Control
                                            Medium
                                        
                                                                                                
                        

                        
                        
                            
                                
                                Asked in
                            
                            
                                                                                                            
                                            G
                                            Google                                            42
                                        
                                                                            
                                            f
                                            Meta                                            38
                                        
                                                                            
                                            a
                                            Amazon                                            35
                                        
                                                                            
                                            ⊞
                                            Microsoft                                            28



            

    




    
        
            Flatten Deeply Nested Array — Solution
            
        
    



    
        The optimal approach uses recursion with depth tracking to elegantly flatten nested arrays. For each element, if it's an array and we haven't reached the depth limit, we recursively flatten it with n-1. Otherwise, we add the element directly to our result. This solution has O(m) time complexity where m is the total number of elements processed, making it highly efficient.    





    
        
            
            Common Approaches
        
        
            
        
    
    
        
        
            
                
                    Approach
                    Time
                    Space
                    Notes
                
            
            
            
                                
                    
                                                    ✓ 
                                                Recursive Solution                    
                    
                        O(m)                    
                    
                        O(d + m)                    
                    
                        Use recursion to traverse the array structure while tracking depth                    
                
                            
        
        
    




    
    
        
            
                
                Recursive Solution — Algorithm Steps
            
            
                
            
        
        
            
                                Base case: if depth n is 0 or negative, return the array as-is
                                Initialize an empty result array
                                For each element in the input array:
                                If element is an array and we can go deeper (n > 1), recursively flatten it with n-1
                                If element is not an array or we've reached depth limit, add it directly
                                Return the flattened result
                            
        
    

    

    
        
            
            Visualization
        
        
            
        
    
    
        
             Tap to expand
            
                            
        
        
                
            
                
                Step-by-Step Walkthrough
            
            
                                
                    
                        1                    
                    
                        
                            Start Recursion                        
                        
                            Begin with the outermost array at depth 0                        
                    
                
                                
                    
                        2                    
                    
                        
                            Check Each Element                        
                        
                            For arrays within depth limit, recurse with n-1                        
                    
                
                                
                    
                        3                    
                    
                        
                            Combine Results                        
                        
                            Merge all flattened sub-results into final array                        
                    
                
                            
        
            


    
    
        
            
                
                    
                    Code -
                
                                
                    
                    
                    
                    
                    
                    
                
                            
            
                
            
        
        
        
        
            
            
                
                
                    
                    
                    
                
                
                solution.c — C
            
            
            
                
                #include <stdio.h>
#include <stdlib.h>

// Simplified C implementation for integer arrays
// Real implementation would need dynamic typing support

typedef struct {
    int* data;
    int size;
    int capacity;
} IntArray;

IntArray* flat_integers(int* arr, int size, int n) {
    IntArray* result = malloc(sizeof(IntArray));
    result->data = malloc(size * sizeof(int));
    result->size = 0;
    result->capacity = size;
    
    // Simplified logic for demonstration
    for (int i = 0; i < size; i++) {
        result->data[result->size++] = arr[i];
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}
            
        
        
    



    
        
            
            Time & Space Complexity
        
        
            
        
    
    
        
            
            
                
                    Time Complexity
                    
                        ⏱️
                        O(m)
                    
                
                
                    Where m is the total number of elements we need to examine across all levels within our depth limit
                    
                        
                            n
                            
                                
                            
                        
                        
                            2n
                            
                                
                            
                        
                    
                    
                        ✓ Linear Growth                    
                
            

            
            
                
                    Space Complexity
                    
                        
                            
                        
                        O(d + m)
                    
                
                
                    O(d) for recursion call stack where d is the depth, plus O(m) for the result array
                    
                        
                            n
                            
                                
                            
                        
                        
                            2n
                            
                                
                            
                        
                    
                    
                        ✓ Linear Space                    
                
            
        
    
  





            
            
                
                    
                        
                    
                    
                        41.3K                    
                    Views
                
                
                    
                        
                    
                    Medium-High
                    Frequency
                
                
                    
                        
                    
                    ~15 min
                    Avg. Time
                
                
                    
                        
                    
                    
                        1.8K                    
                Likes

Approach	Time	Space	Notes
✓ Recursive Solution	O(m)	O(d + m)	Use recursion to traverse the array structure while tracking depth



        

        
            
                
                
                    
                        
                        
                        
                        
                        
                        
                    
                    
                        
                        
                        
                    
                
                
                
                
    
    
        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 Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler