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

Challenge - 5 Problems

❓ Predict Output

intermediate

Minimum Meeting Rooms Required - Output Check

What is the output of the following JavaScript function when given the input intervals [[0, 30], [5, 10], [15, 20]]?

DSA Javascript

function minMeetingRooms(intervals) {
  if (!intervals.length) return 0;
  intervals.sort((a, b) => a[0] - b[0]);
  const heap = [];
  heap.push(intervals[0][1]);
  for (let i = 1; i < intervals.length; i++) {
    if (intervals[i][0] >= heap[0]) {
      heap.shift();
    }
    heap.push(intervals[i][1]);
    heap.sort((a, b) => a - b);
  }
  return heap.length;
}

console.log(minMeetingRooms([[0, 30], [5, 10], [15, 20]]));

A 1

B 3

C 0

D 2

💡 Hint

Think about how many meetings overlap at the same time.

The function sorts intervals by start time and uses a min-heap (simulated by sorting an array) to track end times. It removes the earliest ending meeting if the current meeting starts after or when it ends. The heap size at the end is the minimum number of rooms needed.

For the input, two meetings overlap, so 2 rooms are needed.

❓ Predict Output

intermediate

Minimum Meeting Rooms Required - Different Input

What is the output of the following JavaScript function when given the input intervals [[7, 10], [2, 4]]?

DSA Javascript

function minMeetingRooms(intervals) {
  if (!intervals.length) return 0;
  intervals.sort((a, b) => a[0] - b[0]);
  const heap = [];
  heap.push(intervals[0][1]);
  for (let i = 1; i < intervals.length; i++) {
    if (intervals[i][0] >= heap[0]) {
      heap.shift();
    }
    heap.push(intervals[i][1]);
    heap.sort((a, b) => a - b);
  }
  return heap.length;
}

console.log(minMeetingRooms([[7, 10], [2, 4]]));

A 1

B 3

C 0

D 2

💡 Hint

Check if the meetings overlap or not.

The meetings do not overlap because one ends before the other starts. So only one room is needed.

🔧 Debug

advanced

Identify the Error in Meeting Rooms Code

What error will the following code produce when run with input [[1, 5], [2, 6], [8, 10]]?

DSA Javascript

function minMeetingRooms(intervals) {
  if (!intervals.length) return 0;
  intervals.sort((a, b) => a[0] - b[0]);
  const heap = [];
  heap.push(intervals[0][1]);
  for (let i = 1; i < intervals.length; i++) {
    if (intervals[i][0] >= heap[0]) {
      heap.pop();
    }
    heap.push(intervals[i][1]);
    heap.sort((a, b) => a - b);
  }
  return heap.length;
}

console.log(minMeetingRooms([[1, 5], [2, 6], [8, 10]]));

A TypeError: heap.pop is not a function

B Returns 2

C Returns 3

D Returns 1

💡 Hint

Check how the heap is updated when a meeting ends.

The code uses heap.pop() to remove the earliest ending meeting, but pop() removes the last element, not the first. This causes the heap to grow incorrectly, resulting in returning 3 instead of 2.

🧠 Conceptual

advanced

Understanding the Meeting Rooms Algorithm

Why does sorting the intervals by start time help in finding the minimum number of meeting rooms required?

A It allows processing meetings in the order they start, so we can allocate rooms efficiently as meetings begin.

B It sorts meetings by duration to prioritize shorter meetings first.

C It groups meetings by their end times to reuse rooms immediately after meetings finish.

D It ensures meetings are processed in reverse order to free rooms early.

💡 Hint

Think about how meeting start times relate to room allocation.

Sorting by start time lets us check each meeting in the order they begin. This helps us decide if a room is free or if we need a new one.

🚀 Application

expert

Calculate Minimum Meeting Rooms for Complex Schedule

Given the intervals [[1,4],[2,5],[7,9],[3,6],[10,11],[8,10],[5,7]], what is the minimum number of meeting rooms required?

A 4

B 3

C 2

D 5

💡 Hint

Visualize overlapping intervals and count maximum overlaps.

The maximum number of overlapping meetings at any time is 3, so 3 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 so no meetings overlap

B. The maximum length of a single meeting

C. The total number of meetings scheduled

D. The earliest meeting start time

Solution

1. Step 1: Understand the problem goal

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

2. Step 2: Clarify what is being counted

   We count how many meetings happen at the same time to find the minimum rooms needed.

3. Final Answer:

   The minimum number of meeting rooms needed so no meetings overlap -> Option A

4. Quick Check:

   Minimum rooms = max overlapping meetings [OK]

Hint: Count max overlapping intervals to find rooms needed [OK]

Common Mistakes:

• Confusing total meetings with rooms needed
• Ignoring overlapping times
• Thinking earliest start time is the answer

2. Which of the following JavaScript code snippets correctly sorts an array of meeting intervals by their start time? Assume intervals is an array of objects with 'start' and 'end' properties.

easy

A. intervals.sort((a, b) => b.end - a.end);

B. intervals.sort((a, b) => b.start - a.start);

C. intervals.sort((a, b) => a.end - b.end);

D. intervals.sort((a, b) => a.start - b.start);

Solution

1. Step 1: Identify sorting by start time

   We want to sort intervals by their start property in ascending order.

2. Step 2: Check the sort function

   The comparator (a, b) => a.start - b.start sorts ascending by start time.

3. Final Answer:

   intervals.sort((a, b) => a.start - b.start); -> Option D

4. Quick Check:

   Ascending start time sort = intervals.sort((a, b) => a.start - b.start); [OK]

Hint: Sort intervals by start ascending: (a,b) => a.start - b.start [OK]

Common Mistakes:

• Sorting by end time instead of start
• Sorting descending when ascending needed
• Using incorrect comparator syntax

3. What is the minimum number of meeting rooms required for the following intervals?
const intervals = [{start: 0, end: 30}, {start: 5, end: 10}, {start: 15, end: 20}];

medium

A. 1

B. 2

C. 3

D. 4

Solution

1. Step 1: Analyze overlapping intervals

   Meetings: [0-30], [5-10], [15-20]. The first overlaps with the second and third.

2. Step 2: Count max overlaps

   At time 5-10, two meetings overlap (0-30 and 5-10). At 15-20, two meetings overlap (0-30 and 15-20). Max overlap is 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Max overlapping meetings = 2 rooms needed [OK]

Hint: Find max overlaps by checking intervals start and end times [OK]

Common Mistakes:

• Counting total meetings instead of overlaps
• Assuming 3 rooms because 3 meetings exist
• Ignoring overlap intervals

4. The following code attempts to find the minimum number of meeting rooms needed but has a bug. What is the bug?

function minMeetingRooms(intervals) {
  intervals.sort((a, b) => a.start - b.start);
  let rooms = [];
  for (let meeting of intervals) {
    if (rooms.length === 0 || meeting.start < rooms[rooms.length - 1]) {
      rooms.push(meeting.end);
    } else {
      rooms[rooms.length - 1] = meeting.end;
    }
  }
  return rooms.length;
}

medium

A. It returns the wrong value (should return rooms array)

B. It sorts intervals by end time instead of start time

C. It compares meeting.start with a number incorrectly (rooms array stores end times, but comparison is wrong)

D. It uses push instead of unshift on rooms array

Solution

1. Step 1: Understand rooms array usage

   Rooms array stores end times of meetings currently occupying rooms.

2. Step 2: Check comparison logic

   Comparing meeting.start with rooms[rooms.length - 1] (last end time) is incorrect because rooms should be a min-heap or sorted structure, not just last element.

3. Final Answer:

   It compares meeting.start with a number incorrectly (rooms array stores end times, but comparison is wrong) -> Option C

4. Quick Check:

   Incorrect comparison of start with last end time causes bug [OK]

Hint: Use a min-heap or sorted structure for end times, not last element [OK]

Common Mistakes:

• Comparing start with last end time without sorting
• Not using a priority queue for room end times
• Returning wrong variable

5. Given the intervals [[1,4],[2,5],[7,9],[6,10],[8,11]], what is the minimum number of meeting rooms required? Explain your reasoning.

hard

A. 3

B. 2

C. 4

D. 5

Solution

1. Step 1: Sort intervals by start time

   Sorted intervals: [1,4], [2,5], [6,10], [7,9], [8,11]

2. Step 2: Track overlapping meetings

   Between 1-5, two meetings overlap ([1,4] and [2,5]). Between 6-11, three meetings overlap ([6,10], [7,9], [8,11]). Max overlap is 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Max overlapping meetings = 3 rooms needed [OK]

Hint: Find max overlaps by checking intervals start and end times carefully [OK]

Common Mistakes:

• Not sorting intervals before checking overlaps
• Counting total meetings instead of max overlaps
• Missing overlaps in later intervals