Replace Question Marks in String to Minimize Its Value

Replace Question Marks in String to Minimize Its Value - Problem

Hash Table String Greedy Sorting Heap (Priority Queue) Counting Medium

You are given a string s. Each character s[i] is either a lowercase English letter or '?'.

For a string t having length m containing only lowercase English letters, we define the function cost(i) for an index i as the number of characters equal to t[i] that appeared before it, i.e. in the range [0, i - 1].

The value of t is the sum of cost(i) for all indices i.

For example, for the string t = "aab":

cost(0) = 0 (no 'a' before index 0)
cost(1) = 1 (one 'a' before index 1)
cost(2) = 0 (no 'b' before index 2)

Hence, the value of "aab" is 0 + 1 + 0 = 1.

Your task is to replace all occurrences of '?' in s with any lowercase English letter so that the value of s is minimized.

Return a string denoting the modified string with replaced occurrences of '?'. If there are multiple strings resulting in the minimum value, return the lexicographically smallest one.

Input & Output

Example 1 — Basic Case

$ Input: s = "?ab?"

› Output: "aaba"

💡 Note: Replace first '?' with 'a' (min freq), second '?' with 'a' (still min among remaining). Result has value: cost(0)=0 + cost(1)=1 + cost(2)=0 + cost(3)=2 = 3

Example 2 — All Question Marks

$ Input: s = "???"

› Output: "abc"

💡 Note: Greedily pick 'a', then 'b', then 'c' to minimize value. Each character appears for first time so total value = 0

Example 3 — Mixed Pattern

$ Input: s = "a?a?"

› Output: "abac"

💡 Note: First '?' becomes 'b' (min freq), second '?' becomes 'c' (min freq). Value = 0+0+1+0 = 1

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either a lowercase English letter or '?'

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22 M Meta 18

The key insight is to greedily replace each '?' with the letter having minimum frequency so far. This minimizes the cost function since each character's cost equals the count of same characters before it. Best approach is greedy frequency counting with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force with Backtracking

⏱️ Time: O(26^k × n²) Space: O(n)

For each '?' position, try all 26 lowercase letters recursively. Calculate the value for each complete string and return the one with minimum value (lexicographically smallest if tied).

Greedy with Frequency Counting

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

Scan left to right, maintaining frequency count of each letter. When encountering '?', replace it with the letter having minimum current frequency (lexicographically smallest if tied).

Priority Queue (Min-Heap)

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

Maintain a priority queue of (frequency, letter) pairs. For each '?', extract the minimum frequency letter, use it, increment its frequency, and push it back to the heap.

Brute Force with Backtracking — Algorithm Steps

Identify all positions with '?'
Use backtracking to try all 26^k combinations (k = number of '?')
Calculate value for each complete string
Return the string with minimum value

Visualization

Tap to expand

Step-by-Step Walkthrough

Find '?' positions

Identify all question marks to replace

Try all letters

For each '?', recursively try a-z

Calculate values

Compute cost for each complete string

Code -

solution.c — C

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

char* solution(char* s) {
    int n = strlen(s);
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    for (int i = 0; i < n; i++) {
        if (result[i] == '?') {
            // Count frequency of each character before position i
            int freq[26] = {0};
            for (int j = 0; j < i; j++) {
                if (result[j] != '?') {
                    freq[result[j] - 'a']++;
                }
            }
            
            // Find character with minimum frequency
            int minFreq = freq[0];
            for (int k = 1; k < 26; k++) {
                if (freq[k] < minFreq) {
                    minFreq = freq[k];
                }
            }
            
            for (int c = 0; c < 26; c++) {
                if (freq[c] == minFreq) {
                    result[i] = 'a' + c;
                    break;
                }
            }
        }
    }
    
    return result;
}

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 × n²)

k is number of '?', for each of 26^k combinations we calculate value in O(n²)

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth and string storage

✓ Linear Space

28.4K Views

Medium Frequency

~25 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 Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler