Minimum Time Difference - Practice Coding Problems

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: 75

💡 Note: Sorted: 12:30, 13:45, 14:15. Minimum is between 12:30 and 13:45 which is 75 minutes (1 hour 15 minutes)

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

List of time points in HH:MM format

Process

Convert to minutes and find minimum circular difference

Output

Minimum difference in minutes

Key Takeaway

🎯 Key Insight: On a circular clock, the minimum difference is always between adjacent times after sorting

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

Approach	Time	Space	Notes
✓ Sort First	O(n log n)	O(n)	Sort times, then check adjacent pairs plus wrap-around
Brute Force	O(n²)	O(n)	Check all pairs of times and find minimum difference

Sort First — Algorithm Steps

Convert all times to minutes
Sort the minute values
Check differences between adjacent pairs
Check wrap-around difference (last to first)

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Times

Arrange times in chronological order

Check Adjacent

Compare each pair of consecutive times

Wrap Around

Check difference between last and first time

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 compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

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

int solution(char timePoints[][6], int size) {
    int minutes[size];
    for (int i = 0; i < size; i++) {
        minutes[i] = timeToMinutes(timePoints[i]);
    }
    
    qsort(minutes, size, sizeof(int), compare);
    int minDiff = INT_MAX;
    
    // Check adjacent pairs
    for (int i = 1; i < size; i++) {
        minDiff = min(minDiff, minutes[i] - minutes[i-1]);
    }
    
    // Check wrap-around
    int wrapDiff = 1440 - minutes[size-1] + minutes[0];
    minDiff = min(minDiff, wrapDiff);
    
    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 log n)

Sorting dominates with O(n log n), plus O(n) for adjacent comparisons

⚡ 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

Sort First — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler