Determine if Two Events Have Conflict - Practice Coding Problems

Determine if Two Events Have Conflict - Problem

Array String Easy

You're a busy event coordinator managing a packed schedule! You need to determine if two events scheduled for the same day have a scheduling conflict.

Given two events represented as arrays of strings:

event1 = [startTime1, endTime1]
event2 = [startTime2, endTime2]

Each time is in 24-hour format (HH:MM), and both events are inclusive - meaning if one event ends at 15:30 and another starts at 15:30, they have a conflict at that exact moment.

Goal: Return true if there's any overlap between the two events, false otherwise.

Example: Event1: ["01:15", "02:00"] and Event2: ["02:00", "03:00"] → true (they both occur at 02:00)

Input & Output

example_1.py — Basic Overlap

$ Input: event1 = ["01:15", "02:00"], event2 = ["02:00", "03:00"]

› Output: true

💡 Note: Both events occur at exactly 02:00, so there's a conflict at that moment. Since events are inclusive, touching endpoints count as conflicts.

example_2.py — No Overlap

$ Input: event1 = ["01:00", "02:00"], event2 = ["03:00", "04:00"]

› Output: false

💡 Note: Event1 ends at 02:00 and Event2 starts at 03:00. There's a gap between 02:00 and 03:00, so no conflict exists.

example_3.py — Complete Overlap

$ Input: event1 = ["10:00", "11:00"], event2 = ["09:30", "11:30"]

› Output: true

💡 Note: Event2 completely contains Event1. They overlap from 10:00 to 11:00, which is a significant conflict.

Visualization

Tap to expand

Understanding the Visualization

Receive Booking Requests

Person A wants 09:00-10:30, Person B wants 10:00-11:00

Check Overlap Conditions

Does A start before B ends? Does B start before A ends?

Identify Conflict

Both conditions true → conflict from 10:00-10:30

Make Decision

Return true - these bookings cannot both be accepted

Key Takeaway

🎯 Key Insight: Two time intervals overlap if each one starts before (or when) the other ends. This creates a simple, elegant condition that works for all interval overlap problems!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time operations for parsing and comparison

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables

✓ Linear Space

Constraints

event1.length == event2.length == 2
event1[i].length == event2[i].length == 5
event1[i] and event2[i] are in HH:MM format
0 ≤ HH ≤ 23, 0 ≤ MM ≤ 59
The start time is always before or equal to the end time

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

This interval overlap problem has an elegant O(1) solution. The key insight is that two intervals overlap if and only if: start1 ≤ end2 AND start2 ≤ end1. You can solve this with simple string comparison (since HH:MM format preserves lexicographic order) or by converting times to minutes for clearer mathematical reasoning. Both approaches are optimal and run in constant time.

Common Approaches

Approach	Time	Space	Notes
✓ String Comparison Approach	O(1)	O(1)	Compare time strings directly using lexicographic ordering
Time Conversion Approach	O(1)	O(1)	Convert time strings to minutes and compare numerically

String Comparison Approach — Algorithm Steps

Extract start and end times from both events
Compare start1 <= end2 (event1 starts before event2 ends)
Compare start2 <= end1 (event2 starts before event1 ends)
Return true if both conditions are met

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Events

Extract start and end times from both events

Compare Conditions

Check if start1 <= end2 and start2 <= end1

Determine Conflict

Return true if both conditions are satisfied

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool haveConflict(char event1[2][6], char event2[2][6]) {
    // Two events conflict if:
    // event1 starts before or when event2 ends AND
    // event2 starts before or when event1 ends
    return strcmp(event1[0], event2[1]) <= 0 && strcmp(event2[0], event1[1]) <= 0;
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    char event1[2][6], event2[2][6];
    char *token;
    int count = 0;
    
    // Simple parsing - extract times between quotes
    char *ptr = line;
    while (*ptr && count < 4) {
        if (*ptr == '"') {
            ptr++;
            char *start = ptr;
            while (*ptr && *ptr != '"') ptr++;
            *ptr = '\0';
            
            if (count < 2) {
                strcpy(event1[count], start);
            } else {
                strcpy(event2[count-2], start);
            }
            count++;
        }
        ptr++;
    }
    
    printf("%s\n", haveConflict(event1, event2) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only doing constant string comparisons

✓ Linear Growth

Space Complexity

O(1)

Using only a few variables

✓ Linear Space

Constraints

event1.length == event2.length == 2
event1[i].length == event2[i].length == 5
event1[i] and event2[i] are in HH:MM format
0 ≤ HH ≤ 23, 0 ≤ MM ≤ 59
The start time is always before or equal to the end time

28.4K Views

Medium Frequency

~8 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

String Comparison Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler