body -> onload=load_set visualizza il set di immagini

carica le immagini e le visualizza in lista_img

se onclick su una img set_img

set_img -> costruisce la matrice w_img e la visualizza in word_img

elenca... -> showCombination(inputField.value)

controlla il numero - printWordList(createWordList(new Array(), "", inputText))

esegue la stampa della funzione ricorsiva createWordList(parametri: wordArray, strbase e remainingchars)

wordArray: matrice vuota che sarà restituita con tutte permutazioni

strbase: stringa che genera a permutazione successiva ?

remainingchars: stringa rimanente dopo...

_____________________________________ 

Permutazioni (scelta ordinata) di n ogg. presi r alla volta: P(n,r) = n!/(n-r)!. Se:r=n, P(n,r) = n!

Combinazioni (scelta non ordinata) di n ogg. presi r alla volta: C(n,r) = n!/r!(n-r)!. Se: r=n, C(n,r) = 1

button -elenca- chiama showCombinations(inputField.value) e passa il paramtero che compare nel campo "inputField"

showCombinations(parola) > calculateCombinations(parola) /controlla/ printWordList(createWordList(new Array(), "", inputText)) /calcola e stampa/

printWordList riceve il parametro: (createWordList(new Array(), "", inputText))

createWordList(new Array(), "", inputText))

funzione ricorsiva che riceve 3 parametri:

wordArray (inizialmente vuoto), strbase (vuoto), remainingchars (inizialmente la parola iniziale)

wordArray è la somma di tutte le parole, strbase

printWordList() ricostruisce la matrice interponendo un separatore (, ) e costruisce una nuova matrice con parole formate da immagini al posto di lettere .

algoritmo per la genarazione di tutte le permutazioni in ordine lessicografico. Da "Combinatoria computazionale"

k[] = k[1], k[2], k[3], k[4]

// 1. trovare il massimo i tale che k[i-1] < k[i]

// la posizione più a sinistra tale che il il valore (della cifra) sia maggiore della successiva.

   for (i=n; i=2; i--)

   if k[i] > k[i-1]

    x = k[i-1]

// 2. trovare il massimo j tale che k[i-1] < k[j]

// la posizione più a sinistra tale che il il valore (della cifra) sia maggiore di k[i-1].

// 3. scambiare k[i-1] e k[j]