##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2437.html

# 2437. Number of Valid Clock Times

• Difficulty: Easy.
• Related Topics: .
• Similar Questions: Largest Time for Given Digits, Latest Time by Replacing Hidden Digits.

## Problem

You are given a string of length 5 called time, 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.

Example 1:

Input: time = "?5:00"
Output: 2
Explanation: We can replace the ? with either a 0 or 1, producing "05:00" or "15:00". Note that we cannot replace it with a 2, since the time "25:00" is invalid. In total, we have two choices.

Example 2:

Input: time = "0?:0?"
Output: 100
Explanation: Each ? can be replaced by any digit from 0 to 9, so we have 100 total choices.

Example 3:

Input: time = "??:??"
Output: 1440
Explanation: There are 24 possible choices for the hours, and 60 possible choices for the minutes. In total, we have 24 * 60 = 1440 choices.

Constraints:

• time is a valid string of length 5 in the format "hh:mm".

• "00" <= hh <= "23"

• "00" <= mm <= "59"

• Some of the digits might be replaced with '?' and need to be replaced with digits from 0 to 9.

## Solution (Java, C++, Python)

• class Solution {
public int countTime(String time) {
int ans = 0;
for (int h = 0; h < 24; ++h) {
for (int m = 0; m < 60; ++m) {
String s = String.format("%02d:%02d", h, m);
int ok = 1;
for (int i = 0; i < 5; ++i) {
if (s.charAt(i) != time.charAt(i) && time.charAt(i) != '?') {
ok = 0;
break;
}
}
ans += ok;
}
}
return ans;
}
}

• class Solution {
public:
int countTime(string time) {
int ans = 0;
for (int h = 0; h < 24; ++h) {
for (int m = 0; m < 60; ++m) {
char s[20];
sprintf(s, "%02d:%02d", h, m);
int ok = 1;
for (int i = 0; i < 5; ++i) {
if (s[i] != time[i] && time[i] != '?') {
ok = 0;
break;
}
}
ans += ok;
}
}
return ans;
}
};

• class Solution:
def countTime(self, time: str) -> int:
def check(s, t):
for a, b in zip(s, t):
if a != b and b != '?':
return 0
return 1

return sum(
check(f'{h:02d}:{m:02d}', time) for h in range(24) for m in range(60)
)

• func countTime(time string) int {
ans := 0
for h := 0; h < 24; h++ {
for m := 0; m < 60; m++ {
s := fmt.Sprintf("%02d:%02d", h, m)
ok := 1
for i := 0; i < 5; i++ {
if s[i] != time[i] && time[i] != '?' {
ok = 0
break
}
}
ans += ok
}
}
return ans
}

• function countTime(time: string): number {
let [hh, mm] = time.split(':');
return count(hh, 24) * count(mm, 60);
}

function count(str: string, limit: number): number {
let [a, b] = str.split('').map(d => Number(d));
let ans = 0;
if (isNaN(a) && isNaN(b)) return limit;
if (isNaN(a)) {
for (let i = 0; i <= 9; i++) {
if (i * 10 + b < limit) ans++;
}
return ans;
}
if (isNaN(b)) {
for (let i = 0; i <= 9; i++) {
if (a * 10 + i < limit) ans++;
}
return ans;
}
return 1;
}

• impl Solution {
pub fn count_time(time: String) -> i32 {
let f = |s: &str, m: usize| -> i32 {
let mut cnt = 0;
let first = s.chars().nth(0).unwrap();
let second = s.chars().nth(1).unwrap();

for i in 0..m {
let a = first == '?' || first.to_digit(10).unwrap() as usize == i / 10;

let b = second == '?' || second.to_digit(10).unwrap() as usize == i % 10;

if a && b {
cnt += 1;
}
}

cnt
};

f(&time[..2], 24) * f(&time[3..], 60)
}
}

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).