0155MediumMath

Tide Dial Needle Gap

Tracked in this browser only

Trains the technique from

LeetCode 1344Angle Between Hands of a Clock

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.

A brass tide dial in a harbour office has a round face split into 12 equal spans. The spans carry the numbers 1 to 12, going clockwise, and span 12 sits at the top of the face. Two needles turn clockwise above the face. The long needle sweeps the whole face once per hour. The short needle drifts continuously and takes twelve hours to come back around, so it usually rests partway between two spans rather than on one.

The dial is read as two whole numbers. hour_mark runs from 1 to 12 and names the span the short needle has most recently reached. minute_mark runs from 0 to 59 and counts how many marks past the top of the face the long needle has travelled, out of the 60 marks that make up one full sweep. When hour_mark is 12 and minute_mark is 0, both needles point straight up.

The two needles cut the face into two wedges. Return the size in degrees of the tighter wedge as a floating-point value. Return the exact size; do not round it or truncate it.

Examples

Example 1

Input: hour_mark = 6, minute_mark = 20
Output: 70.0

The needles cut the face into wedges of 70 and 290 degrees, and the tighter of the two is what comes back.

Example 2

Input: hour_mark = 10, minute_mark = 5
Output: 87.5

Here the two wedges are 87.5 and 272.5 degrees, so the reported size is not a whole number of degrees.

Example 3

Input: hour_mark = 12, minute_mark = 0
Output: 0.0

Both needles point straight up, so there is no wedge between them at all.

Constraints

1 <= hour_mark <= 12
0 <= minute_mark <= 59
Both arguments are integers

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 dial_needle_gap(hour_mark: int, minute_mark: int) -> float:

Java

public double dialNeedleGap(int hourMark, int minuteMark)

The intended approach

Time O(1)Space O(1), only a few scalar values are held

Place both needles on the same 360-degree scale measured clockwise from the top. The long needle advances 6 degrees per minute mark. The short needle advances 30 degrees per span, with span 12 folding back to 0, plus another half a degree for each minute mark of drift. Take the absolute difference and, if it overshoots half the face, use the complement instead.

Pythonentry point: dial_needle_gap

def dial_needle_gap(hour_mark, minute_mark):
    # closed-form arithmetic: O(1) time, O(1) space
    long_needle = 6.0 * minute_mark
    # span 12 sits at the top of the face, same place as span 0
    short_needle = 30.0 * (hour_mark % 12) + 0.5 * minute_mark
    gap = abs(long_needle - short_needle)
    return float(min(gap, 360.0 - gap))

The obvious version

Work entirely in integer half-degree ticks so no fractions appear until the very end: the face is 720 ticks around, the long needle moves 12 ticks per minute mark and the short needle 60 ticks per span plus one tick per minute mark. Walk both wedge sizes and keep the smaller, then halve.

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_dial_gap(hour_mark, minute_mark):
    face = 720
    long_ticks = 12 * minute_mark
    short_ticks = 60 * (hour_mark % 12) + minute_mark
    forward = (long_ticks - short_ticks) % face
    backward = (short_ticks - long_ticks) % face
    best = forward
    if backward < best:
        best = backward
    return best / 2.0

How this problem was checked

Reference solution executed against 13 test cases — 13 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