Pregunta de Linq que reduce un subconjunto de duplicados a un solo valor dentro de un conjunto más grande?

Question

¿Hay un comando linq que filtre los duplicados que aparecen en una secuencia?

Ejemplo 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 } 

Gracias.

Answer 1

Similar a la respuesta de svick, excepto con efectos secundarios para evitar las desventajas e inversa:

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; 
    }); 

Editar: Ya no necesita la source.First() como por la preocupación de 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; 
    }) 
); 

pienso Todavía me gusta más la solución de Danny.

Answer 2

En realidad no. Me gustaría escribir esto:

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

Puede utilizar Aggregate() (aunque no estoy seguro de si es mejor que la solución no 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(); 

I piensan es O (n), pero no estoy del todo seguro.

Answer 4

Si está utilizando .NET 4, puede hacerlo utilizando el método Zip incorporado, aunque probablemente preferiría usar un método de extensión personalizado como el que se muestra en 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í hay! Código de una línea y un bucle de la matriz.

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]); 

Y de acuerdo a @ consejos de Hogan, que puede ser mejor:

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

más legible ahora pienso. Significa "elegir el primer elemento y aquellos que no son iguales al anterior".