你完成的完整对局数

1904. 你完成的完整对局数

一款新的在线电子游戏在近期发布，在该电子游戏中，以刻钟为周期规划若干时长为 15 分钟 的游戏对局。这意味着，在 HH:00、HH:15、HH:30 和 HH:45 ，将会开始一个新的对局，其中 HH 用一个从 00 到 23 的整数表示。游戏中使用 24 小时制的时钟 ，所以一天中最早的时间是 00:00 ，最晚的时间是 23:59 。

给你两个字符串 startTime 和 finishTime ，均符合 "HH:MM" 格式，分别表示你进入和退出游戏的确切时间，请计算在整个游戏会话期间，你完成的 完整对局的对局数 。

例如，如果 startTime = "05:20" 且 finishTime = "05:59" ，这意味着你仅仅完成从 05:30 到 05:45 这一个完整对局。而你没有完成从 05:15 到 05:30 的完整对局，因为你是在对局开始后进入的游戏；同时，你也没有完成从 05:45 到 06:00 的完整对局，因为你是在对局结束前退出的游戏。

如果 finishTime 早于 startTime ，这表示你玩了个通宵（也就是从 startTime 到午夜，再从午夜到 finishTime）。

假设你是从 startTime 进入游戏，并在 finishTime 退出游戏，请计算并返回你完成的 完整对局的对局数 。

示例 1：

输入：startTime = "12:01", finishTime = "12:44"
输出：1
解释：你完成了从 12:15 到 12:30 的一个完整对局。
你没有完成从 12:00 到 12:15 的完整对局，因为你是在对局开始后的 12:01 进入的游戏。
你没有完成从 12:30 到 12:45 的完整对局，因为你是在对局结束前的 12:44 退出的游戏。

示例 2：

输入：startTime = "20:00", finishTime = "06:00"
输出：40
解释：你完成了从 20:00 到 00:00 的 16 个完整的对局，以及从 00:00 到 06:00 的 24 个完整的对局。
16 + 24 = 40

示例 3：

输入：startTime = "00:00", finishTime = "23:59"
输出：95
解释：除最后一个小时你只完成了 3 个完整对局外，其余每个小时均完成了 4 场完整对局。

提示：

startTime 和 finishTime 的格式为 HH:MM
00 <= HH <= 23
00 <= MM <= 59
startTime 和 finishTime 不相等

原站题解

去查看

上次编辑到这里，代码来自缓存点击恢复默认模板

class Solution { public: int numberOfRounds(string loginTime, string logoutTime) { } };

java 解法, 执行用时: 1 ms, 内存消耗: 39.7 MB, 提交时间: 2023-07-19 18:24:35

class Solution {
    public int numberOfRounds(String loginTime, String logoutTime) {
        int h1=Integer.parseInt(loginTime.split(":")[0]);
        int m1=Integer.parseInt(loginTime.split(":")[1]);
        int h2=Integer.parseInt(logoutTime.split(":")[0]);
        int m2=Integer.parseInt(logoutTime.split(":")[1]);
        boolean flag=false;
        if(h2>h1 || (h2==h1 && m2>m1)) flag=true;
        m1=15*((m1+14)/15);
        m2=15*(m2/15);
        int time1=h1*60+m1;
        int time2=h2*60+m2;
        int time=flag ? (time2-time1) : (time2-time1+24*60);
        time= time>=0? time:0;
        return time/15;
    }
}

golang 解法, 执行用时: 0 ms, 内存消耗: 1.8 MB, 提交时间: 2023-07-19 18:23:51

func numberOfRounds(startTime, finishTime string) int {
	var h1, m1, h2, m2 int
	fmt.Sscanf(startTime, "%d:%d", &h1, &m1)
	fmt.Sscanf(finishTime, "%d:%d", &h2, &m2)
	if startTime > finishTime { h2 += 24 } // 玩了个通宵
	s, t := h1*60+m1, h2*60+m2
	return (t - t%15 - s) / 15
}

javascript 解法, 执行用时: 52 ms, 内存消耗: 41.1 MB, 提交时间: 2023-07-19 18:21:14

/**
 * @param {string} startTime
 * @param {string} finishTime
 * @return {number}
 */
 var numberOfRounds = function(startTime, finishTime) {
    let m1 = toMinutes(startTime), m2 = toMinutes(finishTime);

    if (m1 > m2) {
        m2 += 24 * 60;
    }

    let ans = Math.floor(m2 / 15) - Math.ceil(m1 / 15);
    return ans < 0 ? 0 : ans;
};

function toMinutes(time) {
    let [h, m] = time.split(':');
    return Number(h) * 60 + Number(m);
}

cpp 解法, 执行用时: 0 ms, 内存消耗: 5.8 MB, 提交时间: 2023-07-19 18:20:01

class Solution {
public:
    int numberOfRounds(string startTime, string finishTime) {
        // 转化为分钟
        int t0 = 60 * stoi(startTime.substr(0, 2)) + stoi(startTime.substr(3, 5));
        int t1 = 60 * stoi(finishTime.substr(0, 2)) + stoi(finishTime.substr(3, 5));
        if (t1 < t0){
            // 此时 finishTime 为第二天
            t1 += 1440;
        }
        // 第一个小于等于 finishTime 的完整对局的结束时间
        t1 = t1 / 15 * 15;
        return max(0, (t1 - t0)) / 15;
    }
};

python3 解法, 执行用时: 48 ms, 内存消耗: 16.1 MB, 提交时间: 2023-07-19 18:19:40

class Solution:
    def numberOfRounds(self, startTime: str, finishTime: str) -> int:
        # 转化为分钟
        t0 = 60 * int(startTime[:2]) + int(startTime[3:])
        t1 = 60 * int(finishTime[:2]) + int(finishTime[3:])
        if t1 < t0:
            # 此时 finishTime 为第二天
            t1 += 1440
        # 第一个小于等于 finishTime 的完整对局的结束时间
        t1 = t1 // 15 * 15
        return max(0, (t1 - t0)) // 15

上一题

下一题

详情