Trovare ogni combinazione di elementi in una tabella (Lua/PseudoCode)

Question

Sto provando a eseguire una funzione con ogni singola combinazione di elementi da una tabella. (A Lua). La tabella e gli elementi possono cambiare, ma la struttura rimarrà la stessa. La tabella è organizzata in modo che [1] di esso sia il primo argomento della funzione, e così via e così via.

Se si tratta di una tabella che ho,

Table = { 
    [1] = {Player1, Player2} 
    [2] = {PlayerA, PlayerB, PlayerC} 
    [3] = {PlayerOne, PlayerTwo} 
} 

Se ho scritto che manualmente, sarebbe probabilmente simile a questa: (Dato che la funzione si chiama Exe).

Exe(Player1, PlayerA, PlayerOne) 
Exe(Player2, PlayerA, PlayerOne) 
Exe(Player3, PlayerA, PlayerOne) 

Exe(Player1, PlayerB, PlayerOne) 
Exe(Player2, PlayerB, PlayerOne) 
Exe(Player3, PlayerB, PlayerOne) 

Exe(Player1, PlayerC, PlayerOne) 
Exe(Player2, PlayerC, PlayerOne) 
Exe(Player3, PlayerC, PlayerOne) 


Exe(Player1, PlayerA, PlayerTwo) 
Exe(Player2, PlayerA, PlayerTwo) 
Exe(Player3, PlayerA, PlayerTwo) 

Exe(Player1, PlayerB, PlayerTwo) 
Exe(Player2, PlayerB, PlayerTwo) 
Exe(Player3, PlayerB, PlayerTwo) 

Exe(Player1, PlayerC, PlayerTwo) 
Exe(Player2, PlayerC, PlayerTwo) 
Exe(Player3, PlayerC, PlayerTwo) 

Tuttavia, non voglio scrivere che fuori, e mi si spezza il regola generale che, se stai copiando e incollando in un programma, si sta facendo male.

Quindi, invece, vorrei passare attraverso la tabella ed eseguire ogni singola combinazione possibile. Il problema in modo che la tabella possa (potenzialmente) avere un numero qualsiasi di tabelle al suo interno, e anche che la tabella all'interno della tabella possa potenzialmente avere un numero illimitato di valori.

Ad esempio, la tabella potrebbe finire per assomigliare questa:

Table = { 
    [1] = {Player1, Player2} 
    [2] = {PlayerA} 
    [3] = {PlayerOne} 
} 

In cui esecuzione finirebbe per assomigliare manualmente:

Exe(Player1, PlayerA, PlayerOne) 
Exe(Player2, PlayerA, PlayerOne) 

Inoltre, la tabella può finire così :

Table = { 
    [1] = {Player1, Player2} 
    [2] = {PlayerA} 
    [3] = {PlayerOne} 
    [4] = {PlayerUno, PlayerDos} 
    [5] = {PlayerApple, PlayerBoy, PlayerCat, PlayerDog} 
} 

In cui l'exeuction finirebbe come ..

Come potete vedere, ho trovato un modello ... Sono stato in grado di dividere la suddetta cosa 'Esecuzione' sopra in segmenti/gruppi, come la linea 1 e la linea 2 hanno una modifica. Quindi, vengono copiati nella riga 4 e 5, ma la variabile successiva viene modificata.

Come potete vedere, ho difficoltà a inserire questo schema in codice. Penso che sarà necessario ricorrere a una funzione di ricorsione, ma non sono sicuro di come estrarlo o di ricorrere attraverso di esso. Sto pensando che dovrò usare le funzioni con ... come gli argomenti e la funzione di decompressione, ma non sono sicuro di come funzionerebbe.

Inoltre, il motivo per cui è necessario, e non solo manualmente copiarlo e incollarlo (che in realtà sarebbe più semplice), è perché verrà generato il contenuto della tabella.

Potete aiutarmi ragazzi?

Answer 1

Utilizzare la ricorsione.

immaginare una funzione che mappa map_all (fcn, tab, idx, ...)fcn al prodotto degli elementi di tutte le tabelle tab[1] per tab[idx] anteporre al ...

Il caso base è quando idx è inferiore a 1.In tal caso, è sufficiente applicare fcn(...)

In caso contrario, map_all(fcn, tab, idx-1, <el>, ...) per tutti <el> in tab[idx]

function map_all (fcn, tab, idx, ...) 
    if idx < 1 then 
     fcn(...) 
    else 
     local t = tab[idx] 
     for i = 1, #t do map_all(fcn, tab, idx-1, t[i], ...) end 
    end 
end 

Quindi,

> Table = { 
>>  [1] = {'Player1', 'Player2'}, 
>>  [2] = {'PlayerA', 'PlayerB', 'PlayerC'}, 
>>  [3] = {'PlayerOne', 'PlayerTwo'} 
>> } 
> map_all(print, Table, #Table) 
Player1 PlayerA PlayerOne 
Player2 PlayerA PlayerOne 
Player1 PlayerB PlayerOne 
Player2 PlayerB PlayerOne 
Player1 PlayerC PlayerOne 
Player2 PlayerC PlayerOne 
Player1 PlayerA PlayerTwo 
Player2 PlayerA PlayerTwo 
Player1 PlayerB PlayerTwo 
Player2 PlayerB PlayerTwo 
Player1 PlayerC PlayerTwo 
Player2 PlayerC PlayerTwo 

e

> Table = { 
>>  [1] = {'Player1', 'Player2'}, 
>>  [2] = {'PlayerA'}, 
>>  [3] = {'PlayerOne'} 
>> } 
> map_all(print, Table, #Table) 
Player1 PlayerA PlayerOne 
Player2 PlayerA PlayerOne 

e

> Table = { 
>>  [1] = {'Player1', 'Player2'}, 
>>  [2] = {'PlayerA'}, 
>>  [3] = {'PlayerOne'}, 
>>  [4] = {'PlayerUno', 'PlayerDos'}, 
>>  [5] = {'PlayerApple', 'PlayerBoy', 'PlayerCat', 'PlayerDog'}, 
>> } 
> map_all(print, Table, #Table) 
Player1 PlayerA PlayerOne PlayerUno PlayerApple 
Player2 PlayerA PlayerOne PlayerUno PlayerApple 
Player1 PlayerA PlayerOne PlayerDos PlayerApple 
Player2 PlayerA PlayerOne PlayerDos PlayerApple 
Player1 PlayerA PlayerOne PlayerUno PlayerBoy 
Player2 PlayerA PlayerOne PlayerUno PlayerBoy 
Player1 PlayerA PlayerOne PlayerDos PlayerBoy 
Player2 PlayerA PlayerOne PlayerDos PlayerBoy 
Player1 PlayerA PlayerOne PlayerUno PlayerCat 
Player2 PlayerA PlayerOne PlayerUno PlayerCat 
Player1 PlayerA PlayerOne PlayerDos PlayerCat 
Player2 PlayerA PlayerOne PlayerDos PlayerCat 
Player1 PlayerA PlayerOne PlayerUno PlayerDog 
Player2 PlayerA PlayerOne PlayerUno PlayerDog 
Player1 PlayerA PlayerOne PlayerDos PlayerDog 
Player2 PlayerA PlayerOne PlayerDos PlayerDog 
>