Latest Time You Can Obtain After Replacing Characters

Latest Time You Can Obtain After Replacing Characters - Problem

String Enumeration Easy

Imagine you have a broken digital clock that displays a 12-hour format time where some digits are corrupted and show up as ? characters. Your goal is to fix this clock by replacing all the ? marks with actual digits to create the latest possible valid time.

The time format is HH:MM where:

HH represents hours from 00 to 11
MM represents minutes from 00 to 59
The earliest time is 00:00 and the latest is 11:59

For example, if you see "?4:5?", you want to make it as late as possible. The hour could be 04 (since 14 would be invalid), and the minute could be 59, giving us "04:59".

Goal: Transform the corrupted time string into the latest possible valid 12-hour format time.

Input & Output

example_1.py — Basic Case

$ Input: s = "?4:5?"

› Output: "04:59"

💡 Note: For the first ?, we can choose 0 or 1 (since 2-9 would make hours > 11). We choose 0 to allow 4 in second position. For the last ?, we choose 9 to maximize minutes, giving us 04:59.

example_2.py — Multiple Hour Options

$ Input: s = "?3:??"

› Output: "03:59"

💡 Note: First digit must be 0 (since 1 would make 13 > 11). Minutes can be maximized to 59, giving us 03:59.

example_3.py — All Question Marks

$ Input: s = "??:??"

› Output: "11:59"

💡 Note: To get the latest time, we maximize hours to 11 (the maximum valid hour in 12-hour format) and minutes to 59, giving us 11:59.

Visualization

Tap to expand

Understanding the Visualization

Check First Hour Digit

If ?, choose 1 (to allow 11:XX) or 0 (to allow 09:XX). Choose 1 for later time.

Check Second Hour Digit

If first digit is 1, max is 1. If first digit is 0, max is 9. Choose accordingly.

Check First Minute Digit

Minutes range 00-59, so first digit can be at most 5.

Check Second Minute Digit

Second minute digit can always be 9 (since 59 is valid).

Key Takeaway

🎯 Key Insight: Instead of trying all combinations, we can determine the optimal digit for each position by considering the constraints of 12-hour format and choosing the maximum valid digit at each step.

Time & Space Complexity

Time Complexity

⏱️

O(10^k)

Where k is the number of ? characters. In worst case k=4, so O(10^4) = O(10000) operations

✓ Linear Growth

Space Complexity

O(1)

Only storing the current best time string and temporary variables

✓ Linear Space

Constraints

s.length == 5
s is in the format "HH:MM"
Each character is either a digit or '?'
Hours range from 00 to 11 (12-hour format)
Minutes range from 00 to 59

Asked in

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

The optimal approach is to work through each position systematically, choosing the highest possible digit that maintains validity. For hours, if the first digit is 1, the second can be at most 1 (to keep ≤ 11). For minutes, both digits can be maximized to 5 and 9 respectively. This gives us O(1) time complexity instead of the brute force O(10^k).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(10^k)	O(1)	Generate all possible digit combinations and find the latest valid time

Brute Force (Try All Combinations) — Algorithm Steps

Find all positions with ? characters
Generate all possible digit combinations for these positions
For each combination, create a complete time string
Validate if the time is in valid 12-hour format (00-11:00-59)
Keep track of the latest valid time found
Return the latest valid time

Visualization

Tap to expand

Step-by-Step Walkthrough

Find ? positions

Identify all positions that need digit replacement

Generate combinations

Try all possible digits (0-9) for each ? position

Validate times

Check if each combination forms a valid 12-hour time

Track latest

Keep the lexicographically largest valid time

Code -

solution.c — C

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

int isValidTime(const char* timeStr) {
    char hours[3] = {timeStr[0], timeStr[1], '\0'};
    char minutes[3] = {timeStr[3], timeStr[4], '\0'};
    int h = atoi(hours);
    int m = atoi(minutes);
    return h >= 0 && h <= 11 && m >= 0 && m <= 59;
}

void generateCombinations(const char* s, int index, char* current, char* latest) {
    if (index == strlen(s)) {
        if (isValidTime(current) && strcmp(current, latest) > 0) {
            strcpy(latest, current);
        }
        return;
    }
    
    if (s[index] == '?') {
        for (char digit = '0'; digit <= '9'; digit++) {
            current[index] = digit;
            current[index + 1] = '\0';
            generateCombinations(s, index + 1, current, latest);
        }
    } else {
        current[index] = s[index];
        current[index + 1] = '\0';
        generateCombinations(s, index + 1, current, latest);
    }
}

char* latestTime(char* s) {
    static char latest[6] = "";
    char current[6];
    generateCombinations(s, 0, current, latest);
    return latest;
}

int main() {
    char s[10];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    // Remove quotes
    char* start = s;
    if (*start == '"') start++;
    char* end = start + strlen(start) - 1;
    if (*end == '"') *end = '\0';
    
    printf("\"%s\"\n", latestTime(start));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^k)

Where k is the number of ? characters. In worst case k=4, so O(10^4) = O(10000) operations

✓ Linear Growth

Space Complexity

O(1)

Only storing the current best time string and temporary variables

✓ Linear Space

Constraints

s.length == 5
s is in the format "HH:MM"
Each character is either a digit or '?'
Hours range from 00 to 11 (12-hour format)
Minutes range from 00 to 59

42.3K Views

Medium Frequency

~12 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler