2024-11-29：替换字符可以得到的最晚时间。用go语言，给定一个字符串 s，其中包含一个12小时制的时间格式，部分数字可能被“?“替换。 将 s 中的问号替换为数字，使得结果字符串表示的时间是一

2024-11-29：替换字符可以得到的最晚时间。用go语言，给定一个字符串 s，其中包含一个12小时制的时间格式，部分数字可能被"?"替换。

将 s 中的问号替换为数字，使得结果字符串表示的时间是一个有效的12小时制时间，并且是可能的最晚时间。

返回替换后的结果字符串。

输入： s = “1?:?4”。

输出： “11:54”。

解释： 通过替换 “?” 字符，可以得到的最晚12小时制时间是 “11:54”。

答案2024-11-28：

chatgpt

题目来自leetcode3114。

大体步骤如下：

1.将输入的时间字符串转换为字节数组并存储在变量 t 中。

2.检查第一个小时位，如果是问号，则根据下一位数字的情况确定替换为 ‘1’ 还是 ‘0’。

3.检查第二个小时位，如果是问号且第一个小时位是 ‘1’，则替换为 ‘1’；否则替换为 ‘9’。

4.检查分钟的第一位，如果是问号，则替换为 ‘5’。

5.检查分钟的第二位，如果是问号，则替换为 ‘9’。

6.将经过替换后的字节数组转换为字符串并返回作为结果。

总的时间复杂度为 O(1)，因为不论输入的时间是什么，操作步骤都是固定的，所需的时间是固定的。

总的额外空间复杂度为 O(1)，因为只使用了固定大小的变量和常量存储空间。

Go完整代码如下：

package main

import (
	"fmt"
)

func findLatestTime(s string) string {
	t := []byte(s)
	if t[0] == '?' {
		if t[1] == '?' || t[1] <= '1' {
			t[0] = '1'
		} else {
			t[0] = '0'
		}
	}
	if t[1] == '?' {
		if t[0] == '1' {
			t[1] = '1'
		} else {
			t[1] = '9'
		}
	}
	if t[3] == '?' {
		t[3] = '5'
	}
	if t[4] == '?' {
		t[4] = '9'
	}
	return string(t)
}


func main() {
	s := "1?:?4"
	fmt.Println(findLatestTime(s))
}

Rust完整代码如下：

fn find_latest_time(s: &str) -> String {
    let mut t: Vec<char> = s.chars().collect();

    if t[0] == '?' {
        if t[1] == '?' || t[1] <= '1' {
            t[0] = '1';
        } else {
            t[0] = '0';
        }
    }
    
    if t[1] == '?' {
        if t[0] == '1' {
            t[1] = '1';
        } else {
            t[1] = '9';
        }
    }
    
    if t[3] == '?' {
        t[3] = '5';
    }
    
    if t[4] == '?' {
        t[4] = '9';
    }
    
    t.iter().collect()
}

fn main() {
    let s = "1?:?4";
    println!("{}", find_latest_time(s));
}