Number of Students Unable to Eat Lunch - Practice Coding Problems

Number of Students Unable to Eat Lunch - Problem

Welcome to the school cafeteria lunch rush! 🍽️

The cafeteria serves two types of sandwiches: circular sandwiches (0) and square sandwiches (1). Students are lined up in a queue, each with their own preference for either circular or square sandwiches.

Here's how the lunch process works:

🥪 Sandwiches are placed in a stack (top sandwich served first)
👥 Students wait in a queue (front student gets served first)
✅ If the front student likes the top sandwich → they take it and leave
❌ If the front student doesn't like the top sandwich → they go to the back of the queue

The process continues until no remaining students want the current top sandwich, meaning some students will go hungry! 😢

Your task: Given the sandwich stack and student preferences, determine how many students will be unable to eat lunch.

Input: Two arrays - students[] (preferences in queue order) and sandwiches[] (sandwich types in stack order)

Output: Number of students who cannot get their preferred sandwich

Input & Output

example_1.py — Basic Case

$ Input: students = [1,1,0,0], sandwiches = [0,1,0,1]

› Output: 0

💡 Note: Front student (wants square) can't take circular sandwich, so goes to back. Queue becomes [1,0,0,1]. Next student (wants circular) takes it! Queue: [0,0,1], Stack: [1,0,1]. Continue this process: all students eventually get fed, so 0 remain hungry.

example_2.py — Some Students Unfed

$ Input: students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]

› Output: 3

💡 Note: We have 4 students wanting square sandwiches and 2 wanting circular. The sandwich stack starts with 1 square, then 3 circular, then 2 square. After serving 1 square + 2 circular + 1 more square (when we get back to it), we have 3 students left wanting square sandwiches but only circular ones remaining in the stack.

example_3.py — Edge Case Single Student

$ Input: students = [1], sandwiches = [0]

› Output: 1

💡 Note: The single student wants a square sandwich (1) but the only sandwich available is circular (0). Since they don't match, the student cannot eat and remains hungry. Hence, 1 student is unable to eat.

Visualization

Tap to expand

Understanding the Visualization

Count Preferences

Count how many students want circular (0) vs square (1) sandwiches

Process Stack Order

Go through sandwiches from top of stack (first served)

Match and Feed

If students want current sandwich type, feed one (decrement count)

Stop at Blockage

When no students want current sandwich, remaining students go hungry

Key Takeaway

🎯 Key Insight: The breakthrough realization is that we don't need to simulate the queue rotation at all! Since students will keep rotating until they find their preferred sandwich (or until it's impossible), we only need to track how many students want each type and process the sandwich stack in order.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make one pass to count students (O(n)) and one pass through sandwiches (O(n)), giving us O(n) total.

✓ Linear Growth

Space Complexity

O(1)

We only need two counters for the two types of sandwiches, regardless of input size.

✓ Linear Space

Constraints

1 ≤ students.length, sandwiches.length ≤ 100
students.length == sandwiches.length
students[i] is 0 or 1, where 0 means circular sandwich preference
sandwiches[i] is 0 or 1, where 1 means square sandwich

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses a counting strategy instead of simulation. Count how many students want each sandwich type, then iterate through the sandwich stack. For each sandwich, if students want that type, decrement the count (feed a student). Stop when no students want the current sandwich type. This achieves O(n) time and O(1) space complexity, much better than the O(n²) simulation approach.

Common Approaches

Approach	Time	Space	Notes
✓ Queue Simulation (Brute Force)	O(n²)	O(n)	Directly simulate the queue and stack operations step by step
Counting Approach (Optimal)	O(n)	O(1)	Count student preferences and match against sandwich stack in order

Queue Simulation (Brute Force) — Algorithm Steps

Initialize queue with student preferences and stack with sandwich types
Track consecutive failed attempts (when students go to back of queue)
For each step: check if front student likes top sandwich
If yes: serve the sandwich and reset failed attempts counter
If no: move student to back and increment failed attempts
Stop when failed attempts equals queue size (no one wants current sandwich)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Students queue up and sandwiches are stacked

Check Match

Front student checks if they like the top sandwich

Serve or Rotate

Student either takes sandwich or goes to back of queue

Repeat Process

Continue until no more matches possible

Code -

solution.c — C

int countStudents(int* students, int studentsSize, int* sandwiches, int sandwichesSize) {
    int* studentQueue = (int*)malloc(studentsSize * sizeof(int));
    int* sandwichStack = (int*)malloc(sandwichesSize * sizeof(int));
    
    for (int i = 0; i < studentsSize; i++) {
        studentQueue[i] = students[i];
    }
    
    for (int i = 0; i < sandwichesSize; i++) {
        sandwichStack[i] = sandwiches[i];
    }
    
    int queueSize = studentsSize;
    int stackSize = sandwichesSize;
    int failedAttempts = 0;
    
    while (queueSize > 0 && failedAttempts < queueSize) {
        if (studentQueue[0] == sandwichStack[0]) {
            // Remove from both queue and stack
            for (int i = 0; i < queueSize - 1; i++) {
                studentQueue[i] = studentQueue[i + 1];
            }
            for (int i = 0; i < stackSize - 1; i++) {
                sandwichStack[i] = sandwichStack[i + 1];
            }
            queueSize--;
            stackSize--;
            failedAttempts = 0;
        } else {
            // Move student to back
            int temp = studentQueue[0];
            for (int i = 0; i < queueSize - 1; i++) {
                studentQueue[i] = studentQueue[i + 1];
            }
            studentQueue[queueSize - 1] = temp;
            failedAttempts++;
        }
    }
    
    free(studentQueue);
    free(sandwichStack);
    return queueSize;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need to rotate through all students multiple times. Each student might go to the back of queue O(n) times.

⚠ Quadratic Growth

Space Complexity

O(n)

We store the queue and stack, which together contain n elements.

⚡ Linearithmic Space

Constraints

1 ≤ students.length, sandwiches.length ≤ 100
students.length == sandwiches.length
students[i] is 0 or 1, where 0 means circular sandwich preference
sandwiches[i] is 0 or 1, where 1 means square sandwich

28.5K Views

Medium Frequency

~12 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Queue Simulation (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler