1

Laurea Magistrale in “Cinema e Media” Corso di “Rappresentazione e Algoritmi” 2014-15

Modulo I - 6 CFU

mutuato da Laurea Magistrale in “Scienze del Corpo e della Mente”

6 CFU

Laurea Magistrale in “Scienze della Mente” Corso di “Intelligenza artificiale” 2013-14

Modulo I - 4 CFU

Vincenzo Lombardo

Note per il corso

Queste note per i corsi di “Rappresentazione e algoritmi” sono parte del programma d’esame 2014/15. L’idea di scrivere le note scaturisce dalla considerazione che, essendo frequentato il corso anche da studenti provenienti da altre sedi in Italia o all’estero, spesso la preparazione di base dell’informatica non è sufficiente per affrontare lo studio dei testi adottati (come da guida degli studi). Dopo una ricerca sul web di testi e dispense possibili, mi sono convinto che sono tutti pensati per scopi diversi da un corso nell’ambito dei media o della psicologia. Gli esempi riportati, la presentazione degli argomenti, l’obiettivo a cui è destinato lo studio non sono familiari agli studenti di “Cinema e media” e di “Scienze del Corpo e della Mente”.

BOZZA: MODELLAZIONE FORMALE DI DATI, CONOSCENZA, PROCESSI

Commenti benvenuti!

Aggiornamento: 27 marzo 2015

2

Capitolo 1

Introduzione alla rappresentazione dei dati e degli algoritmi

Questo capitolo introduce alle nozioni preliminari per la modellazione formale. Si parte da un’alfabetizzazione informatica, nel senso degli elementi fondamentali della computazione, che classificheremo secondo il classico schema dei dati e delle procedure. I dati sono la rappresentazione degli aspetti essenziali di ciò che esiste, in realtà proprio ciò che esiste dal punto di vista della macchina. Li affronteremo dal punto di vista della programmazione, mutuando i tipi di dati e le strutture di dati dalla pratica dei linguaggi di programmazione, cioè a partire da modelli che sono vicini al modello della macchina stessa. Le procedure sono le descrizioni di come avvengono i cambiamenti nei dati, cioè dei meccanismi di manipolazione della rappresentazione finalizzati a un certo obiettivo (la soluzione di un problema, l’aggiornamento di una situazione, il recupero di un valore, …). In questo caso, occorre definire quali siano le operazioni elementari che modificano i dati e i meccanismi di controllo che determinano quale operazione applicare di volta in volta.

Indice

1.   I linguaggi della macchina 2.   La modellazione 3.   La scrittura degli algoritmi 4.   La subroutine 5.   La simulazione degli algoritmi

3

1. I linguaggi della macchina I computer oggi, anche connessi in rete, eseguono compiti molto differenziati tra loro, dalle prenotazioni delle vacanze al controllo di linee di metropolitana, per non dimenticare i compiti noiosi e delicati di tenere sotto controllo il bilancio familiare mediante un foglio di calcolo. Sembra che non ci siano limiti alle mansioni che possono essere affidate a un calcolatore. Nell’esecuzione dei compiti, che possono essere soluzioni di problemi (qual è il viaggio più rapido tra Milano e Tozeur?), calcoli di funzioni (la soluzione di un’equazione differenziale), in generale, per passare da un input a un output, si adottano numerosi paradigmi, costruiti su modelli di macchine. Assumendo la nota architettura di alto livello di un computer, composta da un’unità di elaborazione centrale (CPU), dalla memoria (suddivisa tra centrale e di massa), e dai dispositivi di input/output, si può pensare a un modello di macchina su più livelli di astrazione (la cosiddetta struttura a cipolla), con l’individuazione di un linguaggio di rappresentazione a ogni livello.

Figura 1. Architettura di alto livello di un computer. Per affidare alla macchina le mansioni di varia natura menzionate sopra, occorre esprimere in qualche linguaggio di comunicazione sia le situazioni da affrontare sia i modi per affrontarle. Il linguaggio macchina rappresenta il livello di descrizione più vicino alla modalità di funzionamento fisico di un elaboratore (operazioni al livello dei bit). Anche la più sofisticata delle macchine attuali è un insieme di bit, interruttori che possono cambiare di stato, o come si dice “flippati” da uno stato all’altro dei due possibili, 0/1, Acceso/Spento, On/Off, … , o “testati” per il loro stato. L’operazione base di flip del bit, la descriviamo con un esempio:

DATO: 01101 ISTRUZIONE: FLIP DEL TERZO BIT DATO: 01001 ISTRUZIONE: FLIP DEL PRIMO BIT DATO: 11001

Lo complichiamo leggermente, aggiungendo un test che vincola il flip ad avvenire solo nel caso in cui un bit valga un valore specifico, 0 o 1:

4

DATO: 01101 ISTRUZIONE: SE IL TERZO BIT = 0, ALLORA FLIP DEL QUINTO BIT DATO: 01101 ISTRUZIONE: SE IL TERZO BIT = 1, ALLORA FLIP DEL PRIMO BIT DATO: 11101

L’astrazione del linguaggio assemblato sul linguaggio macchina è quella di inserire notazioni simboliche sulle locazioni di memoria, che contengono istruzioni (rappresentate da codici operativi mnemonici, opcode) e dati (ad esempio, in codifica esadecimale), pur mantenendo una corrispondenza stretta con il linguaggio macchina. Ad esempio, l’istruzione in linguaggio assemblato Intel (riportata alla voce di Wikipedia)

MOV AL, 61h ; Load AL with 97 decimal (61 hex)

permette di caricare il registro AL (un’area di memoria riservata per l’accumulo dei risultati) con il valore numerico 97 (MOV indica proprio il “movimento” del dato verso il registro e 61h è il codice esadecimale del decimale 97). Si noti anche il commento che segue il “;”, utile solo al programmatore (umano) per ricordarsi il significato dell’istruzione. Per eseguire un programma in linguaggio assemblato, al livello macchina si scrive un programma traduttore, l’assemblatore, che si occupa di tradurre le istruzioni in linguaggio assemblato nelle corrispondenti istruzioni in linguaggio macchina (interpretabili direttamente dalla macchina). Il linguaggio assemblato, con la sua astrazione simbolica, porta l’attenzione sulla nozione di rappresentazione dei dati. Infatti, “flippare” i bit o caricare un registro con un dato, sono operazioni di per sé prive di contenuto, se non interpretiamo il significato del bit flippato o del dato caricato, rispettivamente. Una sequenza di bit (anche detta parola binaria) o un simbolo (come AL) possono rappresentare qualsiasi cosa a seconda dell’interpretazione adottata. Nel caso del codice ASCII (7 bit per la rappresentazione dei caratteri) la sequenza di bit

110 0001

rappresenta il carattere ‘a’; la stessa sequenza può essere interpretata come il numero decimale “97” (quindi a livello macchina sarebbe questa la traduzione del dato sopra, 61h, nell’esempio in linguaggio assemblato). Ogni qualvolta si lavori su un certo dominio, si prendono in esame le sue categorie, gli elementi individuali, i tratti che li contraddistinguono, le relazioni tra gli elementi, e si progetta una rappresentazione secondo una codifica. La codifica si basa su una struttura esistente o direttamente sul sistema binario. Vediamo due esempi. 1) Nel mondo delle immagini digitali, il colore di un pixel viene espresso con un valore discreto rispetto a uno spazio colore. Nello spazio colore RGB, una tripla di valori numerici (espressi con una parola binaria di 24 bit, 8+8+8, nella modalità TrueColor) rappresenta rispettivamente le quantità di Rosso (Red), di Verde (Green), e di Blu (Blue) presenti in un colore:

5

In questo caso, quindi, i codici binari sono inseriti in una struttura a tre componenti che si comporta in modo posizionale, assegnando la prima parola binaria al rosso, la seconda al verde, la terza al blu. Questa struttura si chiama Array di tre elementi. [Esercizio: dimostrare che i codici binari rappresentano i numeri decimali della tripla RGB.] 2) Una sequenza di parole che forma una frase in linguaggio naturale può essere rappresentata mediante una struttura a Lista, che inserisce una parola in un elenco che produce un ordinamento da sinistra verso destra:

La differenza con la struttura precedente è che, mentre nel caso delle componenti RGB la distribuzione dei valori nell’Array dipende dalla posizione rispettivamente di R, G e B, ma non c’è una nozione inerente di precedenza tra sinistra e destra. Notiamo anche come le parole all’interno degli elementi si potrebbero rappresentare come liste o array di caratteri, a loro volta rappresentati in codice ASCII (vedi sopra). Queste rappresentazioni sono codificate nei linguaggi di alto livello (l’ultimo che consideriamo nella struttura a cipolla dell’informatica), e presentate come elementi predefiniti (succede per Array e Liste nel linguaggio Java, ad esempio) e come possibilità di costruzione per strutture personalizzate. I linguaggi di alto livello rappresentano una forma di astrazione superiore dalla macchina sottostante; le nozioni implicate, dalle strutture dei dati (organizzate in tipi base e tipi strutturati) alle istruzioni, organizzate in subroutine, sono più vicine alla comprensione che un essere umano ha del processo di risoluzione. Molti sono i paradigmi utilizzati per la progettazione dei linguaggi di programmazione, dal momento che sono molte le metafore usate per concepire una soluzione a un problema: linguaggi imperativi (una sequenza di comandi sottoposti a istruzioni di controllo, condizionali e iteratori, che realizzano le modifiche delle strutture in memoria), linguaggi funzionali (idealmente basati sulla nozione di funzione matematica, con la ricorsione come principale strumento di controllo), linguaggi a oggetti (che strutturano l’universo del problema come comportamenti di dati diversi, i cui risultati vengono combinati attraverso scambio di informazioni). Alcune di queste nozioni ci saranno utili per descrivere gli algoritmi. Prima però abbiamo bisogno di un inquadramento.

6

2. La modellazione Lo schema sottostante illustra il flusso di lavoro per la soluzione di un problema o più in generale la rappresentazione dinamica di una situazione in evoluzione. L’idea che non si tratti solo di risolvere un problema, ma di rappresentare una situazione dinamica, è una visione comune agli approcci di intelligenza artificiale e alla moderna visione dell’informatica in termini di agenti, o servizi, sempre in attesa di comandi.

Figura 2. Rappresentazione e algoritmi nel contesto dei processi di modellazione e interpretazione della realtà.

Nel flusso si può osservare come, per trovare la soluzione di un problema o monitorare l’evoluzione di una situazione, si affronti un passo (creativo, con intervento umano) di modellazione, che traduce in un linguaggio formale una rappresentazione del problema o della situazione attuale. Si noti che si tratta di un passo di modellazione, poiché si richiede l’individuazione degli elementi fondamentali da inserire nella rappresentazione, trascurando gli elementi non significativi. Si noti anche che il linguaggio formale risponde a regole generali di corretta formazione delle frasi, espressioni, in quel linguaggio. Esistono centinaia di linguaggi possibili di rappresentazione, destinati a problemi specifici, dal mondo della fisica, della grafica, delle funzioni matematiche …, o di tipo general purpose, applicabili in senso lato. Ciascuno di essi arriva con i suoi simboli specifici, i costruttori di simboli personalizzati, le regole di composizione per le espressioni del linguaggio. Più avanti, useremo come linguaggio di rappresentazione quello della logica matematica. In base alla rappresentazione del problema/situazione, e in generale di input e output significativi per un certo caso, si elabora un algoritmo che permetta di raggiungere la soluzione o nei casi più complessi l’evoluzione corretta della situazione. L’algoritmo, cioè la sequenza di istruzioni che manipola la rappresentazione, produce una nuova rappresentazione. Occorre un passo inverso rispetto alla modellazione, che interpreti la rappresentazione prodotta in termini di soluzione al problema o di situazione aggiornata (interpretazione). Anche questo passo richiede l’intervento dell’uomo, che fornisce un contesto apposito e delle regole per interpretare correttamente i simboli. Oggi, in molte situazioni, l’interpretazione è fornita mediante un’interfaccia grafica, che presenta all’utente i risultati maturati in termini di strutture dati come quelle viste prime.

7

Come si è visto, gli elementi fondamentali per il raggiungimento della soluzione sono la rappresentazione, risultato del passo di modellazione (e quindi sottoposta a un passo di analisi e descrizione in un linguaggio formale) nonché il terreno su cui lavora l’algoritmo che ricerca la soluzione, e l’algoritmo, il metodo escogitato per risolvere il problema o emulare il comportamento degli attori della situazione, che ne consentono un’evoluzione. L’algoritmica è proprio la scienza e l’arte degli algoritmi. L’algoritmica affronta i problemi modellando un processo di manipolazione dei dati in input in modo da produrre l’output corretto. Con gli algoritmi ci confrontiamo tutti i giorni: le operazioni aritmetiche (pensiamo all’algoritmo dell’addizione appreso a scuola), cercare una parola in un dizionario (sfogliare le pagine guardando le voci riportate a bordo pagina fino alla coppia di pagine che contiene la parola cercata e quindi scorrere le voci all’interno delle due pagine), spedire una email (lanciare il programma client di posta, aprire il modulo di spedizione, inserire l’indirizzo, scrivere il testo, inviarla). Si tratta dello spirito della computazione, non della sua concretizzazione fisica nell’elaboratore digitale. Non è un nostro obbiettivo affrontare uno studio esaustivo degli algoritmi, con le possibili classificazioni (divide et impera, programmazione dinamica, …). Qui descriviamo solo alcuni algoritmi esempio, per comprendere come si possa simulare il loro comportamento nella risoluzione dei problemi. La simulazione ha l’obiettivo di far comprendere il funzionamento della macchina sottostante in termini di evoluzione delle strutture in memoria; gli elementi principali che incontreremo nella scrittura degli algoritmi ci saranno utili per comprendere gli aspetti fondamentali dell’intelligenza artificiale e la rappresentazione della conoscenza in termini logici. Esercizio: Pensare a un problema o a una situazione dalla propria vita quotidiana e a un semplice linguaggio di rappresentazione per le fasi di modellazione e di interpretazione secondo lo schema in Figura XXX. Ad esempio, problema del resto al bar: il linguaggio di rappresentazione contiene solo le unità rappresentate dalle monete esistenti; in input si ha il modello della situazione formato dalla coppia

<valore della somma da pagare, valore della banconota con cui il cliente paga>; in output le monete che formano il resto:

<moneta_1, moneta_2, …, moneta_n>. 3. La scrittura degli algoritmi Sia dato un problema o una situazione, di cui si intende trovare la soluzione o determinarne le possibili evoluzioni, rispettivamente. Facciamo due esempi:

•   un problema può essere l’ordinamento di una sequenza casuale di parole secondo l’ordine alfabetico;

•   una situazione è una possibile configurazione di un videogioco di cui si vuole trovare una possibile evoluzione, l’evoluzione migliore per uno dei personaggi o tutte le possibili evoluzioni.

Un algoritmo consiste di istruzioni elementari, tratte da un insieme di istruzioni che sono possibili per il problema/situazione (ad esempio, spostare una parola della sequenza o muovere un pezzo degli scacchi in modo opportuno), che, dato in input un insieme di valori, produce in output la soluzione al problema o un’evoluzione possibile della situazione.

8

Data la discussione precedente, dovrebbe essere chiaro che occorre fare un passo di modellazione per stabilire quali sono le istruzioni possibili, come si indica l’ordine in cui si eseguono, come sono fatti gli oggetti che sono manipolati dalle istruzioni. L’esecuzione di un algoritmo viene portata avanti dalla macchina, o processore, che legge le istruzioni e i dati (rappresentazioni) da manipolare secondo le istruzioni e produce nuovi dati che rappresentano la soluzione o la nuova situazione. Quale istruzione occorre eseguire a un certo punto è di cruciale importanza, da cui discende che il processore deve essere a conoscenza di come eseguire le istruzioni e dell’ordine con cui si eseguono; infine, il processore deve sapere quando fermarsi. Si possono quindi individuare due tipi di istruzione da comunicare al processore:

•   le istruzioni di contenuto, necessarie per manipolare i dati, dipendenti dalla loro rappresentazione e dal linguaggio usato per la rappresentazione;

•   le istruzioni di controllo, necessarie per stabilire l’ordine di esecuzione delle istruzioni.

Nel tempo sono stati introdotti numerosi paradigmi o modelli di computazione, che hanno introdotto diverse modalità di comportamento degli algoritmi, immaginando processori sottostanti di tipo diverso. Mantenendo la dicotomia tra dati e istruzioni, dobbiamo ricorrere a linguaggi per i dati e per le istruzioni: le istruzioni di contenuto, che manipolano i dati, devono essere coerenti con la rappresentazione dei dati; le istruzioni di controllo devono essere coerenti con il comportamento del processore che dovrà poi eseguire l’algoritmo. Cominciamo dalle istruzioni di controllo. Qui consideriamo un modello ispirato direttamente dall’architettura di macchina vista sopra. L’architettura che consideriamo è di fatto un’architettura virtuale, ma in questo caso coincide abbastanza con l’architettura della macchina fisica vera e propria. Altre architetture virtuali si distanziano di più dalla macchina fisica, rendendo necessaria una realizzazione più articolata delle transizioni tra gli strati della cipolla. a) La prima istruzione di controllo deriva dalla considerazione intuitiva della sequenza di istruzioni (come avviene per le ricette di cucina ad esempio), che fa riferimento diretto all’organizzazione della memoria, che contiene le istruzioni e che è costituita da celle con indirizzi consecutivi. Prelevando le istruzioni dalla memoria, è immediato prelevare un’istruzione a partire dalla precedente, sommando uno all’indirizzo in memoria della precedente. Questa istruzione di controllo si può chiamare sequenzializzazione diretta. Di solito, nella scrittura algoritmica che useremo qui, le istruzioni da eseguire in sequenza sono scritte su righe successive di testo. Ad esempio, in un algoritmo che risolve il problema di ricercare i multipli di 7 tra 1356 e 1376 ci sono due istruzioni in sequenza del tipo

Calcola il resto della divisione per 7 Incrementa il numero corrente di 1

Quando l’esecuzione sarà arrivata a considerare il numero 1357, l’incremento di 1 permetterà di prendere in considerazione il numero 1358 e l’istruzione successiva ne calcolerà il resto della divisione per 7. Nella scrittura algoritmica si darà per scontato questo controllo, posizionando le istruzioni sulle righe del testo. b) La seconda istruzione di controllo si chiama condizionale e ha la forma

if C then A (else B)

9

C è una condizione che viene valutata VERO o FALSO (secondo la logica booleana a due valori, un po’ come avviene per i bit): se essa viene valutata VERO, allora si eseguiranno le istruzioni codificate con A (potrebbe essere una istruzione singola o una sequenza di istruzioni A1, A2, … An, secondo l’istruzione di controllo vista prima); se essa viene valutata FALSO, allora si eseguiranno le istruzioni codificate con B (o la sequenza B1, B2, … Bn). La presenza della parentesi indica che la parte alternativa non è necessaria: l’istruzione condizionale potrebbe essere limitata a fare qualcosa solo se la condizione C risulta vera. In questo caso, il controllo una volta verificato che la condizione C è falsa, si limiterebbe a proseguire con l’istruzione successiva nella sequenza. Riprendendo l’esempio dell’algoritmo che ricerca i multipli di 7, occorre memorizzare un ritrovamento se il resto della divisione è zero:

if Resto della divisione è 0 then Memorizza il numero corrente

C è la condizione che il resto della divisione uguale a 0 sia VERO; A è l’istruzione di memorizzare il numero che ha prodotto tale resto; non si ha una componente alternativa (else). Si noti anche una pratica comune di indentare un’istruzione qualora sia relativa a un ambito (detto scope) specifico: in questo esempio, l’istruzione di memorizzazione avverrà solo nel caso in cui la condizione risulti vera (scope della parte Then). c) Come avrete compreso, per trovare tutti i multipli di 7 tra 1356 e 1376, occorre aumentare di uno una ventina di volte; per le tutte le 21 volte occorre poi calcolare il resto della divisione per 7 e memorizzare eventualmente il numero ottenuto. Questa ripetizione di istruzioni porta a una terza istruzione di controllo: l’iterazione o loop. L’iterazione è la responsabile della realizzazione di processi lunghi di calcolo, anche se il numero di istruzioni è molto ridotto. In particolare, si potrebbero avere processi lunghi un numero qualsiasi di istruzioni (supponete di ricercare i multipli di 7 in un intervallo di valori di lunghezza qualsiasi), ma le istruzioni sono di fatto le tre che abbiamo visto prima (una sequenza di tre istruzioni, di cui l’ultima è un condizionale). Si possono riconoscere due tipi di iterazione. L’iterazione limitata, della forma

for N volte do A

In questo caso si intende che l’istruzione (o la sequenza di istruzioni) A viene eseguita N volte. Ad esempio, nel caso precedente si potrebbe scrivere

for 21 volte do Calcola il resto della divisione per 7 Incrementa il numero corrente di 1

Per 20 volte si incrementa il numero corrente di 1 e si calcola il resto della divisione per 7. Non inserendo i 21 numeri in modo esplicito, rende l’algoritmo generalizzabile a una ventina di numeri consecutivi qualsiasi. L’istruzione di iterazione condizionale o illimitata è necessaria quando non si conosce in anticipo il numero di volte che occorre iterare. Le espressioni in questo caso sono del tipo

while C do A

10

che si interpreta come “mentre la condizione C è VERA fai A”. Questa istruzione determina un controllo del tipo “Verifica la condizione C; se è VERA, esegui A; al termine verifica ancora C; se è VERA, esegui A; … quando la condizione C diventa FALSA, si esce dal ciclo e si procede con l’istruzione successiva al WHILE”. L’esempio precedente, l’algoritmo che ricerca i multipli di 7 tra 1356 e 1376 potrebbe essere codificato nel modo seguente:

Sia 1356 il numero corrente while numero corrente minore o uguale a 1376 do Calcola il resto della divisione per 7 if Resto della divisione è 0 then Memorizza il numero corrente Incrementa il numero corrente di 1

Come si vede, le istruzioni di controllo possono essere annidate in altre istruzioni di controllo (if contenuto nel while) per costruire sofisticate condizioni di esecuzione; anche nella scrittura, l’indentazione riflette questi scope annidati. Nell’esecuzione, il numero corrente all’inizio è fissato a 1356. Superata la prima verifica (1356 ≤ 1376), si calcola il resto della divisione per 7 e in caso sia 0 (non lo sarà prima del 1358), il numero viene memorizzato. Con l’incremento di 1, si rientra nel ciclo con il numero corrente a 1357. Si lascia il while per proseguire all’istruzione successiva quando si raggiunge quota 1377 (in quanto 1377 > 1376). Prima di procedere con un’ultima nozione di controllo che ci sarà molto utile in seguito, soffermiamoci un attimo sulle istruzioni di contenuto. Come abbiamo affermato in precedenza, le istruzioni di contenuto dipendono dalla rappresentazione dei dati che sono manipolati e di conseguenza dal linguaggio utilizzato per la rappresentazione. Una nozione elementare, basata sul modello di architettura di alto livello utilizzato come riferimento, è la nozione di area di memoria, a cui si associa tipicamente un simbolo nei linguaggi di alto livello. Spesso al simbolo è associato anche un tipo di dato: quindi, se diciamo che nc è una variabile di tipo intero, la sua rappresentazione in memoria rappresenterà un numero intero qualsiasi. Operativamente, ci possiamo figurare questa situazione come un’area di memoria che viene indicata con il nome nc.

La scatola disegnata è un’area di memoria adeguata a contenere il dato nc; nella scrittura algoritmica, il dettaglio del tipo di dato è spesso trascurato; ci pensa il programmatore, una volta sottoposto ai vincoli imposti dal linguaggio di programmazione. I nomi delle aree di memoria possono essere costanti o molto più frequentemente variabili; cioè, il loro contenuto viene modificato con istruzioni di contenuto chiamate assegnazioni. Noi le indicheremo con la forma

nc ← 1356

che comporta una modifica dell’area di memoria:

11

Si noti che il simbolo ← indica il movimento del dato dentro l’area di memoria associata con il simbolo nc. L’istruzione

nc ← nc + 1

incrementa di 1 il contenuto dell’area di memoria nc:

Con l’utilizzo delle variabili possiamo riscrivere con istruzioni di contenuto più vicine alla rappresentazione della macchina l’algoritmo della ricerca dei multipli di 7.

nc ← 1356 while nc ≤ 1376 do r ← resto di nc diviso 7 if r = 0 then inserisci nc in un elenco di multipli di 7 nc ← nc + 1

In questa scrittura, le parti di rappresentazione formale dovrebbe essere quasi tutte comprensibili, da consentire un esercizio di simulazione delle variazioni della memoria con l’esecuzione dell’algoritmo. Questa scrittura algoritmica si dice in pseudo-codice e corrisponde a una nozione intuitiva di computazione che fa riferimento a un modello di macchina come l’architettura vista sopra. Man mano che istruzioni in pseudo-codice sono rimpiazzate da istruzioni più vicine alla rappresentazione in memoria (come è avvenuto per l’assegnazione), l’algoritmo muta per diventare un vero e proprio programma. Questo metodo di scrittura di un programma si dice per raffinamenti successivi (stepwise refinement). Noi ci fermeremo quasi sempre a un livello informale, assumendo istruzioni intuitivamente plausibili ma allo stesso tempo immediatamente traducibili in un linguaggio di programmazione imperativo; tuttavia, a volte è utile raffinare per motivi di concisione e non ambiguità della scrittura, in quanto le istruzioni in linguaggio naturale potrebbero risultare tediose e poco comprensibili. In questi termini, rimangono da formalizzare due righe del nostro algoritmo. Cominciamo dalla penultima, “inserisci nc in un elenco di multipli di 7”. Per costruire l’elenco e la corrispondente operazione di inserimento, ci possiamo riferire alle nozioni di Array e Lista introdotte in precedenza. Sono entrambi delle forme di elenco: l’Array è una struttura di più componenti, ciascuno dei quali si può riferire con un indice (o cursore) relativo alla sua posizione assoluta nell’elenco e il posizionamento relativo delle componenti (chi precede o segue chi) si riferiscono alla corrispondente relazione tra i cursori (la componente R precede la componente G nella struttura RGB dei colori perché l’indice assoluto di R è 1, e precede l’indice assoluto di G che è 2); la Lista è di nuovo una struttura di più componenti in un elenco, ma l’ordine tra le componenti si riferisce direttamente alle posizioni relative tra le componenti (“Le” precede “aquile”, come “aquile” precede “volano”, come …,

12

nella frase sopra, e l’indice assoluto di “Le”, che è 1, è una conseguenza del fatto che nessuna parola precede). Noi useremo entrambe le strutture nei nostri esempi, a seconda delle caratteristiche del problema. Nell’esempio attuale useremo la Lista: l’operazione di inserimento al fondo di una lista lo chiameremo “append”, intendendo che il valore inserito si posiziona all’attuale ultima posizione dell’elenco. Il codice viene completato da una creazione della struttura lista (che si assume vuota all’inizio).

nc ← 1356; lista_multipli_di_7 ← Lista_vuota while nc ≤ 1376 do r ← resto di nc diviso 7 if r = 0 then append (nc, lista_multipli_di_7) nc ← nc + 1

La situazione iniziale e finale in memoria della variabile lista_multipli_di_7 è

Ogni append aggiunge un elemento al fondo della lista, fino a un totale di tre elementi nel nostro caso (i multipli di 7 tra 1356 e 1376); l’append è scritta in una formulazione nella notazione funzionale

y ← f(x)

dove per y si intende il risultato della funzione f applicata all’argomento x. Nel nostro caso, gli argomenti sono due: l’elemento da inserire (il numero corrente) e la lista da aggiornare (l’elenco dei multipli di 7 tra 1356 e 1376), quindi sarebbe una sorta di f(x1,x2). Nel caso particolare dell’append, non si ha un risultato vero e proprio, ma l’aggiornamento dell’elenco, cioè della memoria contenente il valore della variabile lista_multipli_di_7. Infine, si noti la formulazione del nome della variabile, una serie di parole inframezzate dal simbolo “_” (underscore): si tratta di una convenzione comune negli ambienti di programmazione. Una convenzione simile è quella che utilizza come nomi di variabili delle composizioni in cui la prima parola inizia con una lettera minuscola e le parole successiva iniziano con una lettera maiuscola: nel nostro esempio sarebbe listaMultipliDi7. L’ultima riga da formalizzare nell’algoritmo è

r ← resto di nc diviso 7

Il resto di una divisione è un’operazione predefinita nei linguaggi di programmazione, denominata modulo. Quindi, eliminando anche la variabile r, la versione definitiva dell’algoritmo è

nc ← 1356; lista_multipli_di_7 ← Lista_vuota while nc ≤ 1376 do if (nc mod 7) = 0 then append (nc, lista_multipli_di_7) nc ← nc + 1

13

4. La subroutine Chiudiamo questa parte sulle istruzioni di contenuto con il concetto di subroutine (o procedura o funzione). Anche con la formalizzazione di append avremmo potuto introdurre la nozione di subroutine, ma la sua realizzazione ci avrebbe portato un po’ distante con i dettagli di aggiornamento della struttura in memoria. Una subroutine si può definire come un’istruzione di contenuto complessa, un’istruzione che fa qualcosa di più articolato di un’istruzione di contenuto basilare e, un po’ come è successo per l’append, si applica a dati con una struttura ben precisa. Cominciamo da un esempio. Vogliamo provare a generalizzare l’algoritmo di ricerca dei multipli di 7 tra 1356 e 1376 alla ricerca di multipli di un numero qualsiasi in un intervallo qualsiasi. Questa generalizzazione si ottiene già introducendo dei simboli variabili per il 7 (ad esempio, la variabile n), il 1356 (inizio_intervallo) e 1376 (fine_intervallo). L’algoritmo diverrebbe già il seguente (notare anche il cambio, non necessario, del nome della variabile elenco):

inizio_intervallo ← 1356; fine_intervallo ← 1376 n ← 7 nc ← inizio_intervallo; lista_multipli_di_n ← Lista_vuota while nc ≤ fine_intervallo do if (nc mod n) = 0 then append (nc, lista_multipli_di_n) nc ← nc + 1

Tuttavia, qui vogliamo provare a variare un po’ la logica dell’algoritmo, della soluzione del problema. Si può pensare di introdurre un’istruzione articolata che, dato un inizio di intervallo e un numero, restituisca il multiplo del numero successivo all’inizio dell’intervallo. Cioè, se inizio_intervallo è 1356 e n è 7, allora la funzione prossimo_multiplo restituisce 1358. Se noi possedessimo tale funzione (o subroutine), potremmo scrivere l’algoritmo precedente in questo modo:

inizio_intervallo ← 1356; fine_intervallo ← 1376 n ← 7; lista_multipli_di_n ← Lista_vuota multiplo ← prossimo_multiplo (inizio_intervallo, n) while multiplo ≤ fine_intervallo do append (nc, lista_multipli_di_n) inizio_intervallo ← multiplo + 1; multiplo ← prossimo_multiplo (inizio_intervallo, n)

Nella nuova versione, l’algoritmo calcola subito il primo multiplo successivo all’inizio dell’intervallo e aggiorna l’elenco dei multipli di n all’interno dell’intervallo finché i multipli, che costituiscono a ogni iterazione il nuovo inizio di intervallo, non superino la fine dell’intervallo. Vediamo ora come scrivere la subroutine prossimo_multiplo.

integer prossimo_multiplo (inizio, num) m ← inizio while (m mod num) ≠ 0 do m ← m + 1 return m

14

La funzione prossimo_multiplo avanza di 1 finché trova un multiplo di num; a quel punto lo restituisce come valore di funzione, che nell’algoritmo precedente finisce nella variabile multiplo. I benefici delle subroutine sono evidenti: non solo abbiamo generalizzato il calcolo del multiplo di un numero successivo a un certo valore, ma la subroutine può essere chiamata a operare anche in altri algoritmi che richiedono la sua competenza specifica. La subroutine è organizzata in modo da pubblicare all’esterno ciò che è necessario per l’esecuzione: all’interno della parentesi, come avveniva anche per append, sono presenti i parametri di input (variabili usate all’interno della subroutine che prendono i valori dall’esterno); il tipo di dato indicato davanti al nome della subroutine (integer, nel nostro esempio) indica come interpretare il risultato (sarà il valore della variabile multiplo). La subroutine si comporta come uno specialista, competente in un determinato ambito, che viene chiamato a eseguire un lavoro; all’esterno (cioè nell’algoritmo chiamante), la subroutine risulta essere una blackbox, una scatola nera che lavora in modo autonomo e restituisce il risultato a fronte di un input ben definito. La possibilità di definire e chiamare le subroutine, presenti in tutti i linguaggi di programmazione, permette di suddividere il lavoro in componenti più semplici e di ridurre al minimo le possibilità di introdurre errori nella programmazione, dal momento che un brano di codice che produce un certo comportamento è inserito solo in un punto del programma. Inoltre, accorcia gli algoritmi, rendendo più leggibile il codice, privo dei dettagli che sono affrontati all’interno della subroutine; chiaramente, nelle subroutine si possono annidare altre subroutine. La nozione di subroutine è immediatamente utile in un caso particolare di istruzione di controllo: la ricorsione. La ricorsione è uno degli aspetti del controllo che porta maggiore confusione, in quanto mette a disposizione degli algoritmi il potere di chiamare se stessi come specialisti competenti di un certo lavoro. La ricorsione è diversa dalla ciclicità ripetitiva se si introducono meccanismi che permettono nelle chiamate ricorsive di ridurre la dimensione del problema affrontato: in poche parole, un algoritmo richiama se stesso su una versione ridotta del problema, combinando quindi in qualche modo il risultato ottenuto per arrivare alla soluzione del problema iniziale. E’ un costrutto simile, in linea di principio, all’iterazione (e infatti si può dimostrare l’equivalenza del potere espressivo), ma che sfrutta la nozione di ambiente di una funzione o subroutine per ridurre il carico di descrizione del controllo. Per illustrare la ricorsione, cominciamo da un esempio celeberrimo, la torre di Hanoi. Ispirato, secondo la tradizione, a un gioco praticato in un tempio indiano, la torre di Hanoi consiste di tre pioli, che chiamiamo A, B e C, e un certo numero di dischi impilati in uno dei pioli, supponiamo A, con il vincolo che un disco più grande non può star sopra un disco più piccolo.

15

Il gioco consiste nello spostare i dischi uno per volta, rispettando sempre il vincolo di cui sopra, per arrivare alla fine ad avere tutti i dischi impilati sul piolo B.

Provando a giocare con i dischi, dopo un po’ di tentativi inutili, si può osservare che per spostare un certo numero di dischi occorre prima rimuovere i dischi sopra il più grande, spostare quindi il disco grande nel piolo di destinazione, e infine spostare sopra quel disco i dischi superiori prima accantonati in un piolo di supporto (per questo ce ne sono tre). Vediamo cosa succede nelle prime tre mosse.

16

Come si nota, per spostare i due dischi più piccoli (3 e 4) da A a B, abbiamo prima spostato il 4 sul piolo di supporto C, quindi il 3 sul piolo di destinazione B e infine abbiamo spostato il 4 sul piolo di destinazione B. Proseguendo, con il medesimo approccio, possiamo arrivare ad avere i tre dischi 2, 3 e 4, sul piolo C, per poter quindi spostare il disco più grande 1 sul piolo di destinazione B. Vediamo come ciò avviene.

17

A questo punto abbiamo spostato tre dischi dalla posizione originale A sul piolo C, che è un piolo di supporto, e abbiamo liberato il piolo B per accogliere il disco 1.

Dopo avere spostato il disco 1, sarà sufficiente ripetere le operazioni effettuate per spostare i tre dischi (2, 3 e 4) da A a C, procedendo in questo caso da C a B, dove possono essere appoggiati, avendo alla base il disco 1, il più grande di tutti. Lasciamo al lettore la simulazione di questi ultimi passi. La considerazione generale da fare è che per spostare 4 dischi da A a B, si è proceduto spostando 3 dischi da A a C, spostandone quindi 1, il più grande, da A a B, infine spostando 3 dischi da C a B. Allo stesso modo, per spostare 3 dischi da A a C, si è proceduto spostando 2 dischi da A a B, quindi spostandone 1, il più grande dei 3, da A a C, infine spostando 2 dischi da B a C. In generale, insomma, per spostare N dischi dal piolo di origine (sia esso A, B o C) al piolo di destinazione (A, B o C), usando il terzo piolo (A, B o C) come supporto, occorre spostarne N-1 dal piolo di origine al piolo di supporto, quindi 1 dal piolo di origini al piolo di destinazione, infine N-1 dal piolo di supporto al piolo di destinazione. Come si vede, per risolvere un problema di dimensione N, si risolvono due problemi di dimensione N-1 e un problema di dimensione 1 (banale); la combinazione dei risultati dei sotto-problemi è intrinseca nella selezione dei ruoli dei pioli di volta in volta (origine, destinazione, supporto). Chiamando la subroutine con il nome hanoi, si ottiene il seguente algoritmo:

hanoi (N, Origine, Destinazione, Supporto) if N = 1 then sposta il disco in Origine in Destinazione else hanoi (N-1, Origine, Supporto, Destinazione) hanoi (1, Origine, Destinazione, Supporto) hanoi (N-1, Supporto, Destinazione, Origine)

La chiamata della subroutine hanoi all’interno della subroutine hanoi, ci fa comprendere che si tratta di una procedura ricorsiva. Si noti anche come i nomi dei parametri indichino, nell’intestazione della subroutine, i ruoli dei pioli stessi: il

18

secondo parametro rappresenta sempre l’origine, il terzo parametro la destinazione, il quarto parametro il piolo di supporto; infine, il primo parametro indica il numero di dischi. Sarà questo numero a essere diminuito a ogni chiamata ricorsiva (N-1), fino ad arrivare a 1, quando avverrà il vero e proprio spostamento di un disco. Come sarà chiaro tra un attimo, infatti, le chiamate ricorsive introducono solo sovrastrutture di controllo che si assicurano solo l’ordine corretto delle mosse, ma non succede nulla finché N non diventa uguale a 1 (parte then del condizionale). Il caso N=1 si chiama base della ricorsione, il caso cioè che si può risolvere in modo immediato (lo spostamento di un disco da origine a destinazione – ci ha pensato la struttura della subroutine ricorsiva ad assicurare che il piolo di destinazione sia libero da impedimenti allo spostamento); la parte else del condizionale si chiama passo di ricorsione, cioè le istruzioni necessarie per condurci al caso base e la combinazione dei risultati. Le strutture di controllo introdotte (sequenza, condizionale, iterazione limitata e illimitata, ricorsione) e la rappresentazione dei dati semplici e aggregati in vettori (Array) e elenchi (Lista) ci permette di simulare l’evoluzione della memoria di un sistema mentre procede la computazione governata da un algoritmo. Nel prossimo paragrafo, simuliamo l’esecuzione dei due algoritmi qui presentati. 5. La simulazione degli algoritmi In questa sezione, simuliamo l’esecuzione dell’algoritmo di ricerca dei multipli di un numero in un certo intervallo e la soluzione del gioco della torre di Hanoi. Alterniamo istruzioni degli algoritmi e contenuti della memoria durante l’esecuzione. 1. Algoritmo di ricerca dei multipli in un intervallo L’algoritmo è riscritto in modo completo, dopo le variazioni introdotte prima, nel modo seguente:

lista ricerca_multipli_in_intervallo (inizio, fine, n) lista_multipli_di_n ← Lista_vuota multiplo ← prossimo_multiplo (inizio, n) while multiplo ≤ fine do append (multiplo, lista_multipli_di_n) multiplo ← prossimo_multiplo (inizio, n) return lista_multipli_di_n

Simuliamo questo algoritmo nel caso della chiamata

ricerca_multipli_in_intervallo(1356, 1376, 7)

Al momento della chiamata, la macchina crea le aree di memoria necessarie, inclusi i parametri e le variabili locali:

19

multiplo ← prossimo_multiplo (inizio, n)

while multiplo ≤ fine do append (multiplo, lista_multipli_di_n) multiplo ← prossimo_multiplo (inizio, n)

while multiplo ≤ fine do append (multiplo, lista_multipli_di_n) multiplo ← prossimo_multiplo (inizio, n)

while multiplo ≤ fine do append (multiplo, lista_multipli_di_n) multiplo ← prossimo_multiplo (inizio, n)

while multiplo ≤ fine do … return lista_multipli_di_n

2. Torre di Hanoi Riscriviamo l’algoritmo ricorsivo della torre di Hanoi:

20

hanoi (N, Origine, Destinazione, Supporto) if N = 1 then sposta il disco in Origine in Destinazione else hanoi (N-1, Origine, Supporto, Destinazione) hanoi (1, Origine, Destinazione, Supporto) hanoi (N-1, Supporto, Destinazione, Origine)

Simuliamo l’algoritmo con la chiamata

hanoi(4, A, B, C)

In questo caso, per dare conto delle chiamate ricorsive, è comodo costruire l’albero delle chiamate. L’albero è una struttura dati adatta alla rappresentazione di strutture gerarchiche: a partire da un nodo radice, si diramano i nodi figli, che possono avere a loro volta dei figli, fino a nodi senza figli, detti foglie. Nel caso dell’albero delle chiamate ricorsive di una funzione, i nodi foglia rappresentano il caso della ricorsione base e la radice la chiamata iniziale; per ogni nodo, si riporta sull’albero la situazione in memoria; la simulazione grafica sui dischi e i pioli la si ritrova nelle pagine precedenti.

21

Esempi di algoritmi e simulazioni La fase di modellazione dei dati e degli algoritmi è una fase creativa della messa in opera di un sistema software, che possa risolvere un problema o rappresentare una situazione in evoluzione. Molte conoscenze di base possono essere a disposizione del “creativo” per disegnare il modello: una formulazione analitica del problema, una pratica quotidiana, la struttura in memoria che già ospita i dati. In questo paragrafo, vediamo due esempi di algoritmi e simulazioni, rispettivamente. I lettori sono invitati a ricavare le simulazioni dagli algoritmi. Ordinamento per inserimento E’ riportato nei testi classici di algoritmi come il metodo più semplice di ordinamento. Richiama il comportamento dei giocatori di carte, che ordinano una mano tipicamente suddividendo l’insieme di carte in due sequenze, una ordinata, che posizioniamo a sinistra, e una non ordinata, che posizioniamo a destra.

Insertion_sort (Array A di n elementi) For i da 2 a n For j da 1 a i-1 If A[i] < A[j] Then Scambia A[i] e A[j]

L’algoritmo usa la struttura Array per memorizzare la sequenza e rappresenta gli elementi con numeri naturali, assumendo la conoscenza del confronto di grandezza tra due numeri (<, >, =). I numeri non sono una limitazione dell’algoritmo; potrebbero essere elementi qualsiasi su cui si può stabilire un confronto di grandezza (ad esempio, l’ordine lessicografico per le parole di un dizionario). L’Array si può scorrere mediante due cursori, i e j, e gli elementi contenuti nell’Array sono indicati A[i] e A[j]. Quindi, l’elemento A[3] indica il contenuto del terzo elemento dell’array A: nell’esempio sottostante, A[3] = 8.

Compresa la struttura in memorizzare, consideriamo i passi dell’algoritmo. Si tratta di due cicli annidati: il ciclo esterno muove il cursore i da 2 a n (ultimo elemento, il settimo nell’esempio); il ciclo interno muove il cursore j dalla posizione 1 a i-1 (una in meno del cursore i attuale). L’idea alla base dell’algoritmo è di dividere la sequenza in due parti: a sinistra una parte ordinata (che all’inizio consiste di un solo elemento, ordinata ovviamente, essendo lunga uno), che cresce di 1 elemento a ogni iterazione, con il cursore i del for più esterno; a destra, una parte non ordinata (che all’inizio è lunga n-1), che decresce di 1 elemento a ogni iterazione del for esterno. Il cursore i scorre nella parte disordinata (sulla destra); il cursore j scorre la parte ordinata (che finisce all’elemento che precede l’i-esimo); il ciclo esterno individua a ogni iterazione un elemento nella parte disordinata da piazzare nella parte ordinata, mediante scambio con un elemento nella parte ordinata (scorsa da j). Nelle

22

illustrazioni, la linea tratteggiata rossa indica la separazione tra la parte ordinata e la parte disordinata: all’inizio si trova tra il primo e il secondo elemento; alla fine si trova dopo la posizione n.

Prima iterazione esterna: i = 2; j da 1 a 1; scambio tra A[1] e A[2] (5 < 7).

Seconda iterazione esterna: i = 3; j da 1 a 2; nessuno scambio (8 è più grande di tutti i numeri della parte ordinata). Terza iterazione esterna: i = 4; j da 1 a 3; tre scambi (5 con 3 in posizione 1, 7 con 5 in posizione 2, 8 con 7 in posizione 3); 8 rimane il numero più grande della parte ordinata.

23

Quarta iterazione esterna: i = 5; j da 1 a 4; nessuno scambio (9 è più grande di tutti i numeri della parte ordinata). Quinta iterazione: i = 6; j da 1 a 5; cinque scambi (4 con 5 in posizione 2, 5 con 7 in posizione 3, 8 con 7 in posizione 4, 9 con 8 in posizione 5).

Sesta iterazione esterna: i = 7; j da 1 a 6; cinque scambi (4 con 5 in posizione 2, 5 con 7 in posizione 3, 8 con 7 in posizione 4, 9 con 8 in posizione 5).

24

[Variante: introduzione della subroutine di ricerca del minimo in una sequenza (search_min) e modifica dell’algoritmo.]

cursor search_min (Array A di n elementi, cursor left, cursor right) min ← A[left]; i_min ← left; For i da left+1 a right If A[i] < min Then min ← A[i]; i_min ← i; return i_min

Insertion_sort (Array A di n elementi) For i da 1 a n i_min ← Search_min (A, i, n) Scambia A[i] e A[i_min]

[Esercizio: Il lettore simuli il funzionamento con questa variante dell’algoritmo.] 2. I numeri di Fibonacci I numeri di Fibonacci sono molto diffusi nella scienza e nell’arte (consultare la pagina di Wikipedia per le curiosità: ad esempio, sono la base per l’installazione luminosa di Mario Merz sulla Mole Antonelliana di Torino – Il volo dei numeri). Il calcolo algoritmico dei numeri di Fibonacci si basa su una formulazione matematica, che spiana il terreno a un approccio ricorsivo alla scrittura dell’algoritmo.

Formulazione matematica Fibonacci(1) = 1 Fibonacci(2) = 1 Fibonacci(n) = Fibonacci (n-1) + Fibonacci (n-2)

integer Fibonacci (n) { if n=1 then return 1 else if n=2 then return 1 else return Fibonacci(n-1) + Fibonacci (n-2) }

La formulazione è espressa in termini ricorsivi, con una ricorsione base per il primo e il secondo numero di Fibonacci e un passo di ricorsione che calcola l’ennesimo numero di Fibonacci sommando i due numeri di Fibonacci precedenti (n-1 e n-2). L’albero della ricorsione nel caso di Fibonacci(5) è nella figura successiva.

25

[Esercizio: Il lettore calcoli il settimo numero di Fibonacci simulando l’algoritmo. ] 3. Gli anagrammi di una parola Nella figura sottostante è illustrato lo schema di un algoritmo per il calcolo di tutti gli anagrammi di una parola: da una parola in input si calcola una permutazione (cioè una variante di ordine tra le lettere della parola) e si verifica che quest’ultima sia una parola presente nel dizionario della lingua italiana. In figura, il caso della parola LIBANO.

Si hanno quindi due subroutine: la prima calcola la prossima permutazione, la seconda ricerca la permutazione proposta nel dizionario. La seconda subroutine è molto semplice:

26

Sia DIZ un Array di N parole boolean cerca_in_dizionario (parola) for i da 1 a N do if parola = DIZ[i] then return true return false

Il calcolo combinatorio delle permutazioni deve generare tutte le permutazioni possibili. L’idea è di portare avanti un’enumerazione ordinata: si introduce un ordine tra le lettere per tener traccia di cosa scambio; si lavora sempre con elementi di ordine maggiore finché non ho fatto tutti gli scambi possibili. L’ordine è arbitrario, ma rimane fissato, una volta che viene stabilito; l’obiettivo è la generazione di permutazioni in ordine crescente (rispetto all’ordine fissato), in modo da non perdersi neanche una permutazione procedendo in modo automatico. I passi dell’algoritmo ad alto livello sono i seguenti:

Data una permutazione, nell’array A, di lunghezza N: 1.   Trova il più grande cursore k (cioè il valore di k più a destra) tale

che A[k] < A[k + 1]. Se tale indice k non esiste, allora questa era l’ultima permutazione

2.   Trova il più grande j (cioè il j più a destra) tale che A[k] < A[j] (l’indice j esiste di sicuro, dal momento che almeno A[k + 1] è più grande di A[k])

3.   Scambia i valori A[k] e A[j]. 4.   Inverti la sequenza dalla posizione [k + 1] alla posizione [N]

L’idea è di generare le permutazioni nell’ordine lessicografico crescente che è stato stabilito. Si assume la struttura seguente in memoria.

Proviamo l’algoritmo sul contenuto dell’array. Nell’ordine introdotto: R-1 < O-2 < S-3 < A-4. Si noti che il cursore lo caratterizziamo con i numeri romani per non causare confusione tra l’ordine lessicografico e i cursori. Si parte da ROSA. Corrisponde al numero 1234.

•   k = III, il massimo indice tale che A[k] (= S-3) < A[k + 1] (= A-4) •   j = IV, A[j] (= A-4) è l’unico valore della sequenza tale che > A[k] (= S-3) •   Si scambiano i valori di A[III] e A[IV]: la sequenza diventa [R-1, O-2, A-4, S-

3] •   La sotto-sequenza dopo k (da k+1) viene invertita: trattandosi di un unico

valore, A[IV], la sotto-sequenza rimane identica. Risultato: [R-1, O-2, A-4, S-3]; corrisponde al numero 1243. ROAS non è presente nel dizionario.

27

•   k = II, il massimo indice tale che A[k] (= O-2) < A[k + 1] (= A-4) •   j = IV, A[j] (= S-3) è il massimo valore della sequenza tale che > A[k] (= O-

2) •   Si scambiano i valori di A[II] e A[IV]: la sequenza diventa [R-1, S-3, A-4, O-

2] •   La sotto-sequenza dopo k (da k+1) viene invertita (indici III e IV): [R-1, S-3,

O-2, A-4] Risultato: [R-1, S-3, O-2, A-4]; corrisponde al numero 1324. RSOA non è presente nel dizionario.

•   k = III, il massimo indice tale che A[k] (= O-2) < A[k + 1] (= A-4) •   j = IV, A[j] (= A-4) è il massimo valore della sequenza tale che > A[k] (= S-

3) •   Si scambiano i valori di A[III] e A[IV]: la sequenza diventa [R-1, S-3, A-4, O-

2] •   La sotto-sequenza dopo k (da k+1) viene invertita: trattandosi di un unico

valore A[IV], la sotto-sequenza rimane identica. Risultato: [R-1, S-3, A-4, O-2]; corrisponde al numero 1342. RSAO non è presente nel dizionario.

•   k = II, il massimo indice tale che A[k] (= S-3) < A[k + 1] (= A-4) •   j = III, A[j] (= A-4) è il massimo valore della sequenza tale che > A[k] (= S-3) •   Si scambiano i valori di A[II] e A[III]: la sequenza diventa [R-1, A-4, S-3, O-

2] •   La sotto-sequenza dopo k (da k+1) viene invertita (indici III e IV): [R-1, A-4,

O-2, S-3]. Risultato: [R-1, A-4, O-2, S-3]; corrisponde al numero 1423. RAOS non è presente nel dizionario.

•   k = III, il massimo indice tale che A[k] (= O-2) < A[k + 1] (= S-3) •   j = IV, A[j] (= S-3) è il massimo valore della sequenza tale che > A[k] (= O-

2) •   Si scambiano i valori di A[III] e A[IV]: la sequenza diventa [R-1, A-4, S-3, O-

2] •   La sotto-sequenza dopo k (da k+1) viene invertita: solo indice III, nessuna

inversione. Risultato: [R-1, A-4, S-3, O-2]; corrisponde al numero 1432. RASO è presente nel dizionario. … Si procede fino alla 24-esima permutazione ([A-4, S-3, O-2, R-1]), per la quale non esiste alcun k per cui A[k] < A[k + 1], cioè è l’ultima permutazione.

28

Di seguito, un raffinamento dell’algoritmo nei termini delle istruzioni di controllo che abbiamo descritto in precedenza.

Array Combinatorio (array A di N caratteri) cursori k,j da 1 a N; repeat // trova k boolean trovato <- false; // booleano per recupero anagrammi for i da 1 a N-1 do if A[i] < A[i+1] then k ← i; trovato ← true; if trovato = false then exit; // trova j for i da k+1 a N do if A[k] < A[i] then j ← i; // scambio buffer ← A[k]; A[k] ← A[j]; A[j] ← buffer; // inverti vettore finale: copio in B invertito e rimetto in A B array di N-k caratteri for i da 1 a N-k do B[i] ← A[N-i+1] for i da 1 a N-k do A[k+i] ← B[i] until trovato=false // ridondante, perché EXIT a monte

Il ciclo repeat-until (non introdotto prima, si noti la differenza con il while) cicla per tutte le permutazioni; dopo il primo for, nell’array A è stata inserita l’ultima permutazione; buffer è una variabile di supporto per realizzare lo scambio; B è un array di supporto per invertire l’ultima parte di A. [Esercizio: comprendere il funzionamento dell’algoritmo raffinato e simularlo per calcolare gli anagrammi di una parola di 4 lettere. ] [Esercizio: sostituire ai for dei costrutti di iterazione di tipo while e simulare. Suggerimento.

1.   Istruzioni base: a.   i ← N-1; b.   while i≥1 AND A[i] ≥ A[i+1] do

i.   i ← i-1; k ← i; 2.   Istruzioni da aggiungere: controllo, cioè if, per uscita senza un K).]

Bibliografia utile per questa sezione David Harel e Yishai Feldman, Algoritmi. Lo spirito dell'informatica, Springer Verlag; 2 edizione (2008), ISBN-10: 8847005795, ISBN-13: 978-8847005792. I primi tre capitoli. Voci di Wikipedia utili: Computer Architecture, Assembly language, Modulo operation, Tower of Hanoi, Recursion, Successione di Fibonacci.