Welcome to Subscribe On Youtube

539. Minimum Time Difference

Description

Given a list of 24-hour clock time points in "HH:MM" format, return the minimum minutes difference between any two time-points in the list.

 

Example 1:

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

Example 2:

Input: timePoints = ["00:00","23:59","00:00"]
Output: 0

 

Constraints:

  • 2 <= timePoints.length <= 2 * 104
  • timePoints[i] is in the format "HH:MM".

Solutions

  1. Convert all the times into minutes values mins, i.e. 13:14 => 13 * 60 + 14.
  2. Sort the mins.
  3. Push the time mins[0] + 24 * 60 to deal with min and max diff.
  4. For each value in mins[1:], calculate the min diff mins[i] - mins[i - 1].
  • class Solution {
    public int findMinDifference(List<String> timePoints) {
        if (timePoints.size() > 24 * 60) {
            return 0;
        }
        List<Integer> mins = new ArrayList<>();
        for (String t : timePoints) {
            String[] time = t.split(":");
            mins.add(Integer.parseInt(time[0]) * 60 + Integer.parseInt(time[1]));
        }
        Collections.sort(mins);
        mins.add(mins.get(0) + 24 * 60);
        int res = 24 * 60;
        for (int i = 1; i < mins.size(); ++i) {
            res = Math.min(res, mins.get(i) - mins.get(i - 1));
        }
        return res;
    }
}

  • class Solution {
public:
    int findMinDifference(vector<string>& timePoints) {
        if (timePoints.size() > 24 * 60)
            return 0;
        vector<int> mins;
        for (auto t : timePoints)
            mins.push_back(stoi(t.substr(0, 2)) * 60 + stoi(t.substr(3)));
        sort(mins.begin(), mins.end());
        mins.push_back(mins[0] + 24 * 60);
        int res = 24 * 60;
        for (int i = 1; i < mins.size(); ++i)
            res = min(res, mins[i] - mins[i - 1]);
        return res;
    }
};

  • '''
>>> a = "000"
>>> int(a)
0

>>> a = "00011"
>>> int(a)
11
'''
class Solution:
    def findMinDifference(self, timePoints: List[str]) -> int:
        if len(timePoints) > 24 * 60:
            return 0
        mins = sorted(int(t[:2]) * 60 + int(t[3:]) for t in timePoints)
        mins.append(mins[0] + 24 * 60) # make it a circle, linking 1st and last slot

        return min(abs(a - b) for a, b in pairwise(mins))

        # below also works, same logic
        # res = mins[-1]
        # for i in range(1, len(mins)):
        #     res = min(res, mins[i] - mins[i - 1])
        # return res

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

class Solution(object):
  def findMinDifference(self, timePoints):
    """
    :type timePoints: List[str]
    :rtype: int
    """
    ans = 24 * 60
    times = [0] * len(timePoints)
    for i, time in enumerate(timePoints):
      h, m = map(int, time.split(":"))
      times[i] = h * 60 + m

    times.sort()

    for i in range(len(times) - 1):
      ans = min(ans, abs(times[i] - times[i + 1]))
    return min(ans, 1440 - abs(times[0] - times[-1]))


  • func findMinDifference(timePoints []string) int {
	if len(timePoints) > 24*60 {
		return 0
	}
	var mins []int
	for _, t := range timePoints {
		time := strings.Split(t, ":")
		h, _ := strconv.Atoi(time[0])
		m, _ := strconv.Atoi(time[1])
		mins = append(mins, h*60+m)
	}
	sort.Ints(mins)
	mins = append(mins, mins[0]+24*60)
	res := 24 * 60
	for i := 1; i < len(mins); i++ {
		res = min(res, mins[i]-mins[i-1])
	}
	return res
}

  • function findMinDifference(timePoints: string[]): number {
    const mins = timePoints
        .map(item => Number(item.slice(0, 2)) * 60 + Number(item.slice(3, 5)))
        .sort((a, b) => a - b);
    const n = mins.length;
    let res = Infinity;
    for (let i = 0; i < n - 1; i++) {
        res = Math.min(res, mins[i + 1] - mins[i]);
    }

    const first = mins[0] + 24 * 60;
    const last = mins[n - 1];
    res = Math.min(res, first - last);

    return res;
}

All Problems

All Solutions