Valid Parentheses - Practice Coding Problems

Valid Parentheses - Problem

String Stack Easy

Imagine you're reading a complex mathematical expression or code snippet - how do you know if all the brackets are properly matched? This classic problem asks you to determine if a string of brackets is valid.

Given a string s containing only parentheses (), square brackets [], and curly braces {}, determine if the input string is valid.

A string is considered valid if:

Every opening bracket has a corresponding closing bracket of the same type
Brackets are closed in the correct order (Last In, First Out - LIFO)
Every closing bracket matches the most recent unmatched opening bracket

Examples:

"()" → Valid ✅
"()[]{}" → Valid ✅
"([)]" → Invalid ❌ (wrong order)
"((" → Invalid ❌ (unmatched opening)

Input & Output

example_1.py — Basic Valid Case

$ Input: s = "()"

› Output: true

💡 Note: The string contains a single pair of parentheses that are properly matched and in correct order.

example_2.py — Multiple Types Valid

$ Input: s = "()[]{}"

› Output: true

💡 Note: All three types of brackets are present and each pair is properly matched in the correct order.

example_3.py — Invalid Order

$ Input: s = "([)]"

› Output: false

💡 Note: Although each opening bracket has a corresponding closing bracket, they are not in the correct order. The ']' closes before ')' but '[' was opened after '('.

Constraints

1 ≤ s.length ≤ 10⁴
s consists of parentheses only: '()[]{}'
Follow-up: Can you solve this in O(1) space? (Hint: It's not possible while maintaining O(n) time)

Visualization

Tap to expand

Understanding the Visualization

Opening Bracket = Add Plate

When we see '(', '[', or '{', we add it to our stack like adding a plate

Closing Bracket = Remove Plate

When we see ')', ']', or '}', we check the top plate and remove it if it matches

Validation Check

If plates don't match or stack is empty when we try to remove, it's invalid

Final State

Valid parentheses leave us with an empty stack - all plates were properly paired!

Key Takeaway

🎯 Key Insight: Valid parentheses follow LIFO order - exactly what a stack provides. Each closing bracket must match the most recently opened bracket, making stack the perfect data structure for this problem!

Asked in

G Google 85 a Amazon 72 ⊞ Microsoft 68 f Meta 45

The optimal solution uses a stack data structure to track opening brackets in O(n) time. For each closing bracket, we check if it matches the most recent opening bracket (LIFO order). This approach naturally handles the nesting requirements and is both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Replacement)	O(n²)	O(n)	Repeatedly remove valid pairs until no more pairs can be removed
Stack-Based Solution (Optimal)	O(n)	O(n)	Use a stack to track opening brackets and match them with closing brackets

Brute Force (String Replacement) — Algorithm Steps

Start with the original string
Search for any valid bracket pair: '()', '[]', or '{}'
If found, remove the pair and start over
Repeat until no more pairs are found
If string is empty, return true; otherwise false

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the input string

Find Pairs

Scan for valid bracket pairs

Remove Pairs

Remove found pairs from string

Repeat

Continue until no more pairs found

Code -

solution.c — C

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

bool isValid(char* s) {
    int len = strlen(s);
    char temp[len + 1];
    strcpy(temp, s);
    
    // Keep removing valid pairs until none are left
    while (true) {
        int originalLength = strlen(temp);
        char result[len + 1];
        int j = 0;
        
        // Remove valid pairs
        for (int i = 0; i < strlen(temp); i++) {
            if (i < strlen(temp) - 1) {
                if ((temp[i] == '(' && temp[i+1] == ')') ||
                    (temp[i] == '[' && temp[i+1] == ']') ||
                    (temp[i] == '{' && temp[i+1] == '}')) {
                    i++; // skip the pair
                    continue;
                }
            }
            result[j++] = temp[i];
        }
        result[j] = '\0';
        
        // If no pairs were removed, break
        if (strlen(result) == originalLength) {
            break;
        }
        strcpy(temp, result);
    }
    
    // Valid if string is empty
    return strlen(temp) == 0;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // remove newline
    printf("%s\n", isValid(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we need to scan the entire string n/2 times, each scan takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

String operations may create intermediate strings

⚡ Linearithmic Space

89.2K Views

Very 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

Brute Force (String Replacement) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler