Given two strings startTime and finishTime in the format "HH:MM" representing the exact time you started and finished playing the game, respectively, calculate the number of full rounds that you played during your game session.

• For example, if startTime = "05:20" and finishTime = "05:59" this means you played only one full round from 05:30 to 05:45. You did not play the full round from 05:15 to 05:30 because you started after the round began, and you did not play the full round from 05:45 to 06:00 because you stopped before the round ended.

If finishTime is earlier than startTime, this means you have played overnight (from startTime to the midnight and from midnight to finishTime).

Return the number of full rounds that you have played if you had started playing at startTime and finished at finishTime.

Example 1:

Input: startTime = "12:01", finishTime = "12:44"
Output: 1
Explanation: You played one full round from 12:15 to 12:30.
You did not play the full round from 12:00 to 12:15 because you started playing at 12:01 after it began.
You did not play the full round from 12:30 to 12:45 because you stopped playing at 12:44 before it ended.

Example 2:

Input: startTime = "20:00", finishTime = "06:00"
Output: 40
Explanation: You played 16 full rounds from 20:00 to 00:00 and 24 full rounds from 00:00 to 06:00.
16 + 24 = 40.

Example 3:

Input: startTime = "00:00", finishTime = "23:59"
Output: 95
Explanation: You played 4 full rounds each hour except for the last hour where you played 3 full rounds.

Constraints:

• startTime and finishTime are in the format HH:MM.
• 00 <= HH <= 23
• 00 <= MM <= 59
• startTime and finishTime are not equal.

Solution: String / Simple math

ans = max(0, floor(end / 15) – ceil(start / 15))

Tips:

1. Write a reusable function to parse time to minutes.
2. a / b for floor, (a + b – 1) / b for ceil

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int numberOfRounds(string startTime, string finishTime) {
    auto parseTime = [](string t) {
      return ((t[0] - '0') * 10 + (t[1] - '0')) * 60 + (t[3] - '0') * 10 + t[4] - '0';
    };
    int m1 = parseTime(startTime);
    int m2 = parseTime(finishTime);
    if (m2 < m1) m2 += 24 * 60;
    return max(0, m2 / 15 - (m1 + 14) / 15);
  }
};

The post 花花酱 LeetCode 1904. The Number of Full Rounds You Have Played appeared first on Huahua's Tech Road.

The valid times are those inclusively between 00:00 and 23:59.

Return the latest valid time you can get from time by replacing the hidden digits.

Example 1:

Input: time = "2?:?0"
Output: "23:50"
Explanation: The latest hour beginning with the digit '2' is 23 and the latest minute ending with the digit '0' is 50.

Example 2:

Input: time = "0?:3?"
Output: "09:39"

Example 3:

Input: time = "1?:22"
Output: "19:22"

Constraints:

• time is in the format hh:mm.
• It is guaranteed that you can produce a valid time from the given string.

Solution 1: Brute Force

Enumerate all possible clock in reverse order and find the first matching one.

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string maximumTime(string time) {
    for (int m = 60 * 24 - 1; m >= 0; --m) {
      int hh = m / 60;
      int mm = m % 60;
      if (time[0] != '?' && time[0] - '0' != hh / 10) continue;
      if (time[1] != '?' && time[1] - '0' != hh % 10) continue;
      if (time[3] != '?' && time[3] - '0' != mm / 10) continue;
      if (time[4] != '?' && time[4] - '0' != mm % 10) continue;
      time[0] = (hh / 10) + '0';
      time[1] = (hh % 10) + '0';
      time[3] = (mm / 10) + '0';
      time[4] = (mm % 10) + '0';
      break;
    }
    return time;
  }
};

Solution 2: Rules

Using rules, fill from left to right.

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string maximumTime(string time) {
    if (time[0] == '?') time[0] = time[1] >= '4' && time[1] <= '9' ? '1' : '2';
    if (time[1] == '?') time[1] = time[0] == '2' ? '3' : '9';
    if (time[3] == '?') time[3] = '5';
    if (time[4] == '?') time[4] = '9';
    return time;
  }
};

The post 花花酱 LeetCode 1736. Latest Time by Replacing Hidden Digits appeared first on Huahua's Tech Road.

Example 1:

Input: hour = 12, minutes = 30
Output: 165

Example 2:

Input: hour = 3, minutes = 30
Output: 75

Example 3:

Input: hour = 3, minutes = 15
Output: 7.5

Example 4:

Input: hour = 4, minutes = 50
Output: 155

Example 5:

Input: hour = 12, minutes = 0
Output: 0

Constraints:

• 1 <= hour <= 12
• 0 <= minutes <= 59
• Answers within 10^-5 of the actual value will be accepted as correct.

Solution: Math

1. Compute the angle of the hour hand (h + m / 60.0) * 360 / 12 as a_h
2. Compute the angle of the minute hand m / 60.0 * 360 as a_m
3. ans = min(abs(a_h – a_m), 360 – abs(a_h – a_m))

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  double angleClock(int hour, int minutes) {
    double a_m = minutes * 360 / 60;
    double a_h = (hour + minutes / 60.0) * 360 / 12;
    return min(abs(a_m - a_h), 360 - abs(a_m - a_h));
  }
};

The post 花花酱 LeetCode 1344. Angle Between Hands of a Clock appeared first on Huahua's Tech Road.

Given a list of 24-hour clock time points in “Hour:Minutes” format, find the minimum minutes difference between any two time points in the list.

Example 1:

Input: ["23:59","00:00"]
Output: 1

Note:

1. The number of time points in the given list is at least 2 and won’t exceed 20000.
2. The input time is legal and ranges from 00:00 to 23:59.

Solution

Time complexity: O(nlog1440)

Space complexity: O(n)

C++

// Author: huahua
// Running time: 16 ms
class Solution {
public:
  int findMinDifference(vector<string>& timePoints) {    
    constexpr int kMins = 24 * 60;
    set<int> seen;    
    for (const string& time : timePoints) {
      int m = stoi(time.substr(0, 2)) * 60 + stoi(time.substr(3));
      if (!seen.insert(m).second) return 0;
    }
    
    int ans = (*seen.begin() - *seen.rbegin() + kMins) % kMins;
    const int* l = nullptr;
    for (const int& t : seen) {
      if (l) ans = min(ans, t - *l);
      l = &t;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 539. Minimum Time Difference appeared first on Huahua's Tech Road.

A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes (0-59).

Each LED represents a zero or one, with the least significant bit on the right.

For example, the above binary watch reads “3:25”.

Given a non-negative integer n which represents the number of LEDs that are currently on, return all possible times the watch could represent.

Example:

Input: n = 1
Return: ["1:00", "2:00", "4:00", "8:00", "0:01", "0:02", "0:04", "0:08", "0:16", "0:32"]

Note:

• The order of output does not matter.
• The hour must not contain a leading zero, for example “01:00” is not valid, it should be “1:00”.
• The minute must be consist of two digits and may contain a leading zero, for example “10:2” is not valid, it should be “10:02”.

Solution 1:

Time complexity: O(11*59*n)

C++

// Author: Huahua
// Running time: 2 ms (beats 100%)
class Solution {
public:
  vector<string> readBinaryWatch(int num) {
    vector<string> ans;
    for (int i = 0; i <= num; ++i)
      for (int h : nums(i, 12))
        for (int m : nums(num - i, 60))
          ans.push_back(to_string(h) + (m < 10 ? ":0" : ":") + to_string(m));
    return ans;
  }
private:
  // Return numbers in [0,r) that has b 1s in their binary format.
  vector<int> nums(int b, int r) {    
    vector<int> ans;
    for (int n = 0; n < r; ++n)
      if (__builtin_popcount(n) == b) ans.push_back(n);
    return ans;
  }  
};

The post 花花酱 LeetCode 401. Binary Watch appeared first on Huahua's Tech Road.

Problem:

https://leetcode.com/problems/next-closest-time/description/
no limit on how many times a digit can be reused.

You may assume the given input string is always valid. For example, “01:34”, “12:09” are all valid. “1:34”, “12:9” are all invalid.

Example 1:

Input: "19:34"
Output: "19:39"
Explanation: The next closest time choosing from digits 1, 9, 3, 4, is 19:39, 
which occurs 5 minutes later.  
It is not 19:33, because this occurs 23 hours and 59 minutes later.

Example 2:

Input: "23:59"
Output: "22:22"
Explanation: The next closest time choosing from digits 2, 3, 5, 9, is 22:22. 
It may be assumed that the returned time is next day's time since it is smaller 
than the input time numerically.

Ads

Solution1: Brute force

// Author: Huahua
// Running time: 3 ms
class Solution {
public:
    string nextClosestTime(string time) {
        set<char> s(time.begin(), time.end());
        int hour = stoi(time.substr(0, 2));
        int min = stoi(time.substr(3, 2));
        while (true) {
            if (++min == 60) {
                min = 0;
                (++hour) %= 24;                
            }
            char buffer[5];
            sprintf(buffer, "%02d:%02d", hour, min);
            set<char> s2(buffer, buffer + sizeof(buffer));
            if (includes(s.begin(), s.end(), s2.begin(), s2.end()))
                return string(buffer);
        }
        return time;
    }
};

// Author: Huahua
// Running time: 85 ms
class Solution {
    public String nextClosestTime(String time) {
        int hour = Integer.parseInt(time.substring(0, 2));
        int min = Integer.parseInt(time.substring(3, 5));
        while (true) {            
            if (++min == 60) {
                min = 0;
                ++hour;
                hour %= 24;
            }
            String curr = String.format("%02d:%02d", hour, min);
            Boolean valid = true;
            for (int i = 0; i < curr.length(); ++i)
                if (time.indexOf(curr.charAt(i)) < 0) {
                    valid = false;
                    break;
                }
            if (valid) return curr;
        }
    }
}

"""
Author: Huahua
Running time: 65 ms
"""
class Solution:
    def nextClosestTime(self, time):        
        s = set(time)
        hour = int(time[0:2])
        minute = int(time[3:5])
        while True:
            minute += 1
            if minute == 60:
                minute = 0
                hour = 0 if hour == 23 else hour + 1
            
            time = "%02d:%02d" % (hour, minute)
            if set(time) <= s:
                return time
        return time

Solution 2: DFS

// Author: Huahua 
// Running time: 3 ms
class Solution {
public:
    string nextClosestTime(string time) {
        vector<int> d = {
            time[0] - '0', time[1] - '0', time[3] - '0', time[4] - '0' };
        
        int h = d[0] * 10 + d[1];
        int m = d[2] * 10 + d[3];
        vector<int> curr(4, 0);
        int now = toTime(h, m);
        int best = now;
        
        dfs(0, d, curr, now, best);
        char buff[5];
        sprintf(buff, "%02d:%02d", best / 60, best % 60);
        return string(buff);
    }
private:
    void dfs(int dep, const vector<int>& digits, vector<int>& curr, int time, int& best) {
        if (dep == 4) {
            int curr_h = curr[0] * 10 + curr[1];
            int curr_m = curr[2] * 10 + curr[3];
            if (curr_h > 23 || curr_m > 59) return;
            int curr_time = toTime(curr_h, curr_m);
            if (timeDiff(time, curr_time) < timeDiff(time, best))
                best = curr_time;
            return;
        }            
        
        for (int digit : digits) {
            curr[dep] = digit;
            dfs(dep + 1, digits, curr, time, best);
        }        
    }
    
    int toTime(int h, int m) {
        return h * 60 + m;
    }
    
    int timeDiff(int t1, int t2) {
        if (t1 == t2) return INT_MAX;
        return ((t2 - t1) + 24 * 60) % (24 * 60);
    }
};

Solution 3: Brute force + Time library

"""
Author: Huahua
Running time: 292 ms
"""
from datetime import *
class Solution:
    def nextClosestTime(self, time):        
        s = set(time)        
        while True:
            time = (datetime.strptime(time, '%H:%M') + 
                    timedelta(minutes=1)).strftime('%H:%M')
            if set(time) <= s: 
                return time
        return time

Related Problems:

• 花花酱 LeetCode 401. Binary Watch

The post 花花酱 LeetCode 681. Next Closest Time appeared first on Huahua's Tech Road.