# Leetcode: Number of Recent Calls

Number of Recent Calls

Similar Problems:

Write a class RecentCounter to count recent requests.

It has only one method: ping(int t), where t represents some time in milliseconds.

Return the number of pings that have been made from 3000 milliseconds ago until now.

Any ping with time in [t – 3000, t] will count, including the current ping.

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

Example 1:

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

Note:

1. Each test case will have at most 10000 calls to ping.
2. Each test case will call ping with strictly increasing values of t.
3. Each call to ping will have 1 <= t <= 10^9.

Github: code.dennyzhang.com

Credits To: leetcode.com

Leave me comments, if you have better ways to solve.

• Solution: queue with array
```// Blog link: https://code.dennyzhang.com/number-of-recent-calls
// Basic Ideas: queue
//
// Complexity: Time O(n), Space O(n)
type RecentCounter struct {
l []int
}

func Constructor() RecentCounter {
return RecentCounter{[]int{}}
}

func (this *RecentCounter) Ping(t int) int {
this.l = append(this.l, t)
i, t2 := 0, t - 3000
for ; i<len(this.l); i++ {
if this.l[i] >= t2 {
break
}
}
this.l = this.l[i:]
return len(this.l)
}

/**
* Your RecentCounter object will be instantiated and called as such:
* obj := Constructor();
* param_1 := obj.Ping(t);
*/
```

Share It, If You Like It.