Question

First an overview of what I am trying to do:

Every time a user presses a key, I am recording the current time and once I have more than 5 records I need to calculate the average time between the key presses (whilst only retaining the last 5 – 10 key presses).

When I first sat down and looked at this problem I thought, easy, I will use a stack and simply keep it at less than 10 items.

Question:

• How do I ensure that a stack only has a maximum of ten values in it?
  (date time type)
• How do I find the average time between each of the date times stored in the stack?

Thanks

Dan

Answer 1

Don’t use a Stack, but use a Queue with limited capacity. This can be achieve by something like :

public class CappedQueue<T> : IEnumerable<T> {

    private readonly m_Capacity;
    private Queue<T> m_InnerQueue;
    public CappedQueue<T>(int capacity) {
        m_Capacity = capacity;
        m_InnerQueue = new Queue<T>(capacity);
    }

    // Wrap required methods 
    public void Enqueue(T item){
        if(m_InnerQueue.Count()) == capacity) {
            m_InnerQueue.Dequeue() ;                
        }

        m_InnerQueue.Enqueue(item);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return m_InnerQueue.GetEnumerator();
    }
}


public class Test {
    public void Foo()
    {
        var queue = new CappedQueue<DateTime>(5);

        queue.Enqueue(DateTime.Now); // each time the user press the key
        queue.Enqueue(DateTime.Now); // each time the user press the key
        queue.Enqueue(DateTime.Now); // each time the user press the key


        TimeSpan diff = (queue.Last() / queue.Fisrt())/queue.Count();
    }
    public void Foo2()
    {
        var queue = new CappedQueue<int>(5);

        queue.Enqueue(10);
        queue.Enqueue(20);
        queue.Enqueue(30);

        var average = queue.Average(x=>x);
    }
}