Das Gegenteil von Intersect()

Intersect verwendet werden kann, zu finden, übereinstimmungen zwischen beiden Sammlungen, etwa so:

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

Allerdings, was möchte ich erreichen das Gegenteil, ich möchte die Liste die Elemente, die fehlen beim Vergleich von zwei Sammlungen:

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

InformationsquelleAutor der Frage Peter Bridger | 2011-04-11

  1. 329

    Wie gesagt, wenn Sie möchten, um 4 als Ergebnis, können Sie dies so tun:

    var nonintersect = array2.Except(array1);

    Wenn Sie möchten, dass die wirkliche nicht-Kreuzung (beide auch 1 und 4), dann sollte dies den trick tun:

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

    Wird dies nicht die meisten performante Lösung, aber für kleine Listen es sollte gut funktionieren.

    InformationsquelleAutor der Antwort Øyvind Bråthen

  2. 77

    Können Sie 

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

    Oder verwenden Sie 

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

    InformationsquelleAutor der Antwort sehe

  3. 11

    Dieser code listet jede Sequenz nur einmal verwendet Select(x => x) zu verbergen das Ergebnis, um eine saubere Linq-Stil-Erweiterung-Methode. Da nutzt es HashSet<T> seine Laufzeit ist O(n + m) wenn die hashes sind gut verteilt. Doppelte Elemente in einer der Listen entfallen sind.

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

    InformationsquelleAutor der Antwort CodesInChaos

  4. 4

    Ich denke, Sie könnten auf der Suche nach Except:

    Den Except-operator erzeugt den Satz
    Unterschied zwischen zwei Sequenzen. Es
    wird nur die Rückkehr der Elemente in der ersten
    Sequenz, die nicht in der
    zweite. Optional können Sie liefern
    eigene Geschlechter-Vergleich-Funktion.

    Check-out dieser linkdieser linkoder Google, für weitere Informationen.

    InformationsquelleAutor der Antwort Grant Thomas

  5. 2

    Bin ich mir nicht 100% sicher, was Ihr NonIntersect Methode tun soll (in Bezug auf set-Theorie) - ist es

    B \ A (alles von B, der nicht auftreten)?

    Wenn ja, dann sollten Sie in der Lage sein zu verwenden, die Außer Betrieb (B. Außer(A)).

    InformationsquelleAutor der Antwort Frank Schmitt

  6. 2
    ///<summary>
///Given two list, compare and extract differences
///http://stackoverflow.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);
    }
}

    InformationsquelleAutor der Antwort alcedo

  7. 2

    array1.NonIntersect(array2);

    Nonintersect diesem Betreiber ist nicht in Linq-Sie tun sollten,

    außer -> union -> außer

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

    InformationsquelleAutor der Antwort safder

  8. -1
    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"

    InformationsquelleAutor der Antwort kiflay

Schreibe einen Kommentar