Welcome to Subscribe On Youtube

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

2224. Minimum Number of Operations to Convert Time (Easy)

You are given two strings current and correct representing two 24-hour times.

24-hour times are formatted as "HH:MM", where HH is between 00 and 23, and MM is between 00 and 59. The earliest 24-hour time is 00:00, and the latest is 23:59.

In one operation you can increase the time current by 1, 5, 15, or 60 minutes. You can perform this operation any number of times.

Return the minimum number of operations needed to convert current to correct.

 

Example 1:

Input: current = "02:30", correct = "04:35"
Output: 3
Explanation:
We can convert current to correct in 3 operations as follows:
- Add 60 minutes to current. current becomes "03:30".
- Add 60 minutes to current. current becomes "04:30".
- Add 5 minutes to current. current becomes "04:35".
It can be proven that it is not possible to convert current to correct in fewer than 3 operations.

Example 2:

Input: current = "11:00", correct = "11:01"
Output: 1
Explanation: We only have to add one minute to current, so the minimum number of operations needed is 1.

 

Constraints:

  • current and correct are in the format "HH:MM"
  • current <= correct

Similar Questions:

Solution 1. Greedy

  • Compute the time difference in seconds
  • Greedily using 60, 15, 5, 1 operations. For each operation op, we use diff / op number of operations to turn diff to diff % op.
  • // OJ: https://leetcode.com/problems/minimum-number-of-operations-to-convert-time/
// Time: O(1)
// Space: O(1)
class Solution {
    int getTime(string &s) {
        return stoi(s.substr(0, 2)) * 60 + stoi(s.substr(3));
    }
public:
    int convertTime(string current, string correct) {
        int diff = getTime(correct) - getTime(current), ops[4] = {60,15,5,1}, ans = 0;
        for (int op : ops) {
            ans += diff / op;
            diff %= op;
        }
        return ans;
    }
};

  • class Solution:
    def convertTime(self, current: str, correct: str) -> int:
        a = int(current[:2]) * 60 + int(current[3:])
        b = int(correct[:2]) * 60 + int(correct[3:])
        ans, d = 0, b - a
        for i in [60, 15, 5, 1]:
            ans += d // i
            d %= i
        return ans

############

# 2224. Minimum Number of Operations to Convert Time
# https://leetcode.com/problems/minimum-number-of-operations-to-convert-time/

class Solution:
    def convertTime(self, current: str, correct: str) -> int:
        if current == correct: return 0
        
        h1, h2 = int(current[:2]), int(correct[:2])
        m1, m2 = int(current[3:]), int(correct[3:])
        
        res = h2 - h1
        
        if m1 > m2:
            m2 += 60
            res -= 1
        
        while m2 > m1:
            d = m2 - m1

            if d >= 15:
                res += 1
                m2 -= 15
            elif d >= 5:
                res += 1
                m2 -= 5
            else:
                res += 1
                m2 -= 1
            
        
        return res
        


  • class Solution {
    public int convertTime(String current, String correct) {
        int a = Integer.parseInt(current.substring(0, 2)) * 60
            + Integer.parseInt(current.substring(3));
        int b = Integer.parseInt(correct.substring(0, 2)) * 60
            + Integer.parseInt(correct.substring(3));
        int ans = 0, d = b - a;
        for (int i : Arrays.asList(60, 15, 5, 1)) {
            ans += d / i;
            d %= i;
        }
        return ans;
    }
}

  • func convertTime(current string, correct string) int {
    parse := func(s string) int {
        h := int(s[0] - '0') * 10 + int(s[1] - '0')
        m := int(s[3] - '0') * 10 + int(s[4] - '0')
        return h * 60 + m
    }
    a, b := parse(current), parse(correct)
    ans, d := 0, b - a
    for _, i := range []int{60, 15, 5, 1} {
        ans += d / i
        d %= i
    }
    return ans
}

Discuss

https://leetcode.com/problems/minimum-number-of-operations-to-convert-time/discuss/1908782/

All Problems

All Solutions