Remove Outermost Parentheses - Practice Coding Problems

Remove Outermost Parentheses - Problem

String Stack Easy

Imagine you have a string of parentheses that represents nested structures, like "(()())(())". Your task is to remove the outermost layer of parentheses from each independent group while keeping the inner structure intact.

A valid parentheses string is either:

Empty string ""
"(" + A + ")" where A is valid
A + B where both A and B are valid

A valid string is primitive if it cannot be split into two non-empty valid strings. For example, "(())" is primitive, but "()()" is not (can be split into "()" + "()").

Goal: Given a valid parentheses string, find all primitive components and remove their outermost parentheses.

Example: "(()())(())" has two primitives: "(()())" and "(())". After removing outer parentheses: "()()" + "()" = "()()()"

Input & Output

example_1.py — Basic Case

$ Input: "(()())(())"

› Output: "()()()"

💡 Note: The input has two primitive groups: "(()())" and "(())". Removing outer parentheses from first gives "()()" and from second gives "()". Combined result: "()()()".

example_2.py — Simple Primitives

$ Input: "()()"

› Output: ""

💡 Note: The input has two primitive groups: "()" and "()". Each primitive has only outer parentheses, so removing them leaves empty strings. Combined result: "".

example_3.py — Nested Structure

$ Input: "(()(()))"

› Output: "()(())"

💡 Note: The input is a single primitive group "(()(()))". Removing the outermost parentheses gives "()(())", which preserves the inner nested structure.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '(' or ')'
s is guaranteed to be a valid parentheses string

Visualization

Tap to expand

Understanding the Visualization

Identify Doll Sets

Each primitive group is a complete set of nested dolls

Track Nesting Depth

Count how deep you are in the current doll set

Remove Outer Shell

When depth is 1, you're touching the outermost doll - skip it

Keep Inner Dolls

When depth > 1, you're at inner dolls - keep them

Key Takeaway

🎯 Key Insight: Use depth tracking to identify outermost parentheses in a single pass - when depth equals 1, you're at the outer shell that needs to be removed!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses a depth counter to track nesting levels in a single pass. When depth equals 1, we're at an outermost parenthesis that should be skipped. This achieves O(n) time and O(1) space complexity by avoiding the need to identify primitive substrings separately.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Identify Each Primitive)	O(n²)	O(n)	Find each primitive substring, then manually remove its outer parentheses
One-Pass Counter (Optimal)	O(n)	O(1)	Track nesting depth and skip outermost parentheses in single pass

Brute Force (Identify Each Primitive) — Algorithm Steps

Scan through string to identify each primitive substring
For each character, maintain a balance counter
When balance returns to 0, we've found a complete primitive
Extract each primitive and remove its first and last characters
Concatenate all processed primitives

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Scanning

Begin with balance = 0, mark start position

Count Parentheses

Increment for '(', decrement for ')'

Found Primitive

When balance reaches 0, extract substring

Remove Outer

Take substring[1:-1] to remove outer parentheses

Code -

solution.c — C

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

char* removeOuterParentheses(char* s) {
    int len = strlen(s);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int resultIdx = 0;
    int balance = 0;
    int start = 0;
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '(') {
            balance++;
        } else {
            balance--;
        }
        
        // Found a complete primitive
        if (balance == 0) {
            // Copy inner part (skip first and last)
            for (int j = start + 1; j < i; j++) {
                result[resultIdx++] = s[j];
            }
            start = i + 1;
        }
    }
    
    result[resultIdx] = '\0';
    return result;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    
    char* result = removeOuterParentheses(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to identify primitives + O(n) string operations for each primitive

⚠ Quadratic Growth

Space Complexity

O(n)

Storing intermediate primitive substrings

⚡ Linearithmic Space

89.3K Views

Medium Frequency

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

Brute Force (Identify Each Primitive) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler