## Algorithm

Problem Name: 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`.

## Code Examples

### #1 Code Example with C++ Programming

```Code - C++ Programming```

``````
class RecentCounter {
public:
RecentCounter() {

}

int ping(int t) {
while (!q.empty() && t - q.front() > 3000) {
q.pop_front();
}
q.push_back(t);
return q.size();
}

private:
deque < int>q;
};
``````
Copy The Code &

Input

cmd
["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]]

Output

cmd
[null, 1, 2, 3, 3]

### #2 Code Example with Java Programming

```Code - Java Programming```

``````
class RecentCounter {

private Queue queue;

public RecentCounter() {
queue = new LinkedList < >();
}

public int ping(int t) {
while (!queue.isEmpty() && t - queue.peek() > 3000) {
queue.remove();
}
return queue.size();
}
}
``````
Copy The Code &

Input

cmd
["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]]

Output

cmd
[null, 1, 2, 3, 3]

### #3 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
const RecentCounter = function() {
this.pings = [];
};

RecentCounter.prototype.ping = function(t) {
if (t === null) return null;
if (t > 3000) {
let delta = t - 3000;
while (this.pings.length > 0 && this.pings[0]  <  delta) {
this.pings.shift();
}
}

this.pings.push(t);
return this.pings.length;
};
``````
Copy The Code &

Input

cmd
["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]]

Output

cmd
[null, 1, 2, 3, 3]

### #4 Code Example with Python Programming

```Code - Python Programming```

``````
class RecentCounter:

def __init__(self):
self.p = collections.deque()

def ping(self, t):
self.p.append(t)
while self.p[0] < t - 3000:
self.p.popleft()
return len(self.p)
``````
Copy The Code &

Input

cmd
["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]]

Output

cmd
[null, 1, 2, 3, 3]

### #5 Code Example with C# Programming

```Code - C# Programming```

``````
using System.Collections.Generic;

namespace LeetCode
{
public class _0933_NumberOfRecentCalls
{
private readonly Queue < int> queue;

public _0933_NumberOfRecentCalls()
{
queue = new Queue<int>();
}

public int Ping(int t)
{
queue.Enqueue(t);
while (t - queue.Peek() > 3000)
queue.Dequeue();
return queue.Count;
}
}

}
``````
Copy The Code &

Input

cmd
["RecentCounter", "ping", "ping", "ping", "ping"] [[], [1], [100], [3001], [3002]]

Output

cmd
[null, 1, 2, 3, 3]