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

Replace Question Marks to Minimize String Value

You are given a string s containing lowercase letters and question marks (?). Your task is to replace all question marks with lowercase letters to minimize the value of the resulting string.

How is the value calculated?
For any string, the value is the sum of costs for each position. The cost at position i equals the number of times the character at position i has appeared before position i.

Example: For string "aab":
• Position 0 ('a'): cost = 0 (no previous 'a')
• Position 1 ('a'): cost = 1 (one previous 'a')
• Position 2 ('b'): cost = 0 (no previous 'b')
• Total value = 0 + 1 + 0 = 1

Goal: Replace all ? characters to minimize the total value. If multiple solutions exist with the same minimum value, return the lexicographically smallest one.

Input & Output

example_1.py — Basic Replacement

$ Input: s = "???" Output: "abc"

› Output: "abc"

💡 Note: Replace all question marks with the lexicographically smallest characters. Since all positions are empty, we choose 'a', 'b', 'c' in order to minimize the total value: 0 + 0 + 0 = 0.

example_2.py — Mixed Characters

$ Input: s = "a?b?" Output: "abac"

› Output: "abac"

💡 Note: Position 0: 'a' (given), Position 1: choose 'b' (freq 0), Position 2: 'b' (given), Position 3: choose 'a' (freq 1) vs 'c' (freq 0) → choose 'c'. Final value: 0 + 0 + 1 + 0 = 1.

example_3.py — All Same Character

$ Input: s = "aaa" Output: "aaa"

› Output: "aaa"

💡 Note: No question marks to replace. The value is 0 + 1 + 2 = 3. This is already the minimum possible for this input.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either a lowercase English letter or '?'
At least one character in s is '?'

Visualization

Tap to expand

Understanding the Visualization

Track Popularity

Keep count of how many times each book (character) has been checked out

Process Customers

For each customer (position), either record their specific choice or recommend optimally

Minimize Costs

When recommending (?), always choose the least popular book to minimize checkout fee

Update Records

After each checkout, increment that book's popularity count for future decisions

Key Takeaway

🎯 Key Insight: The greedy approach works because each character's cost depends only on its previous frequency. By always choosing the least frequent character, we minimize the immediate cost without affecting future optimal choices.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy approach with frequency tracking. For each question mark, we replace it with the least frequent character seen so far. This minimizes the cost at each step since cost equals the number of previous occurrences. The algorithm runs in O(n) time and naturally produces the lexicographically smallest result by always choosing the leftmost character among those with minimum frequency.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(26^k × n)	O(26^k × n)	Generate all possible replacements for question marks and find the one with minimum value
Greedy with Frequency Tracking (Optimal)	O(n)	O(1)	Traverse string once, always choose the least frequent character for each question mark

Brute Force (Try All Combinations) — Algorithm Steps

Find all positions of question marks in the string
Generate all possible combinations of letters for these positions
For each combination, calculate the total value of the resulting string
Keep track of the minimum value found and all strings achieving it
Return the lexicographically smallest string with minimum value

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Question Marks

Identify positions that need replacement

Generate All Combinations

Create every possible string by replacing ? with a-z

Calculate Values

Compute the value for each generated string

Find Minimum

Select the lexicographically smallest string with minimum value

Code -

solution.c — C

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

int calculateValue(char* str) {
    int count[26] = {0};
    int totalValue = 0;
    int len = strlen(str);
    
    for (int i = 0; i < len; i++) {
        totalValue += count[str[i] - 'a'];
        count[str[i] - 'a']++;
    }
    return totalValue;
}

void generateCombinations(char* s, int pos, char* current, int currentLen, char** combinations, int* comboCount, int maxCombos) {
    if (pos == strlen(s)) {
        if (*comboCount < maxCombos) {
            combinations[*comboCount] = malloc((currentLen + 1) * sizeof(char));
            strcpy(combinations[*comboCount], current);
            (*comboCount)++;
        }
        return;
    }
    
    if (s[pos] == '?') {
        for (char c = 'a'; c <= 'z'; c++) {
            current[currentLen] = c;
            current[currentLen + 1] = '\0';
            generateCombinations(s, pos + 1, current, currentLen + 1, combinations, comboCount, maxCombos);
        }
    } else {
        current[currentLen] = s[pos];
        current[currentLen + 1] = '\0';
        generateCombinations(s, pos + 1, current, currentLen + 1, combinations, comboCount, maxCombos);
    }
}

char* fillString(char* s) {
    int maxCombos = 1000000;
    char** combinations = malloc(maxCombos * sizeof(char*));
    int comboCount = 0;
    char* current = malloc(1000 * sizeof(char));
    current[0] = '\0';
    
    generateCombinations(s, 0, current, 0, combinations, &comboCount, maxCombos);
    
    int minValue = INT_MAX;
    char* result = malloc(1000 * sizeof(char));
    result[0] = '\0';
    
    for (int i = 0; i < comboCount; i++) {
        int value = calculateValue(combinations[i]);
        if (value < minValue || (value == minValue && strcmp(combinations[i], result) < 0)) {
            minValue = value;
            strcpy(result, combinations[i]);
        }
        free(combinations[i]);
    }
    
    free(combinations);
    free(current);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^k × n)

k is the number of question marks, 26^k combinations to try, O(n) to calculate value for each

✓ Linear Growth

Space Complexity

O(26^k × n)

Need to store all possible combinations and their corresponding strings

⚡ Linearithmic Space

26.8K Views

High 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