Vérifiez si un tableau est un sous-ensemble d'un autre

Une idée sur la façon de vérifier si cette liste est un sous-ensemble d'une autre?

Plus précisément, j'ai

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

Comment vérifier que t2 est un sous-ensemble de t1, en utilisant LINQ?

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

Utilisez HashSet au lieu de List si vous travaillez avec des ensembles. Ensuite, vous pouvez simplement utiliser IsSubsetOf ()

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

bool isSubset = t2.IsSubsetOf(t1);

Désolé qu'il n'utilise pas LINQ. :-(

Si vous avez besoin d'utiliser des listes, la solution de @ Jared fonctionne avec l'avertissement que vous devrez supprimer tous les éléments répétés qui existent.

Si vous effectuez des tests unitaires, vous pouvez également utiliser la méthode CollectionAssert.IsSubsetOf :

CollectionAssert.IsSubsetOf(subset, superset);

Dans le cas ci-dessus, cela signifierait:

CollectionAssert.IsSubsetOf(t2, t1);

C'est une solution nettement plus efficace que les autres publiées ici, en particulier la meilleure solution:

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

Si vous pouvez trouver un seul élément dans t2 qui n'est pas dans t1, alors vous savez que t2 n'est pas un sous-ensemble de t1. L'avantage de cette méthode est qu'elle se fait entièrement en place, sans allouer d'espace supplémentaire, contrairement aux solutions utilisant .Except ou .Intersect. De plus, cette solution est capable de s'interrompre dès qu'elle trouve un élément unique qui viole la condition du sous-ensemble, tandis que les autres continuent la recherche. Vous trouverez ci-dessous la forme longue optimale de la solution, qui n'est que légèrement plus rapide dans mes tests que la solution abrégée ci-dessus.

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

J'ai fait une analyse rudimentaire des performances de toutes les solutions, et les résultats sont drastiques. Ces deux solutions sont environ 100 fois plus rapides que les solutions .Except () et .Intersect () et n'utilisent aucune mémoire supplémentaire.

@ La solution de Cameron comme méthode d'extension:

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

Usage:

bool isSubset = t2.IsSubsetOf(t1);

(Ceci est similaire, mais pas tout à fait le même que celui publié sur le blog de @ Michael)

En me basant sur les réponses de @Cameron et @Neil, j'ai écrit une méthode d'extension qui utilise la même terminologie que la classe Enumerable.

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

Ici, nous vérifions que s'il y a un élément présent dans la liste enfant (c'est-à-dire t2) qui n'est pas contenu par la liste parent (c'est-à-dire t1) .Si aucun élément n'existe, alors la liste est un sous-ensemble de l'autre

par exemple:

bool isSubset = !(t2.Any(x => !t1.Contains(x)));

Essaye ça

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

L'idée ici est que Intersect ne renverra que les valeurs qui se trouvent dans les deux tableaux. À ce stade, si la longueur de l'ensemble résultant est la même que celle de l'ensemble d'origine, alors tous les éléments de «set» sont également en «check» et donc «set» est un sous-ensemble de «toCheck»

Remarque: ma solution ne fonctionne pas si "set" a des doublons. Je ne le change pas parce que je ne veux pas voler les votes des autres.

Indice: j'ai voté pour la réponse de Cameron.