是否有与uniq命令uniq等效的Linq

Question

Every search I make assumes "Distinct()", but this is NOT my requirement. I just wish to remove all the repeats. Are there any options using linq (ie the Enumerable extensions) ?

For example (in C#)

int[] input = new [] {1,2,3,3,4,5,5,5,6,6,5,4,4,3,2,1,6};

int[] expected = new [] {1,2,3,4,5,6,5,4,3,2,1,6};

Answer 1

It is possible with linq, although for performance and readability a simple for loop would probably be the better option.

int[] input = new[] { 1, 2, 3, 3, 4, 5, 5, 5, 6, 6, 5, 4, 4, 3, 2, 1, 6 };
var result = input.Where((x, i) => i == 0 || x != input[i - 1]).ToArray();

Answer 2

You are asking for non-repeating elements, not unique elements. LINQ-to-Objects operations are essentially iterators. You could write your own iterator method that only yields the first time an item is encountered, eg:

public static IEnumerable<int> DistinctUntilChanged(this IEnumerable<int> source)
{
    int? previous=null;
    foreach(var item in source)
    {
        if (item!=previous)
        {
            previous=item;
            yield return item;
        }
    }
}

var input = new [] {1,2,3,3,4,5,5,5,6,6,5,4,4,3,2,1,6};
var result=input.DistinctUntilChanged().ToArray();

The result will be :

{1,2,3,4,5,6,5,4,3,2,1,6};

UPDATE

Another option is to use Observable.DistinctUntilChanged from the System.Reactive Library, eg:

var input = new[] { 1, 2, 3, 3, 4, 5, 5, 5, 6, 6, 5, 4, 4, 3, 2, 1, 6 };
var result = input.ToObservable()
                  .DistinctUntilChanged()
                  .ToEnumerable()
                  .ToArray();

System.Reactive, and Reactive Extensions are meant to handle sequences of events using the basic LINQ operators and more. It's easy to convert between Observable and Enumerable though, with ToObservable() and ToEnumerable() , so they can be used to handle any collection. After all, an event sequence is similar to an "infinite" sequence

UPDATE 2

In case there's any confusion about the use of int? to store the previous number, it's to allow easy comparison even with the first element of the source without actually calling First() on it. If it was ,eg int previous=0; and the first element was 0, the comparison would filter out the first element.

By using an int? in C# or an int option in F# or a Maybe<int> if we have a Maybe monad we can differentiate between no initial value and an initial value of 0.

Observable.DistinctUntilChanged uses a flag to check whether we are checking the first element. The equivalent code would be:

    public static IEnumerable<int> NonRepeating(this IEnumerable<int> source)
    {
        int previous =0;
        bool isAssigned=false;
        foreach (var item in source)
        {
            if (!isAssigned || item != previous)
            {
                isAssigned = true;
                previous = item;
                yield return item;
            }
        }
    }

MoreLINQ

Finally, one can use the GroupAdjacent method from the MoreLinq library to group repeating items together. Each group contains the repeating source elements. In this particular case though we only need the key values:

var result = input.GroupAdjacent(i => i).Select(i => i.Key).ToArray();

The nice thing about GroupAdjacent is that the elements can be transformed while grouping, eg :

input.GroupAdjacent(i => i,i=>$"Number {i}")

would return groupings of strings.