Maximum Nesting Depth of the Parentheses

Maximum Nesting Depth of the Parentheses - Problem

String Stack Easy

Given a valid parentheses string s, return the nesting depth of s. The nesting depth is the maximum number of nested parentheses.

A valid parentheses string is a string consisting only of '(' and ')' characters where every opening parenthesis has a corresponding closing parenthesis.

Example: In the string "(1+(2*3)+((8)/4))+1", the maximum nesting depth is 3 because at one point we have three levels of nested parentheses: (((.

Input & Output

Example 1 — Mathematical Expression

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

› Output: 3

💡 Note: The deepest nesting occurs at "((8)" where we have 3 levels: outer parentheses, plus parentheses, and inner parentheses around 8

Example 2 — Simple Nested

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

› Output: 3

💡 Note: The string (((3))) has maximum nesting depth of 3 levels deep

Example 3 — No Nesting

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

› Output: 1

💡 Note: All parentheses are at the same level with no nesting, so maximum depth is 1

Constraints

1 ≤ s.length ≤ 100
s consists of digits, '+', '-', '*', '/', '(', and ')'
It is guaranteed that parentheses expression is valid

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The optimal approach uses a simple counter to track current depth while scanning the string once. For each '(' increment depth and update maximum, for each ')' decrement depth. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check Each Position

⏱️ Time: O(n²) Space: O(1)

For every character in the string, scan backwards to count how many opening parentheses are still unclosed at that position. Track the maximum depth found.

Counter-Based Solution (Optimal)

⏱️ Time: O(n) Space: O(1)

Use a simple counter to track current nesting depth. Increment for '(' and decrement for ')'. Track the maximum depth seen during traversal.

Stack-Based Solution

⏱️ Time: O(n) Space: O(n)

Push opening parentheses onto a stack and pop when encountering closing parentheses. The stack size represents current nesting depth.

Brute Force - Check Each Position — Algorithm Steps

Step 1: For each position i in string
Step 2: Count unclosed '(' characters from 0 to i
Step 3: Track maximum depth seen

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position

For each '(' character, recalculate depth

Count Backwards

Scan from start to current position

Track Maximum

Keep track of highest depth seen

Code -

solution.c — C

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

int solution(char* s) {
    int maxDepth = 0;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        if (s[i] == '(') {
            // Count current depth at position i
            int currentDepth = 0;
            for (int j = 0; j <= i; j++) {
                if (s[j] == '(') {
                    currentDepth++;
                } else if (s[j] == ')') {
                    currentDepth--;
                }
            }
            if (currentDepth > maxDepth) {
                maxDepth = currentDepth;
            }
        }
    }
    
    return maxDepth;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we scan up to n characters backwards

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts

✓ Linear Space

30.3K Views

Medium Frequency

~10 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 - Check Each Position — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler