c# - Lo contrario de Intersect()

.net collections

Question

Intersect se puede usar para encontrar coincidencias entre dos colecciones, como por ejemplo:

// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call Intersect extension method.
var intersect = array1.Intersect(array2);
// Write intersection to screen.
foreach (int value in intersect)
{
    Console.WriteLine(value); // Output: 2, 3
}

Sin embargo, lo que me gustaría lograr es lo contrario, me gustaría enumerar los elementos que faltan al comparar dos colecciones:

// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call Intersect extension method.
var intersect = array1.NonIntersect(array2); // I''ve made up the NonIntersect method
// Write intersection to screen.
foreach (int value in intersect)
{
    Console.WriteLine(value); // Output: 4
}

Answer 1

Como se dijo, si quieres obtener 4 como resultado, puedes hacer esto:

var nonintersect = array2.Except(array1);

Si desea la no intersección real (también 1 y 4), entonces debería hacer el truco:

var nonintersect = array1.Except(array2).Union( array2.Except(array1));

Esta no será la solución más eficaz, pero para listas pequeñas debería funcionar bien.

Answer 2

Creo que podrías estar buscando Except :

El operador Except produce la diferencia de conjunto entre dos secuencias. Solo devolverá elementos en la primera secuencia que no aparezcan en la segunda secuencia. Opcionalmente, puede proporcionar su propia función de comparación de igualdad.

Echa un vistazo a este enlace , este enlace , o Google, para obtener más información.

Answer 3

Este código enumera cada secuencia una sola vez y usa Select(x => x) para ocultar el resultado para obtener un método de extensión de estilo Linq limpio. Dado que usa HashSet<T> su tiempo de ejecución es O(n + m) si los hashes están bien distribuidos. Los elementos duplicados en cualquiera de las listas se omiten.

public static IEnumerable<T> SymmetricExcept<T>(this IEnumerable<T> seq1,
    IEnumerable<T> seq2)
{
    HashSet<T> hashSet = new HashSet<T>(seq1);
    hashSet.SymmetricExceptWith(seq2);
    return hashSet.Select(x => x);
}

Answer 4

No estoy 100% seguro de lo que se supone que debe hacer su método NonIntersect (con respecto a la teoría de conjuntos).
B / A (todo lo de B que no ocurre en A)?
En caso afirmativo, debería poder utilizar la operación Excepto (B.Except (A)).

Answer 5

Puedes usar

a.Except(b).Union(b.Except(a));

O puedes usar

var difference = new HashSet(a);
difference.SymmetricExceptWith(b);

Answer 6

array1.NonIntersect (array2);

Este operador no está presente en Linq, debe hacerlo

excepto -> unión -> excepto

a.except(b).union(b.Except(a));

Answer 7

/// <summary>
/// Given two list, compare and extract differences
/// http://.com/questions/5620266/the-opposite-of-intersect
/// </summary>
public class CompareList
{
    /// <summary>
    /// Returns list of items that are in initial but not in final list.
    /// </summary>
    /// <param name="listA"></param>
    /// <param name="listB"></param>
    /// <returns></returns>
    public static IEnumerable<string> NonIntersect(
        List<string> initial, List<string> final)
    {
        //subtracts the content of initial from final
        //assumes that final.length < initial.length
        return initial.Except(final);
    }

    /// <summary>
    /// Returns the symmetric difference between the two list.
    /// http://en.wikipedia.org/wiki/Symmetric_difference
    /// </summary>
    /// <param name="initial"></param>
    /// <param name="final"></param>
    /// <returns></returns>
    public static IEnumerable<string> SymmetricDifference(
        List<string> initial, List<string> final)
    {
        IEnumerable<string> setA = NonIntersect(final, initial);
        IEnumerable<string> setB = NonIntersect(initial, final);
        // sum and return the two set.
        return setA.Concat(setB);
    }
}

Answer 8

string left = "411329_SOFT_MAC_GREEN";
string right= "SOFT_MAC_GREEN";

string[] l = left.Split(''_'');
string[] r = right.Split(''_'');

string[] distinctLeft = l.Distinct().ToArray();
string[] distinctRight = r.Distinct().ToArray();

var commonWord = l.Except(r, StringComparer.OrdinalIgnoreCase)
string result = String.Join("_",commonWord);
result = "411329"