Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2446.html

2446. Determine if Two Events Have Conflict

  • Difficulty: Easy.
  • Related Topics: Array, String.
  • Similar Questions: Merge Intervals, Non-overlapping Intervals, My Calendar I.

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, 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:

  • evnet1.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 (Java, C++, Python)

  • class Solution {
    public boolean haveConflict(String[] event1, String[] event2) {
        return event1[0].compareTo(event2[1]) <= 0 && event1[1].compareTo(event2[0]) >= 0;
    }
}

  • class Solution {
public:
    bool haveConflict(vector<string>& event1, vector<string>& event2) {
        return event1[0] <= event2[1] && event1[1] >= event2[0];
    }
};

  • class Solution:
    def haveConflict(self, event1: List[str], event2: List[str]) -> bool:
        return event1[0] <= event2[1] and event1[1] >= event2[0]


  • func haveConflict(event1 []string, event2 []string) bool {
	return event1[0] <= event2[1] && event1[1] >= event2[0]
}

  • function haveConflict(event1: string[], event2: string[]): boolean {
    return event1[0] <= event2[1] && event1[1] >= event2[0];
}


  • impl Solution {
    pub fn have_conflict(event1: Vec<String>, event2: Vec<String>) -> bool {
        !(event1[1] < event2[0] || event1[0] > event2[1])
    }
}

Explain:

nope.

Complexity:

  • Time complexity : O(n).
  • Space complexity : O(n).

All Problems

All Solutions