The Number of Full Rounds You Have Played

The Number of Full Rounds You Have Played - Problem

Math String Medium

You're participating in an exciting online chess tournament where games run around the clock! 🏆

How it works:

A new chess round starts every 15 minutes
The first round starts at 00:00, then 00:15, 00:30, 00:45, etc.
The last round of the day starts at 23:45

Given your loginTime and logoutTime (in 24-hour format), calculate how many complete chess rounds you participated in.

Special case: If logoutTime is earlier than loginTime, it means you played across midnight (from loginTime to 23:59, then from 00:00 to logoutTime).

Goal: Return the total number of full rounds you completed during your gaming session.

Input & Output

example_1.py — Basic Session

$ Input: loginTime = "09:31", logoutTime = "10:14"

› Output: 1

💡 Note: You logged in at 09:31 and logged out at 10:14. The only complete round that fits entirely in your session is 09:45-10:00.

example_2.py — Midnight Crossover

$ Input: loginTime = "21:30", logoutTime = "03:00"

› Output: 22

💡 Note: You played from 21:30 to midnight, then from midnight to 03:00. Complete rounds: 21:30-21:45, 21:45-22:00, ..., 02:45-03:00 = 22 rounds total.

example_3.py — No Complete Rounds

$ Input: loginTime = "00:47", logoutTime = "00:58"

› Output: 0

💡 Note: Your session (00:47 to 00:58) is only 11 minutes long, which doesn't contain any complete 15-minute rounds.

Constraints

loginTime and logoutTime are in the format HH:MM
loginTime and logoutTime are different times
All times follow the 24-hour clock format
0 ≤ HH ≤ 23, 0 ≤ MM ≤ 59

Visualization

Tap to expand

Understanding the Visualization

Convert to Minutes

Transform HH:MM format to total minutes since midnight

Handle Midnight

If logout < login, add 24*60 to logout time

Find Boundaries

Calculate first round after login and last round before logout

Count Rounds

Calculate difference and divide by 15

Key Takeaway

🎯 Key Insight: Convert everything to minutes and use integer division to find round boundaries - much more efficient than checking each individual round!

Asked in

a Amazon 12 ⊞ Microsoft 8 G Google 6 f Meta 4

The optimal approach converts times to minutes, handles midnight crossover by adding 24*60 to logout time if needed, then uses integer division to find the first complete round after login and last complete round before logout. The key insight is that complete rounds start at multiples of 15 minutes, so we can calculate boundaries mathematically instead of checking every round.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Round)	O(1)	O(1)	Iterate through all possible 15-minute rounds and count valid ones

Brute Force (Check Every Round) — Algorithm Steps

Convert login and logout times to minutes since 00:00
Handle the midnight crossover case by adjusting logout time
Iterate through all 96 possible rounds (0, 15, 30, ..., 1425 minutes)
For each round, check if it starts at or after login and ends at or before logout
Count all valid complete rounds

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert Times

Convert login and logout times to minutes

Check All Rounds

Iterate through all 96 possible rounds

Count Valid Rounds

Count rounds that fit completely in session

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int timeToMinutes(char* time) {
    int hours, minutes;
    sscanf(time, "%d:%d", &hours, &minutes);
    return hours * 60 + minutes;
}

int numberOfRounds(char* loginTime, char* logoutTime) {
    int loginMin = timeToMinutes(loginTime);
    int logoutMin = timeToMinutes(logoutTime);
    
    if (logoutMin < loginMin) {
        logoutMin += 24 * 60;
    }
    
    // Find first complete round after login
    int firstRound = ((loginMin + 14) / 15) * 15;
    // Find last complete round before logout
    int lastRound = (logoutMin / 15) * 15;
    
    if (firstRound <= lastRound) {
        return (lastRound - firstRound) / 15 + 1;
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always checks exactly 96 rounds regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables for counting and time conversion

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Every Round) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler