Minimum Number of Platforms in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to sort the arrival times array.

DSA Java

Arrays.[1](arrivals);

Drag options to blanks, or click blank then click option'

Areverse

Bsort

CcopyOf

Dfill

Attempts:

3 left

💡 Hint

Common Mistakes

Using reverse() instead of sort()

Trying to fill the array instead of sorting

We use Arrays.sort() to sort the arrival times in ascending order.

2fill in blank

medium

Complete the code to check if a train has departed before the next arrives.

DSA Java

if (departures[i] [1] arrivals[j]) {

Drag options to blanks, or click blank then click option'

A<=

B>

C==

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using greater than operator instead of less than or equal

Using equality operator only

We check if the departure time is less than or equal to the next arrival time to free a platform.

3fill in blank

hard

Fix the error in updating the maximum platforms needed.

DSA Java

maxPlatforms = Math.[1](maxPlatforms, platformsNeeded);

Drag options to blanks, or click blank then click option'

Amax

Bmin

Cabs

Dround

Attempts:

3 left

💡 Hint

Common Mistakes

Using Math.min() which gives the smaller value

Using Math.abs() which returns absolute value

We use Math.max() to keep track of the highest number of platforms needed at any time.

4fill in blank

hard

Fill both blanks to correctly iterate and update platform counts.

DSA Java

while (i < n && j < n) {
    if (arrivals[i] [1] departures[j]) {
        platformsNeeded++;
        maxPlatforms = Math.max(maxPlatforms, platformsNeeded);
        i++;
    } else {
        platformsNeeded[2];
        j++;
    }
}

Drag options to blanks, or click blank then click option'

A<=

B--

C++

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using > instead of <= in comparison

Incrementing platforms when a train departs

We increase platforms when arrival is before or at departure, and decrease when a train departs.

5fill in blank

hard

Fill all three blanks to create a map of arrival times to platform counts for visualization.

DSA Java

Map<Integer, Integer> platformMap = new HashMap<>();
for (int k = 0; k < n; k++) {
    platformMap.put(arrivals[k], platformMap.getOrDefault([1], [2]) [3] 1);
}

Drag options to blanks, or click blank then click option'

Aarrivals[k]

B0

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong key in getOrDefault

Using subtraction instead of addition

We use arrivals[k] as key, default 0 if not present, and add 1 to count platforms.

Practice

1. What does the "Minimum Number of Platforms" problem ask you to find given train arrival and departure times?

easy

A. The least number of platforms needed so no train waits

B. The total number of trains arriving in a day

C. The longest time a train stays on a platform

D. The earliest train arrival time

Solution

1. Step 1: Understand the problem goal

   The problem asks for the minimum number of platforms required so that no train has to wait for another to leave.

2. Step 2: Clarify what is being counted

   We count how many trains overlap in time on the station to find the minimum platforms needed.

3. Final Answer:

   The least number of platforms needed so no train waits -> Option A

4. Quick Check:

   Minimum platforms = max trains overlapping [OK]

Hint: Count overlapping trains to find minimum platforms needed [OK]

Common Mistakes:

• Confusing total trains with platforms needed
• Ignoring overlapping times
• Counting earliest arrival only

2. Which Java data structure is best suited to efficiently find the minimum number of platforms needed given sorted arrival and departure arrays?

easy

A. PriorityQueue (Min-Heap)

B. Stack

C. LinkedList

D. HashMap

Solution

1. Step 1: Identify the need for quick minimum departure tracking

   We need to know the earliest train departure to free a platform, so a min-heap helps track minimum departure time efficiently.

2. Step 2: Match data structure to problem

   PriorityQueue in Java is a min-heap, perfect for this use case to manage platforms dynamically.

3. Final Answer:

   PriorityQueue (Min-Heap) -> Option A

4. Quick Check:

   Min-heap tracks earliest departure [OK]

Hint: Use min-heap to track earliest departure times [OK]

Common Mistakes:

• Using HashMap which doesn't maintain order
• Using Stack which is LIFO, not suitable
• Using LinkedList which is inefficient for min queries

3. What is the output of the following Java code snippet that calculates minimum platforms?

int[] arrivals = {900, 940, 950, 1100, 1500, 1800};
int[] departures = {910, 1200, 1120, 1130, 1900, 2000};
System.out.println(minPlatforms(arrivals, departures));

// Assume minPlatforms returns the minimum platforms needed

medium

A. 2

B. 4

C. 3

D. 5

Solution

1. Step 1: Sort arrival and departure times

   Arrivals: 900, 940, 950, 1100, 1500, 1800 Departures: 910, 1120, 1130, 1200, 1900, 2000

2. Step 2: Count overlapping trains

   At 900-910: 1 train At 940-1120: 2 trains overlap At 950-1130: 3 trains overlap (max) After 1130, trains start leaving, so max platforms needed = 3

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Max overlap = 3 platforms [OK]

Hint: Find max overlapping intervals after sorting [OK]

Common Mistakes:

• Not sorting times before processing
• Counting total trains instead of overlaps
• Mixing arrival and departure arrays

4. Identify the bug in this Java method to find minimum platforms:

public static int minPlatforms(int[] arr, int[] dep) {
    Arrays.sort(arr);
    Arrays.sort(dep);
    int i = 0, j = 0, platforms = 0, maxPlatforms = 0;
    while (i < arr.length && j < dep.length) {
        if (arr[i] <= dep[j]) {
            platforms++;
            i++;
        } else {
            platforms--;
            j++;
        }
        maxPlatforms = Math.max(maxPlatforms, platforms);
    }
    return maxPlatforms;
}

medium

A. The loop should run while i < arr.length only

B. The condition should be arr[i] < dep[j] instead of <= to avoid counting simultaneous arrival and departure

C. The platforms variable should not be decremented

D. Arrays.sort should be called only on arrivals

Solution

1. Step 1: Analyze the comparison condition

   The condition arr[i] <= dep[j] counts a train arriving exactly when another departs as overlapping, increasing platforms unnecessarily.

2. Step 2: Correct the condition to avoid overcounting

   Changing to arr[i] < dep[j] treats simultaneous arrival and departure as no overlap, which is correct for platform counting.

3. Final Answer:

   The condition should be arr[i] < dep[j] instead of <= to avoid counting simultaneous arrival and departure -> Option B

4. Quick Check:

   Use strict less than for arrival vs departure [OK]

Hint: Use < not <= to avoid counting simultaneous arrival and departure [OK]

Common Mistakes:

• Using <= causes overcounting platforms
• Not sorting both arrays
• Incorrect loop condition

5. Given arrival times [1000, 1010, 1025, 1030, 1040] and departure times [1020, 1035, 1045, 1050, 1100], what is the minimum number of platforms needed if trains arriving exactly when another departs do NOT require a new platform?

hard

A. 4

B. 5

C. 2

D. 3

Solution

1. Step 1: Sort and analyze arrival and departure times

   Arrivals: 1000, 1010, 1025, 1030, 1040 Departures: 1020, 1035, 1045, 1050, 1100

2. Step 2: Count overlapping trains considering no extra platform if arrival equals departure

   1000-1020: 1 train 1010-1035: overlaps with first, total 2 1025-1045: first gone at 1020, overlaps with second, total 2 1030-1050: overlaps with second (till 1035) and third (till 1045), total 3 1040-1100: second gone at 1035, overlaps with third, fourth, total 3 (max)

3. Step 3: Adjust for arrival equals departure rule

   No arrivals equal departures here, so max platforms = 3

4. Final Answer:

   3 -> Option D

5. Quick Check:

   Max overlap = 3 platforms [OK]

Hint: Count overlaps, exclude equal arrival and departure as overlap [OK]

Common Mistakes:

• Counting equal arrival and departure as overlap
• Not sorting times
• Miscounting overlaps