Check If Word Is Valid After Substitutions

Check If Word Is Valid After Substitutions - Problem

String Stack Medium

String Validation Through Substitution Rules

Imagine you have a special string construction game where you start with an empty string and can only perform one operation: insert the substring "abc" at any position. Your task is to determine if a given string s could have been created using only this operation.

🎯 The Challenge: Given a string s, return true if it's possible to construct s by starting with an empty string and repeatedly inserting "abc" at any position, or false otherwise.

Example Construction:
• Start: "" (empty)
• Insert "abc": "abc"
• Insert "abc" at position 1: "aabcbc" = "aabcbc"
• Insert "abc" at end: "aabcbcabc" = "aabcbcabc"

This problem tests your understanding of stack-based parsing and pattern matching algorithms.

Input & Output

example_1.py — Basic Valid String

$ Input: s = "aabcbc"

› Output: true

💡 Note: We can construct this string: '' → 'abc' → 'aabcbc' (insert 'abc' at position 1). The stack approach: push 'a', push 'a', push 'b', push 'c' (forms 'abc' with previous 'a','b', so pop them), push 'b', push 'c' (forms 'abc', so pop them). Stack becomes empty.

example_2.py — Simple ABC

$ Input: s = "abc"

› Output: true

💡 Note: Direct single insertion: '' → 'abc'. Stack approach: push 'a', push 'b', push 'c' (forms complete 'abc', pop all). Stack becomes empty.

example_3.py — Invalid Pattern

$ Input: s = "abccba"

› Output: false

💡 Note: After processing with stack: 'a','b','c' form 'abc' (popped), then 'c','b','a' remain. Since we can't form valid 'abc' patterns with remaining characters, the string is invalid.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty stack and input string

Process Characters

Push each character onto the stack

Pattern Detection

When 'c' is pushed, check for 'abc' pattern

Pattern Removal

If 'abc' found, remove all three characters

Final Check

String is valid if stack is empty at the end

Key Takeaway

🎯 Key Insight: Use a stack to efficiently validate ABC patterns by detecting and removing complete 'abc' sequences as they form, achieving optimal O(n) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need to scan the string multiple times, each time removing one 'abc'

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursive calls and string copying can use quadratic space

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 2 × 10⁴
s consists only of letters 'a', 'b', and 'c'
Follow-up: Can you solve this in O(n) time with O(1) extra space?

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal solution uses a stack-based approach that processes characters sequentially. When we encounter a 'c' and the stack has 'ab' at the top, we remove the complete 'abc' pattern. This simulates the reverse construction process efficiently in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Substitution	O(n²)	O(n²)	Recursively try removing all occurrences of 'abc' until string is empty or no more removals possible
Stack-Based Pattern Matching	O(n)	O(n)	Use a stack to efficiently validate by matching complete 'abc' patterns and removing them

Recursive Substitution — Algorithm Steps

Find the first occurrence of 'abc' in the string
If found, remove it and recursively check the remaining string
If no 'abc' found and string is not empty, return false
If string becomes empty, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the input string 'aabcbc'

Find First ABC

Locate first occurrence of 'abc' pattern

Remove ABC

Remove the pattern and create new string

Recurse

Repeat process on remaining string

Check Empty

If string becomes empty, return true

Code -

solution.c — C

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

bool isValid(char* s) {
    int len = strlen(s);
    if (len == 0) {
        return true;
    }
    
    // Find 'abc' substring
    char* pos = strstr(s, "abc");
    if (pos == NULL) {
        return false;
    }
    
    // Remove 'abc' by shifting characters
    int index = pos - s;
    memmove(s + index, s + index + 3, len - index - 2);
    
    return isValid(s);
}

int main() {
    char s[1001];
    scanf("%s", s);
    
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"') {
        memmove(s, s + 1, len - 1);
        s[len - 2] = '\0';
    }
    
    printf("%s\n", isValid(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need to scan the string multiple times, each time removing one 'abc'

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursive calls and string copying can use quadratic space

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 2 × 10⁴
s consists only of letters 'a', 'b', and 'c'
Follow-up: Can you solve this in O(n) time with O(1) extra space?

42.3K Views

Medium Frequency

~15 min Avg. Time

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

Recursive Substitution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler