Minimum Additions to Make Valid String - Practice Coding Problems

Minimum Additions to Make Valid String - Problem

You're given a string word that contains only letters 'a', 'b', and 'c'. Your mission is to transform this string into a valid string by inserting the minimum number of additional characters.

A string is considered valid if it can be formed by concatenating the pattern "abc" multiple times. For example:

"abc" ✅ (1 repetition)
"abcabc" ✅ (2 repetitions)
"abcabcabc" ✅ (3 repetitions)
"ab" ❌ (incomplete pattern)
"acb" ❌ (wrong order)

You can insert 'a', 'b', or 'c' at any position and any number of times. Return the minimum number of insertions needed to make the string valid.

Example: If word = "b", you need to insert 'a' before and 'c' after to get "abc", so the answer is 2.

Input & Output

example_1.py — Basic case

$ Input: word = "b"

› Output: 2

💡 Note: We need to insert 'a' before 'b' and 'c' after 'b' to form "abc". Total insertions: 2.

example_2.py — Multiple patterns

$ Input: word = "aaa"

› Output: 6

💡 Note: Each 'a' starts a new "abc" pattern. We need 'bc' after each 'a': "abc" + "abc" + "abc". Total insertions: 2 + 2 + 2 = 6.

example_3.py — Complete patterns

$ Input: word = "abc"

› Output: 0

💡 Note: The string already forms a complete "abc" pattern, so no insertions are needed.

Constraints

0 ≤ word.length ≤ 50
word consists only of letters 'a', 'b', and 'c'
Goal: Minimum insertions to make string = "abc" repeated

Visualization

Tap to expand

Understanding the Visualization

Start State

Begin expecting the first piece 'a' of a new abc set

Process Each Character

For each character, check if it's the expected next piece

Handle Mismatches

If character doesn't match expectation, count insertions needed

Update Expectations

Move to next expected state based on current character

Key Takeaway

🎯 Key Insight: Use a state machine to track your position in the "abc" pattern. Each character either advances you to the next state or requires insertions to get back on track.

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses a state machine approach with O(n) time complexity. Track which character you're expecting next in the current 'abc' pattern (state 0='a', 1='b', 2='c'). When you find the expected character, advance to the next state. When you don't, count the insertions needed to reach the current character's expected position in the pattern.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (All Possibilities)	O(n²)	O(n)	Try all possible ways to partition the string into 'abc' patterns
State Machine (Optimal)	O(n)	O(1)	Track current state in 'abc' pattern and count needed insertions

Dynamic Programming (All Possibilities) — Algorithm Steps

Create DP table where dp[i] represents minimum insertions needed for first i characters
For each position, try to match with 'a', 'b', or 'c' in sequence
Consider cost of inserting missing characters vs using current character
Return dp[n] where n is string length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create array where dp[i] = min additions for first i characters

Try ABC Pattern

For each position, try to form complete 'abc' pattern

Calculate Cost

Count missing characters needed to complete pattern

Update States

Update future positions with minimum cost

Code -

solution.c — C

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

#define MIN(a, b) ((a) < (b) ? (a) : (b))

int minimumAdditions(char* word) {
    int n = strlen(word);
    int dp[n + 1];
    for (int i = 0; i <= n; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int i = 0; i <= n; i++) {
        if (dp[i] == INT_MAX) continue;
        
        char pattern[] = "abc";
        int pos = i;
        int additions = 0;
        
        for (int j = 0; j < 3; j++) {
            if (pos < n && word[pos] == pattern[j]) {
                pos++;
            } else {
                additions++;
            }
        }
        
        dp[pos] = MIN(dp[pos], dp[i] + additions);
        
        if (i < n) {
            dp[i + 1] = MIN(dp[i + 1], dp[i] + 1);
        }
    }
    
    return dp[n];
}

int main() {
    char word[1001];
    scanf("%s", word);
    // Remove quotes if present
    if (word[0] == '"') {
        int len = strlen(word);
        for (int i = 1; i < len - 1; i++) {
            word[i - 1] = word[i];
        }
        word[len - 2] = '\0';
    }
    printf("%d\n", minimumAdditions(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position, we consider multiple previous states and transitions

⚠ Quadratic Growth

Space Complexity

O(n)

DP table to store minimum insertions for each prefix

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Dynamic Programming (All Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler