Clock – Tech Interview Dot Org

Part I: what is the angle between the minute hand and the hour hand at 3:15 on an analog clock? no, its not 0.

Part II: how often does the minute hand pass the hour hand on an analog clock?

Solution

part I: 12 hours on the clock make 360 deg. so one hour is 30 deg. the hour hand will be directly on the 3 when the minute hand is at 12 (3:00). after 15 minutes or 1/4 of an hour, the hour hand will be 1/4 * 30 deg = 7.5 deg. away from the minute hand.

part II: if you just think about it, intuitively you’ll see the minute hand passes the hour hand 11 times every 12 hours, so it must pass it every 1 1/11 hours. but this doesn’t make sense to me. i need to prove it.

if x is our answer then every x hours, the minute hand and the hour hand will be right on top of each other. every hour the hour hand travels 5 units. so between every time that the minute and the hour hand meet, the hour hand will go 5*x units. every hour the minute hand travels 60 units, so it will have gone 60*x units.

what we’re trying to find is the distance traveled by the minute hand to reach the hour hand, once the minute hand has looped around once. consider its 12:00. both hands in the same position. after an hour, minute hand is on 12, hour hand on 1 (its traveled 5 units). now in the time it takes the minute hand to catch up to the hour hand it will travel a little bit further.

we only need to find x where 5*x = 60*(x-1), since the real distance traveled by the minute hand, from where it started to where it ends, is 60*(x-1). the first hour just puts it back where it started, so we’re only concerned with the extra part it traveled to reach the hour hand.

5x = 60(x-1)
5x = 60x - 60
60 = 55x
60/55 = x

there it is. the answer is 60/55 hours, or every 1 and 1/11 hours.

i apologize that this is horribly confusing, but if you stare at it long enough it will make sense.

💡Strategies for Solving This Problem

Geometry and Angle Calculation

Got this at Quora in 2022. Classic clock problem that tests math, angles, and edge case handling. Seems simple but has several tricky aspects.

Common Clock Problems

Angle between hour and minute hands at given time
Times when hands overlap (12 times in 12 hours)
Times when hands form specific angle (e.g. 90°)
Times when hands are opposite (180°)

I'll cover the most common: calculating angle at a given time.

Key Facts

Minute hand:

360° in 60 minutes
6° per minute
At 15 minutes: 15 × 6 = 90°

Hour hand:

360° in 12 hours (720 minutes)
30° per hour
0.5° per minute
At 3:00: 3 × 30 = 90°
At 3:15: 90° + (15 × 0.5) = 97.5°

The hour hand moves continuously, not in discrete jumps!

Approach

Calculate minute hand angle: minutes × 6
Calculate hour hand angle: (hours × 30) + (minutes × 0.5)
Find difference: |angle1 - angle2|
If > 180°, take 360° - angle (smaller angle)

Example: 3:15

Minute hand: 15 × 6 = 90°
Hour hand: (3 × 30) + (15 × 0.5) = 90 + 7.5 = 97.5°
Difference: |90 - 97.5| = 7.5°

Example: 9:00

Minute hand: 0 × 6 = 0°
Hour hand: (9 × 30) + (0 × 0.5) = 270°
Difference: |0 - 270| = 270°
Since 270° > 180°, take 360° - 270° = 90°

Edge Cases

12:00: Both at 0°, angle = 0°
6:00: Hands opposite, angle = 180°
3:00: Hands perpendicular, angle = 90°
12:30: Minute at 180°, hour at 15°, angle = 165°

At Quora

Interviewer asked for angle at 3:15. I calculated 7.5°. Then he asked "When are hands exactly overlapping?" That's trickier - need to solve equation. Then "How many times do they overlap in 24 hours?" Answer: 22 times (not 24!).

✅Solution

Solution: Calculate Angle Between Clock Hands

function clockAngle(hours, minutes) {
    // Normalize hours to 12-hour format
    hours = hours % 12;

    // Calculate angles from 12 o'clock position
    const minuteAngle = minutes * 6; // 6° per minute

    // Hour hand moves 30° per hour + 0.5° per minute
    const hourAngle = (hours * 30) + (minutes * 0.5);

    // Find difference
    let angle = Math.abs(hourAngle - minuteAngle);

    // Take smaller angle
    if (angle > 180) {
        angle = 360 - angle;
    }

    return angle;
}

// Test cases
const testCases = [
    [3, 0],   // 90°
    [3, 15],  // 7.5°
    [6, 0],   // 180°
    [9, 0],   // 90°
    [12, 0],  // 0°
    [12, 30], // 165°
    [1, 10],  // 35°
    [11, 50], // 125°
];

console.log("TimettAngle");
console.log("=" * 30);

testCases.forEach(([h, m]) => {
    const angle = clockAngle(h, m);
    const time = `${h}:${m.toString().padStart(2, '0')}`;
    console.log(`${time}tt${angle}°`);
});

/* Output:
Time		Angle
==============================
3:00		90°
3:15		7.5°
6:00		180°
9:00		90°
12:00		0°
12:30		165°
1:10		35°
11:50		125°
*/

Finding Overlap Times

function findOverlapTimes() {
    // Hands overlap when hourAngle = minuteAngle
    // (h * 30) + (m * 0.5) = m * 6
    // h * 30 = m * 5.5
    // m = h * 30 / 5.5 = h * 60 / 11

    const overlapTimes = [];

    for (let h = 0; h < 12; h++) {
        const minutes = (h * 60) / 11;

        // Convert to mm:ss format
        const m = Math.floor(minutes);
        const s = Math.round((minutes - m) * 60);

        overlapTimes.push({
            hour: h,
            minute: m,
            second: s,
            decimal: minutes
        });
    }

    return overlapTimes;
}

// Find all overlap times in 12 hours
const overlaps = findOverlapTimes();

console.log("nClock hands overlap at:");
overlaps.forEach(t => {
    const h = t.hour;
    const m = t.minute.toString().padStart(2, '0');
    const s = t.second.toString().padStart(2, '0');
    console.log(`${h}:${m}:${s} (${t.decimal.toFixed(4)} minutes)`);
});

/* Output:
Clock hands overlap at:
0:00:00 (0.0000 minutes)
1:05:27 (5.4545 minutes)
2:10:55 (10.9091 minutes)
3:16:22 (16.3636 minutes)
4:21:49 (21.8182 minutes)
5:27:16 (27.2727 minutes)
6:32:44 (32.7273 minutes)
7:38:11 (38.1818 minutes)
8:43:38 (43.6364 minutes)
9:49:05 (49.0909 minutes)
10:54:33 (54.5455 minutes)
*/

Finding Times for Specific Angle

function findTimesForAngle(targetAngle, precision = 0.1) {
    const times = [];

    // Check every minute (or finer precision)
    for (let h = 0; h < 12; h++) {
        for (let m = 0; m < 60; m += precision) {
            const angle = clockAngle(h, Math.floor(m));

            if (Math.abs(angle - targetAngle) < 1) {
                times.push({
                    hour: h,
                    minute: Math.floor(m),
                    angle: angle
                });
            }
        }
    }

    // Remove duplicates
    const unique = times.filter((t, i, arr) =>
        i === arr.findIndex(x =>
            x.hour === t.hour && x.minute === t.minute
        )
    );

    return unique;
}

// Find all times when hands form 90° angle
const rightAngles = findTimesForAngle(90);

console.log("nHands form 90° angle at:");
rightAngles.forEach(t => {
    console.log(`${t.hour}:${t.minute.toString().padStart(2, '0')} (${t.angle.toFixed(1)}°)`);
});

Python Version

def clock_angle(hours, minutes):
    """Calculate angle between clock hands"""
    hours = hours % 12

    minute_angle = minutes * 6
    hour_angle = (hours * 30) + (minutes * 0.5)

    angle = abs(hour_angle - minute_angle)

    if angle > 180:
        angle = 360 - angle

    return angle


def find_overlap_times():
    """Find all times when hands overlap in 12 hours"""
    overlaps = []

    for h in range(12):
        # Solve: h * 30 + m * 0.5 = m * 6
        # m = h * 60 / 11
        minutes = (h * 60) / 11

        m = int(minutes)
        s = round((minutes - m) * 60)

        overlaps.append({
            'hour': h,
            'minute': m,
            'second': s,
            'time': f"{h}:{m:02d}:{s:02d}"
        })

    return overlaps


# Test
test_times = [(3, 0), (3, 15), (6, 0), (9, 0), (12, 0), (12, 30)]

print("Clock Angle Calculator")
print("=" * 40)

for h, m in test_times:
    angle = clock_angle(h, m)
    print(f"{h}:{m:02d} -> {angle}°")

print("nOverlap times in 12 hours:")
for overlap in find_overlap_times():
    print(f"  {overlap['time']}")

print(f"nTotal overlaps in 12 hours: {len(find_overlap_times())}")
print(f"Total overlaps in 24 hours: {len(find_overlap_times()) * 2 - 2}")
print("  (Subtract 2 because 12:00 is counted in both halves)")

Complexity Analysis

Single angle calculation:

Time: O(1) - just arithmetic
Space: O(1)

Finding all overlaps:

Time: O(1) - exactly 11 overlaps in 12 hours
Space: O(1)

Finding times for specific angle:

Time: O(12 × 60) = O(1) for brute force
Can optimize to O(1) with math

Key Insights

Hour hand moves continuously: Not just at hour marks
11 overlaps, not 12: In 12 hours (hands meet every 12/11 hours)
Always take smaller angle: Unless problem asks for reflex angle
Use modulo for 24-hour times: hours % 12

Common Mistakes

Forgetting hour hand moves with minutes: Not just hours × 30
Not taking smaller angle: 270° should be 90°
Thinking 12 overlaps: Actually 11 in 12 hours
Integer division issues: Use float division for precision

Follow-up Questions

When do all three hands overlap? Only at 12:00:00
Angle between minute and second hands? Same logic, second hand moves 6° per second
Analog clock with milliseconds? Add fourth hand, more complex
Clock running fast/slow? Adjust angular velocities

Real-World Applications

UI/UX design: Analog clock widgets
Angle calculations: General geometry problems
Time synchronization: Clock alignment algorithms
Interview prep: Very common problem at tech companies