Permutation / combinaison fixe

Question

Je cherche un moyen où je peux générer différentes combinaisons de 4 éléments de sets de telle manière que l'élément de chaque ensemble ait une place fixe dans la combinaison finale: pour mieux expliquer mon exigence, laissez-moi donner un échantillon de ces 4 ensembles et enfin ce que je suis à la recherche:

Set # 1 (Street Pre Direction) {n, s} set # 2 (nom de rue) {Frankford, Baily} set # 3 (type de rue) {Ave, ST} set # 4 (Street Post Direction) {S}

Permettez-moi de répertorier quelques combinaisons attendant:
N Baily Ave S
S Frankford St S
S Baily Av S
.
.
.

Maintenant, comme vous pouvez le voir que l'élément de chaque ensemble tombe à sa place
La pré-direction est en place 1
Le nom de rue est en place 2
Le type Streety est en place 3
La description de la rue est en place 4

Je recherche le moyen le plus efficace de mener à bien cette tâche, une façon de le faire est de travailler à 2 sets à la fois comme:
Faire la combinaison de l'ensemble 1 et de l'ensemble 2 -> Créez un nouvel ensemble 5 des combinaisons résultantes
Faire la combinaison de l'ensemble 5 et de l'ensemble 3 -> Créez un nouvel ensemble 6 des combinaisons résultantes
Faire une combinaison de l'ensemble 6 et du set 4 -> Cela me donnera les combinaisons finales

Y a-t-il une meilleure façon de faire cette chose? Aide aimablement. Je préférerai C # ou Java.

Merci

Answer 1

@ David B Et si la liste des prédirections est vide, y a-t-il un moyen que nous obtenions toujours les combinaisons car à votre chemin, aucun produit cartésien ne sera retourné.

---

David B ici:

var query =
  from d in predirections.DefaultIfEmpty()
  from n in names.DefaultIfEmpty()
  from t in types.DefaultIfEmpty()
  from s in postdirections.DefaultIfEmpty()
  select new {d, n, t, s};

Answer 2

Voici quelques Linq (C #) qui vous donnent toutes les combinaisons, ce n'est pas "la manière la plus efficace".

var query =
  from d in predirections
  from n in names
  from t in types
  from s in postdirections
  select new {d, n, t, s};

Answer 3

Il semble que vous recherchiez le produit cartésien de certains ensembles. Vous pouvez le faire en utilisant des boucles imbriquées. Voici le code Haskell, que vous n'avez pas demandé.

Prelude> [[x,y] | x <- ['1'..'3'], y <- ['A'..'C']]
["1A","1B","1C","2A","2B","2C","3A","3B","3C"]