IEnumerable - Returns elements within either side of an element

Question

I need to get an element from IEnumerable, and then return myself and a range of elements on each side.

So something like this:

var enumerable = new[] {54, 107, 24, 223, 134, 65, 36, 7342, 812, 96, 106}; var rangeSize = 2; var range = enumerable.MySelectRange(x => x == 134, rangeSize); 

will return something like { 24, 223, 134, 65, 36 } .

(This project uses .Net 3.5)

EDIT Well, people seem to have hung up on an ints array. I modified this example to hope that it becomes clearer what I need.

Keep in mind that this is not necessary for IEnumerable<int> , but in fact it will be IEnumerable<TSomething> .

Answer 1

This extension method finds the first element in the sequence that satisfies the given predicate, and then returns that element together with a certain number of its neighboring elements. It handles end cases.

 public static IEnumerable<T> FirstAndNeighbours<T>( this IEnumerable<T> source, Func<T,bool> predicate, int numOfNeighboursEitherSide) { using (var enumerator = source.GetEnumerator()) { var precedingNeighbours = new Queue<T>(numOfNeighboursEitherSide); while(enumerator.MoveNext()) { var current = enumerator.Current; if (predicate(current)) { //We have found the first matching element. First, we must return //the preceding neighbours. foreach (var precedingNeighbour in precedingNeighbours) yield return precedingNeighbour; //Next, return the matching element. yield return current; //Finally, return the succeeding neighbours. for (int i = 0; i < numOfNeighboursEitherSide; ++i) { if (!enumerator.MoveNext()) yield break; yield return enumerator.Current; } yield break; } //No match yet, keep track of this preceding neighbour. if (precedingNeighbours.Count >= numOfNeighboursEitherSide) precedingNeighbours.Dequeue(); precedingNeighbours.Enqueue(current); } } } 

Answer 2

EDIT: Updated answer due to question update **

extension method should do this, now supports any type T

 public static IEnumerable<T> Range<T>(this IEnumerable<T> enumerable, Func<T,bool> selector, int size) { Queue<T> queue = new Queue<T>(); bool found = false; int count = 0; foreach(T item in enumerable) { if(found) { if(count++ < size) { yield return item; } else { yield break; } } else { if(queue.Count>size) queue.Dequeue(); if(selector(item)) { found = true; foreach(var stackItem in queue) yield return stackItem; yield return item; } else { queue.Enqueue(item); } } } 

use close to what you need

  var enumerable = new[] {54, 107, 24, 223, 134, 65, 36, 7342, 812, 96, 106}; Console.WriteLine(String.Join(",",enumerable.ToArray())); var rangeSize = 2; var range = enumerable.Range((x) => x == 134, rangeSize); Console.WriteLine(String.Join(",",range.ToArray())); 

Real-time example: http://rextester.com/rundotnet?code=ACKDD76841

Answer 3

The following are correct answers for non-linear sequences and are effective, for example:

 const int PivotValue = 5; const int RangeSize = 2; int[] enumerable = new[] { 0, 1, 2, 3, 4, 5, 600, 700, 800, 900, 1000 }; IEnumerable<int> range = enumerable.PivotRange(PivotValue, RangeSize);} //3, 4, 5, 600, 700. 

Code - General Version

 public static IEnumerable<T> PivotRange<T>( this IEnumerable<T> source, T pivot, int size) where T : IComparable<T> { T[] left = new T[size]; int lCount = 0, rCount = 0; IEnumerator<T> enumerator = source.GetEnumerator(); while (enumerator.MoveNext()) { T item = enumerator.Current; if (item.CompareTo(pivot) == 0) { int start = lCount > size ? lCount % size : 0; int end = Math.Min(size, lCount); for (int i = start; i < start + end; i++) yield return left[i % size]; yield return pivot; while (enumerator.MoveNext() && rCount++ < size) yield return enumerator.Current; break; } if (size <= 0) continue; left[lCount++ % size] = item; } } 

Update - unit tests

 [Test] public void Linear() { const int PivotValue = 5; const int RangeSize = 2; int[] enumerable = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int[] range = enumerable.PivotRange(PivotValue, RangeSize).ToArray(); CollectionAssert.AreEqual(new[] { 3, 4, 5, 6, 7 }, range); } [Test] public void NonLinear() { const int PivotValue = 5; const int RangeSize = 2; int[] enumerable = new[] { 0, 1, 2, 3, 4, 5, 600, 700, 800, 900, 1000 }; int[] range = enumerable.PivotRange(PivotValue, RangeSize).ToArray(); CollectionAssert.AreEqual(new[] { 3, 4, 5, 600, 700 }, range); } [Test] public void NoLeft() { const int PivotValue = 5; const int RangeSize = 2; int[] enumerable = new[] { 5, 600, 700, 800, 900, 1000 }; int[] range = enumerable.PivotRange(PivotValue, RangeSize).ToArray(); CollectionAssert.AreEqual(new[] { 5, 600, 700 }, range); } [Test] public void NoRight() { const int PivotValue = 5; const int RangeSize = 2; int[] enumerable = new[] { 0, 1, 2, 3, 4, 5 }; int[] range = enumerable.PivotRange(PivotValue, RangeSize).ToArray(); CollectionAssert.AreEqual(new[] { 3, 4, 5 }, range); } [Test] public void ZeroRange() { const int PivotValue = 5; const int RangeSize = 0; int[] enumerable = new[] { 0, 1, 2, 3, 4, 5 }; int[] range = enumerable.PivotRange(PivotValue, RangeSize).ToArray(); CollectionAssert.AreEqual(new[] { 5 }, range); } [Test] public void LeftShorterThanRange() { const int PivotValue = 5; const int RangeSize = 2; int[] enumerable = new[] { 4, 5, 6, 7, 8 }; int[] range = enumerable.PivotRange(PivotValue, RangeSize).ToArray(); CollectionAssert.AreEqual(new[] { 4, 5, 6, 7 }, range); } [Test] public void RightShorterThanRange() { const int PivotValue = 5; const int RangeSize = 2; int[] enumerable = new[] { 2, 3, 4, 5, 6, }; int[] range = enumerable.PivotRange(PivotValue, RangeSize).ToArray(); CollectionAssert.AreEqual(new[] { 3, 4, 5, 6 }, range); } 

Answer 4

Assuming you can get the index of the middle element:

 var enumerable = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int range = 2; int index = 10; enumerable.Skip(index-range).Take(range) .Union(enumerable.Skip(index).Take(1)) .Union( enumerable.Skip(index+1).Take(range) ).Dump(); 

(calling Dump() for LinqPad )

EDIT:

Thanks to Gabe's comment, he got rid of two additional Skip() / Take() :

 enumerable.Skip((index < range) ? 0 : index-range) .Take(((index < range) ? index : range) + range + 1) .Dump(); 

Answer 5

You can do something like this.

 var enumerable = new[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; var rangeSize = 2; var index = enumerable.FirstOrDefault(x=> x == 2); var range = enumerable.Skip(index + 1).Take(5); 

Answer 6

This is a queue-based version, only I implement my own queue (unlike others that use Queue ). The advantage of implementing your own queue is that it is a bit more efficient.

 public static IEnumerable<T> MySelectRange<T>(this IEnumerable<T> source, Func<T, bool> selector, int rangeSize) { var firstN = new T[rangeSize]; int pos = 0; bool found = false; foreach (T item in source) { if (found) if (pos++ <= rangeSize) yield return item; else break; if (selector(item)) { found = true; for (int i = Math.Max(0, pos - rangeSize); i < pos; i++) yield return firstN[i % rangeSize]; yield return item; pos = 0; } else if (rangeSize > 0) firstN[pos++ % rangeSize] = item; } } 

Answer 7

As long as the elements are unique, the function below will work for you.

 public static IEnumerable<T> MySelectRange<T>(this IEnumerable<T> me, Func<T, bool> pred, int range) { var first = me.TakeWhile(i => !pred(i)).TakeLast(range); var second = me.SkipWhile(i => !pred(i)).Take(range + 1); return first.Concat(second); } 

NOTE. TakeLast seems to be from the Rx library

Answer 8

It might be that simple:

 public IEnumerable<T> GetRange<T>(IEnumerable<T> enumerable, int rangeSize, T value) { for (int i = 0; i < enumerable.Count(); ++i) { if (enumerable.ElementAt(i).Equals(value)) { for (int j = Math.Max(0, i - rangeSize); j < Math.Min(i + rangeSize + 1, enumerable.Count()); ++j) { yield return enumerable.ElementAt(j); } } } } }