Number of Valid Clock Times - Practice Coding Problems

Number of Valid Clock Times - Problem

String Enumeration Easy

You are given a string time of length 5 representing the current time on a digital clock in the format "hh:mm". The earliest possible time is "00:00" and the latest possible time is "23:59".

In the string time, the digits represented by the ? symbol are unknown, and must be replaced with a digit from 0 to 9.

Return an integer answer, the number of valid clock times that can be created by replacing every ? with a digit from 0 to 9.

Input & Output

Example 1 — Single Unknown Digits

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

› Output: 20

💡 Note: First digit can be 0, 1, or 2 (since 34:5X would be invalid). Last digit can be 0-9. Total: 2 valid first digits × 10 last digits = 20 combinations.

Example 2 — Multiple Unknown Positions

$ Input: time = "0?:??"

› Output: 60

💡 Note: First hour digit is 0, second can be 0-9 (10 choices). Minutes can be 00-59 (60 choices). But we need mm format, so it's 10 × 6 = 60.

Example 3 — All Digits Known

$ Input: time = "12:34"

› Output: 1

💡 Note: No question marks, so only one valid time: 12:34 itself.

Constraints

time.length == 5
time is in the format "hh:mm"
Each character is either a digit or '?'

Visualization

Tap to expand

Understanding the Visualization

Input Analysis

Time string "?4:5?" with unknown digits marked as '?'

Apply Constraints

Valid hours: 00-23, Valid minutes: 00-59

Count Combinations

First '?' can be 0,1 (2 choices), last '?' can be 0-9 (10 choices)

Key Takeaway

🎯 Key Insight: Count valid possibilities for each position separately, then multiply - much faster than generating all combinations!

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to count valid digit possibilities for each position instead of generating all combinations. For hours (00-23): first digit can be 0,1,2 and second digit depends on the first. For minutes (00-59): first digit can be 0-5 and second can be 0-9. Best approach is conditional counting with Time: O(1), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(10^k)	O(k)	Try all possible digit combinations and count valid times
Conditional Counting	O(1)	O(1)	Count valid possibilities for each digit position based on constraints

Brute Force Enumeration — Algorithm Steps

Replace each '?' with digits 0-9 recursively
For each complete time string, validate if it's between 00:00 and 23:59
Count all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Find '?' positions

Identify positions that need digit replacement

Try digits 0-9

For each '?', recursively try all digits

Validate time

Check if final time is valid (00:00 to 23:59)

Code -

solution.c — C

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

int backtrack(char* s, int index, int len) {
    if (index == len) {
        int hours = (s[0] - '0') * 10 + (s[1] - '0');
        int minutes = (s[3] - '0') * 10 + (s[4] - '0');
        return (hours <= 23 && minutes <= 59) ? 1 : 0;
    }
    
    if (s[index] != '?') {
        return backtrack(s, index + 1, len);
    }
    
    int count = 0;
    for (char digit = '0'; digit <= '9'; digit++) {
        s[index] = digit;
        count += backtrack(s, index + 1, len);
        s[index] = '?';
    }
    return count;
}

int solution(char* time) {
    return backtrack(time, 0, strlen(time));
}

int main() {
    char time[10];
    fgets(time, sizeof(time), stdin);
    time[strcspn(time, "\n")] = 0;
    int result = solution(time);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^k)

k is the number of '?' characters, each can be 0-9, so 10^k total combinations to check

✓ Linear Growth

Space Complexity

O(k)

Recursion depth equals the number of '?' characters in the string

✓ Linear Space

23.4K Views

Medium Frequency

~15 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 Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler