Minimum Additions to Make Valid String

Minimum Additions to Make Valid String - Problem

Given a string word to which you can insert letters 'a', 'b' or 'c' anywhere and any number of times, return the minimum number of letters that must be inserted so that word becomes valid.

A string is called valid if it can be formed by concatenating the string "abc" several times.

Input & Output

Example 1 — Single Character

$ Input: word = "b"

› Output: 2

💡 Note: Insert 'a' before 'b' and 'c' after 'b' to get 'abc'. Total insertions: 2

Example 2 — Partial Pattern

$ Input: word = "aaa"

› Output: 6

💡 Note: Each 'a' needs 'bc' to complete 'abc'. Three 'a's need 3×2 = 6 insertions total

Example 3 — Already Valid

$ Input: word = "abc"

› Output: 0

💡 Note: String is already valid, no insertions needed

Constraints

1 ≤ word.length ≤ 50
word consists only of letters 'a', 'b', and 'c'

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is to track pending characters that need completion. Use counters for 'a's waiting for 'b' and 'b's waiting for 'c'. Best approach is Greedy State Machine with Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force with Recursion

⏱️ Time: O(4ⁿ) Space: O(n)

For each position in the string, try inserting 'a', 'b', 'c' or nothing, then recursively solve the rest. Check if the final string can be formed by concatenating 'abc' multiple times.

Greedy State Machine

⏱️ Time: O(n) Space: O(1)

Use counters to track how many 'a's are waiting for 'b', and how many 'b's are waiting for 'c'. When we see a character, either match it with pending letters or add insertions to complete the pattern.

Stack-Based Simulation

⏱️ Time: O(n) Space: O(n)

Push characters onto stack and try to form 'abc' patterns. When we see 'c', check if top two elements are 'b' and 'a'. If not, calculate how many characters need to be inserted.

Brute Force with Recursion — Algorithm Steps

For each position, try 4 options: insert 'a', 'b', 'c', or nothing
Recursively solve remaining substring
Check if final string is valid (multiple 'abc' concatenations)
Return minimum insertions across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Analysis

Start with input string 'b'

Try Insertions

At each position, try inserting 'a', 'b', 'c' or nothing

Check Validity

Verify if result can be formed by 'abc' repetitions

Code -

solution.c — C

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

int solution(char* word) {
    int a = 0, b = 0, insertions = 0;
    int len = strlen(word);
    
    for (int i = 0; i < len; i++) {
        char c = word[i];
        if (c == 'a') {
            a++;
        } else if (c == 'b') {
            if (a > 0) {
                a--;
                b++;
            } else {
                insertions++;
                b++;
            }
        } else if (c == 'c') {
            if (b > 0) {
                b--;
            } else {
                insertions += 2;
            }
        }
    }
    
    return insertions + 2 * a + b;
}

int main() {
    char word[1000];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    
    int result = solution(word);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4ⁿ)

At each of n positions, we try 4 options (insert a/b/c or nothing)

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n levels deep

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler