Meeting Rooms Problem Minimum Rooms Required in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Minimum meeting rooms needed for given intervals

What is the output of the following code that calculates the minimum number of meeting rooms required?

DSA Python

def minMeetingRooms(intervals):
    starts = sorted([i[0] for i in intervals])
    ends = sorted([i[1] for i in intervals])
    s, e = 0, 0
    rooms = 0
    while s < len(intervals):
        if starts[s] < ends[e]:
            rooms += 1
            s += 1
        else:
            e += 1
            s += 1
    return rooms

intervals = [[0, 30], [5, 10], [15, 20]]
print(minMeetingRooms(intervals))

A 0

B 2

C 1

D 3

💡 Hint

Think about how many meetings overlap at the same time.

The code sorts start and end times separately. It increments rooms when a meeting starts before the earliest ending meeting ends. Here, three meetings overlap at some point, so 3 rooms are needed.

❓ Predict Output

intermediate

Output for non-overlapping meetings

What is the output of this code for non-overlapping meeting intervals?

DSA Python

def minMeetingRooms(intervals):
    starts = sorted([i[0] for i in intervals])
    ends = sorted([i[1] for i in intervals])
    s, e = 0, 0
    rooms = 0
    while s < len(intervals):
        if starts[s] < ends[e]:
            rooms += 1
            s += 1
        else:
            e += 1
            s += 1
    return rooms

intervals = [[1, 2], [3, 4], [5, 6]]
print(minMeetingRooms(intervals))

A 1

B 2

C 3

D 0

💡 Hint

No meetings overlap here.

Since no meetings overlap, only one room is needed at any time.

🔧 Debug

advanced

Identify the error in meeting rooms calculation

What error does this code raise when run?

DSA Python

def minMeetingRooms(intervals):
    starts = sorted([i[0] for i in intervals])
    ends = sorted([i[1] for i in intervals])
    s, e = 0, 0
    rooms = 0
    while s < len(intervals):
        if starts[s] <= ends[e]:
            rooms += 1
            s += 1
        else:
            e += 1
    return rooms

intervals = [[0, 30], [5, 10], [15, 20]]
print(minMeetingRooms(intervals))

A 0

B IndexError

C 3

D TypeError

💡 Hint

Check the loop increments carefully.

The code increments s only in the if branch but not in else, causing an infinite loop or IndexError when s exceeds length.

🧠 Conceptual

advanced

Why sorting start and end times separately helps?

Why do we sort start and end times separately when calculating minimum meeting rooms?

A To compare meetings in chronological order and track overlaps efficiently

B To find the longest meeting duration

C To count total number of meetings only

D To merge intervals into one big interval

💡 Hint

Think about how to detect overlaps by comparing start and end times.

Sorting start and end times separately allows us to iterate through meetings in order and count how many overlap at any time, which determines rooms needed.

❓ Predict Output

expert

Minimum rooms for complex overlapping intervals

What is the output of this code for complex overlapping intervals?

DSA Python

def minMeetingRooms(intervals):
    starts = sorted([i[0] for i in intervals])
    ends = sorted([i[1] for i in intervals])
    s, e = 0, 0
    rooms = 0
    max_rooms = 0
    while s < len(intervals):
        if starts[s] < ends[e]:
            rooms += 1
            max_rooms = max(max_rooms, rooms)
            s += 1
        else:
            rooms -= 1
            e += 1
    return max_rooms

intervals = [[1, 10], [2, 7], [3, 19], [8, 12], [10, 20], [11, 30]]
print(minMeetingRooms(intervals))

A 4

B 3

C 5

D 6

💡 Hint

Count maximum overlaps at any time.

The maximum number of overlapping meetings is 5 at some point, so 5 rooms are needed.

Practice

1. What does the "Meeting Rooms Problem Minimum Rooms Required" ask you to find given a list of meeting time intervals?

easy

A. The minimum number of meeting rooms needed to hold all meetings without overlap

B. The maximum duration of a single meeting

C. The total number of meetings scheduled

D. The earliest start time among all meetings

Solution

1. Step 1: Understand the problem goal

   The problem asks for the minimum number of rooms needed so that no two meetings overlap in the same room.

2. Final Answer:

   The minimum number of meeting rooms needed to hold all meetings without overlap -> Option A

3. Quick Check:

   Minimum rooms = rooms needed to avoid overlap [OK]

Hint: Count overlaps to find minimum rooms needed [OK]

Common Mistakes:

• Confusing total meetings with rooms needed
• Ignoring overlapping intervals
• Counting meeting duration instead of rooms

2. Which of the following Python code snippets correctly sorts a list of meeting intervals by their start time?

easy

A. intervals.sort(key=lambda x: x[1])

B. intervals.sort(key=lambda x: x[0])

C. intervals.sort()

D. intervals.sort(key=lambda x: x)

Solution

1. Step 1: Identify sorting by start time

   Each interval is a list or tuple like [start, end]. Sorting by x[0] sorts by start time.

2. Step 2: Check other options

   Sorting by x[1] sorts by end time, sort() without key sorts lexicographically (primarily by start but also end), lambda x: x sorts by whole interval.

3. Final Answer:

   intervals.sort(key=lambda x: x[0]) -> Option B

4. Quick Check:

   Sort by start time = key=lambda x: x[0] [OK]

Hint: Sort intervals by start time using key=lambda x: x[0] [OK]

Common Mistakes:

• Sorting by end time instead of start time
• Using sort() without key on lists of lists
• Confusing lambda syntax

3. What is the output of the following Python code that calculates minimum meeting rooms needed?

intervals = [[0, 30], [5, 10], [15, 20]]
starts = sorted([i[0] for i in intervals])
ends = sorted([i[1] for i in intervals])
rooms = 0
end_ptr = 0
for start in starts:
    if start < ends[end_ptr]:
        rooms += 1
    else:
        end_ptr += 1
print(rooms)

medium

A. 1

B. 3

C. 2

D. 0

Solution

1. Step 1: Sort start and end times

   starts = [0,5,15], ends = [10,20,30]. Initialize rooms=0, end_ptr=0.

2. Step 2: Trace the loop

   - start=0 < ends[0]=10: yes, rooms=1 (end_ptr=0)
   - start=5 < ends[0]=10: yes, rooms=2 (end_ptr=0)
   - start=15 < ends[0]=10: no, end_ptr=1
   Final rooms=2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Maximum concurrent meetings = 2 [OK]

Hint: Compare starts with earliest end to count rooms [OK]

Common Mistakes:

• Not moving end pointer correctly
• Counting rooms too many times
• Mixing start and end comparisons

4. The following code is intended to find the minimum number of meeting rooms needed. What is the bug?

def minMeetingRooms(intervals):
    starts = sorted([i[0] for i in intervals])
    ends = sorted([i[1] for i in intervals])
    rooms = 0
    end_ptr = 0
    for start in starts:
        if start > ends[end_ptr]:
            end_ptr += 1
        else:
            rooms += 1
    return rooms

print(minMeetingRooms([[0, 30], [5, 10], [15, 20]]))

medium

A. The comparison should be start < ends[end_ptr], not start > ends[end_ptr]

B. The ends list is not sorted

C. The rooms variable is not initialized

D. The function does not return any value

Solution

1. Step 1: Analyze the comparison logic

   The code uses if start > ends[end_ptr] to advance end_ptr, but correct logic requires advancing when start >= ends[end_ptr] (or equivalently, increment rooms when start < ends[end_ptr]).

2. Step 2: Understand impact

   Wrong comparison fails when start == ends[end_ptr], incorrectly counting extra room.

3. Final Answer:

   The comparison should be start < ends[end_ptr], not start > ends[end_ptr] -> Option A

4. Quick Check:

   Correct comparison fixes room count [OK]

Hint: Use start < ends[end_ptr] to check overlap [OK]

Common Mistakes:

• Using wrong comparison operator
• Not sorting ends list
• Forgetting to increment end pointer

5. Given the meeting intervals [[1, 4], [2, 5], [7, 9], [3, 6], [10, 11]], what is the minimum number of meeting rooms required to schedule all meetings without overlap?

hard

A. 4

B. 2

C. 1

D. 3

Solution

1. Step 1: Sort start and end times

   starts = [1,2,3,7,10], ends = [4,5,6,9,11].

2. Step 2: Simulate two-pointer algorithm

   rooms=0, end_ptr=0
   - start=1 < 4: rooms=1
   - start=2 < 4: rooms=2
   - start=3 < 4: rooms=3
   - start=7 < 4: no, end_ptr=1
   - start=10 < 5: no, end_ptr=2
   The final rooms value (3) is the max concurrent meetings needed.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Max overlap (e.g., [1,4],[2,5],[3,6]) = 3 [OK]

Hint: Track overlaps by comparing starts and ends [OK]

Common Mistakes:

• Not updating end pointer correctly
• Counting all meetings as overlapping
• Ignoring meeting end times