c# - studio - LINQ: determina si dos secuencias contienen exactamente los mismos elementos

la secuencia no contiene ningún elemento coincidente

Question

Necesito determinar si dos conjuntos contienen exactamente los mismos elementos. El orden no importa.

Por ejemplo, estas dos matrices deberían considerarse iguales:

IEnumerable<int> data = new []{3, 5, 6, 9};
IEnumerable<int> otherData = new []{6, 5, 9, 3}

Un conjunto no puede contener ningún elemento, que no esté en el otro.

¿Se puede hacer esto usando los operadores de consulta incorporados? ¿Y cuál sería la forma más eficiente de implementarlo, teniendo en cuenta que la cantidad de elementos podría oscilar entre unos pocos y cientos?

Answer 1

1. Primero, verifica la duración. Si son diferentes, los conjuntos son diferentes.
2. puedes hacer data.Intersect(otherData); y comprueba que la longitud sea idéntica.
3. O bien, simplifique los conjuntos e itere a través de ellos.

Answer 2

Aquí hay otra manera de hacerlo:

IEnumerable<int> data = new[] { 3, 5, 6, 9 };
IEnumerable<int> otherData = new[] { 6, 5, 9, 3 };

data = data.OrderBy(d => d);
otherData = otherData.OrderBy(d => d);
data.Zip(otherData, (x, y) => Tuple.Create(x, y)).All(d => d.Item1 == d.Item2);

Answer 3

Esto debería ayudar:

    IEnumerable<int> data = new []{ 3,5,6,9 };
    IEnumerable<int> otherData = new[] {6, 5, 9, 3};

    if(data.All(x => otherData.Contains(x)))
    {
        //Code Goes Here
    }

Answer 4

Primero compruebe si ambas colecciones de datos tienen el mismo número de elementos y la comprobación si todos los elementos en una colección se presentan en la otra

        IEnumerable<int> data = new[] { 3, 5, 6, 9 };
        IEnumerable<int> otherData = new[] { 6, 5, 9, 3 };

        bool equals = data.Count() == otherData.Count() && data.All(x => otherData.Contains(x));

Answer 5

Si desea tratar las matrices como "conjuntos" e ignorar el orden y los elementos duplicados, puede utilizar el HashSet<T>.SetEquals :

var isEqual = new HashSet<int>(first).SetEquals(second);

De lo contrario, la mejor opción es, probablemente, ordenar ambas secuencias de la misma manera y usar SequenceEqual para compararlas.

Answer 6

Si puede tener duplicados (o si desea una solución que tenga un mejor rendimiento para listas más largas), probaría algo como esto:

static bool IsSame<T>(IEnumerable<T> set1, IEnumerable<T> set2)
{
    if (set1 == null && set2 == null)
        return true;
    if (set1 == null || set2 == null)
        return false;

    List<T> list1 = set1.ToList();
    List<T> list2 = set2.ToList();

    if (list1.Count != list2.Count)
        return false;

    list1.Sort();
    list2.Sort();

    return list1.SequenceEqual(list2);
}

ACTUALIZACIÓN: uy, ustedes tienen razón, la solución Except () a continuación debe mirar a ambos lados antes de cruzar la calle. Y tiene un rendimiento pésimo para listas más largas. Ignora la sugerencia a continuación! :-)

Aquí hay una manera fácil de hacerlo. Tenga en cuenta que esto supone que las listas no tienen duplicados.

bool same = data.Except (otherData).Count() == 0;

Answer 7

Sugiero ordenar ambos y hacer una comparación elemento por elemento.

data.OrderBy(x => x).SequenceEqual(otherData.OrderBy(x => x))

No estoy seguro de cuán rápido es la implementación de OrderBy , pero si es un tipo O (n log n), como es de esperar, el algoritmo total es O (n log n) también.

Para algunos casos de datos, puede mejorar esto mediante el uso de una implementación personalizada de OrderBy que, por ejemplo, utiliza una clasificación de conteo, para O (n + k), con k el tamaño del rango en el que se encuentran los valores.