Minimum Number of Platforms in DSA C# - Build from Scratch

Minimum Number of Platforms

📖 Scenario: You are managing a small train station. You want to find out the minimum number of platforms needed so that no train has to wait.Each train has an arrival time and a departure time.

🎯 Goal: Build a program that calculates the minimum number of platforms required for the trains given their arrival and departure times.

📋 What You'll Learn

Create two arrays called arrivals and departures with exact train times.

Create an integer variable called platforms_needed to track platforms required.

Write a loop to find the minimum number of platforms needed using the arrival and departure arrays.

Print the final number of platforms needed.

💡 Why This Matters

🌍 Real World

Train stations and airports use this logic to manage platforms or gates efficiently to avoid delays.

💼 Career

This problem teaches scheduling and resource allocation skills useful in software engineering and operations roles.

1

Create train arrival and departure arrays

Create two integer arrays called arrivals and departures with these exact values:
arrivals = new int[] {900, 940, 950, 1100, 1500, 1800};
departures = new int[] {910, 1200, 1120, 1130, 1900, 2000};

DSA C#

# Your code here

Hint

Use int[] to create arrays and assign the exact times given.

2

Create a variable to track platforms needed

Create an integer variable called platforms_needed and set it to 1 to start counting platforms.

DSA C#

int[] arrivals = new int[] {900, 940, 950, 1100, 1500, 1800};
int[] departures = new int[] {910, 1200, 1120, 1130, 1900, 2000};
# Your code here

Hint

Start with 1 platform since at least one train will arrive.

3

Calculate minimum platforms needed

Write code to calculate the minimum number of platforms needed.
First, sort the arrivals and departures arrays.
Then use two integer variables i and j starting at 1 and 0 respectively.
Use a while loop that runs while i < arrivals.Length and j < departures.Length.
Inside the loop, if arrivals[i] <= departures[j], increment platforms_needed and i.
Else, decrement platforms_needed and increment j.
Keep track of the maximum platforms needed in an integer variable called max_platforms.

DSA C#

int[] arrivals = new int[] {900, 940, 950, 1100, 1500, 1800};
int[] departures = new int[] {910, 1200, 1120, 1130, 1900, 2000};
int platforms_needed = 1;
// Your code here

Hint

Sort the arrays first. Use two pointers to compare arrival and departure times. Increase or decrease platforms needed accordingly. Track the maximum platforms needed.

4

Print the minimum number of platforms needed

Print the value of max_platforms to show the minimum number of platforms required.

DSA C#

using System;

class Program
{
    static void Main()
    {
        int[] arrivals = new int[] {900, 940, 950, 1100, 1500, 1800};
        int[] departures = new int[] {910, 1200, 1120, 1130, 1900, 2000};
        Array.Sort(arrivals);
        Array.Sort(departures);

        int platforms_needed = 1;
        int max_platforms = 1;
        int i = 1, j = 0;

        while (i  max_platforms)
                    max_platforms = platforms_needed;
            }
            else
            {
                platforms_needed--;
                j++;
            }
        }
        // Your code here
    }
}

Hint

Use Console.WriteLine(max_platforms); to print the result.

Practice

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

easy

A. The total time trains spend at the station

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

C. The maximum speed of any train

D. The total number of trains arriving in a day

Solution

1. Step 1: Understand the problem context

   The problem wants to find how many platforms are needed so that no train has to wait for another to leave.

2. Step 2: Identify the key output

   The output is the minimum number of platforms required to handle all trains without delay.

3. Final Answer:

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

4. Quick Check:

   Minimum platforms = no waiting trains [OK]

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

Common Mistakes:

• Confusing total trains with platforms needed
• Ignoring overlapping arrival and departure times
• Thinking about train speed or duration instead

2. Which of the following C# code snippets correctly declares arrays for arrival and departure times for the Minimum Number of Platforms problem?

easy

A. int arrival = [900, 940, 950]; int departure = [910, 1200, 1120];

B. int arrival[] = (900, 940, 950); int departure[] = (910, 1200, 1120);

C. int[] arrival = {900, 940, 950}; int[] departure = {910, 1200, 1120};

D. int[] arrival = (900, 940, 950); int[] departure = (910, 1200, 1120);

Solution

1. Step 1: Recall C# array declaration syntax

   In C#, arrays are declared with type[], and values inside curly braces {}.

2. Step 2: Check each option for correct syntax

   int[] arrival = {900, 940, 950}; int[] departure = {910, 1200, 1120}; uses int[] and curly braces {}, which is correct. Others use parentheses or wrong syntax.

3. Final Answer:

   int[] arrival = {900, 940, 950}; int[] departure = {910, 1200, 1120}; -> Option C

4. Quick Check:

   C# arrays use type[] and {} [OK]

Hint: Use int[] and curly braces {} for arrays in C# [OK]

Common Mistakes:

• Using parentheses () instead of curly braces {}
• Declaring arrays without [] after type
• Using square brackets [] for initialization

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

int[] arrival = {900, 940, 950, 1100, 1500, 1800};
int[] departure = {910, 1200, 1120, 1130, 1900, 2000};

int platforms = CalculateMinPlatforms(arrival, departure);
Console.WriteLine(platforms);

// Assume CalculateMinPlatforms correctly implements the algorithm.

medium

A. 5

B. 4

C. 2

D. 3

Solution

1. Step 1: Sort arrival and departure times

   Arrival: 900, 940, 950, 1100, 1500, 1800 Departure: 910, 1120, 1130, 1200, 1900, 2000

2. Step 2: Count overlapping trains to find max platforms

   At 950, trains at 900, 940, 950 overlap (3 trains). Later overlaps are fewer.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Max overlap = 3 platforms [OK]

Hint: Find max overlapping intervals for minimum platforms [OK]

Common Mistakes:

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

4. Identify the error in this C# code snippet for calculating minimum platforms:

int[] arrival = {900, 940, 950};
int[] departure = {910, 1200, 1120};

Array.Sort(arrival);
Array.Sort(departure);

int i = 0, j = 0, platforms = 0, maxPlatforms = 0;
while (i < arrival.Length && j < departure.Length) {
    if (arrival[i] <= departure[j]) {
        platforms++;
        i++;
    } else {
        platforms--;
        j++;
    }
    maxPlatforms = Math.Max(maxPlatforms, platforms);
}
Console.WriteLine(maxPlatforms);

medium

A. The comparison should be 'arrival[i] < departure[j]' instead of '<='

B. The loop condition should be 'i < arrival.Length || j < departure.Length'

C. The arrays should not be sorted before processing

D. The platforms variable should not be incremented

Solution

1. Step 1: Analyze the comparison operator in the loop

   Using '<=' causes counting a train as arriving exactly when another departs, increasing platforms unnecessarily.

2. Step 2: Correct comparison to '<' to avoid overlap at exact departure time

   Changing to '<' means a train arriving at the same time another departs does not increase platform count.

3. Final Answer:

   The comparison should be 'arrival[i] < departure[j]' instead of '<=' -> Option A

4. Quick Check:

   Use '<' to avoid counting simultaneous arrival and departure as overlap [OK]

Hint: Use '<' not '<=' when comparing arrival and departure [OK]

Common Mistakes:

• Using '<=' causes overcounting platforms
• Not sorting arrays before processing
• Incorrect loop condition causing missed trains

5. Given arrival times [900, 940, 950, 1100, 1500, 1800] and departure times [910, 1200, 1120, 1130, 1900, 2000], how would you modify the algorithm to also return the time intervals when the maximum number of platforms are needed?

hard

A. Track intervals when platform count equals max during iteration and store them

B. Return only the maximum platform count without intervals

C. Sort only arrival times and ignore departure times

D. Count total trains without checking overlaps

Solution

1. Step 1: Modify algorithm to track platform count changes

   While iterating, record start time when platforms reach max and end time when count drops.

2. Step 2: Store intervals where platform count equals maximum

   Keep a list of intervals with max platforms to return after processing all times.

3. Final Answer:

   Track intervals when platform count equals max during iteration and store them -> Option A

4. Quick Check:

   Record max platform intervals during count updates [OK]

Hint: Save start/end times when platform count hits max [OK]

Common Mistakes:

• Ignoring time intervals, returning only counts
• Not updating intervals when platform count changes
• Sorting only one array causing wrong intervals