2026-10-11：统计起止时间经过的秒数。用go语言，输入两个合法的字符串，分别代表起始时间和结束时间，格式固定为“小时:分钟:秒”。目|go语言|下标|字符串|整型|秒数

2026-10-11：统计起止时间经过的秒数。用go语言，输入两个合法的字符串，分别代表起始时间和结束时间，格式固定为“小时:分钟:秒”。

目标是计算这两个时间点之间相差的总秒数。

需要注意，计算区间包含起始和结束这两个时间点本身。

startTime.length == 8。

endTime.length == 8。

startTime 和 endTime 均为格式 "HH:MM:SS" 的有效时间。

00 <= HH <= 23。

00 <= MM <= 59。

00 <= SS <= 59。

endTime 不早于 startTime。

输入： startTime = "12:34:56", endTime = "13:00:00"。

输出： 1504。

解释：

endTime 比 startTime 晚 25 分 4 秒，共计 1504 秒。

题目来自力扣3986。

大体的处理过程

第一步：解析字符串，提取时间分量
由于两个时间字符串的长度都是固定的 8 位，且格式严格为“HH:MM:SS”，程序不需要进行复杂的字符串分割或循环遍历，而是直接通过下标（索引）来定位并提取字符。

• 程序会分别处理起始时间和结束时间。
• 提取第 0 位和第 1 位的字符，将这两个字符减去字符 '0' 转换为整数，然后通过乘以 10 加上第二位，组合成十进制的小时数。
• 同理，提取第 3 位和第 4 位的字符，组合成分钟数；提取第 6 位和第 7 位的字符，组合成秒数。
• 字符串中的冒号（第 2 位和第 5 位）被直接跳过，作为分隔符不参与计算。

第二步：统一单位，转换为总秒数
为了便于计算时间差，程序将提取出的小时、分钟、秒统一换算为从“00:00:00”起算的“总秒数”。

• 小时数乘以 3600（一小时包含的秒数）。
• 分钟数乘以 60（一分钟包含的秒数）。
• 将上述两个乘积与秒数相加，得到一个表示该时间点的整型数值（总秒数）。

第三步：计算时间差
程序将结束时间的总秒数减去起始时间的总秒数。

• 得到的结果即为两者之间相差的秒数。
• 结合题目描述中的“计算区间包含起始和结束这两个时间点本身”，这里的数学处理就是纯粹的“结束时间总秒数 - 起始时间总秒数”。以题目示例为例：13:00:00 转换为 13×3600 = 46800 秒；12:34:56 转换为 12×3600 + 34×60 + 56 = 43200 + 2040 + 56 = 45296 秒。两者相减得到 1504 秒（包含了起点这一秒的时长跨度）。

第四步：输出结果
在主程序中，将计算得到的整型差值打印出来，即可得到最终的输出结果。

复杂度分析

总的时间复杂度：O(1)
无论输入的时间字符串是什么，程序始终只进行固定次数的字符访问（各读取3次，共6次下标访问）、固定次数的四则运算，没有循环或递归操作。执行时间不随外部数据规模的变化而变化，因此时间复杂度为常数级。

总的额外空间复杂度：O(1)
在计算过程中，程序只使用了几个固定数量的整型变量（如用于存储小时、分钟、秒以及两个总秒数的变量），没有开辟与输入长度相关的数组、列表、哈希表等动态数据结构。因此额外空间复杂度为常数级。

Go完整代码如下：

package main

 import (
    "fmt"
)

 func parse(t string)int {
    hour := int(t[0]-'0')*10 + int(t[1]-'0')
    minute := int(t[3]-'0')*10 + int(t[4]-'0')
    second := int(t[6]-'0')*10 + int(t[7]-'0')
    return hour*3600 + minute*60 + second
}

 func secondsBetweenTimes(startTime, endTime string)int {
    return parse(endTime) - parse(startTime)
}

 func main() {
    startTime := "12:34:56"
    endTime := "13:00:00"
    result := secondsBetweenTimes(startTime, endTime)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 def parse(t: str) -> int:
    # Python 中更优雅的方法是使用 split，无需像 Go 那样逐个字符计算
    hour, minute, second = map(int, t.split(':'))
    return hour * 3600 + minute * 60 + second

 def seconds_between_times(start_time: str, end_time: str) -> int:
    return parse(end_time) - parse(start_time)

 if __name__ == "__main__":
    start_time = "12:34:56"
    end_time = "13:00:00"
    result = seconds_between_times(start_time, end_time)
    print(result)

C++完整代码如下：

  



 using namespace std;

 // 解析时间字符串为总秒数
int parse(conststring& t) {
    int hour = (t[0] - '0') * 10 + (t[1] - '0');
    int minute = (t[3] - '0') * 10 + (t[4] - '0');
    int second = (t[6] - '0') * 10 + (t[7] - '0');
    return hour * 3600 + minute * 60 + second;
}

 // 计算两个时间之间的秒数差
int secondsBetweenTimes(conststring& startTime, conststring& endTime) {
    return parse(endTime) - parse(startTime);
}

 int main() {
    string startTime = "12:34:56";
    string endTime = "13:00:00";

     int result = secondsBetweenTimes(startTime, endTime);
    cout << result << endl;

     return0;
}