Loading…

easyIntervalsLC #252Frequently asked

Meeting Rooms

Q: How do you solve Meeting Rooms using the Brute Force — Check Every Pair approach?

When to use it: Say it first to define 'overlap' precisely, then note it's quadratic and sorting fixes that. The literal reading: a person can attend all meetings unless some two of them overlap, so check all pairs. **The overlap definition.** Two meetings `a` and `b` overlap iff `a.start < b.end && b.start < a.end` — each starts before the other ends. Strict `<` encodes the 'touching is fine' rule. Loop over every pair and return false the moment one overlaps. **Why we don't ship it.** With `n` up to 10⁴ that's ~50 million comparisons — passable, but it ignores structure. Sorting by start guarantees that if meeting `i` overlaps anything earlier, it overlaps meeting `i−1` specifically, so comparing all pairs is wasteful. State this, then sort. Time complexity: O(n²). Space complexity: O(1).

Q: How do you solve Meeting Rooms using the Sort by Start, Scan Adjacent (Optimal) approach?

When to use it: The expected answer. Frame it as 'sort by start; the only possible conflict is with the previous meeting'. Sort the meetings by start time, then scan once comparing each meeting to its immediate predecessor. **Why adjacency is enough.** After sorting by start, the meetings are in non-decreasing start order. Suppose meeting `i` overlaps some earlier meeting `k < i`. Because starts are sorted, meeting `i−1` also starts no later than `i` and no earlier than `k`, and the earliest-ending relevant boundary to worry about is the one right before `i`. Concretely: if `meetings[i].start < meetings[i-1].end`, they overlap; if not, `i` starts at or after `i−1` ends, and since every earlier meeting ends no later than... — the cleanest framing is that once sorted, a conflict always shows up between *some* adjacent pair, so checking all adjacent pairs catches every conflict. No all-pairs loop needed. **The conflict test.** `meetings[i].start < meetings[i-1].end` with strict `<`. Equality (`start == prevEnd`) is back-to-back, which is allowed. The instant the test is true, return false; if the scan completes, return true. **Why a boolean, not a merge.** Unlike Merge Intervals, we don't build anything — we just need existence of a conflict, so we short-circuit on the first one. That's what keeps this an 'easy': same sort, simpler payload. Time complexity: O(n log n). Space complexity: O(1).

LCPractice

Intervals · 4 of 7 · 6 min

Given an array of meeting time intervals where intervals[i] = [startᵢ, endᵢ], determine if a person could attend all meetings.

A person can attend all meetings if and only if no two meetings overlap. Meetings that merely touch — one ending exactly when the next begins, like [0,30] and [30,60] — do not conflict.

In plain English

There's one person (or one room) and a list of meetings. The question is binary: can they make every single meeting? They can exactly when the schedule has no time conflict — no meeting overlaps another. Touching back-to-back is allowed.

Examples

Example 1

Input: intervals = [[0,30],[5,10],[15,20]]
Output: false
Note: [0,30] overlaps [5,10] (5 < 30) — the person can't be in two meetings at once.

Example 2

Input: intervals = [[7,10],[2,4]]
Output: true
Note: Sorted: [2,4] then [7,10]. 7 ≥ 4, no overlap — all meetings attendable.

Example 3

Input: intervals = [[0,30],[30,60]]
Output: true
Note: They touch at 30. Back-to-back is allowed, so no conflict.

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ startᵢ < endᵢ ≤ 10⁶
A meeting ending at time t and another starting at t do NOT overlap

Clarifying questions4First question: Does a meeting ending at time t conflict with one starting at t?Explore questions

Q1.Does a meeting ending at time t conflict with one starting at t?
No — back-to-back meetings are fine. So the overlap test is strict: start < previous end.
Q2.Is the input sorted?
No. I'll sort by start so I only have to compare adjacent meetings.
Q3.What should I return for an empty list or a single meeting?
True — with zero or one meeting there's nothing to conflict with.
Q4.Do I need to report which meetings clash, or just yes/no?
Just a boolean. That lets me return early on the first conflict found.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

A person can attend every meeting only if no two meetings overlap. Sort by start time, then check adjacent pairs: if any meeting starts before the previous one ends, return false. After sorting, the only meeting that can conflict with the current one is its immediate predecessor — so one linear scan suffices. O(n log n) sort, O(n) scan.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you realize sorting by start reduces 'do any two overlap?' from O(n²) pair-checking to a single neighbor scan.

Where candidates slip

Comparing every pair (O(n²)) instead of sorting, or getting the boundary wrong so a meeting starting exactly when another ends is flagged as a conflict.

How to stand out

Explain why adjacency-after-sorting is sufficient, use strict `<` for the touch-is-ok semantics, and note this is the warm-up to Meeting Rooms II where you count rooms instead of returning a boolean.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Brute Force — Check Every Pair	`O(n²)`	`O(1)`	Say it first to define 'overlap' precisely, then note it's quadratic and sorting fixes that.	Read
2	Sort by Start, Scan Adjacent (Optimal)Optimal	`O(n log n)`	`O(1)`	The expected answer. Frame it as 'sort by start; the only possible conflict is with the previous meeting'.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewQuestion about meeting intervalsYes/no, count rooms, or merge?Count roomsMergeExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Brute Force — Check Every Pair

TimeO(n²)SpaceO(1)

Say it first to define 'overlap' precisely, then note it's quadratic and sorting fixes that.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Two meetings conflict iff a.start < b.end AND b.start < a.end. What's the most direct way to check all of them?

2Hint 2Explore hint

Compare every unordered pair (i, j) with i < j; return false on the first overlap.

3Hint 3Explore hint

It's correct but O(n²). Is there an ordering that makes only neighbors worth comparing?

A · Core idea

The literal reading: a person can attend all meetings unless some two of them overlap, so check all pairs.

The overlap definition. Two meetings a and b overlap iff a.start < b.end && b.start < a.end — each starts before the other ends. Strict < encodes the 'touching is fine' rule. Loop over every pair and return false the moment one overlaps.

Why we don't ship it. With n up to 10⁴ that's ~50 million comparisons — passable, but it ignores structure. Sorting by start guarantees that if meeting i overlaps anything earlier, it overlaps meeting i−1 specifically, so comparing all pairs is wasteful. State this, then sort.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

intervals = [[0,30],[5,10],[15,20]]

(0,30)&(5,10)

0 < 10 and 5 < 30 → overlap

Statereturn false

first conflict ends it

Final resultfalse

C · Code with teaching comments

Reference implementation previewpublic boolean canAttendMeetings(int[][] intervals) { int n = intervals.length; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (intervals[i][0] < intervals[j][1] &&Explore the full code

solution.javaJava

Brute Force — Check Every Pair — reference

2 teaching notes

1
public boolean canAttendMeetings(int[][] intervals) {
2
    int n = intervals.length;
3
    for (int i = 0; i < n; i++) {
4
        for (int j = i + 1; j < n; j++) {
5
            // First half of the symmetric overlap test — i starts before j ends.
6
            if (intervals[i][0] < intervals[j][1] &&
7
                // Second half — j starts before i ends. Both true ⇒ they overlap.
8
                intervals[j][0] < intervals[i][1]) {
9
                return false;
10
            }
11
        }
12
    }
13
    return true;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(n²) timeO(1) spaceOpen the invariant and proofExplore the proof

All-pairs checking is the honest baseline, but it throws away the fact that overlap is a local property once you order by time. Sorting turns a global pairwise question into a local neighbor question.

ComplexityO(n²) time, O(1) space — n(n−1)/2 pair comparisons in the worst case; no extra storage. Sorting cuts this to O(n) comparisons after an O(n log n) sort.

E · Edge cases and pitfalls5intervals = [] — Outer loop never runs → returns true (nothing to attend).Explore edge cases

Edge cases handled

intervals = []Outer loop never runs → returns true (nothing to attend).
intervals = [[0,30],[30,60]]0 < 60 but 30 < 30 is false → not an overlap → returns true.

Pitfalls

Using `<=` flips the touching rule and wrongly reports back-to-back meetings as conflicts.
O(n²) is needless when sorting gives O(n) comparisons.
Forgetting to return early — no need to keep scanning after the first conflict.

03.2

Approach 2 of 2 · Optimal

Sort by Start, Scan Adjacent (Optimal)

TimeO(n log n)SpaceO(1)

The expected answer. Frame it as 'sort by start; the only possible conflict is with the previous meeting'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

If meetings were sorted by start time, which earlier meeting is the only one that could still be running when the current one begins?

2Hint 2Explore hint

Sort by start. Walk from the second meeting; if its start is before the previous meeting's end, there's a conflict.

3Hint 3Explore hint

Return false on the first conflict; if you reach the end, return true.

A · Core idea

Sort the meetings by start time, then scan once comparing each meeting to its immediate predecessor.

Why adjacency is enough. After sorting by start, the meetings are in non-decreasing start order. Suppose meeting i overlaps some earlier meeting k < i. Because starts are sorted, meeting i−1 also starts no later than i and no earlier than k, and the earliest-ending relevant boundary to worry about is the one right before i. Concretely: if meetings[i].start < meetings[i-1].end, they overlap; if not, i starts at or after i−1 ends, and since every earlier meeting ends no later than... — the cleanest framing is that once sorted, a conflict always shows up between some adjacent pair, so checking all adjacent pairs catches every conflict. No all-pairs loop needed.

The conflict test. meetings[i].start < meetings[i-1].end with strict <. Equality (start == prevEnd) is back-to-back, which is allowed. The instant the test is true, return false; if the scan completes, return true.

Why a boolean, not a merge. Unlike Merge Intervals, we don't build anything — we just need existence of a conflict, so we short-circuit on the first one. That's what keeps this an 'easy': same sort, simpler payload.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

intervals = [[0,30],[5,10],[15,20]] (sorted by start: same order)

Array state

i=1

[5,10] start 5 < 30 → conflict

prev ↓

[0,30]

[0]

i ↓

[5,10]

[1]

[15,20]

[2]

Current pointerResolved stateNot processed

Final resultfalse

C · Code with teaching comments

solution.javaJava

Sort by Start, Scan Adjacent (Optimal) — optimal

3 teaching notes

1
public boolean canAttendMeetings(int[][] intervals) {
2
    // Sort by start so conflicts can only be between neighbors.
3
    Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
4
    for (int i = 1; i < intervals.length; i++) {
5
        // Current meeting starts before the previous ends → overlap. Strict < allows
6
        // back-to-back.
7
        if (intervals[i][0] < intervals[i - 1][1]) {
8
            // One conflict is enough — short-circuit.
9
            return false;
10
        }
11
    }
12
    return true;
13
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.13 lines

D · Why it works and complexityO(n log n) timeO(1) spaceOpen the invariant and proofExplore the proof

Sorting localizes the question: 'do ANY two overlap?' becomes 'does any meeting start before its predecessor ends?'. The same sort-then-neighbor move underlies Merge Intervals — the difference is Meeting Rooms answers yes/no and stops early, while Merge builds the fused list. Recognizing they're the same skeleton makes both automatic.

ComplexityO(n log n) time, O(1) space — Sorting is O(n log n) and dominates; the single neighbor scan is O(n). Sorting in place keeps extra space at O(1) (ignoring sort internals).

E · Edge cases and pitfalls5intervals = [[7,10],[2,4]] — Sorted → [2,4],[7,10]; 7 < 4 is false → no conflict → true.Explore edge cases

Edge cases handled

intervals = [[7,10],[2,4]]Sorted → [2,4],[7,10]; 7 < 4 is false → no conflict → true.
intervals = [[0,30],[30,60],[60,90]]Each starts exactly when the prior ends; 30<30, 60<60 both false → true.

Pitfalls

Forgetting to sort — adjacent comparison is only valid on start-sorted input.
Using `<=` instead of `<` — flags valid back-to-back meetings as conflicts.
Comparing to a running max-end instead of the immediate predecessor (works, but unnecessary here; predecessor end is non-decreasing after sorting by start only if no overlaps — when overlaps exist you've already returned false).

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic boolean canAttendMeetings(int[][] intervals) { Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0])); for (int i = 1; i < intervals.length; i++) { if (intervals[i][0] < intervals[i - 1][1]) { return false;Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Wrong boundary on touching meetings

A meeting ending at t and another starting at t do not conflict. Using <= reports [0,30] and [30,60] as overlapping and returns false incorrectly.

Explore the code comparison

Don't write this

if intervals[i][0] <= intervals[i - 1][1]:   # flags back-to-back
    return False

Write this instead

if intervals[i][0] < intervals[i - 1][1]:    # touching is allowed
    return False

Not sorting before the neighbor scan

The adjacent comparison only catches all conflicts when meetings are ordered by start. On unsorted input a conflict can sit between non-adjacent entries and be missed.

Explore the code comparison

Don't write this

for (int i = 1; i < intervals.length; i++) {   // no sort
    if (intervals[i][0] < intervals[i - 1][1]) return false;
}

Write this instead

Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
for (int i = 1; i < intervals.length; i++) {
    if (intervals[i][0] < intervals[i - 1][1]) return false;
}

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Sort by start, check adjacent overlap

Code pattern to memorize

meetings.sort(by start)
for i in 1..n-1:
    if meetings[i].start < meetings[i-1].end: return False
return True

Rules to remember

1Sort by start first. Then overlaps can only be between neighbors — no need to compare all pairs.
2Conflict test is start[i] < end[i-1] (strict <): a meeting that begins exactly when the prior ends is fine.
3You want a boolean, not a merge — return false the instant you find one conflict.
4Compare each meeting to the immediate predecessor in sorted order, not to a running 'max end'.
5Empty or single-meeting input → trivially true.

Use this pattern when

'Can one person/resource attend/handle ALL intervals?' yes/no question
Detect whether ANY two intervals overlap
Single-resource feasibility check
You need a boolean, not a count or a merged set

Choose another pattern when

'How many rooms?' → max concurrency, min-heap or sweep (LC 253)
'Merge the overlaps' → sort by start, sweep-merge (LC 56)
'Remove fewest to make disjoint' → greedy by end (LC 435)
Endpoints are inclusive (a meeting [1,2] blocks another starting at 2) → use `<=`

Interview takeaway

When you only need to know IF intervals collide, sort by start and look at neighbors — a single adjacent overlap is enough to answer no. It's the lightweight cousin of Merge Intervals: same sort, but you short-circuit on the first conflict instead of building a merged list.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternOverlap-Detection Sweep. Sort by start, then a conflict can only be adjacent — short-circuit on the first. The boolean cousin of Merge Intervals and the warm-up to Meeting Rooms II.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Same pattern

←

Non-overlapping Intervals

Continue · Next problem

Meeting Rooms II

easyIntervalsLC #252Frequently asked

Meeting Rooms

LCPractice

Intervals · 4 of 7 · 6 min

Given an array of meeting time intervals where intervals[i] = [startᵢ, endᵢ], determine if a person could attend all meetings.

In plain English

Examples

Example 1

Input: intervals = [[0,30],[5,10],[15,20]]
Output: false
Note: [0,30] overlaps [5,10] (5 < 30) — the person can't be in two meetings at once.

Example 2

Input: intervals = [[7,10],[2,4]]
Output: true
Note: Sorted: [2,4] then [7,10]. 7 ≥ 4, no overlap — all meetings attendable.

Example 3

Input: intervals = [[0,30],[30,60]]
Output: true
Note: They touch at 30. Back-to-back is allowed, so no conflict.

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ startᵢ < endᵢ ≤ 10⁶
A meeting ending at time t and another starting at t do NOT overlap

Clarifying questions4First question: Does a meeting ending at time t conflict with one starting at t?Explore questions

Q1.Does a meeting ending at time t conflict with one starting at t?
No — back-to-back meetings are fine. So the overlap test is strict: start < previous end.
Q2.Is the input sorted?
No. I'll sort by start so I only have to compare adjacent meetings.
Q3.What should I return for an empty list or a single meeting?
True — with zero or one meeting there's nothing to conflict with.
Q4.Do I need to report which meetings clash, or just yes/no?
Just a boolean. That lets me return early on the first conflict found.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you realize sorting by start reduces 'do any two overlap?' from O(n²) pair-checking to a single neighbor scan.

Where candidates slip

Comparing every pair (O(n²)) instead of sorting, or getting the boundary wrong so a meeting starting exactly when another ends is flagged as a conflict.

How to stand out

Explain why adjacency-after-sorting is sufficient, use strict `<` for the touch-is-ok semantics, and note this is the warm-up to Meeting Rooms II where you count rooms instead of returning a boolean.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Brute Force — Check Every Pair	`O(n²)`	`O(1)`	Say it first to define 'overlap' precisely, then note it's quadratic and sorting fixes that.	Read
2	Sort by Start, Scan Adjacent (Optimal)Optimal	`O(n log n)`	`O(1)`	The expected answer. Frame it as 'sort by start; the only possible conflict is with the previous meeting'.	Read

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Brute Force — Check Every Pair

TimeO(n²)SpaceO(1)

Say it first to define 'overlap' precisely, then note it's quadratic and sorting fixes that.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Two meetings conflict iff a.start < b.end AND b.start < a.end. What's the most direct way to check all of them?

2Hint 2Explore hint

Compare every unordered pair (i, j) with i < j; return false on the first overlap.

3Hint 3Explore hint

It's correct but O(n²). Is there an ordering that makes only neighbors worth comparing?

A · Core idea

The literal reading: a person can attend all meetings unless some two of them overlap, so check all pairs.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

intervals = [[0,30],[5,10],[15,20]]

(0,30)&(5,10)

0 < 10 and 5 < 30 → overlap

Statereturn false

first conflict ends it

Final resultfalse

C · Code with teaching comments

solution.javaJava

Brute Force — Check Every Pair — reference

2 teaching notes

1
public boolean canAttendMeetings(int[][] intervals) {
2
    int n = intervals.length;
3
    for (int i = 0; i < n; i++) {
4
        for (int j = i + 1; j < n; j++) {
5
            // First half of the symmetric overlap test — i starts before j ends.
6
            if (intervals[i][0] < intervals[j][1] &&
7
                // Second half — j starts before i ends. Both true ⇒ they overlap.
8
                intervals[j][0] < intervals[i][1]) {
9
                return false;
10
            }
11
        }
12
    }
13
    return true;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(n²) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(n²) time, O(1) space — n(n−1)/2 pair comparisons in the worst case; no extra storage. Sorting cuts this to O(n) comparisons after an O(n log n) sort.

E · Edge cases and pitfalls5intervals = [] — Outer loop never runs → returns true (nothing to attend).Explore edge cases

Edge cases handled

intervals = []Outer loop never runs → returns true (nothing to attend).
intervals = [[0,30],[30,60]]0 < 60 but 30 < 30 is false → not an overlap → returns true.

Pitfalls

Using `<=` flips the touching rule and wrongly reports back-to-back meetings as conflicts.
O(n²) is needless when sorting gives O(n) comparisons.
Forgetting to return early — no need to keep scanning after the first conflict.

03.2

Approach 2 of 2 · Optimal

Sort by Start, Scan Adjacent (Optimal)

TimeO(n log n)SpaceO(1)

The expected answer. Frame it as 'sort by start; the only possible conflict is with the previous meeting'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

If meetings were sorted by start time, which earlier meeting is the only one that could still be running when the current one begins?

2Hint 2Explore hint

Sort by start. Walk from the second meeting; if its start is before the previous meeting's end, there's a conflict.

3Hint 3Explore hint

Return false on the first conflict; if you reach the end, return true.

A · Core idea

Sort the meetings by start time, then scan once comparing each meeting to its immediate predecessor.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

intervals = [[0,30],[5,10],[15,20]] (sorted by start: same order)

Array state

i=1

[5,10] start 5 < 30 → conflict

prev ↓

[0,30]

[0]

i ↓

[5,10]

[1]

[15,20]

[2]

Current pointerResolved stateNot processed

Final resultfalse

C · Code with teaching comments

solution.javaJava

Sort by Start, Scan Adjacent (Optimal) — optimal

3 teaching notes

1
public boolean canAttendMeetings(int[][] intervals) {
2
    // Sort by start so conflicts can only be between neighbors.
3
    Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
4
    for (int i = 1; i < intervals.length; i++) {
5
        // Current meeting starts before the previous ends → overlap. Strict < allows
6
        // back-to-back.
7
        if (intervals[i][0] < intervals[i - 1][1]) {
8
            // One conflict is enough — short-circuit.
9
            return false;
10
        }
11
    }
12
    return true;
13
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.13 lines

D · Why it works and complexityO(n log n) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(n log n) time, O(1) space — Sorting is O(n log n) and dominates; the single neighbor scan is O(n). Sorting in place keeps extra space at O(1) (ignoring sort internals).

E · Edge cases and pitfalls5intervals = [[7,10],[2,4]] — Sorted → [2,4],[7,10]; 7 < 4 is false → no conflict → true.Explore edge cases

Edge cases handled

intervals = [[7,10],[2,4]]Sorted → [2,4],[7,10]; 7 < 4 is false → no conflict → true.
intervals = [[0,30],[30,60],[60,90]]Each starts exactly when the prior ends; 30<30, 60<60 both false → true.

Pitfalls

Forgetting to sort — adjacent comparison is only valid on start-sorted input.
Using `<=` instead of `<` — flags valid back-to-back meetings as conflicts.
Comparing to a running max-end instead of the immediate predecessor (works, but unnecessary here; predecessor end is non-decreasing after sorting by start only if no overlaps — when overlaps exist you've already returned false).

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Wrong boundary on touching meetings

A meeting ending at t and another starting at t do not conflict. Using <= reports [0,30] and [30,60] as overlapping and returns false incorrectly.

Explore the code comparison

Don't write this

if intervals[i][0] <= intervals[i - 1][1]:   # flags back-to-back
    return False

Write this instead

if intervals[i][0] < intervals[i - 1][1]:    # touching is allowed
    return False

Not sorting before the neighbor scan

The adjacent comparison only catches all conflicts when meetings are ordered by start. On unsorted input a conflict can sit between non-adjacent entries and be missed.

Explore the code comparison

Don't write this

for (int i = 1; i < intervals.length; i++) {   // no sort
    if (intervals[i][0] < intervals[i - 1][1]) return false;
}

Write this instead

Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
for (int i = 1; i < intervals.length; i++) {
    if (intervals[i][0] < intervals[i - 1][1]) return false;
}

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Sort by start, check adjacent overlap

Code pattern to memorize

meetings.sort(by start)
for i in 1..n-1:
    if meetings[i].start < meetings[i-1].end: return False
return True

Rules to remember

1Sort by start first. Then overlaps can only be between neighbors — no need to compare all pairs.
2Conflict test is start[i] < end[i-1] (strict <): a meeting that begins exactly when the prior ends is fine.
3You want a boolean, not a merge — return false the instant you find one conflict.
4Compare each meeting to the immediate predecessor in sorted order, not to a running 'max end'.
5Empty or single-meeting input → trivially true.

Use this pattern when

'Can one person/resource attend/handle ALL intervals?' yes/no question
Detect whether ANY two intervals overlap
Single-resource feasibility check
You need a boolean, not a count or a merged set

Choose another pattern when

'How many rooms?' → max concurrency, min-heap or sweep (LC 253)
'Merge the overlaps' → sort by start, sweep-merge (LC 56)
'Remove fewest to make disjoint' → greedy by end (LC 435)
Endpoints are inclusive (a meeting [1,2] blocks another starting at 2) → use `<=`

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Same pattern

←

Non-overlapping Intervals

Continue · Next problem

Meeting Rooms II