he-006

# HumanEval/6

Implement a file **`solution.py`** that completes the function below. Keep the given name and signature; your file must define it at module level.

```python
from typing import List


def parse_nested_parens(paren_string: str) -> List[int]:
    """ Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
    For each of the group, output the deepest level of nesting of parentheses.
    E.g. (()()) has maximum two levels of nesting while ((())) has three.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """
```

<!-- imported from OpenAI HumanEval (HumanEval/6) -->

# Auto-generated from OpenAI HumanEval HumanEval/6. Do not edit by hand.
from solution import *  # noqa: F401,F403 (prompt helpers may be referenced by tests)
from solution import parse_nested_parens as candidate

METADATA = {
    'author': 'jt',
    'dataset': 'test'
}


def check(candidate):
    assert candidate('(()()) ((())) () ((())()())') == [2, 3, 1, 3]
    assert candidate('() (()) ((())) (((())))') == [1, 2, 3, 4]
    assert candidate('(()(())((())))') == [4]


def test_he_006():
    check(candidate)

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

To solve this problem, we need to determine the maximum depth of nested parentheses for each group in a given string. Each group is separated by spaces, and the depth is defined as the highest level of nested parentheses within that group.

### Approach
1. **Split the Input String**: First, we split the input string into individual groups using the `split()` method. This gives us a list of strings, each representing a group of parentheses.
2. **Track Depth for Each Group**: For each group, we initialize two variables: `current_depth` to keep track of the current level of nesting and `max_depth` to record the maximum depth encountered in the group.
3. **Iterate Through Characters**: For each character in the group:
   - If the character is an opening parenthesis '(', increment `current_depth` and update `max_depth` if `current_depth` exceeds `max_depth`.
   - If the character is a closing parenthesis ')', decrement `current_depth`.
4. **Collect Results**: After processing each group, append the maximum depth to the result list.
5. **Return the Result**: Finally, return the list of maximum depths for all groups.

### Solution Code
```python
from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    groups = paren_string.split()
    result = []
    for group in groups:
        current_depth = 0
        max_depth = 0
        for char in group:
            if char == '(':
                current_depth += 1
                if current_depth > max_depth:
                    max_depth = current_depth
            else:
                current_depth -= 1
        result.append(max_depth)
    return result
```

### Explanation
- **Splitting the Input**: The input string is split into groups using `split()`, which handles the separation based on spaces.
- **Tracking Depth**: For each group, we iterate through each character, adjusting the `current_depth` and updating `max_depth` as needed. This ensures we capture the deepest level of nesting.
- **Efficiency**: The solution efficiently processes each group in linear time relative to the length of the group, making it optimal for the given problem constraints.

This approach ensures that we accurately determine the maximum depth of nested parentheses for each group, providing the correct result as required.

Okay, I need to solve this problem where I have to parse a string of nested parentheses groups and return the maximum depth of each group. Hmm, let's think about how to approach this.

So, the input is a string where each group is separated by spaces. For example, the sample input is '(()()) ((())) () ((())()())' which gives the output [2,3,1,3]. Each number represents the maximum depth of nesting for each respective group.

First, I need to split the input string into individual groups. That's easy, I can use the split() method which will split on whitespace, giving me a list of each parenthesis string.

Next, for each group, I need to determine the maximum depth of nesting. How do I calculate that? Well, I remember that for nested parentheses, you can track the current depth by incrementing when you see an opening parenthesis '(' and decrementing when you see a closing ')'. The maximum value reached during this process is the depth for that group.

So, for each group string, I'll initialize a current_depth variable to 0 and a max_depth variable to 0. Then, I'll iterate through each character in the string. For each '(', I'll increase current_depth by 1 and update max_depth if current_depth is greater than the current max_depth. For each ')', I'll decrease current_depth by 1. By the end of the string, max_depth will hold the maximum depth for that group.

Wait, but what if the parentheses are mismatched? Like, more closing than opening. But the problem statement probably assumes that each group is a valid string of parentheses, so I don't need to handle errors there.

So, putting it all together:

1. Split the input string into groups.
2. For each group:
   a. Initialize current_depth and max_depth to 0.
   b. Iterate through each character.
   c. Update current_depth and max_depth accordingly.
3. Collect all max_depth values into a list and return it.

Let me think about the sample input. Take the first group '(()())':
- The first '(', current_depth becomes 1, max_depth is 1.
- Next '(', current_depth 2, max_depth 2.
- Then ')', current_depth 1.
- Next '(', current_depth 2 again, but max_depth is already 2.
- Then ')', current_depth 1.
- Then ')', current_depth 0.
So the max_depth is 2, which matches the sample.

Another example: '((()))' has three levels. Each '(', increases depth, and the max is 3.

What about the group '()'? It's just one level, so max_depth is 1.

So the algorithm should work.

Now, let's think about how to implement this in Python.

The function is called parse_nested_parens and takes a string as input. It returns a list of integers.

So, step by step:

- Split the input into groups: groups = paren_string.split()
- For each group in groups:
   - current_depth = 0
   - max_depth = 0
   - for char in group:
       if char == '(': current_depth +=1
       else: current_depth -=1
       if current_depth > max_depth:
           max_depth = current_depth
   - add max_depth to the result list
- return the result list.

Wait, but what about empty groups? Well, the problem says each group is a valid string, so probably no empty strings.

Let me test this logic with the sample input.

Sample input: '(()()) ((())) () ((())()())'

Split into ['(()())', '((()))', '()', '((())()())']

For '(()())':
As before, max_depth is 2.

For '((()))':
Each '(', so current_depth goes 1,2,3. Then three ')', so max is 3.

For '()':
current_depth goes 1, then back to 0. Max is 1.

For '((())()())':
Let's see. The string is ((())()()). Let's track:

- '(', depth 1, max 1
- '(', depth 2, max 2
- '(', depth 3, max 3
- ')', 2
- ')', 1
- '(', 2, which is less than max 3
- ')', 1
- '(', 2
- ')', 1
- ')', 0
So the max is 3.

So the output is [2,3,1,3], which matches the sample.

Great, so the logic works.

Now, implement this in code.

So, the code would look like:

def parse_nested_parens(paren_string: str) -> List[int]:
    groups = paren_string.split()
    result = []
    for group in groups:
        current_depth = 0
        max_depth = 0
        for char in group:
            if char == '(':
                current_depth += 1
                if current_depth > max_depth:
                    max_depth = current_depth
            else:
                current_depth -= 1
        result.append(max_depth)
    return result

Wait, but in the code, for each '(', we check if current_depth is greater than max_depth and update. That's correct.

Yes, that should do it.

I think this should handle all cases correctly.