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

Challenge - 5 Problems

❓ Predict Output

intermediate

Minimum Meeting Rooms Required - Output Check

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

DSA Typescript

function minMeetingRooms(intervals: number[][]): number {
  if (intervals.length === 0) return 0;
  const starts = intervals.map(i => i[0]).sort((a, b) => a - b);
  const ends = intervals.map(i => i[1]).sort((a, b) => a - b);
  let rooms = 0, endIndex = 0;
  for (let i = 0; i < starts.length; i++) {
    if (starts[i] < ends[endIndex]) {
      rooms++;
    } else {
      endIndex++;
    }
  }
  return rooms;
}

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

A 1

B 3

C 2

D 0

💡 Hint

Think about how many meetings overlap at the same time.

The code sorts start and end times separately and uses two pointers to track overlaps. It increments rooms when a meeting starts before the earliest ending meeting ends. For the input, two meetings overlap, so minimum rooms needed is 2.

❓ Predict Output

intermediate

Minimum Meeting Rooms - Different Input

What is the output of this TypeScript function for the given meeting intervals?

DSA Typescript

function minMeetingRooms(intervals: number[][]): number {
  if (intervals.length === 0) return 0;
  const starts = intervals.map(i => i[0]).sort((a, b) => a - b);
  const ends = intervals.map(i => i[1]).sort((a, b) => a - b);
  let rooms = 0, endIndex = 0;
  for (let i = 0; i < starts.length; i++) {
    if (starts[i] < ends[endIndex]) {
      rooms++;
    } else {
      endIndex++;
    }
  }
  return rooms;
}

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

A 1

B 2

C 3

D 0

💡 Hint

Check if any meetings overlap.

The meetings [7,10] and [2,4] do not overlap, so only one room is needed.

🧠 Conceptual

advanced

Understanding the Two Pointer Technique in Meeting Rooms

In the minimum meeting rooms problem, why do we sort start and end times separately and use two pointers to traverse them?

A To merge intervals into one big interval for easier counting.

B To sort meetings by their duration instead of start time.

C To find the longest meeting duration by comparing starts and ends.

D To efficiently track when meetings start and end to count overlaps without checking every pair.

💡 Hint

Think about how to detect overlapping intervals efficiently.

Sorting starts and ends separately allows us to move through meetings in chronological order, counting how many meetings overlap at any time by comparing start times with earliest end times.

🔧 Debug

advanced

Identify the Bug in Meeting Rooms Code

What error or wrong output will this TypeScript code produce when calculating minimum meeting rooms?

DSA Typescript

function minMeetingRooms(intervals: number[][]): number {
  if (intervals.length === 0) return 0;
  const starts = intervals.map(i => i[0]).sort();
  const ends = intervals.map(i => i[1]).sort();
  let rooms = 0, endIndex = 0;
  for (let i = 0; i < starts.length; i++) {
    if (starts[i] < ends[endIndex]) {
      rooms++;
    } else {
      endIndex++;
    }
  }
  return rooms;
}

console.log(minMeetingRooms([[1, 3], [2, 4], [10, 12]]));

A Throws a TypeError at runtime

B Returns 3 (incorrect number of rooms)

C Returns 2 (correct output)

D Returns 1 (incorrect number of rooms)

💡 Hint

Check how the sort method is used on numbers.

The code uses sort() without a compare function, so it sorts numbers as strings, causing incorrect order and wrong room count.

🚀 Application

expert

Calculate Minimum Meeting Rooms for Complex Schedule

Given the following meeting intervals, what is the minimum number of meeting rooms required?

DSA Typescript

function minMeetingRooms(intervals: number[][]): number {
  if (intervals.length === 0) return 0;
  const starts = intervals.map(i => i[0]).sort((a, b) => a - b);
  const ends = intervals.map(i => i[1]).sort((a, b) => a - b);
  let rooms = 0, endIndex = 0;
  for (let i = 0; i < starts.length; i++) {
    if (starts[i] < ends[endIndex]) {
      rooms++;
    } else {
      endIndex++;
    }
  }
  return rooms;
}

console.log(minMeetingRooms([[1, 5], [2, 6], [4, 8], [9, 10], [9, 12], [11, 15]]));

A 3

B 4

C 2

D 5

💡 Hint

Count maximum overlaps carefully.

The maximum number of overlapping meetings is 3 during intervals [4,5] and [9,10].

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 maximum duration of a single meeting

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

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 meetings overlap in the same room.

2. Step 2: Clarify what is NOT asked

   It is not about meeting durations, counts, or earliest times, but about room allocation to avoid conflicts.

3. Final Answer:

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

4. Quick Check:

   Minimum rooms = no overlapping meetings [OK]

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

Common Mistakes:

• Confusing total meetings with rooms needed
• Thinking about meeting length instead of overlaps
• Ignoring overlapping intervals

2. Which TypeScript code snippet correctly sorts an array of meeting intervals by their start time?

easy

A. intervals.sort((a, b) => a[0] + b[0]);

B. intervals.sort((a, b) => b[1] - a[1]);

C. intervals.sort((a, b) => a[1] - b[0]);

D. intervals.sort((a, b) => a[0] - b[0]);

Solution

1. Step 1: Identify sorting by start time

   We want to sort intervals by their start time, which is the first element in each interval array.

2. Step 2: Check the sorting function

   The correct comparator subtracts start times: a[0] - b[0]. This sorts ascending by start time.

3. Final Answer:

   intervals.sort((a, b) => a[0] - b[0]); -> Option D

4. Quick Check:

   Sort by start time = a[0] - b[0] [OK]

Hint: Sort intervals by start time using a[0] - b[0] [OK]

Common Mistakes:

• Sorting by end time instead of start time
• Using addition instead of subtraction in comparator
• Mixing start and end indices in comparator

3. Given the following TypeScript code, what is the output?

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

function minMeetingRooms(intervals: number[][]): number {
  intervals.sort((a, b) => a[0] - b[0]);
  const heap: number[] = [];

  for (const interval of intervals) {
    if (heap.length && heap[0] <= interval[0]) {
      heap.shift();
    }
    heap.push(interval[1]);
    heap.sort((a, b) => a - b);
  }

  return heap.length;
}

console.log(minMeetingRooms(intervals));

medium

A. 2

B. 3

C. 1

D. 0

Solution

1. Step 1: Sort intervals by start time

   Sorted intervals: [[0,30], [5,10], [15,20]] (already sorted)

2. Step 2: Simulate heap to track end times

   First interval: heap = [30] Second interval starts at 5, heap[0]=30 > 5, so no removal, heap = [30,10], sorted to [10,30] Third interval starts at 15, heap[0]=10 <= 15, remove 10, heap = [30], then add 20, heap = [20,30]

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Max overlapping meetings = 2 rooms needed [OK]

Hint: Track earliest end time to reuse rooms [OK]

Common Mistakes:

• Not sorting intervals before processing
• Not removing ended meetings from heap
• Assuming heap length equals total meetings

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

function minMeetingRooms(intervals: number[][]): number {
  intervals.sort((a, b) => a[1] - b[1]);
  const heap: number[] = [];

  for (const interval of intervals) {
    if (heap.length && heap[0] <= interval[0]) {
      heap.shift();
    }
    heap.push(interval[1]);
    heap.sort((a, b) => a - b);
  }

  return heap.length;
}

medium

A. Intervals are sorted by end time instead of start time

B. Heap is not sorted after push

C. The condition to remove from heap is incorrect

D. The function returns the wrong value

Solution

1. Step 1: Check sorting criteria

   The intervals are sorted by end time (a[1] - b[1]) but should be sorted by start time to process meetings in order.

2. Step 2: Understand impact of wrong sorting

   Sorting by end time breaks the logic of checking overlaps because meetings are not processed in chronological start order.

3. Final Answer:

   Intervals are sorted by end time instead of start time -> Option A

4. Quick Check:

   Sort by start time, not end time [OK]

Hint: Always sort intervals by start time first [OK]

Common Mistakes:

• Sorting by end time instead of start time
• Not sorting heap after insertion
• Incorrect condition to remove ended meetings

5. You have the following 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. 3

D. 1

Solution

1. Step 1: Sort intervals by start time

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

2. Step 2: Track overlapping meetings

   At time 1: room count = 1 At time 2: overlaps with [1,4], rooms = 2 At time 3: overlaps with [1,4] and [2,5], rooms = 3 At time 7: previous meetings ended, rooms = 1 At time 10: rooms = 1

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Max overlaps = 3 rooms needed [OK]

Hint: Count max overlaps at any time for rooms needed [OK]

Common Mistakes:

• Not sorting intervals before counting overlaps
• Underestimating overlaps by ignoring simultaneous meetings
• Assuming one room fits all meetings