What is the time complexity of Angle Between Hands of a Clock?

The optimal solution has a time complexity of O(1).

What data structures are used to solve Angle Between Hands of a Clock?

This problem uses Math. Understanding these concepts is essential for solving this Medium problem efficiently.

What are the key insights for solving Angle Between Hands of a Clock?

Insight 1: The minute hand moves 360 degrees in 60 minutes, meaning it moves 6 degrees per minute. Insight 2: The hour hand moves 360 degrees in 12 hours (720 minutes). Therefore, it moves 30 degrees per hour, and 0.5 degrees per minute.

Which companies ask LeetCode 1344. Angle Between Hands of a Clock in interviews?

This problem is frequently asked at Epic Systems, Siemens, UKG.

JavaScript is required for the full interactive experience. However, all content is accessible without JavaScript.

Angle Between Hands of a Clock - LeetCode 1344 Solution

Angle Between Hands of a Clock - Complete Solution Guide

Angle Between Hands of a Clock is LeetCode problem 1344, a Medium level challenge. This complete guide provides step-by-step explanations, multiple solution approaches, and optimized code in python3, java, cpp, c.

Problem Statement

Given two numbers, hour and minutes , return the smaller angle (in degrees) formed between the hour and the minute hand . Answers within 10 -5 of the actual value will be accepted as correct. Example 1: Input: hour = 12, minutes = 30 Output: 165 Example 2: Input: hour = 3, minutes = 30 Output: 75 Example 3: Input: hour = 3, minutes = 15 Output: 7.5 Constraints: 1 <= hour <= 12 0 <= minutes <= 59

Detailed Explanation

The problem asks us to calculate the smaller angle between the hour and minute hands on an analog clock, given the current hour and minute. The hour is between 1 and 12 inclusive, and the minutes are between 0 and 59 inclusive. The output should be the angle in degrees, with answers within 10<sup>-5</sup> of the actual value considered correct.

Solution Approach

The solution involves calculating the angle of each hand independently from the 12 o'clock position. The minute hand's angle is simply 6 degrees per minute. The hour hand's angle is a bit more complex: it's 30 degrees per hour, plus an additional offset due to the minutes. Once we have the angles of both hands, we find the absolute difference and return the smaller of that difference and its complement to 360 (i.e., 360 - difference).

Step-by-Step Algorithm

Step 1: Calculate the angle of the minute hand: `minute_angle = minutes * 6.0`
Step 2: Calculate the angle of the hour hand: `hour_angle = (hour % 12 + minutes / 60.0) * 30.0`. This includes the base hour position (30 degrees/hour) and the additional movement due to the minutes.
Step 3: Calculate the absolute difference between the two angles: `diff = abs(hour_angle - minute_angle)`
Step 4: Return the smaller angle: `return min(diff, 360.0 - diff)`

Key Insights

Insight 1: The minute hand moves 360 degrees in 60 minutes, meaning it moves 6 degrees per minute.
Insight 2: The hour hand moves 360 degrees in 12 hours (720 minutes). Therefore, it moves 30 degrees per hour, and 0.5 degrees per minute.
Insight 3: The angle can be calculated by finding the absolute difference between the angles of the hour and minute hands. The smaller angle is the minimum of this difference and 360 minus this difference.
Insight 4: Take the hour modulo 12. This handles the case when hour is 12. Without it, for example at 12:00, the hour angle calculation would be incorrect.

Complexity Analysis

Time Complexity: O(1)

Space Complexity: O(1)

Topics

This problem involves: Math.

Companies

Asked at: Epic Systems, Siemens, UKG.

Angle Between Hands of a Clock | LeetCode 1344

Medium

Math

Time: O(1)Space: O(1)

Solution Code

Available in:

class Solution {
    public double angleClock(int hour, int minutes) {
        // Angle of the minute hand from the 12 o'clock position.
        // Each minute corresponds to 360/60 = 6 degrees.
        double minute_angle = minutes * 6.0;

        // Angle of the hour hand from the 12 o'clock position.
        // Each hour corresponds to 360/12 = 30 degrees.
        // The hour hand also moves based on the minutes.
        // The total hour position is (hour + minutes/60).
        // We use hour % 12 to handle the 12 o'clock case.
        double hour_angle = (hour % 12 + minutes / 60.0) * 30.0;

        // The difference between the two angles.
        double diff = Math.abs(hour_angle - minute_angle);

        // Return the smaller of the two possible angles.
        return Math.min(diff, 360.0 - diff);
    }
}

View Full Solution on GitHubGitHub Solution View on LeetCodeLeetCode

Problem Info

Description

Problem 1344: Angle Between Hands of a Clock - Detailed explanation and solution approaches.

Topics

Math

Companies

Epic SystemsSiemensUKG

Stats

Difficulty:Medium

Languages:4

Companies:3

Problem #:1344

Problem Explanation

💡

Think Before You Code

🤔 Ask Yourself

→What is the input? What output do I need?
→Can I solve a smaller version of this problem first?
→What patterns have I seen in similar problems?

✏️ Try This First

Before looking at the solution, try to solve it on paper with a simple example!

🚀 Try on LeetCode

Solution Approach

📋

Step-by-Step Solution

4 steps

1
Step 1: Calculate the angle of the minute hand: `minute_angle = minutes * 6.0`
2
Step 2: Calculate the angle of the hour hand: `hour_angle = (hour % 12 + minutes / 60.0) * 30.0`. This includes the base hour position (30 degrees/hour) and the additional movement due to the minutes.
3
Step 3: Calculate the absolute difference between the two angles: `diff = abs(hour_angle - minute_angle)`
4
Step 4: Return the smaller angle: `return min(diff, 360.0 - diff)`

💡

Pro Tip for Students

Try tracing through each step with a small example on paper before coding. Understanding "why" each step happens is more important than memorizing the code!

⚡

Complexity Analysis

⏱️

Time Complexity

O(1)

⚡ Constant time - Super fast! Same speed regardless of input size.

💾

Space Complexity

O(1)

💪 Constant space - Uses same memory regardless of input!

📝

Why?

The solution involves only basic arithmetic operations, which take constant time. The space used is constant as we only store a few variables.

📖New to Big O? Click to learn more

Big O Notation - Quick Guide

O(1)Best - Instant

O(log n)Excellent - Binary Search

O(n)Good - One loop

O(n log n)OK - Sorting

O(n²)Slow - Nested loops

O(2ⁿ)Very Slow - Recursion

Alternative Approaches

Direct Calculation using Clock Positions

Instead of calculating angles directly, one could calculate the position of each hand as a fraction of the clock face (0 to 1) and then use the fractional difference to calculate the angle.

Time: O(1)Space: O(1)

Trade-offs: This approach might be slightly less intuitive to understand than calculating the angles directly.

✨

Key Insights

1Insight 1: The minute hand moves 360 degrees in 60 minutes, meaning it moves 6 degrees per minute.
2Insight 2: The hour hand moves 360 degrees in 12 hours (720 minutes). Therefore, it moves 30 degrees per hour, and 0.5 degrees per minute.
3Insight 3: The angle can be calculated by finding the absolute difference between the angles of the hour and minute hands. The smaller angle is the minimum of this difference and 360 minus this difference.
4Insight 4: Take the hour modulo 12. This handles the case when hour is 12. Without it, for example at 12:00, the hour angle calculation would be incorrect.

📚

Key Terms Explained

For Students

Edge Cases

Edge case 1: hour = 12. The `hour % 12` operation ensures correct calculation since 12 o'clock is the same position as 0 o'clock.
Edge case 2: minutes = 0. The algorithm correctly calculates the angle when the minutes are 0, as the minute hand is at the 12 o'clock position.
Edge case 3: hour = 6, minutes = 0. Result should be 180 degrees. The code will return the correct output.
Edge case 4: hour = 1, minutes = 0. Result should be 30 degrees. The code handles this correctly.

⚠️

Common Mistakes to Avoid

✗Common mistake 1: Forgetting to account for the hour hand's movement due to the minutes. The hour hand doesn't just jump between hours; it moves continuously.

✗Common mistake 2: Not considering both possible angles and returning the smaller one. The hands can form two angles that add up to 360 degrees.

✗Common mistake 3: Not using `hour % 12`, leading to errors when hour is 12.

✅

Learning Tip

Every mistake is a learning opportunity! When you make an error, understand why it happened before moving on.

🌍

Where is This Used in Real Life?

💼Real-world scenario 1: Calculating the angle between any two rotating objects, such as gears in a machine.

🏦Real-world scenario 2: Animation and graphics programming, where calculating angles is fundamental for rotating and positioning elements.

💡Understanding real-world applications helps you see the "why" behind algorithms. It's not just about passing interviews—these concepts power the apps and websites you use every day!

Author's Notes

💡 Key Insight

When dealing with arrays, always consider if sorting would simplify the problem. Many array problems have O(n) solutions using hash maps or two-pointer technique.

🎯 Interview Tip

Medium problems are the bread and butter of technical interviews. Practice explaining your approach before coding.

⚠️ Watch Out

Always test your solution with edge cases: empty input, single element, and boundary values.

Written by Saswata Mondal

Software Engineer • Algorithms Enthusiast • Interview Coach

👨‍💻

About the Author

👨‍💻

Saswata MondalAuthor400+ LC Problems

B.Tech CSE, IEM Kolkata | LeetCode Rating: 1672 (Top 15%)

Certified: IBM Java Developer, NPTEL Programming in Java

Last updated: August 24, 2024LeetCode Profile GitHub

This solution has been crafted based on my experience solving 400+ LeetCode problems. Each explanation is designed to help you understand the underlying concepts, not just memorize the code.

Community Tips & Insights

In a real interview, always clarify constraints first. Ask about input size and value ranges.

@TechLeadJul 13

Don't forget to handle the edge case when the input is empty. Many candidates miss this in interviews.

@DevExpert92Jul 6

❓

Frequently Asked Questions

What techniques are commonly tested in medium-difficulty problems?

Medium problems often require combining multiple techniques: two-pointer with hash maps, BFS/DFS with state tracking, dynamic programming with optimization, or divide-and-conquer approaches. They test your ability to recognize patterns and choose the right combination of techniques.

How should I practice algorithm problems effectively?

Focus on understanding patterns rather than memorizing solutions. After solving a problem, review optimal solutions and understand the intuition. Group similar problems to recognize patterns. Practice explaining your approach out loud. Review problems after a few days to test retention.

What is the optimal approach for "Angle Between Hands of a Clock"?

For this medium-level Math problem, the key is to identify the core pattern. Analyze the input constraints to determine acceptable time complexity. Consider whether standard techniques can optimize the solution. Always handle edge cases and validate your approach with examples before coding.

🤖 Need help with this problem?