Replace All ?'s to Avoid Consecutive Repeating Characters

Replace All ?'s to Avoid Consecutive Repeating Characters - Problem

String Easy

You're given a string s containing lowercase English letters and mysterious ? characters. Your mission is to replace every question mark with a lowercase letter such that no two adjacent characters in the final string are identical.

Think of the question marks as blank spaces that need to be filled wisely. You cannot change any existing letters - only the question marks are yours to modify.

The good news: The input string is guaranteed to have no consecutive repeating letters among the non-? characters, so a solution always exists!

Goal: Return any valid string where all ? characters have been replaced with letters, and no two consecutive characters are the same.

Example: "?zs" could become "azs" or "bzs", but not "zzs" since that would create consecutive identical characters.

Input & Output

example_1.py — Basic replacement

$ Input: s = "?zs"

› Output: "azs"

💡 Note: We replace the '?' with 'a' because it doesn't match its right neighbor 'z'. The result "azs" has no consecutive repeating characters.

example_2.py — Multiple question marks

$ Input: s = "ubv?w"

› Output: "ubvaw"

💡 Note: The '?' is surrounded by 'v' and 'w'. We can use 'a' since it doesn't conflict with either neighbor.

example_3.py — Edge case with conflicts

$ Input: s = "a?c"

› Output: "abc"

💡 Note: The '?' cannot be 'a' (left neighbor) or 'c' (right neighbor), so we use 'b' as the first valid option.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters and '?' characters only
No consecutive repeating characters exist in the input (except '?')
A solution always exists with the given constraints

Visualization

Tap to expand

Understanding the Visualization

Walk Through Tables

Move from left to right, checking each empty table

Check Neighbors

Look at who's sitting on the left and right of empty table

Choose Personality

Pick the first personality type (A, B, C) that won't clash

Seat Customer

Place the customer and move to next empty table

Key Takeaway

🎯 Key Insight: Since we only need to avoid conflicts with immediate neighbors (at most 2 characters), we can always find a valid letter among 'a', 'b', 'c' using a greedy approach. This makes the problem much simpler than it initially appears!

Asked in

G Google 12 f Facebook 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses a greedy one-pass approach. For each '?' character, we simply try letters 'a', 'b', 'c' until we find one that doesn't conflict with adjacent characters. Since we need to avoid at most 2 neighbors, one of these 3 letters will always work, making this O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(26^k)	O(k)	Generate all possible character combinations and find the first valid one
One-Pass Greedy (Optimal)	O(n)	O(1)	Replace each '?' with the first valid letter by checking only adjacent characters

Brute Force (Try All Combinations) — Algorithm Steps

Find the first '?' character in the string
Try each letter 'a' to 'z' in that position
For each letter, recursively solve the remaining '?' characters
Check if the complete string has no consecutive repeating characters
Return the first valid solution found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First ?

Locate the first question mark to replace

Try Letters a-z

Attempt each letter and check conflicts

Recurse

If no conflict, move to next question mark

Backtrack

If dead end reached, undo and try next letter

Code -

solution.c — C

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

bool backtrack(char* s, int index, int len) {
    if (index == len) return true;
    
    if (s[index] != '?') {
        return backtrack(s, index + 1, len);
    }
    
    for (char c = 'a'; c <= 'z'; c++) {
        // Check left neighbor
        if (index > 0 && s[index - 1] == c) continue;
        // Check right neighbor
        if (index < len - 1 && s[index + 1] == c) continue;
        
        s[index] = c;
        if (backtrack(s, index + 1, len)) return true;
        s[index] = '?'; // backtrack
    }
    
    return false;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // remove newline
    
    backtrack(s, 0, strlen(s));
    printf("%s\n", s);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^k)

Where k is the number of '?' characters. In the worst case, we try all 26 letters for each '?' position

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth equals the number of '?' characters

✓ Linear Space

23.4K Views

Medium Frequency

~12 min Avg. Time

856 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler