How do you approach Number of Students Unable to Eat Lunch?

Simulate it: rotate the queue until the front student matches the top sandwich.

What is the time complexity of Number of Students Unable to Eat Lunch?

Time complexity: O(n^2) for simulation, O(n) for counting. Space complexity: O(n) for the queue, O(1) for counting.

What are common mistakes on Number of Students Unable to Eat Lunch?

Popping without first checking the stack is non-empty. Ignoring what is left on the stack at the end - a non-empty stack is usually itself part of the answer. Pushing values where the problem needs indices back.

gitGood.dev

← Back to problems

Number of Students Unable to Eat Lunch

EasyData Structures

Description

The school cafeteria offers circular (`0`) and square (`1`) sandwiches. The students stand in a **queue**, and the sandwiches sit in a **stack**. Each number represents a preference: - If the student at the front of the queue prefers the sandwich on top of the stack, they take it and leave the queue. - Otherwise, they skip it and go to the **end** of the queue. This continues until none of the students in the queue want the top sandwich, at which point everyone still in the queue is unable to eat. You are given two arrays: `students`, where `students[i]` is the preference of the i-th student in the queue (front first), and `sandwiches`, where `sandwiches[j]` is the type of the j-th sandwich in the stack (top first). Return the number of students that are unable to eat.

Example 1

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

Output: 0

Explanation: After some rotations every student gets a sandwich they like.

Example 2

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

Output: 3

Example 3

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

Output: 0

Constraints

- 1 <= students.length, sandwiches.length <= 100 - students.length == sandwiches.length - sandwiches[i] is 0 or 1. - students[i] is 0 or 1.

Number of Students Unable to Eat Lunch: approach, complexity and pitfalls

An easy stack problem, graded against 7 test cases (4 of them hidden).

The pattern: Stack

Last-in-first-out processing - matching, nesting, and deferred evaluation.

Reach for it when you see: Balanced brackets, nested structures, undo/back semantics, or expression evaluation.

More Stackproblems →

If you are stuck

Show the 3-step hint ladder

Simulate it: rotate the queue until the front student matches the top sandwich.
When do you stop? If every student currently in the queue has cycled past the top sandwich without taking it, no one ever will.
Counting shortcut: track how many students want each type. Walk the sandwich stack top-down; the first sandwich nobody wants blocks everyone behind it.

The optimal approach

Show the approach: Solution 1: Queue Simulation

Use a queue for students and an index for the top of the sandwich stack. If the front student matches the top sandwich, both advance; otherwise the student rotates to the back. Stop when a full rotation happens with no sandwich taken - the remaining queue length is the answer.

Solution 2: Counting (no simulation)

Order in the queue never matters for *whether* a sandwich gets taken - only the counts of students preferring 0 and 1 do. Walk the stack top-down, decrementing the matching preference count; the first sandwich with a zero count blocks all remaining students.

Time: O(n^2) for simulation, O(n) for counting
Space: O(n) for the queue, O(1) for counting

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.
Zero. Zero appears in the input, which is the value most likely to break a truthiness check used in place of an explicit comparison.

Common Stack mistakes

These apply to the pattern as a whole, not just this problem.

Popping without first checking the stack is non-empty.
Ignoring what is left on the stack at the end - a non-empty stack is usually itself part of the answer.
Pushing values where the problem needs indices back.

← Back to problems

Number of Students Unable to Eat Lunch

EasyData Structures

Description

Example 1

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

Output: 0

Explanation: After some rotations every student gets a sandwich they like.

Example 2

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

Output: 3

Example 3

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

Output: 0

Constraints

- 1 <= students.length, sandwiches.length <= 100 - students.length == sandwiches.length - sandwiches[i] is 0 or 1. - students[i] is 0 or 1.

Number of Students Unable to Eat Lunch: approach, complexity and pitfalls

An easy stack problem, graded against 7 test cases (4 of them hidden).

The pattern: Stack

Last-in-first-out processing - matching, nesting, and deferred evaluation.

Reach for it when you see: Balanced brackets, nested structures, undo/back semantics, or expression evaluation.

More Stackproblems →

If you are stuck

Show the 3-step hint ladder

Simulate it: rotate the queue until the front student matches the top sandwich.
When do you stop? If every student currently in the queue has cycled past the top sandwich without taking it, no one ever will.
Counting shortcut: track how many students want each type. Walk the sandwich stack top-down; the first sandwich nobody wants blocks everyone behind it.

The optimal approach

Show the approach: Solution 1: Queue Simulation

Solution 2: Counting (no simulation)

Time: O(n^2) for simulation, O(n) for counting
Space: O(n) for the queue, O(1) for counting

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.
Zero. Zero appears in the input, which is the value most likely to break a truthiness check used in place of an explicit comparison.

Common Stack mistakes

These apply to the pattern as a whole, not just this problem.

Popping without first checking the stack is non-empty.
Ignoring what is left on the stack at the end - a non-empty stack is usually itself part of the answer.
Pushing values where the problem needs indices back.