The Number of Full Rounds You Have Played

The Number of Full Rounds You Have Played - Problem

Math String Medium

You are participating in an online chess tournament. There is a chess round that starts every 15 minutes. The first round of the day starts at 00:00, and after every 15 minutes, a new round starts.

For example, the second round starts at 00:15, the fourth round starts at 00:45, and the seventh round starts at 01:30.

You are given two strings loginTime and logoutTime where:

loginTime is the time you will login to the game, and
logoutTime is the time you will logout from the game.

If logoutTime is earlier than loginTime, this means you have played from loginTime to midnight and from midnight to logoutTime.

Return the number of full chess rounds you have played in the tournament.

Note: All the given times follow the 24-hour clock. That means the first round of the day starts at 00:00 and the last round of the day starts at 23:45.

Input & Output

Example 1 — Basic Same Day

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

› Output: 1

💡 Note: Login at 09:31, can join round starting at 09:45. Round runs 09:45-10:00, which completes before 10:14 logout. Only 1 full round played.

Example 2 — Day Wraparound

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

› Output: 22

💡 Note: Play from 21:30 to midnight (6 rounds: 21:30, 21:45, 22:00, 22:15, 22:30, 22:45, 23:00, 23:15, 23:30, 23:45), then from midnight to 03:00 (12 rounds: 00:00 to 02:45). Total: 10 + 12 = 22 rounds.

Example 3 — Exact Timing

$ Input: loginTime = "00:00", logoutTime = "23:59"

› Output: 95

💡 Note: Play almost full day from 00:00 to 23:59. Last complete round starts at 23:45 and ends at 00:00. Total rounds from 00:00 to 23:45 = 96, but last round at 23:45 doesn't complete before 23:59, so 95 rounds.

Constraints

loginTime and logoutTime are in the format "HH:MM"
00 ≤ HH ≤ 23
00 ≤ MM ≤ 59
loginTime and logoutTime are different

Visualization

Tap to expand

Understanding the Visualization

Input

Two time strings: loginTime and logoutTime in HH:MM format

Process

Count complete 15-minute rounds between these times

Output

Number of full rounds that can be played

Key Takeaway

🎯 Key Insight: Convert times to minutes and use division to count 15-minute intervals efficiently

Asked in

G Google 15 a Amazon 12 M Microsoft 8 🍎 Apple 6

The key insight is to convert time strings to minutes since midnight and use mathematical division to count 15-minute intervals. Handle day wraparound by adding 24 hours when logout ≤ login. Best approach uses direct mathematical calculation with ceiling/floor division. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Approach - Direct Calculation	O(1)	O(1)	Calculate the first valid round start time and last valid round start time, then use division
Brute Force - Check Every 15-Minute Slot	O(1)	O(1)	Iterate through all possible 15-minute rounds and count those within the play time

Mathematical Approach - Direct Calculation — Algorithm Steps

Convert login and logout times to minutes since midnight
Find first round start >= login time using ceiling division
Find last round start < logout time
Handle day wraparound case
Calculate number of rounds using division

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert & Adjust

Convert times to minutes, handle day wraparound

Find Boundaries

Calculate first and last valid round start times

Count Rounds

Use division to count rounds between boundaries

Code -

solution.c — C

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

int timeToMinutes(char* time) {
    int hours = (time[0] - '0') * 10 + (time[1] - '0');
    int minutes = (time[3] - '0') * 10 + (time[4] - '0');
    return hours * 60 + minutes;
}

int solution(char* loginTime, char* logoutTime) {
    int login = timeToMinutes(loginTime);
    int logout = timeToMinutes(logoutTime);
    
    // Handle day wraparound
    if (logout <= login) {
        logout += 24 * 60;
    }
    
    // Find first round that starts at or after login
    int firstRound = ((login + 14) / 15) * 15;
    
    // Find last round that can complete before logout
    int lastRound = ((logout - 15) / 15) * 15;
    
    if (firstRound > lastRound) {
        return 0;
    }
    
    // Calculate number of rounds
    return (lastRound - firstRound) / 15 + 1;
}

int main() {
    char loginTime[10], logoutTime[10];
    fgets(loginTime, sizeof(loginTime), stdin);
    fgets(logoutTime, sizeof(logoutTime), stdin);
    
    // Remove newlines
    loginTime[strcspn(loginTime, "\n")] = 0;
    logoutTime[strcspn(logoutTime, "\n")] = 0;
    
    int result = solution(loginTime, logoutTime);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only performs constant number of mathematical operations regardless of input

✓ Linear Growth

Space Complexity

O(1)

Uses only a few variables for calculations

✓ 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

Mathematical Approach - Direct Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler