Maximum Nesting Depth of the Parentheses - Practice Coding Problems

Maximum Nesting Depth of the Parentheses - Problem

String Stack Easy

Given a valid parentheses string s, find the maximum nesting depth of the parentheses.

The nesting depth is defined as the maximum number of parentheses that are nested within each other at any point in the string. Think of it as counting how many "levels deep" the parentheses go.

Example: In the string "(1+(2*3)+((8)/4))+1", at the deepest point we have ((8) which represents 2 levels of nesting, so the answer is 2.

Your task is to traverse the string and keep track of the current nesting level, updating the maximum depth whenever you encounter a deeper level of nesting.

Input & Output

example_1.py — Python

$ Input: s = "(1+(2*3)+((8)/4))+1"

› Output: 3

💡 Note: The string has nested parentheses. At the deepest point ((8), we have 3 levels: the outermost (, then the ( before (, then the ( before 8. So the maximum nesting depth is 3.

example_2.py — Python

$ Input: s = "(1)+((2))+(((3)))"

› Output: 3

💡 Note: The deepest nesting occurs in (((3))) where we have 3 levels of parentheses nested within each other.

example_3.py — Python

$ Input: s = "1+(2*3)/(2-1)"

› Output: 1

💡 Note: The parentheses (2*3) and (2-1) are at the same level with no nesting, so the maximum depth is 1.

Constraints

1 ≤ s.length ≤ 100
s consists of digits 0-9 and characters '+', '-', '*', '/', '(', ')'
s is a valid parentheses string (guaranteed to be properly balanced)

Visualization

Tap to expand

Understanding the Visualization

Start with no dolls

current_depth = 0, max_depth = 0

Open dolls for '('

Increment depth, update maximum if needed

Close dolls for ')'

Decrement current depth

Track maximum

Remember the most dolls ever open simultaneously

Key Takeaway

🎯 Key Insight: We only need to track the current nesting level and remember the maximum depth reached - no need to store previous states or use complex data structures!

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a single pass through the string with two counters: current_depth tracks the current nesting level, and max_depth stores the maximum depth seen so far. When we encounter '(', we increment current depth and update max if needed. When we see ')', we decrement current depth. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Counter (Optimal)	O(n)	O(1)	Track current depth and maximum depth in one pass through the string
Brute Force (Check All Substrings)	O(n²)	O(1)	Check every possible substring to find maximum depth

Single Pass Counter (Optimal) — Algorithm Steps

Initialize current_depth = 0 and max_depth = 0
Iterate through each character in the string
If character is '(': increment current_depth and update max_depth if needed
If character is ')': decrement current_depth
Return max_depth

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set current_depth = 0, max_depth = 0

Process '('

Increment current_depth, update max_depth if needed

Process ')'

Decrement current_depth

Continue

Single pass through entire string

Code -

solution.c — C

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

int maxDepth(char* s) {
    int maxDepth = 0;
    int currentDepth = 0;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '(') {
            currentDepth++;
            if (currentDepth > maxDepth) {
                maxDepth = currentDepth;
            }
        } else if (s[i] == ')') {
            currentDepth--;
        }
    }
    
    return maxDepth;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    // Remove newline if present
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", maxDepth(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string of length n

✓ Linear Growth

Space Complexity

O(1)

Only using two integer variables for counters

✓ Linear Space

68.0K Views

Medium Frequency

~8 min Avg. Time

1.6K 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

Single Pass Counter (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler