# Problem 4: Flatten a Nested List

Hey everyone! 👋

I know I've been a bit quiet lately. I actually came down with a pretty bad flu last week, which completely knocked me out. 🤒 That's why I missed posting about the coding challenges. I'm finally feeling a bit better and ready to get back into the swing of things!

Today, we're tackling a classic problem: **Flattening a Nested List**.

## The Problem

The goal is to write a function that takes a list which might contain other lists (nested to any depth) and converts it into a single, one-dimensional list.

**Examples:**

* `flatten([[1, 2], [3, 4], [5, 6]])` should return `[1, 2, 3, 4, 5, 6]`
    
* `flatten([1, [2, 3], [[4, 5], 6]])` should return `[1, 2, 3, 4, 5, 6]`
    

## The Solution

Here is the Python implementation using recursion. Recursion is perfect here because we don't know how deep the nesting goes!

```python
def flatten(nested_list):
    """
    Flattens a nested list into a single-level list.
    """
    result = []
    for item in nested_list:
        if isinstance(item, list):
            flattened_sublist = flatten(item)  # Recursively flatten the sublist
            result.extend(flattened_sublist)
        else:
            result.append(item)
    return result

# Test cases
print(flatten([[1, 2], [3, 4], [5, 6]]))
# Output: [1, 2, 3, 4, 5, 6]

print(flatten([1, [2, 3], [[4, 5], 6]]))
# Output: [1, 2, 3, 4, 5, 6]
```

## Code Breakdown

Let's walk through the code line by line to understand exactly what's happening.

1. `def flatten(nested_list):`
    
    * Defines a function called `flatten` that takes `nested_list` as input.
        
2. `result = []`
    
    * Initializes an empty list called `result`. This will store our final flattened elements.
        
3. `for item in nested_list:`
    
    * Begins iterating through each element in the input `nested_list`.
        
4. `if isinstance(item, list):`
    
    * Checks if the current `item` is a list using `isinstance()`. This is the crucial step that detects nested lists.
        
5. `flattened_sublist = flatten(item)`
    
    * If the item *is* a list, we recursively call `flatten()` on it. This handles the "nesting" by treating that sublist as its own problem to solve.
        
6. `result.extend(flattened_sublist)`
    
    * Since `flatten()` returns a list, we use `.extend()` to add all those individual elements to our main `result` list. If we used `.append()`, we'd just end up with another list inside our result!
        
7. `else:`
    
    * `result.append(item)`
        
    * If the item is *not* a list (it's just a number, string, etc.), we directly add it to `result`.
        
8. `return result`
    
    * Finally, returns the fully processed, flat list.
        

The beauty of this function is its flexibility. Thanks to recursion, it can handle a list nested 2 levels deep or 200 levels deep with the exact same logic!

---

Thanks for sticking with me while I recovered! I'll be catching up on more challenges soon. Happy coding! 💻