Score of Parentheses

Score of Parentheses - Problem

String Stack Medium

Given a balanced parentheses string s, return the score of the string.

The score of a balanced parentheses string is based on the following rules:

() has score 1
AB has score A + B, where A and B are balanced parentheses strings
(A) has score 2 * A, where A is a balanced parentheses string

Input & Output

Example 1 — Basic Nested

$ Input: s = "(())"

› Output: 2

💡 Note: Inner () has score 1, outer parentheses double it: 2 * 1 = 2

Example 2 — Complex Structure

$ Input: s = "(()(()))"

› Output: 6

💡 Note: First () at depth 1 contributes 2¹ = 2, second () at depth 2 contributes 2² = 4, total: 2 + 4 = 6

Example 3 — Simple Concatenation

$ Input: s = "()()"

› Output: 2

💡 Note: Two separate () pairs: 1 + 1 = 2

Constraints

2 ≤ s.length ≤ 50
s consists of only '(' and ')'

Visualization

Tap to expand

Asked in

G Google 42 M Microsoft 35

The key insight is that only () pairs contribute to the score, each contributing 2^depth. The optimal approach tracks nesting depth and sums contributions in O(n) time and O(1) space.

Common Approaches

✓ Depth Counting (Optimal)

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

The key insight is that only () pairs contribute to the score, and each contributes 2^depth to the final result. We track depth and add 2^depth whenever we find a () pair.

Recursive Parsing

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

This approach recursively parses the parentheses string, identifying balanced substrings and applying the scoring rules directly. It handles concatenation (AB = A + B) and nesting ((A) = 2 * A).

Stack-Based Approach

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

This approach uses a stack to keep track of scores at different nesting levels. When we encounter '(', we push a new level. When we encounter ')', we calculate the score for the current level and add it to the previous level.

Depth Counting (Optimal) — Algorithm Steps

Track current depth
For '(': increment depth
For ')': if previous was '(', add 2^depth to score, then decrement depth
Return total score

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Depth

Monitor nesting level

Score () Pairs

Add 2^depth for each () found

Result

Sum all contributions

Code -

solution.c — C

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

int solution(char* s) {
    int score = 0;
    int depth = 0;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '(') {
            depth++;
        } else {
            depth--;
            if (s[i-1] == '(') {
                score += 1 << depth; // 2^depth
            }
        }
    }
    
    return score;
}

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)

Single pass through the string, constant work per character

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a few variables for depth and score tracking

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~15 min Avg. Time

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

Depth Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler