Reverse Substrings Between Each Pair of Parentheses

Reverse Substrings Between Each Pair of Parentheses - Problem

String Stack Medium

You are given a string s that consists of lowercase English letters and brackets.

Reverse the strings in each pair of matching parentheses, starting from the innermost one.

Your result should not contain any brackets.

Input & Output

Example 1 — Nested Parentheses

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

› Output: iloveu

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

Example 2 — Multiple Groups

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

› Output: leetcode

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

Example 3 — No Parentheses

$ Input: s = "abcd"

› Output: abcd

💡 Note: No parentheses to process, return string as-is.

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

Asked in

a Amazon 25 G Google 18 M Microsoft 12 f Facebook 8

The key insight is that nested parentheses create a natural stack structure. The stack approach is most intuitive: push new levels for '(', reverse and merge on ')'. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Iterative Replacement

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

Find the innermost parentheses pair, reverse the substring between them, replace it in the original string, and repeat until no parentheses remain.

Stack-Based Approach

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

Use a stack where each level represents a string being built. When we encounter '(', push new level. When we encounter ')', pop and reverse current level, append to previous level.

Wormhole Technique

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

Instead of reversing strings, we use a clever traversal technique where we pre-process parentheses pairs and navigate through them like wormholes, changing direction at each pair.

Brute Force - Iterative Replacement — Algorithm Steps

Step 1: Find the first closing bracket ')'
Step 2: Find its matching opening bracket '(' by going backwards
Step 3: Reverse the substring between these brackets
Step 4: Replace the parentheses and content with reversed string
Step 5: Repeat until no parentheses remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Innermost

Locate first ')' and its matching '('

Reverse Content

Reverse the string between the brackets

Replace & Repeat

Continue until no brackets remain

Code -

solution.c — C

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

char* solution(char* s) {
    int len = strlen(s);
    char* result = malloc((len + 1) * sizeof(char));
    strcpy(result, s);
    
    while (1) {
        len = strlen(result);
        int closeIdx = -1;
        
        // Find first closing bracket
        for (int i = 0; i < len; i++) {
            if (result[i] == ')') {
                closeIdx = i;
                break;
            }
        }
        
        if (closeIdx == -1) break;
        
        // Find matching opening bracket
        int openIdx = closeIdx - 1;
        while (openIdx >= 0 && result[openIdx] != '(') {
            openIdx--;
        }
        
        // Reverse substring between brackets
        int start = openIdx + 1;
        int end = closeIdx - 1;
        while (start < end) {
            char temp = result[start];
            result[start] = result[end];
            result[end] = temp;
            start++;
            end--;
        }
        
        // Create new string without the brackets
        char* newResult = malloc((len - 1) * sizeof(char));
        int newIdx = 0;
        
        // Copy before opening bracket
        for (int i = 0; i < openIdx; i++) {
            newResult[newIdx++] = result[i];
        }
        
        // Copy middle (already reversed)
        for (int i = openIdx + 1; i < closeIdx; i++) {
            newResult[newIdx++] = result[i];
        }
        
        // Copy after closing bracket
        for (int i = closeIdx + 1; i < len; i++) {
            newResult[newIdx++] = result[i];
        }
        
        newResult[newIdx] = '\0';
        free(result);
        result = newResult;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each pair of parentheses, we scan the string and create new strings

✓ Linear Growth

Space Complexity

O(n)

String manipulation creates temporary strings

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~15 min Avg. Time

2.5K 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 - Iterative Replacement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler