problemeasyalgorithmsleetcode-2446leetcode 2446leetcode2446

Determine if Two Events Have Conflict

EasyUpdated: Aug 2, 2025
Practice on:
LeetCode

Problem

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, returnfalse.

Examples

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.

Solution

Method 1 – Time Interval Overlap

Intuition

Two events have a conflict if their time intervals overlap. If the start of one event is less than or equal to the end of the other, and vice versa, then they overlap.

Approach

  1. Convert the time strings to minutes for easy comparison.
  2. For two intervals [s1, e1] and [s2, e2], check if max(s1, s2) <= min(e1, e2).
  3. If true, the events overlap; otherwise, they do not.

Code

C++
class Solution {
public:
    bool haveConflict(vector<string>& event1, vector<string>& event2) {
        auto toMin = [](const string& t) {
            return stoi(t.substr(0,2)) * 60 + stoi(t.substr(3,2));
        };
        int s1 = toMin(event1[0]), e1 = toMin(event1[1]);
        int s2 = toMin(event2[0]), e2 = toMin(event2[1]);
        return max(s1, s2) <= min(e1, e2);
    }
};
Go
import "strconv"
func toMin(t string) int {
    h, _ := strconv.Atoi(t[:2])
    m, _ := strconv.Atoi(t[3:])
    return h*60 + m
}
func haveConflict(event1, event2 []string) bool {
    s1, e1 := toMin(event1[0]), toMin(event1[1])
    s2, e2 := toMin(event2[0]), toMin(event2[1])
    return max(s1, s2) <= min(e1, e2)
}
func max(a, b int) int { if a > b { return a }; return b }
func min(a, b int) int { if a < b { return a }; return b }
Java
class Solution {
    private int toMin(String t) {
        return Integer.parseInt(t.substring(0,2)) * 60 + Integer.parseInt(t.substring(3,5));
    }
    public boolean haveConflict(String[] event1, String[] event2) {
        int s1 = toMin(event1[0]), e1 = toMin(event1[1]);
        int s2 = toMin(event2[0]), e2 = toMin(event2[1]);
        return Math.max(s1, s2) <= Math.min(e1, e2);
    }
}
Kotlin
class Solution {
    private fun toMin(t: String) = t.substring(0,2).toInt() * 60 + t.substring(3,5).toInt()
    fun haveConflict(event1: Array<String>, event2: Array<String>): Boolean {
        val s1 = toMin(event1[0]); val e1 = toMin(event1[1])
        val s2 = toMin(event2[0]); val e2 = toMin(event2[1])
        return maxOf(s1, s2) <= minOf(e1, e2)
    }
}
Python
class Solution:
    def haveConflict(self, event1: list[str], event2: list[str]) -> bool:
        def to_min(t: str) -> int:
            return int(t[:2]) * 60 + int(t[3:])
        s1, e1 = to_min(event1[0]), to_min(event1[1])
        s2, e2 = to_min(event2[0]), to_min(event2[1])
        return max(s1, s2) <= min(e1, e2)
Rust
impl Solution {
    pub fn have_conflict(event1: Vec<String>, event2: Vec<String>) -> bool {
        fn to_min(t: &str) -> i32 {
            t[0..2].parse::<i32>().unwrap() * 60 + t[3..].parse::<i32>().unwrap()
        }
        let s1 = to_min(&event1[0]); let e1 = to_min(&event1[1]);
        let s2 = to_min(&event2[0]); let e2 = to_min(&event2[1]);
        std::cmp::max(s1, s2) <= std::cmp::min(e1, e2)
    }
}
TypeScript
class Solution {
    haveConflict(event1: string[], event2: string[]): boolean {
        const toMin = (t: string) => parseInt(t.slice(0,2)) * 60 + parseInt(t.slice(3));
        const s1 = toMin(event1[0]), e1 = toMin(event1[1]);
        const s2 = toMin(event2[0]), e2 = toMin(event2[1]);
        return Math.max(s1, s2) <= Math.min(e1, e2);
    }
}

Complexity

  • ⏰ Time complexity: O(1), as all operations are constant time.
  • 🧺 Space complexity: O(1), as no extra space is used.

Comments