Comment utiliser LINQ pour générer toutes les combinaisons possibles à partir de plusieurs tableaux à l'aide du produit cartésien?

Utilisation de LINQ pour générer toutes les combinaisons possibles à partir de plusieurs tableaux: l'approche du produit cartésien

Cet article montre comment exploiter LINQ (requête intégrée par le langage) pour générer efficacement toutes les combinaisons possibles à partir de plusieurs tableaux à l'aide du produit cartésien. Le format de sortie souhaité est une représentation de chaîne suivant le motif a(i) b(j) c(k) n(p), où i, j, k, et p sont des indices dans les plages définies pour chaque tableau.

Comprendre le produit cartésien

Le produit cartésien est un concept mathématique fondamental. Étant donné les ensembles A et B, le produit cartésien A X B est l'ensemble de toutes les paires ordonnées (A, B) où «A» appartient à A et «B» appartient à B. Cela s'étend à plusieurs ensembles.

par exemple, si a = {a, b} et b = {1, 2}, alors a x b = {(a, 1), (a, 2), (b, 1), (b, 2)}.

implémentation linq

Le code LINQ suivant génère les combinaisons souhaitées:

var arr1 = new[] { "a", "b", "c" };
var arr2 = new[] { 3, 2, 4 };

var result = from cpLine in CartesianProduct(
                 from count in arr2 select Enumerable.Range(1, count))
             select cpLine.Zip(arr1, (x1, x2) => x2 + x1);

// Helper function (implementation below)
public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(params IEnumerable<IEnumerable<T>>[] sequences) { ... } 

Ce code utilise une fonction d'assistance CartesianProduct (détaillée ci-dessous) pour calculer le produit cartésien des séquences générées à partir de arr2. Chaque élément dans arr2 définit la plage d'indices pour un élément correspondant dans arr1. La méthode Zip combine ensuite les résultats avec arr1 pour créer les chaînes de sortie finales.

La fonction d'assistance CartesianProduct

Voici une implémentation possible de la fonction CartesianProduct:

public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(params IEnumerable<IEnumerable<T>>[] sequences)
{
    if (sequences == null)
        throw new ArgumentNullException(nameof(sequences));

    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };

    return sequences.Aggregate(
        emptyProduct,
        (accumulator, sequence) =>
            from acc in accumulator
            from item in sequence
            select acc.Concat(new[] { item })
    );
}

Cette fonction calcule récursivement le produit cartésien d'un nombre arbitraire de séquences d'entrée.

sortie de l'échantillon

Le code, lorsqu'il est exécuté, produit la sortie suivante, démontrant toutes les combinaisons possibles:

<code>a1 b1 c1 
a1 b1 c2 
a1 b1 c3 
a1 b1 c4 

a1 b2 c1 
a1 b2 c2 
a1 b2 c3 
a1 b2 c4

a2 b1 c1 
a2 b1 c2 
a2 b1 c3 
a2 b1 c4 

a2 b2 c1 
a2 b2 c2 
a2 b2 c3 
a2 b2 c4

a3 b1 c1 
a3 b1 c2 
a3 b1 c3 
a3 b1 c4 

a3 b2 c1 
a3 b2 c2 
a3 b2 c3 
a3 b2 c4 </code>

Cela présente efficacement la puissance de LINQ pour la génération de toutes les combinaisons possibles à partir de plusieurs tableaux.

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!