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
.
Examples#
Example 1#
1
2
3
Input: event1 = [ "01:15" , "02:00" ], event2 = [ "02:00" , "03:00" ]
Output: true
Explanation: The two events intersect at time 2 : 00.
Example 2#
1
2
3
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#
1
2
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#
Convert the time strings to minutes for easy comparison.
For two intervals [s1, e1] and [s2, e2], check if max(s1, s2) <= min(e1, e2)
.
If true, the events overlap; otherwise, they do not.
Code#
Cpp
Go
Java
Kotlin
Python
Rust
Typescript
1
2
3
4
5
6
7
8
9
10
11
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);
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
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 }
1
2
3
4
5
6
7
8
9
10
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);
}
}
1
2
3
4
5
6
7
8
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)
}
}
1
2
3
4
5
6
7
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)
1
2
3
4
5
6
7
8
9
10
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)
}
}
1
2
3
4
5
6
7
8
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.