Clock

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

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

Common Mistakes

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

Follow-up Questions

1. When do all three hands overlap? Only at 12:00:00
2. Angle between minute and second hands? Same logic, second hand moves 6° per second
3. Analog clock with milliseconds? Add fourth hand, more complex
4. 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

Related Problems

• Bumblebee - Geometry problems
• Fuse on Fire - Time calculations
• Compute X^Y For Floats and Negative Values - Mathematical formulas