String Without AAA or BBB - Practice Coding Problems

String Without AAA or BBB - Problem

String Greedy Medium

Given two integers a and b, construct a string that contains exactly a occurrences of the character 'a' and exactly b occurrences of the character 'b'.

The challenge is to arrange these characters such that:

The total length of the string is a + b
No three consecutive 'a' characters appear together (no "aaa")
No three consecutive 'b' characters appear together (no "bbb")

Think of it as a balancing act - you need to distribute the characters strategically to avoid creating forbidden patterns while using all available characters.

For example, if a = 1 and b = 2, you could return "abb", "bab", or "bba" - all are valid solutions!

Input & Output

example_1.py — Basic Case

$ Input: a = 1, b = 2

› Output: "abb"

💡 Note: We have 1 'a' and 2 'b's to use. One valid arrangement is "abb" - it uses exactly 1 'a' and 2 'b's, has no 'aaa' or 'bbb' patterns. Other valid solutions include "bab" and "bba".

example_2.py — Larger Difference

$ Input: a = 5, b = 1

› Output: "aabaaa"

💡 Note: With 5 'a's and 1 'b', we need to distribute the 'a's carefully. The greedy approach gives "aabaaa" - it places 'b' strategically to break up the 'a's and prevent 'aaa' patterns while using all characters.

example_3.py — Equal Counts

$ Input: a = 2, b = 2

› Output: "abab"

💡 Note: When counts are equal, we can alternate characters safely. "abab" uses exactly 2 'a's and 2 'b's with no forbidden patterns. "baba" would also be valid.

Constraints

0 ≤ a ≤ 100
0 ≤ b ≤ 100
It is guaranteed that an answer exists for all valid inputs
At least one of a or b will be greater than 0

Visualization

Tap to expand

Understanding the Visualization

Count Your Notes

Start with your available 'A' and 'B' notes, like having 5 A-notes and 1 B-note

Choose Wisely

Always prioritize the note you have more of - if you have many A's, play 2 A's together when safe

Break the Pattern

Add a different note to prevent monotony - place a B between groups of A's

Repeat Until Done

Continue this process until you've used all your notes, creating a balanced melody

Key Takeaway

🎯 Key Insight: Like composing music, we balance abundance with variety. Always use more of what you have plenty of, but break it up strategically to maintain harmony and avoid monotonous patterns!

Asked in

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

The optimal solution uses a greedy strategy that runs in O(a+b) time. The key insight is to always prioritize the more abundant character, adding 2 characters at a time when safe (when it won't create 3 consecutive same characters), then 1 of the other character to break patterns. This approach naturally prevents forbidden 'aaa' or 'bbb' sequences while efficiently using all available characters.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Strategy (Optimal)	O(a+b)	O(1)	Greedily add 2 characters of the more frequent type, then 1 of the other
Brute Force (Generate All Permutations)	O((a+b)!)	O((a+b)!)	Generate all possible arrangements and find the first valid one

Greedy Strategy (Optimal) — Algorithm Steps

Compare counts of remaining 'a' and 'b' characters
If one character has significantly more count, add 2 of it (if safe)
Otherwise, add 1 of the more frequent character
Add 1 of the other character to break any potential pattern
Repeat until all characters are used

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Counts

Check which character has more remaining count

Decide Characters

Add 2 of abundant char (if safe), then 1 of other

Avoid Patterns

Prevent 3 consecutive chars by strategic placement

Repeat

Continue until all characters are used

Code -

solution.c — C

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

char* strWithout3a3b(int a, int b) {
    int total = a + b;
    char* result = (char*)malloc((total + 1) * sizeof(char));
    int idx = 0;
    
    while (a > 0 || b > 0) {
        int writeA = 0;
        
        if (idx >= 2) {
            char last = result[idx - 1];
            char secondLast = result[idx - 2];
            
            if (last == secondLast) {
                // Last 2 chars are same, must write the other one
                writeA = (last == 'b');
            } else {
                // Last 2 chars are different, write the more frequent one
                writeA = (a >= b);
            }
        } else {
            // Not enough history, write the more frequent one
            writeA = (a >= b);
        }
        
        if (writeA) {
            // Decide how many 'a's to write
            int writeTwo = (a >= b + 2) && (idx == 0 || result[idx - 1] != 'a');
            if (writeTwo) {
                result[idx++] = 'a';
                result[idx++] = 'a';
                a -= 2;
            } else {
                result[idx++] = 'a';
                a--;
            }
        } else {
            // Decide how many 'b's to write
            int writeTwo = (b >= a + 2) && (idx == 0 || result[idx - 1] != 'b');
            if (writeTwo) {
                result[idx++] = 'b';
                result[idx++] = 'b';
                b -= 2;
            } else {
                result[idx++] = 'b';
                b--;
            }
        }
    }
    
    result[total] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(a+b)

We process each character exactly once, building the result string character by character

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for counters (excluding the output string)

✓ Linear Space

73.9K Views

Medium Frequency

~15 min Avg. Time

1.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

Greedy Strategy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler