Reverse Substrings Between Each Pair of Parentheses

Reverse Substrings Between Each Pair of Parentheses - Problem

String Stack Medium

You are given a string s consisting of lowercase English letters and parentheses. Your task is to reverse the substrings enclosed within each pair of matching parentheses, starting from the innermost pairs and working outward.

Think of it like peeling an onion - you process the innermost parentheses first, reverse their content, then move to the outer layers. The final result should not contain any parentheses.

Example: If you have "(abcd)", you reverse "abcd" to get "dcba". For nested cases like "(u(love)i)", you first reverse "love" to get "evol", making it "(uevoli)", then reverse the outer content to get "iloveu".

Input & Output

example_1.py — Basic Case

$ Input: s = "(abcd)"

› Output: "dcba"

💡 Note: We have one pair of parentheses containing "abcd". Reversing it gives "dcba" and we remove the parentheses.

example_2.py — Nested Parentheses

$ Input: s = "(u(love)i)"

› Output: "iloveu"

💡 Note: First reverse innermost "love" → "evol", giving "(uevoli)". Then reverse "uevoli" → "iloveu".

example_3.py — Multiple Pairs

$ Input: s = "(ed(et(oc))el)"

› Output: "leetcode"

💡 Note: Process innermost first: "oc" → "co", then "etco" → "octe", finally "edocteel" → "leetcode".

Constraints

1 ≤ s.length ≤ 2000
s only contains lowercase English letters and parentheses
It is guaranteed that all parentheses are balanced

Visualization

Tap to expand

Understanding the Visualization

Enter outer doll

Start processing the outermost parentheses level

Dive deeper

When we find '(', we go to the next nesting level

Hit the core

Process the innermost content first

Reverse and bubble up

Reverse content and merge with the previous level

Complete the message

Continue until all levels are processed

Key Takeaway

🎯 Key Insight: Use a stack to naturally handle the nested structure, processing inner levels first and bubbling results upward through reversals.

Asked in

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

The optimal approach uses a stack data structure to handle nested parentheses efficiently. We process the string in a single pass, using the stack to manage different nesting levels. When encountering '(', we start a new level; when encountering ')', we reverse the current level and merge it with the previous one. This gives us O(n²) time complexity in the worst case due to string operations, but processes the structure naturally in one pass.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Approach	O(n²)	O(n)	Use stack to keep track of characters and reverse when encountering closing parentheses

Stack-Based Approach — Algorithm Steps

Initialize a stack with an empty string
Iterate through each character in the input string
If character is '(': push new empty string to stack
If character is ')': pop top, reverse it, append to new top
If character is letter: append to current top string
Return the single remaining string in stack

Visualization

Tap to expand

Step-by-Step Walkthrough

Push on '('

Start new level in stack

Append letters

Add characters to current level

Pop and reverse on ')'

Reverse current level and merge with previous

Continue processing

Process remaining characters

Code -

solution.c — C

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

#define MAX_SIZE 1000

void reverseStr(char* str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

char* reverseParentheses(char* s) {
    char stack[MAX_SIZE][MAX_SIZE];
    int top = 0;
    strcpy(stack[0], "");
    
    for (int i = 0; s[i]; i++) {
        if (s[i] == '(') {
            top++;
            strcpy(stack[top], "");
        } else if (s[i] == ')') {
            reverseStr(stack[top]);
            strcat(stack[top-1], stack[top]);
            top--;
        } else {
            int len = strlen(stack[top]);
            stack[top][len] = s[i];
            stack[top][len+1] = '\0';
        }
    }
    
    char* result = malloc(strlen(stack[0]) + 1);
    strcpy(result, stack[0]);
    return result;
}

int main() {
    char s[MAX_SIZE];
    scanf("%s", s);
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    char* result = reverseParentheses(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for traversal, but string operations can be O(n) in worst case due to reversals

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the stack and strings stored in it

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 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

Stack-Based Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler