Minimum Time Difference

Minimum Time Difference - Problem

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.

The time difference should be calculated as the shortest circular distance on a 24-hour clock. For example, the difference between "23:59" and "00:01" is 2 minutes (not 1438 minutes).

Note: The answer is guaranteed to be in the range [0, 720] since the maximum possible difference between any two times in a day is 12 hours (720 minutes).

Input & Output

Example 1 — Basic Case

$ Input: timePoints = ["23:59","00:01","00:03"]

› Output: 2

💡 Note: The minimum difference is between "23:59" and "00:01" which is 2 minutes (going from 23:59 to 00:01 crosses midnight)

Example 2 — Same Hour

$ Input: timePoints = ["00:00","23:59","00:00"]

› Output: 0

💡 Note: There are duplicate times "00:00", so the minimum difference is 0 minutes

Example 3 — Mid-day Times

$ Input: timePoints = ["12:30","14:15","13:45"]

› Output: 30

💡 Note: Sorted: 12:30, 13:45, 14:15. Minimum is between 13:45 and 14:15 which is 30 minutes

Constraints

2 ≤ timePoints.length ≤ 2 × 10⁴
timePoints[i] is in the format "HH:MM"

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that after sorting times by minutes, the minimum difference must occur between adjacent times or across midnight. Best approach is sort first then check adjacent pairs. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(n)

Convert each time to minutes, then check every possible pair of times. For each pair, calculate both clockwise and counterclockwise differences and take the minimum.

Sort First

⏱️ Time: O(n log n) Space: O(n)

Convert times to minutes and sort them. The minimum difference must be between adjacent times in the sorted array, or between the last and first time (wrap-around midnight).

Brute Force — Algorithm Steps

Convert all times to minutes from 00:00
Check every pair of times
For each pair, calculate min(forward_diff, backward_diff)
Return the overall minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Minutes

Transform HH:MM format to minutes from midnight

Compare All Pairs

Check every combination of two times

Find Minimum

Track the smallest difference found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int timeToMinutes(const char* time) {
    int h = (time[0] - '0') * 10 + (time[1] - '0');
    int m = (time[3] - '0') * 10 + (time[4] - '0');
    return h * 60 + m;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int solution(char timePoints[][6], int size) {
    int minutes[size];
    for (int i = 0; i < size; i++) {
        minutes[i] = timeToMinutes(timePoints[i]);
    }
    
    int minDiff = INT_MAX;
    
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            int diff1 = abs_val(minutes[i] - minutes[j]);
            int diff2 = 1440 - diff1;
            minDiff = min(minDiff, min(diff1, diff2));
        }
    }
    
    return minDiff;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char timePoints[1000][6];
    int count = 0;
    
    char* token = strtok(line, "[\",]");
    while (token != NULL) {
        if (strlen(token) == 5 && token[2] == ':') {
            strcpy(timePoints[count], token);
            count++;
        }
        token = strtok(NULL, "[\",]");
    }
    
    printf("%d\n", solution(timePoints, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all n×(n-1)/2 pairs of times

⚡ Linearithmic

Space Complexity

O(n)

Array to store converted minute values

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler