Check if All A's Appears Before All B's - Practice Coding Problems

Check if All A's Appears Before All B's - Problem

String Easy

Given a string s consisting of only the characters 'a' and 'b', determine if all occurrences of 'a' appear before all occurrences of 'b' in the string.

In other words, the string should follow the pattern where we have zero or more 'a' characters followed by zero or more 'b' characters. Return true if this pattern holds, otherwise return false.

Examples:

"aaabbb" → true (all a's before all b's)
"abab" → false (a's and b's are mixed)
"aaa" → true (only a's)
"bbb" → true (only b's)

Input & Output

example_1.py — Basic Valid Pattern

$ Input: s = "aaabbb"

› Output: true

💡 Note: All 'a' characters appear before all 'b' characters, forming a valid pattern.

example_2.py — Invalid Mixed Pattern

$ Input: s = "abab"

› Output: false

💡 Note: There's an 'a' after a 'b' (at indices 2), which violates the required pattern.

example_3.py — Only A's

$ Input: s = "aaa"

› Output: true

💡 Note: Since there are no 'b' characters, all 'a's trivially appear before all 'b's.

Constraints

1 ≤ s.length ≤ 100
s[i] is either 'a' or 'b'
The string contains only lowercase letters 'a' and 'b'

Visualization

Tap to expand

Understanding the Visualization

Start Reading

Begin scanning the shelf from left to right

Track State

Remember when you first see a non-fiction book (b)

Detect Error

If you find a fiction book (a) after seeing non-fiction, shelf is incorrectly organized

Complete Scan

If no errors found, the shelf is properly organized

Key Takeaway

🎯 Key Insight: Use a boolean flag to track when we've seen the first 'b'. Any 'a' found after this point immediately indicates an invalid pattern, allowing for early termination and optimal O(n) performance.

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Meta 12

The optimal solution uses a single-pass state tracking approach with O(n) time complexity. The key insight is to track whether we've seen a 'b' character, and immediately return false if we encounter an 'a' after seeing a 'b'. This approach is efficient and elegant, requiring only one boolean variable and one pass through the string.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass (Optimal)	O(n)	O(1)	Track state: once we see 'b', any 'a' after it makes the string invalid

Single Pass (Optimal) — Algorithm Steps

Initialize a flag to track if we've seen any 'b'
Iterate through each character in the string
If current character is 'b', set the flag to true
If current character is 'a' and we've seen 'b', return false
If we complete the loop without issues, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with seenB = false

Process 'a'

If seenB is true, return false; otherwise continue

Process 'b'

Set seenB = true and continue

Complete

If we reach the end, return true

Code -

solution.c — C

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

bool checkString(char* s) {
    bool seenB = false;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        if (s[i] == 'b') {
            seenB = true;
        } else if (s[i] == 'a' && seenB) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = 0;
    }
    printf("%s\n", checkString(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character is visited exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using one boolean variable regardless of input size

✓ Linear Space

24.7K Views

Medium Frequency

~8 min Avg. Time

892 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

Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler