Controllare se un array è un sottoinsieme di un altro

Qualche idea su come verificare se tale elenco è un sottoinsieme di un altro?

In particolare, ho

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

Come verificare che t2 sia un sottoinsieme di t1, usando LINQ?

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

Utilizzare HashSet invece di Elenco se si lavora con i set. Quindi puoi semplicemente usare IsSubsetOf ()

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

bool isSubset = t2.IsSubsetOf(t1);

Mi dispiace che non usi LINQ. :-(

Se è necessario utilizzare gli elenchi, la soluzione di @ Jared funziona con l'avvertenza che sarà necessario rimuovere eventuali elementi ripetuti esistenti.

Se si esegue il test unitario è anche possibile utilizzare il metodo CollectionAssert.IsSubsetOf :

CollectionAssert.IsSubsetOf(subset, superset);

Nel caso precedente ciò significherebbe:

CollectionAssert.IsSubsetOf(t2, t1);

Questa è una soluzione significativamente più efficiente rispetto alle altre pubblicate qui, in particolare la soluzione migliore:

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

Se riesci a trovare un singolo elemento in t2 che non è in t1, allora sai che t2 non è un sottoinsieme di t1. Il vantaggio di questo metodo è che viene eseguito tutto sul posto, senza allocare spazio aggiuntivo, a differenza delle soluzioni che utilizzano .Except o .Intersect. Inoltre, questa soluzione è in grado di rompersi non appena trova un singolo elemento che viola la condizione del sottoinsieme, mentre gli altri continuano a cercare. Di seguito è la forma lunga ottimale della soluzione, che è solo leggermente più veloce nei miei test rispetto alla soluzione abbreviata sopra.

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

Ho fatto un'analisi rudimentale delle prestazioni di tutte le soluzioni e i risultati sono drastici. Queste due soluzioni sono circa 100 volte più veloci delle soluzioni .Except () e .Intersect () e non utilizzano memoria aggiuntiva.

@ La soluzione di Cameron come metodo di estensione:

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

Uso:

bool isSubset = t2.IsSubsetOf(t1);

(Questo è simile, ma non è lo stesso di quello pubblicato sul blog di @ Michael)

Basandomi sulle risposte di @Cameron e @Neil, ho scritto un metodo di estensione che utilizza la stessa terminologia della 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();
}

Qui controlliamo che se ci sono elementi presenti nella lista figlio (cioè t2) che non è contenuta nella lista padre (cioè t1). Se nessuno di questi esiste allora l'elenco è sottoinsieme dell'altro

per esempio:

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

Prova questo

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

L'idea qui è che Intersect restituirà solo i valori presenti in entrambe le matrici. A questo punto se la lunghezza dell'insieme risultante è uguale all'insieme originale, anche tutti gli elementi in "set" sono in "check" e quindi "set" è un sottoinsieme di "toCheck"

Nota: la mia soluzione non funziona se "set" ha duplicati. Non lo sto cambiando perché non voglio rubare i voti degli altri.

Suggerimento: ho votato a favore della risposta di Cameron.