Skip to main content
Talentd

Determine if Two Events Have Conflict - Solution & Explanation

EasyArrayString12 min readAsked at: Goldman Sachs, Google
Practice this problem

Problem Statement

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] and
  • event2 = [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 == 2
  • event1[i].length == event2[i].length == 5
  • startTime1 <= endTime1
  • startTime2 <= endTime2
  • All the event times follow the HH:MM format.

Approach Overview

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.

Approach 1: Approach 1: Convert Times to Minutes

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.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(1) since the operations are constant time calculations.
Space Complexity: O(1) as no extra space beyond integer variables is used.

Try this approach in the editor →

Approach 2: Approach 2: Direct String Comparison

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.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(1).
Space Complexity: O(1).

Try this approach in the editor →

Approach 3: String Comparison

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).

Code

PythonJavaC++GoTypeScriptRust

Python

Java

C++

Go

TypeScript

Rust

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Approach 1: Convert Times to Minutes

Time Complexity: O(1) since the operations are constant time calculations.
Space Complexity: O(1) as no extra space beyond integer variables is used.

Approach 2: Direct String Comparison

Time Complexity: O(1).
Space Complexity: O(1).

String Comparison—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Convert Times to MinutesO(1)O(1)When you want numeric comparison or expect additional time calculations
Direct String ComparisonO(1)O(1)When timestamps are guaranteed to follow HH:MM format and quick comparison is sufficient

Video Solution

2446. Determine if Two Events Have Conflict | Leetcode Weekly 316 | LeetCode 2446 • Bro Coders • 1,577 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Determine if Two Events Have Conflict easy or hard?
Determine if Two Events Have Conflict is categorized as an Easy problem. The challenge focuses on recognizing the interval overlap rule and implementing simple comparisons rather than complex algorithms or data structures.
Determine if Two Events Have Conflict Python/Java solution
Python and Java implementations typically follow the same logic: either convert HH:MM strings into minutes using parsing or directly compare the strings. After conversion or comparison, apply the interval overlap condition to determine whether the events conflict.
How to solve Determine if Two Events Have Conflict in O(1)?
Convert each HH:MM timestamp into minutes from midnight or compare the strings directly. After that, apply the interval overlap rule: if event1.start ≤ event2.end and event2.start ≤ event1.end, the events conflict. Because only four timestamps are processed, the solution runs in constant time.
What is the best approach for Determine if Two Events Have Conflict?
The best approach checks interval overlap using the condition start1 ≤ end2 and start2 ≤ end1. You can either convert times to total minutes or compare the HH:MM strings directly. Both approaches run in O(1) time and O(1) space because the input size is fixed.
Is Determine if Two Events Have Conflict asked at Google/Amazon/Meta?
Interval overlap and time comparison problems frequently appear in interviews at companies like Amazon, Google, and Meta. While this exact problem may vary, the core concept of checking overlapping intervals is a common interview pattern.
What data structure is used in Determine if Two Events Have Conflict?
The problem mainly uses arrays to store start and end times and simple string manipulation for parsing. No advanced data structures are required, making it a straightforward interval comparison task.
What is the time complexity of Determine if Two Events Have Conflict?
The time complexity is O(1). The problem only involves comparing two intervals with a fixed number of timestamps, so the number of operations does not grow with input size. Space complexity is also O(1).

Ready to solve this problem?

Practice Determine if Two Events Have Conflict with our built-in code editor and test cases.

Practice on FleetCode
Previous

Merge Intervals

Next

My Calendar I