Minimum Time Difference - Practice Coding Problems

Minimum Time Difference - Problem

Imagine you're building a scheduling system that needs to find the closest time slots between appointments. Given a list of time points in 24-hour format ("HH:MM"), you need to find the minimum difference in minutes between any two time points.

This problem becomes interesting when you consider that time is circular - the difference between 23:59 and 00:01 is only 2 minutes, not 23 hours and 58 minutes!

Goal: Return the smallest possible time difference in minutes between any pair of time points.

Example: For times ["23:59", "00:00", "12:30"], the minimum difference is 1 minute (between 23:59 and 00:00).

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: The difference between 23:59 and 00:00 is 1 minute (crossing midnight). This demonstrates the wrap-around behavior of time.

example_2.py — Multiple Times

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

› Output: 0

💡 Note: There are duplicate times (00:00 appears twice), so the minimum difference is 0 minutes.

example_3.py — Regular Times

$ Input: ["12:30", "14:15", "16:45"]

› Output: 105

💡 Note: The differences are: 12:30→14:15 = 105 min, 14:15→16:45 = 150 min, 16:45→12:30 (wrap) = 1065 min. Minimum is 105.

Constraints

2 ≤ timePoints.length ≤ 2 × 10⁴
timePoints[i] is in the format "HH:MM"
All times are valid 24-hour format times

Visualization

Tap to expand

Understanding the Visualization

Place Times on Clock

Convert each time to minutes from midnight and visualize as points on a circular clock

Sort Chronologically

Arrange times in chronological order around the clock face

Check Adjacent Arcs

Measure the distance between each consecutive pair of times

Check Wrap-around

Don't forget the arc from the last time back to the first time (crossing midnight)

Key Takeaway

🎯 Key Insight: Time is circular! After sorting, we only need to check adjacent differences plus the wrap-around from last to first time, reducing from O(n²) to O(n) comparisons after sorting.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses sorting and adjacent comparison approach. Convert times to minutes, sort them, then check differences between adjacent pairs plus the wrap-around difference. This leverages the key insight that after sorting, the minimum difference must be between consecutive times or between the last and first time (considering the 24-hour cycle). Time complexity: O(n log n) due to sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n²)	O(1)	Compare every pair of times and find the minimum difference
Sorting + Adjacent Comparison (Optimal)	O(n log n)	O(n)	Sort times and check adjacent pairs plus wrap-around

Brute Force (Check All Pairs) — Algorithm Steps

Convert all time strings to minutes from midnight
Compare every pair of times using nested loops
For each pair, calculate both direct difference and wrap-around difference
Track the minimum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Minutes

Convert all times to minutes from midnight

Compare All Pairs

Check every possible pair using nested loops

Calculate Differences

For each pair, find both direct and wrap-around differences

Track Minimum

Keep track of the smallest difference found

Code -

solution.c — C

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

int timeToMinutes(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 findMinDifference(char** timePoints, int timePointsSize) {
    int* minutes = (int*)malloc(timePointsSize * sizeof(int));
    
    for (int i = 0; i < timePointsSize; i++) {
        minutes[i] = timeToMinutes(timePoints[i]);
    }
    
    int minDiff = INT_MAX;
    for (int i = 0; i < timePointsSize; i++) {
        for (int j = i + 1; j < timePointsSize; j++) {
            int diff = abs(minutes[i] - minutes[j]);
            if (1440 - diff < diff) diff = 1440 - diff;
            if (diff < minDiff) minDiff = diff;
        }
    }
    
    free(minutes);
    return minDiff;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all n*(n-1)/2 pairs of times, leading to quadratic time complexity

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables, not counting input storage

✓ Linear Space

42.2K Views

Medium Frequency

~18 min Avg. Time

1.8K 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 (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler