You are given two arrays of strings that represent two inclusive events that happened on the same day, event1 and event2, where:
event1 = [startTime1, endTime1] andevent2 = [startTime2, endTime2].Event times are valid 24 hours format in the form of HH:MM.
A conflict happens when two events have some non-empty intersection (i.e., some moment is common to both events).
Return true if there is a conflict between two events. Otherwise, return false.
Example 1:
Input: event1 = ["01:15","02:00"], event2 = ["02:00","03:00"] Output: true Explanation: The two events intersect at time 2:00.
Example 2:
Input: event1 = ["01:00","02:00"], event2 = ["01:20","03:00"] Output: true Explanation: The two events intersect starting from 01:20 to 02:00.
Example 3:
Input: event1 = ["10:00","11:00"], event2 = ["14:00","15:00"] Output: false Explanation: The two events do not intersect.
Constraints:
event1.length == event2.length == 2event1[i].length == event2[i].length == 5startTime1 <= endTime1startTime2 <= endTime2HH:MM format.Problem Overview: You are given two events where each event contains a start and end time in HH:MM format. The goal is to determine whether the two time intervals overlap. If any portion of the time ranges intersects, the events are considered to be in conflict.
Approach 1: Convert Times to Minutes (O(1) time, O(1) space)
This approach converts each HH:MM time string into the total number of minutes from midnight. Split the string into hours and minutes, compute hours * 60 + minutes, and store the numeric values. Once both events are represented as integer ranges, checking overlap becomes a simple interval comparison: two events conflict if start1 ≤ end2 and start2 ≤ end1. This technique removes string handling complexity and turns the problem into a basic numeric comparison.
Because each event contains only two timestamps, the computation runs in constant time. This approach is often preferred when working with time calculations or when the problem later expands to require arithmetic on times. The method relies only on basic operations on a small array of values and simple parsing from a string.
Approach 2: Direct String Comparison (O(1) time, O(1) space)
The HH:MM format is lexicographically ordered. That means standard string comparison already preserves chronological order. Instead of converting to integers, you can directly compare the time strings. The same interval overlap rule applies: if event1.start ≤ event2.end and event2.start ≤ event1.end, the events conflict.
This works because the format always contains two digits for hours and minutes, ensuring correct lexical ordering. For example, "09:30" < "10:00" evaluates correctly with normal string comparison. This method avoids parsing entirely and produces a clean, minimal solution with just a few comparisons.
Since each comparison involves fixed-length strings and there are only two intervals, the time complexity remains constant. Space complexity is also constant because no additional structures are required.
Recommended for interviews: Interviewers typically expect the interval-overlap insight first: two intervals intersect unless one ends before the other begins. Either implementation is acceptable. Converting times to minutes demonstrates clear reasoning about time representation, while direct string comparison shows awareness of how formatted timestamps behave lexicographically. Mentioning both approaches shows strong problem-solving depth.
This approach involves converting the time given in HH:MM format into minutes since the start of the day for easier comparison. By describing times in a single unit, it simplifies determining if time intervals overlap. Once converted, you can easily check for overlap between the two events by seeing if the start time of one event is within the duration of the other event.
This C function converts each event time from HH:MM format into total minutes elapsed since midnight using the toMinutes helper function. Next, it checks if the events overlap by ensuring the end time of one is not less than the start time of the other.
Time Complexity: O(1) since the operations are constant time calculations.
Space Complexity: O(1) as no extra space beyond integer variables is used.
This approach directly compares the start and end times as strings, taking advantage of lexical comparison in HH:MM format, where times can be compared directly as strings. This approach is particularly simple because the format ensures that lexicographical order corresponds to chronological order.
In this C solution, strcmp is used to leverage lexicographical order for comparing the event times. If one event ends before or at the same time another starts, there is no overlap.
Time Complexity: O(1).
Space Complexity: O(1).
If the start time of event1 is later than the end time of event2, or the end time of event1 is earlier than the start time of event2, then the two events will not conflict. Otherwise, the two events will conflict.
The time complexity is O(1), and the space complexity is O(1).
| Approach | Complexity |
|---|---|
| Approach 1: Convert Times to Minutes | Time Complexity: O(1) since the operations are constant time calculations. |
| Approach 2: Direct String Comparison | Time Complexity: O(1). |
| String Comparison | — |
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Convert Times to Minutes | O(1) | O(1) | When you want numeric comparison or expect additional time calculations |
| Direct String Comparison | O(1) | O(1) | When timestamps are guaranteed to follow HH:MM format and quick comparison is sufficient |
2446. Determine if Two Events Have Conflict | Leetcode Weekly 316 | LeetCode 2446 • Bro Coders • 1,546 views views
Watch 9 more video solutions →Practice Determine if Two Events Have Conflict with our built-in code editor and test cases.
Practice on FleetCode