Problem

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.

Examples

Example 1

1
2
3
4
5
6

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

1
2
3

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

Method 1 – Simple Linear Scan

Intuition

We just need to count how many students are doing homework at the given queryTime. For each student, if queryTime is between their start and end time (inclusive), we count them. This is a direct application of the problem statement.

Approach

  1. Initialize a counter ans to 0.
  2. For each student, check if startTime[i] <= queryTime <= endTime[i].
  3. If true, increment ans.
  4. Return ans.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Solution {
public:
    int busyStudent(vector<int>& startTime, vector<int>& endTime, int queryTime) {
        int ans = 0, n = startTime.size();
        for (int i = 0; i < n; ++i) {
            if (startTime[i] <= queryTime && queryTime <= endTime[i]) ++ans;
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9

func busyStudent(startTime []int, endTime []int, queryTime int) int {
    ans := 0
    for i := 0; i < len(startTime); i++ {
        if startTime[i] <= queryTime && queryTime <= endTime[i] {
            ans++
        }
    }
    return ans
}
1
2
3
4
5
6
7
8
9

class Solution {
    public int busyStudent(int[] startTime, int[] endTime, int queryTime) {
        int ans = 0;
        for (int i = 0; i < startTime.length; ++i) {
            if (startTime[i] <= queryTime && queryTime <= endTime[i]) ans++;
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9

class Solution {
    fun busyStudent(startTime: IntArray, endTime: IntArray, queryTime: Int): Int {
        var ans = 0
        for (i in startTime.indices) {
            if (startTime[i] <= queryTime && queryTime <= endTime[i]) ans++
        }
        return ans
    }
}
1
2
3
4
5
6
7

class Solution:
    def busyStudent(self, startTime: list[int], endTime: list[int], queryTime: int) -> int:
        ans = 0
        for s, e in zip(startTime, endTime):
            if s <= queryTime <= e:
                ans += 1
        return ans
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

impl Solution {
    pub fn busy_student(start_time: Vec<i32>, end_time: Vec<i32>, query_time: i32) -> i32 {
        let mut ans = 0;
        for (&s, &e) in start_time.iter().zip(end_time.iter()) {
            if s <= query_time && query_time <= e {
                ans += 1;
            }
        }
        ans
    }
}
1
2
3
4
5
6
7
8
9

class Solution {
    busyStudent(startTime: number[], endTime: number[], queryTime: number): number {
        let ans = 0;
        for (let i = 0; i < startTime.length; ++i) {
            if (startTime[i] <= queryTime && queryTime <= endTime[i]) ans++;
        }
        return ans;
    }
}

Complexity

  • ⏰ Time complexity: O(n), where n is the number of students. We check each student once.
  • 🧺 Space complexity: O(1), as we use only a constant amount of extra space.