0949MediumArrayMathStringSorting

Closest Two Times on the Clock

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

Clock times are given as timePoints, each written as "HH:MM" on a twenty-four hour clock.

Return the fewest minutes between any two of the times, treating the clock as running round: the gap from one time to another may be measured either way about midnight, and the smaller is taken.

Examples

Example 1

Input: timePoints = ["07:42", "19:03", "07:55", "02:18"]
Output: 13

Sorted, the times run 02:18, 07:42, 07:55 and 19:03. The closest pair is 07:42 and 07:55, thirteen minutes apart.

Example 2

Input: timePoints = ["22:30", "01:15"]
Output: 165

Going forwards from 22:30 to 01:15 is two hours and forty-five minutes, which is shorter than going the other way round the clock.

Example 3

Input: timePoints = ["13:13", "13:13"]
Output: 0

The same time appears twice, so the gap between them is nothing.

Constraints

2 <= timePoints.length <= 2 * 10^4
timePoints[i] is written as "HH:MM" on a twenty-four hour clock

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def find_min_difference(timePoints: list[str]) -> int:

Java

public int findMinDifference(List<String> timePoints)

The intended approach

Time O(n log n) for n times, the sort dominating.Space O(n) for the minutes.

Turn each time into minutes past midnight and sort them. The closest pair must then sit next to each other in that order, because any wider pair spans at least one neighbouring gap and so cannot be smaller. The clock running round adds one more pair to check: the last time of the day and the first, whose gap is a whole day less their difference. Taking the smallest over the neighbouring gaps and that one wrap-around gap gives the answer. Two identical times give a gap of nothing, which the sort catches for free.

Pythonentry point: find_min_difference

def find_min_difference(timePoints):
    minutes = []
    for text in timePoints:
        hours = int(text[0]) * 10 + int(text[1])
        mins = int(text[3]) * 10 + int(text[4])
        minutes.append(hours * 60 + mins)
    minutes.sort()
    best = 24 * 60 - minutes[-1] + minutes[0]
    for i in range(1, len(minutes)):
        gap = minutes[i] - minutes[i - 1]
        if gap < best:
            best = gap
    return best

The obvious version

Compare every pair of times directly, taking each gap the shorter way round the clock, and keep the smallest. Quadratic in the number of times and it never sorts anything.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_find_min_difference(timePoints):
    day = 24 * 60
    minutes = []
    for text in timePoints:
        parts = text.split(":")
        minutes.append(int(parts[0]) * 60 + int(parts[1]))
    best = None
    for i in range(len(minutes)):
        for j in range(i + 1, len(minutes)):
            gap = minutes[i] - minutes[j]
            if gap < 0:
                gap = -gap
            other = day - gap
            if other < gap:
                gap = other
            if best is None or gap < best:
                best = gap
    return best

How this problem was checked

Reference solution executed against 10 test cases — 10 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in