Query Linq che riduce un sottoinsieme di duplicati in un singolo valore all'interno di un set più grande?

Question

Esiste un comando linq che filtra i duplicati visualizzati in una sequenza?

Esempio con '4':

Original { 1 2 3 4 4 4 5 6 7 4 4 4 8 9 4 4 4 } 
Filtered { 1 2 3 4 5 6 7 4 8 9 4 } 

Grazie.

Answer 1

Simile alla risposta di svick, se non con gli effetti collaterali per evitare i contro e invertire:

int[] source = new int[] { 1, 2, 3, 4, 4, 4, 5, 6, 7, 4, 4, 4, 8, 9, 4, 4, 4 }; 

List<int> result = new List<int> { source.First() }; 
source.Aggregate((acc, c) => 
    { 
     if (acc != c) 
      result.Add(c); 
     return c; 
    }); 

Edit: non ha più bisogno del source.First() come per la preoccupazione di mquander:

int[] source = new int[] { 1, 2, 3, 4, 4, 4, 5, 6, 7, 4, 4, 4, 8, 9, 4, 4, 4 }; 

List<int> result = new List<int>(); 
result.Add(
    source.Aggregate((acc, c) => 
    { 
     if (acc != c) 
      result.Add(acc); 
     return c; 
    }) 
); 

penso Mi piace ancora di più la soluzione di Danny.

Answer 2

Non proprio. Mi piacerebbe scrivere questo:

public static IEnumerable<T> RemoveDuplicates(this IEnumerable<T> sequence) 
{ 
    bool init = false; 
    T current = default(T); 

    foreach (var x in sequence) 
    { 
     if (!init || !object.Equals(current, x)) 
      yield return x; 

     current = x; 
     init = true; 
    } 
} 

Answer 3

È possibile utilizzare Aggregate() (anche se non sono sicuro se è meglio che la soluzione non LINQ):

var ints = new[] { 1, 2, 3, 4, 4, 4, 5, 6, 7, 4, 4, 4, 8, 9, 4, 4, 4 }; 

var result = ints.Aggregate(
    Enumerable.Empty<int>(), 
    (list, i) => 
     list.Any() && list.First() == i 
     ? list 
     : new[] { i }.Concat(list)).Reverse(); 

ho penso è O (n), ma non ne sono completamente sicuro.

Answer 4

Se si utilizza .NET 4, è possibile farlo utilizzando il metodo integrato Zip, anche se probabilmente preferirei utilizzare un metodo di estensione personalizzato come quello mostrato in mquander's answer.

// replace "new int[1]" below with "new T[1]" depending on the type of element 
var filtered = original.Zip(new int[1].Concat(original), 
          (l, r) => new { L = l, R = r }) 
         .Where((x, i) => (i == 0) || !object.Equals(x.L, x.R)) 
         .Select(x => x.L); 

Answer 5

Sì, c'è! Codice a una riga e un loop della matrice.

int[] source = new int[] { 1, 2, 3, 4, 4, 4, 5, 6, 7, 4, 4, 4, 8, 9, 4, 4, 4 }; 
var result = source.Where((item, index) => index + 1 == source.Length 
          || item != source[index + 1]); 

E secondo @ consiglio di Hogan, può essere meglio:

var result = source.Where((item, index) => index == 0 
          || item != source[index - 1]); 

più leggibile ora penso. Significa "scegliere il primo elemento e quelli che non sono uguali a quello precedente".