Bitmask Subset Energy Evaluator 2 — Problem Statement & Solution Guide

StackMediumParenthesis Score Calculator

TimeO(n)

SpaceO(n)

Problem Description

You are tasked with evaluating the structural integrity of a nested expression string using a stack-based scoring mechanism. The input is a string s consisting of parentheses (, ) and digits 0-9. The string is guaranteed to be well-formed, meaning every opening parenthesis has a corresponding closing parenthesis in the correct order.

The energy score of the string is calculated as follows: Each pair of matching parentheses contributes to the total energy. Specifically, the contribution of a pair is equal to the product of the depth of the pair (where the outermost pair has depth 1) and the sum of all digits located strictly between that pair of parentheses. If there are no digits between a pair, its contribution is 0. The total energy is the sum of contributions from all parenthesis pairs.

For example, in the string (12(3)), the outer pair has depth 1 and contains digits 1, 2, and 3 (sum = 6), contributing 1 * 6 = 6. The inner pair has depth 2 and contains digit 3 (sum = 3), contributing 2 * 3 = 6. The total energy is 6 + 6 = 12.

Given the string s, compute and return the total energy score.

DSA Pattern Breakdown

"Bitmask Subset Energy Evaluator 2"

medium

WHY DOES IT MATTER?

Stack‑based parsing guarantees linear time by avoiding repeated rescans of nested substrings. It also provides a clear, deterministic way to handle arbitrarily deep nesting without recursion limits.

OPTIMIZATION CHALLENGE

The key insight is to compute the energy incrementally at each closing parenthesis, rather than recomputing the entire substring. This reduces the time complexity from O(n^2) to O(n) and the space complexity to O(n) for the stack.

REAL-WORLD CONNECTION

In distributed systems, a stack is used to manage call‑stack traces or to serialize nested transactions. For example, a microservice that processes nested JSON objects can use a stack to keep track of parent contexts while streaming the payload.

When explaining your solution, emphasize that the stack stores only the necessary state (e.g., the accumulated value for the current depth). Avoid pushing the entire substring; this keeps memory usage minimal and makes the algorithm scalable.

COMPLEXITY AT A GLANCE

⏱ Time:O(n)

💾 Space:O(n)

Core Theory — Why This Approach?

The problem reduces to parsing a well‑formed parenthesized expression that may contain digits. A stack is the canonical data structure for handling nested delimiters because it naturally models the LIFO nature of opening and closing parentheses. As we scan the string from left to right, each '(' pushes a placeholder onto the stack; each digit is accumulated into the current inner value; and each ')' triggers a pop, at which point we combine the accumulated value with the previous context (e.g., multiply by 2, add, or apply a custom energy function). Naïve approaches that repeatedly scan the substring between every pair of parentheses or that use recursion without memoization end up with O(n^2) time or stack overflow for deep nesting. The optimal paradigm is a single linear pass that maintains a stack of intermediate scores, guaranteeing O(n) time and O(n) auxiliary space, which is essential for large inputs (up to 10^6 characters).

Interview Questions on This Problem

Q1How would you design a solution that evaluates the energy of a nested parenthesized string containing digits, ensuring it runs in linear time?

I would perform a single left‑to‑right scan, using a stack to store intermediate scores. When encountering '(', push a marker; when encountering a digit, accumulate it into the current inner value; when encountering ')', pop the stack, combine the accumulated value with the previous context (e.g., multiply by 2 or add), and push the result back. This guarantees O(n) time and O(n) space.

Q2What pitfalls should you watch for when implementing the stack‑based evaluation in a production system?

Common pitfalls include: 1) Forgetting to reset the accumulator after processing a closing parenthesis; 2) Using a stack of integers that overflows if the energy can grow large—use 64‑bit integers or BigInteger; 3) Mis‑handling empty parentheses "()" which should contribute a base energy (often 1). Defensive coding and unit tests for these edge cases are essential.

Q3Can you explain how this pattern relates to parsing arithmetic expressions in compilers?

In compilers, the shunting yard algorithm or recursive descent parsing also uses a stack to manage operator precedence and parentheses. The core idea—pushing context on '(' and popping on ')'—is identical. Understanding this pattern helps interviewers assess your grasp of language parsing and stack‑based evaluation.

Examples

Example 1

Input

s = "(12(3))"

Output

Explanation: Outer pair: depth 1, digits [1,2,3], sum=6, contribution=6. Inner pair: depth 2, digits [3], sum=3, contribution=6. Total = 6+6=12.

Example 2

Input

s = "(5)"

Output

Explanation: Single pair at depth 1, digits [5], sum=5, contribution=1*5=5. Total = 5.

Example 3

Input

s = "((1)(2))"

Output

Explanation: Outer pair: depth 1, digits [1,2], sum=3, contribution=3. First inner pair: depth 2, digits [1], sum=1, contribution=2. Second inner pair: depth 2, digits [2], sum=2, contribution=4. Total = 3+2+4=9. Wait, let me recalculate. Outer: depth 1, digits between outer parens are 1 and 2, sum=3, contrib=3. Inner1: depth 2, digit 1, sum=1, contrib=2. Inner2: depth 2, digit 2, sum=2, contrib=4. Total=3+2+4=9. Correction: The example output should be 9.

Example 4

Input

s = "(1(2(3)))"

Output

Explanation: Outer: depth 1, digits [1,2,3], sum=6, contrib=6. Middle: depth 2, digits [2,3], sum=5, contrib=10. Inner: depth 3, digits [3], sum=3, contrib=9. Total=6+10+9=25. Correction: Let's re-verify. Outer contains 1,2,3 sum=6*1=6. Middle contains 2,3 sum=5*2=10. Inner contains 3 sum=3*3=9. Total=25.

Constraints

1 <= s.length <= 10^5
s consists of '(' , ')' and digits '0'-'9'
s is a well-formed parenthesis string
The total sum of digits in s does not exceed 10^9

Optimal Approach & Strategy

Traverse the string once, using a stack to store intermediate scores. When a closing parenthesis is encountered, pop the stack, combine the accumulated value with the previous context, and push the result back. This yields O(n) time and O(n) space.

Brute Force Approach

A naive approach would recursively find matching parentheses, extract the substring inside, compute its energy, and then combine it with the outer context. This leads to repeated scanning of the same characters, resulting in O(n^2) time.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(n)

function solution(nums) {
   let sum = 0;
   for (let num of nums) {
       sum += num;
   }
   return sum;
}

class Solution {
   public:
   int solution(vector<int>& nums) {
       int sum = 0;
       for (int num : nums) {
           sum += num;
       }
       return sum;
   }
};

class Solution {
   public int solution(int[] nums) {
       int sum = 0;
       for (int num : nums) {
           sum += num;
       }
       return sum;
   }
}

def solution(nums):
   sum = 0
   for num in nums:
       sum += num
   return sum

function solution(nums) {
   let sum = 0;
   for (let num of nums) {
       sum += num;
   }
   return sum;
}

Asked in Top Tech Interviews

PhonePeAmazon

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 2 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 2 — 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