## 933. Number of Recent Calls

You have a `RecentCounter` class which counts the number of recent requests within a certain time frame.

Implement the `RecentCounter` class:

• `RecentCounter()` Initializes the counter with zero recent requests.
• `int ping(int t)` Adds a new request at time `t`, where `t` represents some time in milliseconds, and returns the number of requests that has happened in the past `3000` milliseconds (including the new request). Specifically, return the number of requests that have happened in the inclusive range `[t - 3000, t]`.

It is guaranteed that every call to `ping` uses a strictly larger value of `t` than the previous call.

Example 1:

```Input
["RecentCounter", "ping", "ping", "ping", "ping"]
[[], [1], [100], [3001], [3002]]
Output
[null, 1, 2, 3, 3]

Explanation
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1);     // requests = [1], range is [-2999,1], return 1
recentCounter.ping(100);   // requests = [1, 100], range is [-2900,100], return 2
recentCounter.ping(3001);  // requests = [1, 100, 3001], range is [1,3001], return 3
recentCounter.ping(3002);  // requests = [1, 100, 3001, 3002], range is [2,3002], return 3
```

Constraints:

• `1 <= t <= 109`
• Each test case will call `ping` with strictly increasing values of `t`.
• At most `104` calls will be made to `ping`.

## Rust Solution

``````use std::collections::VecDeque;

#[derive(Default)]
struct RecentCounter {
queue: VecDeque<i32>,
}

impl RecentCounter {
fn new() -> Self {
RecentCounter {
queue: VecDeque::new(),
}
}
fn ping(&mut self, t: i32) -> i32 {
self.queue.push_back(t);
while let Some(p) = self.queue.pop_front() {
if p >= t - 3000 {
self.queue.push_front(p);
break;
}
}
self.queue.len() as i32
}
}

#[test]
fn test() {
let mut obj = RecentCounter::new();
assert_eq!(obj.ping(1), 1);
assert_eq!(obj.ping(100), 2);
assert_eq!(obj.ping(3001), 3);
assert_eq!(obj.ping(3002), 3);
}
``````

Having problems with this solution? Click here to submit an issue on github.