Comment vérifier la liste contient une valeur quelconque de la liste B?

Liste A:

1, 2, 3, 4

Liste B:

2, 5

Comment vérifier si Une liste contient une valeur quelconque de la liste B?

par exemple, quelque chose comme A. contient(a=>un.id = B. id)?

InformationsquelleAutor wahaha | 2012-09-11

c#linq list

93

Si vous n'avez pas de soins sur les performances, vous pouvez essayer:
```
a.Any(item => b.Contains(item))
//or, as in the column using a method group
a.Any(b.Contains)
```
Mais je voudrais essayer d'abord ceci:
```
a.Intersect(b).Any()
```
- Fonctionne comme un charme. Puisque vous êtes la première personne à répondre donc j'ai marqué la vôtre comme la réponse. Merci.
- Vous ne pouvez pas utiliser " a " à la fois comme la liste et dans le lambda. a.Any(a => b.Contains(a)). Je voudrais suggérer à l'aide d'une méthode de groupe au lieu a.Any(b.Contains)
- J'ai été en utilisant le "Tout..Contient" approche avant, mais une Intersection approche a un ordre de grandeur plus rapide pour mon problème. Merci pour l'alternative!
InformationsquelleAutor Justin Niessner

J'ai profilé Justins deux solutions. a.Any(a => b.Contains(a)) est plus rapide.

using System;
using System.Collections.Generic;
using System.Linq;

namespace AnswersOnSO
{
    public class Class1
    {
        public static void Main(string []args)
        {
//           How to check if list A contains any value from list B?
//           e.g. something like A.contains(a=>a.id = B.id)?
            var a = new List<int> {1,2,3,4};
            var b = new List<int> {2,5};
            var times = 10000000;

            DateTime dtAny = DateTime.Now;
            for (var i = 0; i < times; i++)
            {
                var aContainsBElements = a.Any(b.Contains);
            }
            var timeAny = (DateTime.Now - dtAny).TotalSeconds;

            DateTime dtIntersect = DateTime.Now;
            for (var i = 0; i < times; i++)
            {
                var aContainsBElements = a.Intersect(b).Any();
            }
            var timeIntersect = (DateTime.Now - dtIntersect).TotalSeconds;

            //timeAny: 1.1470656 secs
            //timeIn.: 3.1431798 secs
        }
    }
}

Si A et B sont de même taille et de grands? Il semble comme cette analyse de la performance dépend de la taille relative de ces listes
J'ai essayé @radbyx de la solution avec deux ensembles de 500 entiers aléatoires, et Any était de loin plus rapide que Intersect. code.dcoder.tech/files/code/5dcc1bf388de5305e2f24b9e/... Any était d'environ 4 secondes, et Intersect était d'environ 185 secondes.

InformationsquelleAutor radbyx

13

Vous pouvez Intersect les deux listes:
```
if (A.Intersect(B).Any())
```
InformationsquelleAutor D Stanley

J'écris une méthode plus rapide pour les faire petit à définir. Mais je l'ai tester une partie des données qu'il est plus rapide, qui se Croisent, mais quelque temps se Croisent rapide que mon code.

    public static bool Contain<T>(List<T> a, List<T> b)
    {
        if (a.Count <= 10 && b.Count <= 10)
        {
            return a.Any(b.Contains);
        }

        if (a.Count > b.Count)
        {
            return Contain((IEnumerable<T>) b, (IEnumerable<T>) a);
        }
        return Contain((IEnumerable<T>) a, (IEnumerable<T>) b);
    }

    public static bool Contain<T>(IEnumerable<T> a, IEnumerable<T> b)
    {
        HashSet<T> j = new HashSet<T>(a);
        return b.Any(j.Contains);
    }

L'Intersection des appels Set qui n'ont pas de vérifier la deuxième taille, ce qui est l'Intersection du code.

        Set<TSource> set = new Set<TSource>(comparer);
        foreach (TSource element in second) set.Add(element);
        foreach (TSource element in first)
            if (set.Remove(element)) yield return element;

La différence dans les deux méthodes est de mon utilisation d'une méthode de HashSet et de vérifier le nombre et le Intersect utilisation set qui est plus rapide que HashSet. Nous n'avons pas warry ses performances.

Le test :

   static void Main(string[] args)
    {
        var a = Enumerable.Range(0, 100000);
        var b = Enumerable.Range(10000000, 1000);
        var t = new Stopwatch();
        t.Start();
        Repeat(()=> { Contain(a, b); });
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//490ms

        var a1 = Enumerable.Range(0, 100000).ToList();
        var a2 = b.ToList();
        t.Restart();
        Repeat(()=> { Contain(a1, a2); });
        t.Stop();

        Console.WriteLine(t.ElapsedMilliseconds);//203ms

        t.Restart();
        Repeat(()=>{ a.Intersect(b).Any(); });
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//190ms

        t.Restart();
        Repeat(()=>{ b.Intersect(a).Any(); });
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//497ms

        t.Restart();
        a.Any(b.Contains);
        t.Stop();
        Console.WriteLine(t.ElapsedMilliseconds);//600ms

    }

    private static void Repeat(Action a)
    {
        for (int i = 0; i < 100; i++)
        {
            a();
        }
    }

InformationsquelleAutor lindexi

Désolé, si c'est irelevant, mais sera de retour liste de correspondances à l'aide de FindAll() dans le cas où vous avez besoin de ceci:

        private bool IsContain(string cont)
    {
        List<string> ListToMatch= new List<string>() {"string1","string2"};

        if (ListToMatch.ToArray().Any(cont.Contains))
        {
            return false;
        }
        else
            return true;
    }

Et utilisation:

List<string> ListToCheck = new List<string>() {"string1","string2","string3","string4"};
List<string> FinalList = ListToCheck.FindAll(IsContain);

La dernière liste ne contient que les éléments qui correspondent string1 et string2 de la liste pour vérifier.
Facile peut être commuté à l'int List.

InformationsquelleAutor Atanas Atanasov

-1

Je l'utilise pour compter:
```
int cnt = 0;

foreach (var lA in listA)
{
    if (listB.Contains(lA))
    {
        cnt++;
    }
}
```
- Un nombre n'est pas demandé. C'est très inefficace, code impératif.
- Un peu plus d'explication est peut-être pour cette réponse, comme la raison pour laquelle vous avez choisi d'utiliser un nombre au lieu d'une valeur booléenne. Ce t faire le travail même si.
InformationsquelleAutor Jan

Vous devez vous connecter pour publier un commentaire.