Überprüfen, ob ein Array eine Teilmenge eines anderen

Question

ist Eine Idee, wie überprüft werden kann, ob diese Liste eine Teilmenge eines anderen ist?

Insbesondere, ich habe

List<double> t1 = new List<double> { 1, 3, 5 }; 
List<double> t2 = new List<double> { 1, 5 }; 

Wie das t2 zu überprüfen, eine Teilmenge von t1 ist, mithilfe von LINQ?

Answer 1

bool isSubset = !t2.Except(t1).Any(); 

Answer 2

Versuchen Sie, diese

static bool IsSubSet<A>(A[] set, A[] toCheck) { 
    return set.Length == (toCheck.Intersect(set)).Count(); 
} 

Die Idee dabei ist, dass Intersect nur die Werte zurück, die in den beiden Arrays sind. An diesem Punkt, wenn die Länge der resultierenden Menge die gleiche wie die ursprüngliche Menge ist, sind alle Elemente in "set" ebenfalls "check" und daher ist "set" eine Teilmenge von "toCheck" Die Lösung funktioniert nicht, wenn "set" Duplikate enthält. Ich ändere es nicht, weil ich nicht die Stimmen anderer Leute stehlen will.

Hinweis: Ich habe für Camerons Antwort gestimmt.

Answer 3

Verwenden Sie HashSet anstelle von List, wenn Sie mit Sets arbeiten. Dann können Sie einfach IsSubsetOf()

HashSet<double> t1 = new HashSet<double>{1,3,5}; 
HashSet<double> t2 = new HashSet<double>{1,5}; 

bool isSubset = t2.IsSubsetOf(t1); 

Leider verwenden, dass es nicht LINQ nicht verwendet. :-(

Wenn Sie Listen verwenden, dann @ Jared Lösung mit dem Vorbehalt, arbeitet, die Sie sich wiederholende Elemente entfernen müssen, die vorhanden sind

Answer 4

@ Camerons Lösung als Erweiterung Methode:.

public static bool IsSubsetOf<T>(this IEnumerable<T> a, IEnumerable<T> b) 
{ 
    return !a.Except(b).Any(); 
} 

Verbrauch:

bool isSubset = t2.IsSubsetOf(t1); 

(Dies ist ähnlich, aber nicht ganz die gleiche wie die ein @ Michaels Blog posted on)

Answer 5

Wenn Sie Komponententests sind, können Sie auch die CollectionAssert.IsSubsetOf Methode verwenden:

Im obigen Fall dies bedeuten würde: Das

CollectionAssert.IsSubsetOf(t2, t1); 

Answer 6

ist eine deutlich effizientere Lösung als die anderen hier gepostet, vor allem die oberste Lösung:

bool isSubset = t2.All(elem => t1.Contains(elem)); 

Wenn Sie ein einzelnes Element in t2 finden, das nicht in t1 ist, dann wissen Sie, dass t2 keine Untermenge von t1 ist. Der Vorteil dieser Methode besteht darin, dass sie im Gegensatz zu den Lösungen, die .Except oder .Intersect verwenden, im Gegensatz zu den Lösungen direkt vor Ort bereitgestellt wird, ohne zusätzlichen Speicherplatz zuzuweisen. Außerdem kann diese Lösung brechen, sobald ein einzelnes Element gefunden wird, das die Teilmengenbedingung verletzt, während die anderen die Suche fortsetzen. Unten ist die optimale lange Form der Lösung, die in meinen Tests nur marginal schneller ist als die obige Kurzschriftlösung.

bool isSubset = true; 
foreach (var element in t2) { 
    if (!t1.Contains(element)) { 
     isSubset = false; 
     break; 
    } 
} 

Ich habe einige rudimentäre Performance-Analyse aller Lösungen, und die Ergebnisse sind drastisch. Diese beiden Lösungen sind etwa 100x schneller als die Lösungen .Except() und .Intersect() und verwenden keinen zusätzlichen Speicher.

Answer 7

Aufbauend auf den Antworten von @Cameron und @Neil habe ich eine Erweiterungsmethode geschrieben, die dieselbe Terminologie wie die Enumerable-Klasse verwendet.

/// <summary> 
/// Determines whether a sequence contains the specified elements by using the default equality comparer. 
/// </summary> 
/// <typeparam name="TSource">The type of the elements of source.</typeparam> 
/// <param name="source">A sequence in which to locate the values.</param> 
/// <param name="values">The values to locate in the sequence.</param> 
/// <returns>true if the source sequence contains elements that have the specified values; otherwise, false.</returns> 
public static bool ContainsAll<TSource>(this IEnumerable<TSource> source, IEnumerable<TSource> values) 
{ 
    return !values.Except(source).Any(); 
}