Question

1700. Number of Students Unable to Eat Lunch

中文文档

Description

The school cafeteria offers circular and square sandwiches at lunch break, referred to by numbers 0 and 1 respectively. All students stand in a queue. Each student either prefers square or circular sandwiches.

The number of sandwiches in the cafeteria is equal to the number of students. The sandwiches are placed in a stack. At each step:

• If the student at the front of the queue prefers the sandwich on the top of the stack, they will take it and leave the queue.
• Otherwise, they will leave it and go to the queue's end.

This continues until none of the queue students want to take the top sandwich and are thus unable to eat.

You are given two integer arrays students and sandwiches where sandwiches[i] is the type of the i​​​​​​th sandwich in the stack (i = 0 is the top of the stack) and students[j] is the preference of the j​​​​​​th student in the initial queue (j = 0 is the front of the queue). 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:
- Front student leaves the top sandwich and returns to the end of the line making students = [1,0,0,1].
- Front student leaves the top sandwich and returns to the end of the line making students = [0,0,1,1].
- Front student takes the top sandwich and leaves the line making students = [0,1,1] and sandwiches = [1,0,1].
- Front student leaves the top sandwich and returns to the end of the line making students = [1,1,0].
- Front student takes the top sandwich and leaves the line making students = [1,0] and sandwiches = [0,1].
- Front student leaves the top sandwich and returns to the end of the line making students = [0,1].
- Front student takes the top sandwich and leaves the line making students = [1] and sandwiches = [1].
- Front student takes the top sandwich and leaves the line making students = [] and sandwiches = [].
Hence all students are able to eat.

Example 2:

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

 

Constraints:

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

Solutions

Solution 1: Counting

We observe that the positions of the students can be adjusted, but the positions of the sandwiches cannot be adjusted. That is to say, if the sandwich in front is not taken, then all the sandwiches behind cannot be taken.

Therefore, we first use a counter $cnt$ to count the types of sandwiches that students like and their corresponding quantities.

Then we traverse the sandwiches. If we cannot find a student who likes this sandwich in $cnt$, it means that the sandwiches behind cannot be taken, and we return the current number of remaining students.

If the traversal is over, it means that all students have sandwiches to eat, and we return $0$.

The time complexity is $O(n)$, where $n$ is the number of sandwiches. The space complexity is $O(1)$.

class Solution:
  def countStudents(self, students: List[int], sandwiches: List[int]) -> int:
    cnt = Counter(students)
    for v in sandwiches:
      if cnt[v] == 0:
        return cnt[v ^ 1]
      cnt[v] -= 1
    return 0

class Solution {
  public int countStudents(int[] students, int[] sandwiches) {
    int[] cnt = new int[2];
    for (int v : students) {
      ++cnt[v];
    }
    for (int v : sandwiches) {
      if (cnt[v]-- == 0) {
        return cnt[v ^ 1];
      }
    }
    return 0;
  }
}

class Solution {
public:
  int countStudents(vector<int>& students, vector<int>& sandwiches) {
    int cnt[2] = {0};
    for (int& v : students) ++cnt[v];
    for (int& v : sandwiches) {
      if (cnt[v]-- == 0) {
        return cnt[v ^ 1];
      }
    }
    return 0;
  }
};

func countStudents(students []int, sandwiches []int) int {
  cnt := [2]int{}
  for _, v := range students {
    cnt[v]++
  }
  for _, v := range sandwiches {
    if cnt[v] == 0 {
      return cnt[v^1]
    }
    cnt[v]--
  }
  return 0
}

function countStudents(students: number[], sandwiches: number[]): number {
  const count = [0, 0];
  for (const v of students) {
    count[v]++;
  }
  for (const v of sandwiches) {
    if (count[v] === 0) {
      return count[v ^ 1];
    }
    count[v]--;
  }
  return 0;
}

impl Solution {
  pub fn count_students(students: Vec<i32>, sandwiches: Vec<i32>) -> i32 {
    let mut count = [0, 0];
    for &v in students.iter() {
      count[v as usize] += 1;
    }
    for &v in sandwiches.iter() {
      let v = v as usize;
      if count[v as usize] == 0 {
        return count[v ^ 1];
      }
      count[v] -= 1;
    }
    0
  }
}

int countStudents(int* students, int studentsSize, int* sandwiches, int sandwichesSize) {
  int count[2] = {0};
  for (int i = 0; i < studentsSize; i++) {
    count[students[i]]++;
  }
  for (int i = 0; i < sandwichesSize; i++) {
    int j = sandwiches[i];
    if (count[j] == 0) {
      return count[j ^ 1];
    }
    count[j]--;
  }
  return 0;
}