Minimum Remove to Make Valid Parentheses - Practice Coding Problems

Minimum Remove to Make Valid Parentheses - Problem

String Stack Medium

Given a string containing parentheses '(', ')' and lowercase English characters, your task is to remove the minimum number of parentheses to make the string valid.

A valid parentheses string is defined as:

Empty string or contains only lowercase characters
Can be written as AB where both A and B are valid strings
Can be written as (A) where A is a valid string

Goal: Return any valid string after removing the minimum number of parentheses.

Example: "()())" → "(())" or "()()"

Input & Output

example_1.py — Basic Case

$ Input: s = "()())"

› Output: "(())" or "()()"

💡 Note: We have one extra closing parenthesis. We can remove it to get either "(())" or "()()" - both are valid.

example_2.py — Extra Opening

$ Input: s = "((("

› Output: ""

💡 Note: All parentheses are opening brackets with no closing matches, so we remove all of them.

example_3.py — Mixed with Letters

$ Input: s = "(v)())()"

› Output: "(v)()()"

💡 Note: Remove one extra closing parenthesis. Letters remain unchanged as they don't affect validity.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '(' or ')' or lowercase English letter
Return any valid answer - multiple solutions may exist

Visualization

Tap to expand

Understanding the Visualization

Track Opening

Use stack to remember positions of unmatched '(' characters

Match Closing

When we see ')', try to match with most recent '(' from stack

Clean Up

Remove all unmatched parentheses (both '(' and ')') from final result

Key Takeaway

🎯 Key Insight: Use a stack to track unmatched opening parentheses and immediately identify invalid closing ones - this gives us the minimum removals in just one pass!

Asked in

f Meta 42 G Google 38 a Amazon 31 ⊞ Microsoft 24

The optimal solution uses a stack-based approach in a single pass. Track indices of unmatched opening parentheses in a stack, and mark invalid closing parentheses immediately. This achieves O(n) time complexity with O(n) space for the most efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Stack Approach (Optimal)	O(n)	O(n)	Single pass using stack to track indices of unmatched parentheses
Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Generate all possible substrings by removing parentheses and check validity
Two-Pass Stack Simulation	O(n)	O(n)	First pass removes invalid closing parentheses, second pass removes excess opening parentheses

One-Pass Stack Approach (Optimal) — Algorithm Steps

Use stack to track indices of unmatched '(' characters
For each ')', try to pop from stack (match with '(')
Mark all remaining stack indices as invalid
Build result string skipping invalid indices
Return the cleaned string

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan & Stack

Push '(' indices, match ')' with stack top

Mark Invalid

Mark unmatched ')' and remaining '(' as invalid

Build Result

Create result string skipping marked indices

Code -

solution.c — C

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

char* minRemoveToMakeValid(char* s) {
    int len = strlen(s);
    int* stack = (int*)malloc(len * sizeof(int));
    int stackTop = -1;
    bool* toRemove = (bool*)calloc(len, sizeof(bool));
    
    // Single pass to identify invalid parentheses
    for (int i = 0; i < len; i++) {
        if (s[i] == '(') {
            stack[++stackTop] = i;
        } else if (s[i] == ')') {
            if (stackTop >= 0) {
                stackTop--; // Match found
            } else {
                toRemove[i] = true; // Invalid ')'
            }
        }
    }
    
    // Add remaining unmatched '(' to removal set
    while (stackTop >= 0) {
        toRemove[stack[stackTop--]] = true;
    }
    
    // Build result string
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int resultLen = 0;
    
    for (int i = 0; i < len; i++) {
        if (!toRemove[i]) {
            result[resultLen++] = s[i];
        }
    }
    
    result[resultLen] = '\0';
    
    free(stack);
    free(toRemove);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with constant time stack operations

✓ Linear Growth

Space Complexity

O(n)

Space for stack and boolean array to mark invalid indices

⚡ Linearithmic Space

89.2K Views

High Frequency

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

One-Pass Stack Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler