LINQ Query to identify fragments in a series

Question

Suppose I have the following array (my sequences are all sorted in ascending order, and contain positive integers)

var mySequence = new [] {1, 2, 3, 7, 8, 9, 15, 16, 17};

I want to write a linq query to select the continuous numbers in a series treated as a group. So, in above example I would get { [1, 2, 3], [7, 8, 9], [15, 16, 17] }.

I could write a foreach() sequence, run through each element and see where the sequence is taking a hop and yield a group there. But is there any LINQ-only way of doing it? I might be able to move my foreach() code into a new extension method so my code still looks LINQy, but I am wondering if there is anything available in System.Linq already for that.

EDIT: I had created my own extension (as follows), but Me.Name came up with something very smart in his Answer.

internal class Sequence
{
    public int Start { get; set; }
    public int End { get; set; }
}

internal static class EnumerableMixins
{
    public static IEnumerable<Sequence> GroupFragments(this IEnumerable<int> sequence)
    {
        if (sequence.Any())
        {
            var lastNumber = sequence.First();
            var firstNumber = lastNumber;

            foreach(var number in sequence.Skip(1))
            {
                if (Math.Abs(number - lastNumber) > 1)
                {
                    yield return new Sequence() { Start = firstNumber, End = lastNumber };

                    firstNumber = lastNumber = number;
                }
                else
                {
                    lastNumber = number;
                }
            }


            yield return new Sequence() { Start = firstNumber, End = lastNumber };
        }
    }
}

Answer 1

An old trick to find these kinds of islands is to subtract the index and the numeric value. The result will represent unique groups. Using the select overload including the index:

var mySequence = new [] {1, 2, 3, 7, 8, 9, 15, 16, 17};

var groups = mySequence
    .Select((val,ind) => new{val, group = val - ind})
    .GroupBy(v=>v.group, v=>v.val)
    .Select(v=> v.ToList()).ToList();

(Used ToList here, but of course ToArray can be used if arrays are preferred)

Answer 2

I little late but anyway I want to share the idea. You could also create an iterator like this:

public static class Extensions
{
    public static IEnumerable<IEnumerable<int>> ContinuousNumbers(this IEnumerable<int> source)
    {
        using (var e = source.GetEnumerator())
        {
            if (e.MoveNext())
            {
                var list = new List<int> { e.Current};
                int temp = e.Current;
                while (e.MoveNext())
                {
                    if (e.Current == temp+1)
                    {
                        list.Add(e.Current);
                        temp++;
                    }
                    else
                    {
                        yield return list;
                        list = new List<int> { e.Current};
                        temp = e.Current;
                    }
                }

                if (list.Count > 0)
                {
                    yield return list;
                }
            }
        }
    }
}

Another variant could be using the Aggregate extension method:

var result = mySequence.Aggregate(new List<List<int>>(),
                                   (r, current) =>
                                   {
                                       if ( r.Count==0  ||  (r.Last().Count>0 && r.Last().Last() != current-1))
                                           r.Add(new List<int> { current});
                                       else
                                           r.Last().Add(current);
                                       return r;
                                   });