{x}
blog image

Number of Students Doing Homework at a Given Time

Given two integer arrays startTime and endTime and given an integer queryTime.

The ith student started doing their homework at the time startTime[i] and finished it at time endTime[i].

Return the number of students doing their homework at time queryTime. More formally, return the number of students where queryTime lays in the interval [startTime[i], endTime[i]] inclusive.

 

Example 1:

Input: startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
Output: 1
Explanation: We have 3 students where:
The first student started doing homework at time 1 and finished at time 3 and wasn't doing anything at time 4.
The second student started doing homework at time 2 and finished at time 2 and also wasn't doing anything at time 4.
The third student started doing homework at time 3 and finished at time 7 and was the only student doing homework at time 4.

Example 2:

Input: startTime = [4], endTime = [4], queryTime = 4
Output: 1
Explanation: The only student was doing their homework at the queryTime.

 

Constraints:

  • startTime.length == endTime.length
  • 1 <= startTime.length <= 100
  • 1 <= startTime[i] <= endTime[i] <= 1000
  • 1 <= queryTime <= 1000

Solution Explanation for 1450. Number of Students Doing Homework at a Given Time

This problem asks to find the number of students who are working on their homework at a specific queryTime. Each student has a startTime and endTime for their homework. A student is considered to be working if queryTime falls within the inclusive range [startTime, endTime].

Approach

The most straightforward approach is to iterate through each student's homework schedule and check if the queryTime falls within their working period. We can achieve this with a single loop, making the solution efficient.

Code Implementation (Python)

class Solution:
    def busyStudent(self, startTime: List[int], endTime: List[int], queryTime: int) -> int:
        count = 0  # Initialize a counter for students doing homework
        for i in range(len(startTime)): # Iterate through each student
            if startTime[i] <= queryTime <= endTime[i]: # Check if queryTime is within the student's homework time
                count += 1 #Increment the count if the student is working at queryTime
        return count

Time and Space Complexity Analysis

  • Time Complexity: O(n), where n is the number of students. This is because we iterate through the startTime and endTime arrays once.

  • Space Complexity: O(1). We only use a constant amount of extra space to store the count variable.

Code Implementation in other Languages

The core logic remains the same across different programming languages. Here's how it would look in a few other languages:

Java:

class Solution {
    public int busyStudent(int[] startTime, int[] endTime, int queryTime) {
        int count = 0;
        for (int i = 0; i < startTime.length; i++) {
            if (startTime[i] <= queryTime && queryTime <= endTime[i]) {
                count++;
            }
        }
        return count;
    }
}

C++:

class Solution {
public:
    int busyStudent(vector<int>& startTime, vector<int>& endTime, int queryTime) {
        int count = 0;
        for (int i = 0; i < startTime.size(); ++i) {
            if (startTime[i] <= queryTime && queryTime <= endTime[i]) {
                count++;
            }
        }
        return count;
    }
};

JavaScript:

/**
 * @param {number[]} startTime
 * @param {number[]} endTime
 * @param {number} queryTime
 * @return {number}
 */
var busyStudent = function(startTime, endTime, queryTime) {
    let count = 0;
    for (let i = 0; i < startTime.length; i++) {
        if (startTime[i] <= queryTime && queryTime <= endTime[i]) {
            count++;
        }
    }
    return count;
};

The time and space complexity remain the same (O(n) and O(1), respectively) for all these implementations. The choice of language only affects the syntax, not the fundamental algorithm.