Permutazione/combinazione fissa del luogo

Question

Sto cercando un modo in cui posso generare una combinazione diversa di 4 set elementi in modo tale che l'elemento di ogni set abbia un posto fisso nella combinazione finale: per spiegare meglio il mio requisito, lasciami dare un campione di quei 4 set e infine ciò che io Sto cercando:

Set#1 (Street pre direzione) {n, s} set#2 (nome stradale) {Frankford, baily} set#3 (tipo di strada) {Ave, st} set#4 (strada di strada) {s}

Lasciami elencare poche combinazioni in attesa:
N Baily Ave s
S Frankford st S
S baily av s
.
.
.

Ora come puoi vedere che l'elemento di ogni set sta cadendo al suo posto
La pressione è in posizione 1
Il nome della strada è al posto 2
Il tipo di strada è al posto 3
La descrizione della strada è al posto 4

Sto cercando il modo più efficiente per svolgere questo compito, un modo per farlo è lavorare in 2 set alla volta come:
Combinazione del set 1 e set 2 -> crea un nuovo set 5 di combinazioni risultanti
Combinazione del set 5 e set 3 -> crea un nuovo set 6 di combinazioni risultanti
Combinazione di set 6 e set 4 -> Questo mi darà le combinazioni finali

C'è un modo migliore per fare questa cosa? Aiuto gentilmente. Preferirò C# o Java.

Grazie

Answer 1

@ David B Cosa succede se l'elenco delle previsioni è vuoto, c'è un modo in cui otteniamo ancora le combinazioni poiché attraverso il tuo modo non verrà restituito alcun prodotto cartesiano.

---

David B qui:

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

Ecco alcuni LINQ (C#) che ti danno tutte le combinazioni, non è "il modo più efficiente".

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

Sembra che tu stia cercando il prodotto cartesiano di alcuni set. Puoi farlo usando nidificati per loop. Ecco il codice Haskell, che non hai chiesto.

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