Replace All ?'s to Avoid Consecutive Repeating Characters

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

String Easy

Given a string s containing only lowercase English letters and the '?' character, convert all the '?' characters into lowercase letters such that the final string does not contain any consecutive repeating characters.

You cannot modify the non '?' characters.

It is guaranteed that there are no consecutive repeating characters in the given string except for '?'.

Return the final string after all the conversions (possibly zero) have been made. If there is more than one solution, return any of them. It can be shown that an answer is always possible with the given constraints.

Input & Output

Example 1 — Basic Case

$ Input: s = "?zs"

› Output: "azs"

💡 Note: Replace '?' with 'a'. Since 'a' ≠ 'z', no consecutive repeating characters exist. Result: "azs"

Example 2 — Multiple Question Marks

$ Input: s = "ubv?w"

› Output: "ubvaw"

💡 Note: Replace '?' with 'a'. Check: 'v' ≠ 'a' and 'a' ≠ 'w', so no consecutive repeats. Result: "ubvaw"

Example 3 — Adjacent Conflicts

$ Input: s = "?a?"

› Output: "bac"

💡 Note: First '?' cannot be 'a' (next char), so use 'b'. Second '?' cannot be 'a' (prev char), so use 'c'. Result: "bac"

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters and '?' characters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The greedy approach is optimal: iterate through the string and replace each '?' with the first letter from 'abc' that doesn't match its neighbors. Since we have 26 letters and at most 2 neighbors to avoid, a solution always exists. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(26^k) Space: O(k)

For each '?' character, try all 26 lowercase letters and recursively check if the resulting string has no consecutive repeating characters. This explores all possible combinations until finding a valid solution.

Greedy - Single Pass Replacement

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

Iterate through the string once, and for each '?' character, try letters 'a', 'b', 'c' until finding one that differs from both the previous and next characters. This works because we have 26 letters and at most 2 neighbors to avoid.

Brute Force - Try All Combinations — Algorithm Steps

Iterate through each character in the string
For each '?', try letters 'a' to 'z'
Recursively fill remaining '?' characters
Check if final string has no consecutive repeats

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First ?

Locate the first '?' character to replace

Try Letters

Try 'a', 'b', 'c'... until finding one that doesn't conflict

Recurse

Move to next '?' and repeat the process

Code -

solution.c — C

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

char* backtrack(char* s, int index, int len) {
    if (index == len) {
        char* result = malloc((len + 1) * sizeof(char));
        strcpy(result, s);
        return result;
    }
    
    if (s[index] != '?') {
        return backtrack(s, index + 1, len);
    }
    
    for (char c = 'a'; c <= 'z'; c++) {
        s[index] = c;
        // Check if current placement is valid
        int valid = 1;
        if (index > 0 && s[index] == s[index-1]) {
            valid = 0;
        }
        if (index < len-1 && s[index+1] != '?' && s[index] == s[index+1]) {
            valid = 0;
        }
        
        if (valid) {
            char* result = backtrack(s, index + 1, len);
            if (result != NULL) return result;
        }
        
        s[index] = '?';  // backtrack
    }
    
    return NULL;
}

char* solution(char* s) {
    int len = strlen(s);
    char* copy = malloc((len + 1) * sizeof(char));
    strcpy(copy, s);
    return backtrack(copy, 0, len);
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^k)

k is number of '?' characters, trying 26 letters for each position

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth equals number of '?' characters

✓ Linear Space

23.4K Views

Medium Frequency

~15 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler