var buf = new Queue<T>(); foreach (T i in source) { buf.Enqueue(i); if (buf.Count > n) yield return buf.Dequeue(); } // source.Count == 11 var x = FilterLast(source, 3).Take(4);

This code implements filtering a sequence by skipping the first n elements and starting to yield elements from position n+1.

Explanation:

• Elements from source are added one by one to the queue buf.
• If the size of the queue exceeds n, the oldest element is dequeued (and returned via yield return).

Thus, the first n elements are not returned, but subsequent ones are.

In your example, source.Count == 11, n == 3, so the first 3 elements are skipped, and starting from the 4th element, they are returned.

The expression FilterLast(source, 3).Take(4) will return 4 elements, from the 4th to the 7th of the original sequence.

Example function:

IEnumerable<T> FilterLast<T>(IEnumerable<T> source, int n)
{
    var buf = new Queue<T>();
    foreach (var i in source)
    {
        buf.Enqueue(i);
        if (buf.Count > n)
            yield return buf.Dequeue();
    }
}

// Usage:
var result = FilterLast(source, 3).Take(4);

This is useful when you need to filter out the first n elements of a sequence without a full traversal or creating intermediate collections.