Quelle est l'approche LINQ optimale pour obtenir un sous-ensemble aléatoire ?

Extension LINQ optimale pour l'extraction aléatoire de sous-collections

Dans le monde de la programmation, il est souvent nécessaire d'extraire un sous-ensemble aléatoire d'une collection donnée. Pour les passionnés de LINQ, vous vous demandez peut-être quel est le moyen optimal d'y parvenir.

Une approche consiste à utiliser la méthode d'extension .Shuffle(), qui effectue le mélange Fisher-Yates-Durstenfeld. Cette méthode randomise efficacement l'ordre des éléments dans une collection, ce qui en fait une solution idéale pour créer une sous-collection aléatoire.

Pour illustrer son utilisation, supposons que vous ayez une collection nommée yourCollection avec N éléments et que vous souhaitiez extraire n éléments aléatoires où n <= N. Voici comment implémenter cela à l'aide de la méthode .Shuffle() :

var randomItems = yourCollection.Shuffle().Take(n);

Ce code mélange d'abord les éléments dans yourCollection en utilisant la méthode .Shuffle(). Il utilise ensuite la méthode .Take() pour extraire les n premiers éléments de la collection mélangée. Le résultat est une sous-collection aléatoire du nombre n.

Voici un exemple d'implémentation de la méthode d'extension .Shuffle() vous-même :

public static class EnumerableExtensions
{
    public static IEnumerable Shuffle(this IEnumerable source)
    {
        return source.Shuffle(new Random());
    }

    public static IEnumerable Shuffle(
        this IEnumerable source, Random rng)
    {
        if (source == null)
            throw new ArgumentNullException(nameof(source));
        if (rng == null)
            throw new ArgumentNullException(nameof(rng));

        return source.ShuffleIterator(rng);
    }

    private static IEnumerable ShuffleIterator(
        this IEnumerable source, Random rng)
    {
        var buffer = source.ToList();
        for (int i = 0; i < buffer.Count; i++)
        {
            int j = rng.Next(i, buffer.Count);
            yield return buffer[j];

            buffer[j] = buffer[i];
        }
    }
}

En utilisant cette méthode d'extension, vous pouvez facilement mélanger et extraire une sous-collection aléatoire de n'importe quelle taille à partir d'une requête LINQ. Cette technique offre une solution pratique et efficace pour une tâche courante de manipulation de données.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!