Verifique se uma matriz é um subconjunto de outra

Alguma idéia de como verificar se essa lista é um subconjunto de outra?

Especificamente, eu tenho

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

Como verificar se t2 é um subconjunto de t1, usando LINQ?

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

Use HashSet em vez de List se estiver trabalhando com conjuntos. Então você pode simplesmente usar IsSubsetOf ()

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

bool isSubset = t2.IsSubsetOf(t1);

Desculpe por não usar o LINQ. :-(

Se você precisar usar listas, a solução do @ Jared funcionará com a ressalva de que você precisará remover todos os elementos repetidos existentes.

Se você estiver testando a unidade, também poderá utilizar o método CollectionAssert.IsSubsetOf :

CollectionAssert.IsSubsetOf(subset, superset);

No caso acima, isso significaria:

CollectionAssert.IsSubsetOf(t2, t1);

Esta é uma solução significativamente mais eficiente que as outras postadas aqui, especialmente a solução principal:

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

Se você puder encontrar um único elemento em t2 que não esteja em t1, saberá que t2 não é um subconjunto de t1. A vantagem desse método é que ele é feito no local, sem alocar espaço adicional, ao contrário das soluções usando .Except ou .Intersect. Além disso, esta solução pode quebrar assim que encontrar um único elemento que viole a condição do subconjunto, enquanto os outros continuam pesquisando. Abaixo está a forma longa ideal da solução, que é marginalmente mais rápida em meus testes do que a solução abreviada acima.

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

Fiz algumas análises rudimentares de desempenho de todas as soluções e os resultados são drásticos. Essas duas soluções são cerca de 100x mais rápidas que as soluções .Except () e .Intersect () e não usam memória adicional.

@ A solução da Cameron como método de extensão:

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

Uso:

bool isSubset = t2.IsSubsetOf(t1);

(Isso é semelhante, mas não o mesmo que o postado no blog do @ Michael)

Com base nas respostas de @Cameron e @Neil, escrevi um método de extensão que usa a mesma terminologia que a 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();
}

Aqui, verificamos que, se houver algum elemento presente na lista filho (por exemplo t2) que não esteja contido na lista pai (por exemplo t1). Se nenhum deles existir, a lista será um subconjunto do outro

por exemplo:

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

Tente isto

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

A idéia aqui é que o Intersect retornará apenas os valores que estão nas duas matrizes. Nesse momento, se o comprimento do conjunto resultante for igual ao conjunto original, todos os elementos em "conjunto" também estarão em "verificação" e, portanto, "conjunto" será um subconjunto de "toCheck"

Nota: Minha solução não funcionará se "set" tiver duplicatas. Não estou mudando, porque não quero roubar os votos de outras pessoas.

Dica: votei na resposta de Cameron.