Valid Parenthesis String - Practice Coding Problems

Valid Parenthesis String - Problem

Imagine you're a compiler trying to validate parentheses in code, but with a twist! You're given a string s containing only three types of characters: opening parenthesis '(', closing parenthesis ')', and a wildcard '*'.

Your task is to determine if this string can be made valid by treating each * as either:

An opening parenthesis '('
A closing parenthesis ')'
An empty string (ignore it completely)

A valid parentheses string follows these rules:

Every opening parenthesis '(' must have a matching closing parenthesis ')'
Every closing parenthesis ')' must have a matching opening parenthesis '('
Opening parentheses must come before their corresponding closing parentheses

Goal: Return true if the string can be made valid, false otherwise.

Input & Output

example_1.py — Basic wildcard usage

$ Input: s = "()"

› Output: true

💡 Note: Simple valid parentheses without wildcards

example_2.py — Wildcard as closing bracket

$ Input: s = "(*)"

› Output: true

💡 Note: The '*' can be used as ')' to close the opening '('

example_3.py — Multiple wildcards

$ Input: s = "(*))"

› Output: true

💡 Note: First '*' can be '(' and we get "(())" which is valid

Visualization

Tap to expand

Understanding the Visualization

Count potential partners

Track minimum and maximum possible male dancers waiting

Process each dancer

Males increase count, females decrease count, flexible dancers create a range

Check feasibility

If we ever have too many females (negative max), it's impossible

Final validation

Check if perfect pairing (0 unmatched) is within our range

Key Takeaway

🎯 Key Insight: Instead of trying every combination, track the range of possibilities. Wildcards create flexibility, but we only need to know if perfect pairing (0 unmatched) is achievable within our range.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only using two variables to track the range

✓ Linear Space

Constraints

1 ≤ s.length ≤ 100
s[i] is '(', ')' or '*'
The string contains only parentheses and wildcards

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 25

The optimal solution uses greedy range tracking in O(n) time. Instead of trying all wildcard combinations, we maintain the range of possible unmatched opening brackets at each position. The key insight is that wildcards give us flexibility - they can increase or decrease our bracket count, creating a range of possibilities rather than a single value.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(3^k)	O(n)	Try every possible assignment of wildcards using backtracking
Greedy Range Tracking (Optimal)	O(n)	O(1)	Track min and max possible unmatched opening brackets in one pass

Brute Force (Try All Combinations) — Algorithm Steps

Start from the first character with balance counter = 0
For '(' increment balance, for ')' decrement balance
For '*' try all three options recursively: '(', ')', empty
If balance goes negative, this path is invalid
At the end, check if balance equals 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at root

Begin with balance=0, index=0

Process '('

Increment balance to 1

Branch on '*'

Try three branches: '(', ')', empty

Check validity

Prune branches where balance < 0

Code -

solution.c — C

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

bool backtrack(char* s, int i, int balance, int len) {
    if (balance < 0) return false;
    if (i == len) return balance == 0;
    
    char c = s[i];
    if (c == '(') {
        return backtrack(s, i + 1, balance + 1, len);
    } else if (c == ')') {
        return backtrack(s, i + 1, balance - 1, len);
    } else { // c == '*'
        return backtrack(s, i + 1, balance + 1, len) ||  // '*' as '('
               backtrack(s, i + 1, balance - 1, len) ||  // '*' as ')'
               backtrack(s, i + 1, balance, len);         // '*' as empty
    }
}

bool checkValidString(char* s) {
    return backtrack(s, 0, 0, strlen(s));
}

int main() {
    char s[101];
    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;
    }
    printf("%s\n", checkValidString(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^k)

Where k is the number of wildcards. Each wildcard has 3 choices, leading to 3^k combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion depth can go up to n levels in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
s[i] is '(', ')' or '*'
The string contains only parentheses and wildcards

52.0K Views

Medium-High Frequency

~15 min Avg. Time

2.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler