Bitmask Subset Energy Evaluator 9 — Problem Statement & Solution Guide

StackMediumParenthesis Score Calculator

TimeO(n)

SpaceO(1)

Problem Description

You are provided with a string $s$ consisting solely of the characters '(' and ')'. The system defines the 'energy' of a valid parenthesis sequence as the sum of the nesting depths of all matched pairs. Specifically, for every pair of parentheses, its contribution to the total energy is equal to the number of open parentheses currently on the stack at the moment the closing parenthesis is encountered. If the string contains any unmatched parentheses, the sequence is invalid, and the energy is defined as -1.

Your task is to compute the total energy of the given string. You must process the string in a single pass, maintaining a stack to track the current depth. When an opening parenthesis is encountered, push it onto the stack. When a closing parenthesis is encountered, if the stack is empty, return -1 immediately. Otherwise, pop the top element, add the current stack size (after popping) plus one to the total energy, and continue. If the stack is not empty at the end of the string, return -1.

This problem requires careful handling of edge cases, including empty strings, strings with only opening or only closing parentheses, and deeply nested structures. The solution must operate in linear time relative to the length of the string.

DSA Pattern Breakdown

"Bitmask Subset Energy Evaluator 9"

medium

WHY DOES IT MATTER?

The pattern demonstrates how a seemingly recursive stack problem can be flattened into a linear scan using a depth counter, a technique that appears in parsing, expression evaluation, and many streaming algorithms where memory is at a premium.

OPTIMIZATION CHALLENGE

The key insight is recognizing that the exact identity of each '(' is irrelevant; only the current stack size matters for the energy contribution, allowing us to replace the explicit stack with a single integer counter.

REAL-WORLD CONNECTION

Think of a call stack in a distributed microservice trace: each service call pushes a frame, and the depth of a call reflects latency overhead. Summing depths is analogous to measuring total call‑stack pressure, helping engineers size resources for tracing systems.

During an interview, write the counter update logic first, then add a quick validation check (depth never negative, ends at zero). This shows you understand both the computation and the correctness constraints.

COMPLEXITY AT A GLANCE

⏱ Time:O(n)

💾 Space:O(1)

Core Theory — Why This Approach?

The energy of a valid parenthesis sequence is defined as the sum of the nesting depth of each matched pair. When scanning the string from left to right, every opening '(' pushes a new frame onto an implicit stack, increasing the current depth by one. When a closing ')' is encountered, the depth before popping represents the nesting depth of that pair, which is added to the total energy, and then the stack depth is decremented. A naive solution would attempt to locate each matching pair by scanning forward or using recursion, leading to O(n^2) time on long strings because each closing parenthesis could trigger a linear search for its partner. The optimal paradigm leverages the fact that the depth at any position can be tracked with a single integer counter, eliminating the need for an explicit stack or back‑tracking, thus achieving linear time and constant auxiliary space.

In practice, this problem is a classic example of a "stack‑simulation" where the stack’s size is the only state needed. By incrementing a counter on '(' and adding the counter's value to the answer before decrementing it on ')', we capture exactly the contribution of each pair without storing the entire stack. This approach also naturally validates the sequence: if the counter ever becomes negative or is non‑zero at the end, the string is invalid. The combination of a single pass, O(n) time, and O(1) extra memory makes it the optimal solution for large inputs up to 10^6 characters.

Interview Questions on This Problem

Q1How would you compute the total nesting depth sum of a parenthesis string in a single pass, and why does this method guarantee O(n) time?

Maintain a depth counter initialized to 0 and an answer accumulator. Iterate over the string: on '(' increment depth; on ')' add the current depth to answer then decrement depth. This processes each character once, giving O(n) time, and uses only O(1) extra space.

Q2In a fintech platform, why might you prefer the counter‑based solution over building an explicit stack of indices when validating large transaction logs encoded as parentheses?

Transaction logs can be massive; an explicit stack of indices would consume O(n) memory, risking out‑of‑memory errors. The counter‑based method uses constant memory, reduces GC pressure, and still validates correctness, which is critical for high‑throughput financial systems.

Q3A startup asks you to extend the energy definition to include a weight for each '(' character. How would you adapt the O(n) algorithm to handle an array of weights w[i] associated with each opening parenthesis?

Store the weight of each '(' on a simple stack (or reuse the same counter if weights are uniform). When encountering ')', pop the weight, multiply it by the current depth (or add directly if weight already represents contribution), and add to the total. This still runs in O(n) time; the extra stack holds at most the current depth, so space remains O(d) ≤ O(n).

Examples

Example 1

Input

s = "()()"

Output

Explanation: Process '(': stack = ['('], size = 1. Process ')': pop, stack = [], size = 0, energy += 0 + 1 = 1. Process '(': stack = ['('], size = 1. Process ')': pop, stack = [], size = 0, energy += 0 + 1 = 1. Total energy = 1 + 1 = 2. Stack is empty at end, so valid.

Example 2

Input

s = "(())"

Output

Explanation: Process '(': stack = ['('], size = 1. Process '(': stack = ['(', '('], size = 2. Process ')': pop, stack = ['('], size = 1, energy += 1 + 1 = 2. Process ')': pop, stack = [], size = 0, energy += 0 + 1 = 1. Total energy = 2 + 1 = 3. Stack is empty at end, so valid.

Example 3

Input

s = "())"

Output

-1

Explanation: Process '(': stack = ['('], size = 1. Process ')': pop, stack = [], size = 0, energy += 0 + 1 = 1. Process ')': stack is empty, so return -1 immediately.

Example 4

Input

s = "((()))"

Output

Explanation: Process '(': stack = ['('], size = 1. Process '(': stack = ['(', '('], size = 2. Process '(': stack = ['(', '(', '('], size = 3. Process ')': pop, stack = ['(', '('], size = 2, energy += 2 + 1 = 3. Process ')': pop, stack = ['('], size = 1, energy += 1 + 1 = 2. Process ')': pop, stack = [], size = 0, energy += 0 + 1 = 1. Total energy = 3 + 2 + 1 = 6. Stack is empty at end, so valid.

Constraints

1 <= s.length <= 10^5
s consists only of '(' and ')'
Time complexity must be O(n)
Space complexity must be O(n)

Optimal Approach & Strategy

The optimal solution uses a single integer to track current depth, adding that depth to the answer whenever a ')' is processed, then decrementing the depth. This yields O(n) time and O(1) auxiliary space.

Brute Force Approach

A naive method would locate each closing parenthesis, then scan backwards to find its matching opening '(' and compute the depth by counting intervening '(' characters, leading to O(n^2) time. It also requires storing matched indices, increasing space usage.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(n)

function solution(nums) {
   if (nums.length === 0) return 0;
   let sum = 0;
   for (let num of nums) {
       sum += num;
   }
   // Apply Parenthesis Score Calculator methodology here
   return sum;
}

class Solution {
   public:
   int solution(vector<int>& nums) {
       if (nums.size() == 0) return 0;
       int sum = 0;
       for (int num : nums) {
           sum += num;
       }
       // Apply Parenthesis Score Calculator methodology here
       return sum;
   }
   };

class Solution {
   public int solution(int[] nums) {
       if (nums.length == 0) return 0;
       int sum = 0;
       for (int num : nums) {
           sum += num;
       }
       // Apply Parenthesis Score Calculator methodology here
       return sum;
   }
   }

def solution(nums):
   if not nums:
       return 0
   sum = 0
   for num in nums:
       sum += num
   # Apply Parenthesis Score Calculator methodology here
   return sum

function solution(nums) {
   if (nums.length === 0) return 0;
   let sum = 0;
   for (let num of nums) {
       sum += num;
   }
   // Apply Parenthesis Score Calculator methodology here
   return sum;
}

Asked in Top Tech Interviews

AtlassianSwiggy

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Bitmask Subset Energy Evaluator 9 Solution

Problem Statement

Input

Output

Input

Output

Input

Output

Input

Output

Constraints

More Stack

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Bitmask Subset Energy Evaluator 9 — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor