Use Linq to break a list by special values?

Question

I'm trying to use Linq to convert IEnumerable<int> to IEnumerable<List<int>> - the input stream will be separated by special value 0.

IEnumerable<List<int>> Parse(IEnumerable<int> l) 
{
    l.Select(x => {
      .....; //?
      return new List<int>();
    });
}
var l = new List<int> {0,1,3,5,0,3,4,0,1,4,0};
Parse(l) // returns {{1,3,5}, {3, 4}, {1,4}}

How to implement it using Linq instead of imperative looping? Or is Linq not good for this requirement because the logic depends on the order of the input stream?

Answer 1

Simple loop would be good option.

Alternatives:

• Enumerable.Aggregate and start new list on 0
• Write own extension similar to Create batches in linq or Use LINQ to group a sequence of numbers with no gaps

Aggregate sample

var result = list.Aggregate(new List<List<int>>(),
    (sum,current) => { 
       if(current == 0) 
            sum.Add(new List<int>());
       else 
            sum.Last().Add(current);
    return sum;
});

Note: this is only sample of the approach working for given very friendly input like {0,1,2,0,3,4}.

One can even make aggregation into immutable lists but that will look insane with basic .Net types.

Answer 2

Here's an answer that lazily enumerates the source enumerable, but eagerly enumerates the contents of each returned list between zeroes. It properly throws upon null input or upon being given a list that does not start with a zero (though allowing an empty list through--that's really an implementation detail you have to decide on). It does not return an extra and empty list at the end like at least one other answer's possible suggestions does.

public static IEnumerable<List<int>> Parse(this IEnumerable<int> source, int splitValue = 0) {
   if (source == null) {
      throw new ArgumentNullException(nameof (source));
   }
   using (var enumerator = source.GetEnumerator()) {
      if (!enumerator.MoveNext()) {
         return Enumerable.Empty<List<int>>();
      }
      if (enumerator.Current != splitValue) {
         throw new ArgumentException(nameof (source), $"Source enumerable must begin with a {splitValue}.");
      }
      return ParseImpl(enumerator, splitValue);
   }
}

private static IEnumerable<List<int>> ParseImpl(IEnumerator<int> enumerator, int splitValue) {
   var list = new List<int>();
   while (enumerator.MoveNext()) {
      if (enumerator.Current == splitValue) {
         yield return list;
         list = new List<int>(); 
      }
      else {
         list.Add(enumerator.Current);
      }
   }
   if (list.Any()) {
      yield return list;
   }
}

This could easily be adapted to be generic instead of int, just change Parse to Parse<T>, change int to T everywhere, and use a.Equals(b) or !a.Equals(b) instead of a == b or a != b.

Answer 3

You could create an extension method like this:

    public static IEnumerable<IEnumerable<T>> SplitBy<T>(this IEnumerable<T> source, T value)
    {
        using (var e = source.GetEnumerator())
        {
            if (e.MoveNext())
            {
                var list = new List<T> { };
                //In case the source doesn't start with 0
                if (!e.Current.Equals(value))
                {
                    list.Add(e.Current);
                }
                while (e.MoveNext())
                {
                    if ( !e.Current.Equals(value))
                    {
                        list.Add(e.Current);
                    }
                    else
                    {
                        yield return list;
                        list = new List<T> { };
                    }

                }
                //In case the source doesn't end with 0
                if (list.Count>0)
                {
                    yield return list;
                }

            }
        }
    }

Then, you can do the following:

var l = new List<int> { 0, 1, 3, 5, 0, 3, 4, 0, 1, 4, 0 };
var result = l.SplitBy(0);

Answer 4

You could use GroupBy with a counter.

var list = new List<int> {0,1,3,5,0,3,4,0,1,4,0};

int counter = 0;
var result = list.GroupBy(x => x==0 ? counter++ : counter)
                 .Select(g => g.TakeWhile(x => x!=0).ToList())
                 .Where(l => l.Any());

Answer 5

Edited to fix possibility of zeroes within numbers

Here is a semi-LINQ solution:

var l = new List<int> {0,1,3,5,0,3,4,0,1,4,0};
string
    .Join(",", l.Select(x => x == 0 ? "|" : x.ToString()))
    .Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries)
    .Select(x => x.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries));

This is probably not preferable to using a loop due to performance and other reasons, but it should work.