Codestin Search App

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

Constraints

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

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.

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
✓ Greedy Range Tracking (Optimal)	O(n)	O(1)	Track min and max possible unmatched opening brackets in one pass
Brute Force (Try All Combinations)	O(3^k)	O(n)	Try every possible assignment of wildcards using backtracking

Greedy Range Tracking (Optimal) — Algorithm Steps

Initialize min_open = 0, max_open = 0
For '(': increment both min_open and max_open
For ')': decrement both min_open and max_open
For '*': decrement min_open (use as ')'), increment max_open (use as '(')
If max_open < 0, impossible to balance
Keep min_open >= 0 (can't have negative unmatched)
At end, check if 0 is in range [min_open, max_open]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial state

min=0, max=0

Process '('

min=1, max=1

Process '*'

min=0, max=2

Process ')'

min=0, max=1 (still possible)

Code -

solution.c — C

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

bool checkValidString(char* s) {
    int minOpen = 0;  // Minimum possible unmatched '('
    int maxOpen = 0;  // Maximum possible unmatched '('
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        char c = s[i];
        if (c == '(') {
            minOpen++;
            maxOpen++;
        } else if (c == ')') {
            minOpen--;
            maxOpen--;
        } else { // c == '*'
            minOpen--;  // Use '*' as ')'
            maxOpen++;  // Use '*' as '('
        }
        
        // If maxOpen < 0, we have too many ')' that can't be balanced
        if (maxOpen < 0) {
            return false;
        }
        
        // minOpen should never be negative
        if (minOpen < 0) {
            minOpen = 0;
        }
    }
    
    // Check if 0 unmatched brackets is possible
    return minOpen <= 0 && 0 <= maxOpen;
}

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(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

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

Constraints

Visualization

Related Problems

Common Approaches

Greedy Range Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler