【Day 34 】2024-05-11 - 1904. 你完成的完整对局数

[azl397985856]

1904. 你完成的完整对局数

入选理由

暂无

题目地址

https://leetcode-cn.com/problems/the-number-of-full-rounds-you-have-played/

前置知识

• 模拟

  题目描述

  
  一款新的在线电子游戏在近期发布，在该电子游戏中，以 刻钟 为周期规划若干时长为 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 不相等

[zhiyuanpeng]

class Solution:
    def numberOfRounds(self, loginTime: str, logoutTime: str) -> int:
        if 0 <= self.time2minute(logoutTime) - self.time2minute(loginTime) < 15:
            return 0
        login_m = self.roundUpper(loginTime)
        logout_m = self.roundLower(logoutTime)
        if self.time2minute(loginTime) > self.time2minute(logoutTime):
            logout_m += 24*60
        ans = (logout_m - login_m)//15
        return ans

    def time2minute(self, time):
        return int(time[:2])*60 + int(time[3:])

    def roundUpper(self, time):
        interval = [0, 15, 30, 45, 60]
        minute = int(time[3:])
        min_v, min_i = minute, 0
        for i in range(1, len(interval)):
            if abs(minute - interval[i]) < abs(min_v):
                min_v = minute - interval[i]
                min_i = i
        if min_v > 0:
            minute = interval[min_i] + 15
        else:
            minute = interval[min_i]

        h, m = divmod(minute, 60)

        return (int(time[:2])+h)*60+m

    def roundLower(self, time):
        interval = [0, 15, 30, 45, 60]
        minute = int(time[3:])
        min_v, min_i = minute, 0
        for i in range(1, len(interval)):
            if abs(minute - interval[i]) < abs(min_v):
                min_v = minute - interval[i]
                min_i = i
        if min_v >= 0:
            minute = interval[min_i]
        else:
            minute = interval[min_i] - 15

        return int(time[:2])*60+minute

time O(1) spaceO(1)

[xil324]

class Solution(object):
    def numberOfRounds(self, loginTime, logoutTime):
        """
        :type loginTime: str
        :type logoutTime: str
        :rtype: int
        """
        login_minutes = self.convert_to_minutes(loginTime)
        logout_minutes = self.convert_to_minutes(logoutTime)
        if login_minutes > logout_minutes:
            logout_minutes += 60 * 24
        if login_minutes / 15 > login_minutes // 15:
            login_minutes += 14
        rounds = logout_minutes // 15 - (login_minutes+14)//15
        return max(0,rounds)

    def convert_to_minutes(self, time):
        return 60 * int(time[:2]) + int(time[3:])

[Lizhao-Liu]

    func numberOfRounds(_ loginTime: String, _ logoutTime: String) -> Int {
        let (startM, endM) = getMinutes(loginTime, logoutTime)

        let start = Int(ceil(Double(startM) / 15.0))
        let end = Int(floor(Double(endM) / 15))

       return max(end - start, 0)

    }

    func getMinutes(_ startTime: String, _ endTimes: String) -> (Int, Int) {
        var components = startTime.components(separatedBy: ":")
        let startH = Int(components[0])!
        var startM = Int(components[1])!

        components = endTimes.components(separatedBy: ":")
        var endH = Int(components[0])!
        var endM = Int(components[1])!

        if (startH > endH) || (startH == endH && startM > endM) {
            endH += 24
        }

        startM = startH * 60 + startM
        endM = endH * 60 + endM

        return (startM, endM)
    }

[maike-hps]

function countMatches(startTime, finishTime): startMinutes = convertToMinutes(startTime) finishMinutes = convertToMinutes(finishTime)

if finishMinutes < startMinutes:
    finishMinutes += 24 * 60  # 玩家玩了通宵，将结束时间增加一天的分钟数

totalMinutes = finishMinutes - startMinutes
matchesInHour = 4
totalMatches = totalMinutes // 15

# 如果开始时间不是15的倍数，减去一个对局
if startMinutes % 15 != 0:
    totalMatches -= 1

# 如果结束时间不是15的倍数，加上一个对局
if finishMinutes % 15 != 0:
    totalMatches += 1

return max(0, totalMatches)

function convertToMinutes(time): hours, minutes = split time by ":" return hours * 60 + minutes

[xy147]

js代码

 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);
}

复杂度分析

时间复杂度：O(n)

空间复杂度：O(n)

[Dtjk]

class Solution:
    def numberOfRounds(self, s, f):
        sh, sm = s.split(":")
        eh, em = f.split(":")
        sh, sm, eh, em = int(sh), int(sm), int(eh), int(em)
        if sh == eh:
            if sm <= em:
                d = em//15-(sm//15)-(1 if sm % 15 > 0 else 0)
                return d if d > 0 else 0
            else:
                sm = 60-sm
                val = 0
                val += sm//15
                val += em//15
                return 23*4+val
        else:
            if eh < sh:
                eh += 24
            val = 0
            sm = 60-sm
            val += sm//15
            val += em//15
            sh += 1
            return (eh-sh)*4+val

[Hermione666]

from datetime import datetime, timedelta import math class Solution: def numberOfRounds(self, loginTime: str, logoutTime: str) -> int:

    time1 = datetime.strptime(loginTime, "%H:%M")
    time2 = datetime.strptime(logoutTime, "%H:%M")

    if time2<time1:
        time2=time2.replace(day=time2.day+1)

    rounded_up_minutes = math.ceil(time1.minute /15) * 15
    if rounded_up_minutes==60:
        try:
            time1 = time1.replace(hour=time1.hour+1)
            time1 = time1.replace(minute=0)
        except:
            time1 = time1.replace(day=time1.day+1)
            time1 = time1.replace(hour=0)
            time1 = time1.replace(minute=0)

    else:
        time1 = time1.replace(minute=rounded_up_minutes)

    rounded_down_minutes = (time2.minute // 15) * 15
    # print(rounded_down_minutes)

    time2 = time2.replace(minute=rounded_down_minutes)
    # print(time1)
    # print(time2)

    time_difference=time2-time1

    interval = timedelta(minutes=15)
    num_intervals=time_difference / interval #this gives a floating point number
    if num_intervals<=0:
        return 0
    # print(time_difference)

    return int(num_intervals)

[CathyShang]

class Solution:
    def numberOfRounds(self, loginTime: str, logoutTime: str) -> int:
        sh, sm = map(int, loginTime.split(":"))
        eh, em = map(int, logoutTime.split(":"))
        day = 0
        if sh * 60 + sm > eh * 60 + em: day += 1
        # 开始-> 15,30,45,0
        if 0 < sm <= 15:
            sm = 15
        elif 15 < sm <= 30:
            sm = 30
        elif 30 < sm <= 45:
            sm = 45
        elif 45 < sm <= 60:
            sm = 0
            sh += 1
        # 结束-> 0,15,30,45
        if 0 <= em < 15:
            em = 0
        elif 15 <= em < 30:
            em = 15
        elif 30 <= em < 45:
            em = 30
        elif 45 <= em < 60:
            em = 45
        # 转换为分钟，被15整除    
        st = sh * 60 + sm
        et = eh * 60 + em
        if day == 1: et += 1440 #add 24h
        return max(0, (et - st)) // 15

参考思路