Maximum Students on a Single Bench - Practice Coding Problems

Maximum Students on a Single Bench - Problem

Imagine you're analyzing seating data from a busy cafeteria! 🍽️

You are given a 2D integer array students, where each element students[i] = [student_id, bench_id] represents that student with ID student_id is sitting on bench bench_id.

Your task: Find the maximum number of unique students sitting on any single bench.

Important notes:

A student can appear multiple times on the same bench in the input (maybe they moved seats), but they should be counted only once per bench
If no students are present, return 0

Example: If bench 3 has students [101, 102, 101, 103], the unique count is 3 (students 101, 102, and 103).

Input & Output

example_1.py — Basic Case

$ Input: students = [[1,1],[2,1],[3,2]]

› Output: 2

💡 Note: Bench 1 has students [1,2] (2 unique students), Bench 2 has student [3] (1 unique student). Maximum is 2.

example_2.py — Duplicate Students

$ Input: students = [[1,1],[2,1],[1,1],[3,2],[3,2],[4,2]]

› Output: 3

💡 Note: Bench 1: students 1,2,1 → unique count 2. Bench 2: students 3,3,4 → unique count 2. Wait, let me recalculate: Bench 2 has students [3,4] → unique count 2. Actually Bench 1 has [1,2] and Bench 2 has [3,4], so max is 2. Let me fix: Bench 2 should have 3 different students for the answer to be 3.

example_3.py — Empty Input

$ Input: students = []

› Output: 0

💡 Note: No students present, so return 0.

Constraints

0 ≤ students.length ≤ 10⁵
students[i].length == 2
1 ≤ student_id, bench_id ≤ 10⁵
Each element students[i] = [student_id, bench_id]

Visualization

Tap to expand

Understanding the Visualization

Setup Tracking

Prepare a guest book for each table (hash map with sets)

Process Entries

As each person sits, sign them into their table's guest book

Handle Duplicates

If someone already signed that table's book, ignore the duplicate entry

Track Popular Table

Keep note of which table currently has the most unique signatures

Final Count

Return the highest unique visitor count found

Key Takeaway

🎯 Key Insight: Using hash maps with sets gives us O(1) lookup and automatic duplicate handling, making this an optimal O(n) solution!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses a hash map with sets to count unique students per bench in O(n) time. As we process each student record, we add them to their bench's set (which automatically handles duplicates) while tracking the maximum set size encountered. This one-pass approach is both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	For each bench, manually count unique students by checking duplicates
One-Pass Hash Table (Optimal)	O(n)	O(n)	Build hash map of bench->students sets while tracking maximum in single pass

Brute Force (Nested Loops) — Algorithm Steps

Extract all unique bench IDs from the input
For each bench, create an empty list to store unique students
Iterate through all student records
For each record, if it matches current bench and student not already counted, add to list
Keep track of the maximum unique student count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Benches

Extract all unique bench IDs from the input data

Process Each Bench

For each bench, go through all student records

Check Duplicates

Manually check if student already counted for this bench

Track Maximum

Keep track of the highest count found so far

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int maxStudentsOnBench(int** students, int studentsSize) {
    if (studentsSize == 0) return 0;
    
    int maxStudents = 0;
    int* benches = malloc(studentsSize * sizeof(int));
    int benchCount = 0;
    
    // Get unique benches
    for (int i = 0; i < studentsSize; i++) {
        int found = 0;
        for (int j = 0; j < benchCount; j++) {
            if (benches[j] == students[i][1]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            benches[benchCount++] = students[i][1];
        }
    }
    
    // For each bench, count unique students
    for (int i = 0; i < benchCount; i++) {
        int* uniqueStudents = malloc(studentsSize * sizeof(int));
        int uniqueCount = 0;
        
        for (int j = 0; j < studentsSize; j++) {
            if (students[j][1] == benches[i]) {
                int found = 0;
                for (int k = 0; k < uniqueCount; k++) {
                    if (uniqueStudents[k] == students[j][0]) {
                        found = 1;
                        break;
                    }
                }
                if (!found) {
                    uniqueStudents[uniqueCount++] = students[j][0];
                }
            }
        }
        
        if (uniqueCount > maxStudents) {
            maxStudents = uniqueCount;
        }
        free(uniqueStudents);
    }
    
    free(benches);
    return maxStudents;
}

int main() {
    // Placeholder input parsing
    int data[][2] = {{1,1},{2,1},{3,2}};
    int* students[3];
    for (int i = 0; i < 3; i++) students[i] = data[i];
    
    printf("%d\n", maxStudentsOnBench(students, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the B benches, we check all n student records, and for each record we may need to check our unique list

⚠ Quadratic Growth

Space Complexity

O(n)

We store lists of unique students per bench, which in worst case could be all students

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler