Matlab/Octave - Esercitazione 11 - Informatica Bvalente.dei.polimi.it/materiale/esercitazioni/matlab/esercitazione... · MATLAB/Octave - Esercitazione 11. Politecnico di Milano -

Politecnico di Milano - DEI Dipartimento di Elettronica e Informazione Informatica B - Esercitazione 11 del 11/01/2013

Salvo Daniele Valente

Dipartimento di Elettronica e Informazione

Facoltà di Ingegneria IndustrialeLaurea in Ingegneria Energetica, Meccanica e dei Trasporti

1

Matlab/Octave - Esercitazione 11

‣programmazione ricorsiva




Esercizio 1

2

MATLAB/Octave - Esercitazione 11

Scrivere un programma che:dato un numero N calcola la somma dei primi N numeri pari positivi in maniera ricorsiva.

La somma dei primi N numeri pari è la seguente:

SN = 2*1 + 2*2 + 2*3 + … + 2*i + … + 2*(N-1) + 2*N.




3

La programmazione ricorsiva prevede la creazione, o il semplice utilizzo, di funzioni che richiamano se stesse al loro interno.

Analizzando la formula della somma dei primi N numeri pari:

SN = 2*1 + 2*2 + 2*3 + … + 2*i + … + 2*(N-1) + 2*N

Notiamo che:‣ se N = 1, SN = 2 (CASO BASE)‣ se N > 1, SN = 2*N + SN-1 (PASSO INDUTTIVO)

(somma dell’N-esimo numero pari + la sommatoria dei primi N-1 numeri pari.)

Il passo induttivo richiama il valore della somma effettuato al passo precedente e lo incrementa con il nuovo valore: 2*N.Il problemi con struttura di questo tipo sono facilmente risolvibili con una programmazione ricorsiva.

Esercizio 1 - SoluzioneMATLAB/Octave - Esercitazione 11




4

La funzione che calcola la somma dei primi N numeri pari, dunque, sarà:

function somma = sommaPari(N) if (N == 1) somma = 2;else somma = 2*N + sommaPari(N-1);end

Lo script principale sarà molto semplice e si limiterà a richiamare la prima istanza della funzione:

N = input('inserire il valore N: ');

S = sommaPari(N); disp(['La somma dei primi N numeri pari è: ', num2str(S)]);

‣CASO BASE

‣PASSO INDUTTIVO





Esercizio 2

5

Si progetti la funzione ricorsiva che svolge il compito seguente:-siano dati due vettori V1 e V2, rispettivamente di dimensioni N1 e N2;

-la funzione restituisce 1 se tutti gli elementi del vettore V2 si trovano nel vettore V1 nell’ordine inverso rispetto V2, ma non necessariamente in posizioni immediatamente consecutive;

-se questo non si verifica, la funzione restituisce valore 0.

Esempio:V1 = [a c d e b] V2 = [b e a] il programma restituisce 1;V1 = [a c d e b] V2 = [e f a] il programma restituisce 0;





6

V1 = [a c d e b] V2 = [b e a]

[a c d e b] [b e a]

[c d e b] [b e]

[d e b] [b e]

[e b] [b e]

[b] [b]

[] []

V1 = [a c d e b] V2 = [e f a]

[a c d e b] [e f a]

[c d e b] [e f]

[d e b] [e f]

[e b] [e f]

[b] [e f]

[] [e f]

esempio esito positivo: esempio esito negativo:

L’algoritmo procede confrontando gli estremi dei due vettori. In grassetto sono evidenziati gli elementi messi a confronto ad ogni iterazione:

i due elementi sono uguali,accorcio entrambi i vettori

i due elementi sono diversi,accorcio solamente V1

entrambi i vettori hanno lunghezza nulla, vuol dire che V2 è interamente contenuto in V1 in ordine inverso

i due elementi sono uguali,accorcio entrambi i vettori

i due elementi sono diversi,accorcio solamente V1

V1 è vuoto mentre V2 no. V2 non è contenuto in V1 in ordine inverso.





7

Caso base:(con esito positivo): se il vettore V2 è vuoto, termina con esito positivo 1 (un vettore vuoto, senza elementi, è senz’altro contenuto in qualsiasi altro vettore).

(con esito negativo): se il vettore V1 è vuoto ma V2 non lo è, termina con esito negativo 0 (un vettore non vuoto, che contiene almeno un elemento, non può essere contenuto in un vettore vuoto).

Passo induttivo:se l’elemento iniziale di V1 è uguale a quello finale di V2 elimina l’elemento iniziale di V1 e quello finale di V2.

se l’elemento iniziale di V1 è diverso da quello finale di V2 elimina soltanto l’elemento iniziale di V1.

[] []

[] [e f]

[a c d e b] [b e a]

[c d e b] [e f]





8

Chiamata ricorsiva:ricorri sui due vettori V1 e V2 accorciati in uno dei due modi indicati nel passo induttivo.

Nella formulazione di un programma ricorsivo ci si deve sempre il porre il problema della terminazione:nel passo induttivo almeno uno dei due vettori V1 o V2 viene sempre accorciato (se non tutti e due) e quindi dopo un numero finito di passi almeno uno dei due vettori sarà vuoto. L’algoritmo termina quando almeno uno dei due vettori è vuoto e questo coincide con uno dei due casi base.‣ La terminazione della ricorsione è dunque sempre garantita.

La terminazione DEVE essere garantita altrimenti il programma ciclerebbe all’infinito.





9

function r = contieneInverso(v1,v2) if (isempty(v2)) r = 1; else if (isempty(v1)) r = 0; else if (v1(1) == v2(end)) r = contieneInverso(v1(2:end),v2(1:end-1)); else r = contieneInverso(v1(2:end),v2(1:end)); end endend

‣ caso base positivo

‣ caso base negativo

‣ passo induttivo positivo‣ passo induttivo

negativo





10

Script principale:

V1 = input('inserire il vettore V1: ');V2 = input('inserire il vettore V2: '); r = contieneInverso(V1,V2); if (r) disp(['tutti gli elementi di V2 sono contenuti in ordine inverso in V1']);else disp(['gli elementi di V2 non sono contenuti in ordine inverso in V1']);end





11

Scrivere un programma che stampi a video tutte le possibili N! permutazioni degli elementi di un vettore di N interi.

>> permuta([1 2 3])>>!1 2 3! ! 1 3 2! ! 2 1 3! ! 2 3 1! ! 3 1 2! ! 3 2 1

Esercizio 3MATLAB/Octave - Esercitazione 11




12

Calcoliamo le permutazioni di N elementi con il seguente algoritmo:

1.si tiene fisso un elemento del vettore V (per la scrittura del codice è più comodo fissare l’ultimo) e si calcolano le permutazioni dei restanti N-1 elementi.

2.si mantiene fisso il penultimo degli N elementi e si calcolano le permutazioni dei restanti N-1

1 2 3V1 = 3 1 2

3 2 1

P =

permutazioni dei restanti N-1 elementi

3 1 2

3 2 1

2 1 3

2 3 1

P =

1 2 3V =

vettore iniziale vettore degli indici matrice delle permutazioni

1 2 3V1 =

elemento fisso

elemento fisso





13

3.si scambia il l’ultimo degli N elementi elemento con il terzultimo e si ripete il passo 1

3 2 1

3 1 2

2 3 1

2 1 3

1 2 3

1 3 2

P =

Una volta calcolate le permutazioni degli indici del vettore, possiamo risalire a alle permutazioni di qualsiasi cosa sia contenuta nel vettore V. Nell’esempio seguente il vettore V contiene lettere.

1 2 3V1 =

3 2 1

3 1 2

2 3 1

2 1 3

1 2 3

1 3 2

P = a b cV = c a b

c b a

b a c

b c a

a c b

a b c

V1(P) =

1 2 3V1 =

elemento fisso





14

Il numero delle permutazioni di n oggetti è pari al fattoriale di n:

n! = n·(n-1)·(n-2)·(n-3)···1

Il problema si presta naturalmente ad una formulazione di tipo ricorsivo.

Caso base:‣ il vettore V è vuoto o ha lunghezza unitaria. L’iterazione termina ed in uscita viene

restituito il vettore stesso.

Passo induttivo:‣ fisso l’ultimo elemento del vettore V e calcolo le permutazioni dei restanti elementi, dal

penultimo al primo.





15

Definisco la funzione permuta che sarà chiamata ricorsivamente.

function P = permuta(V)

Calcolo le permutazioni degli indici del vettore. Le lettere verranno sostituite alla fine.n = length(V); % ottengo la lunghezza del vettore in input

if n <= 1 % CASO BASE: se il vettore è vuoto o contiene un solo elemento, restituisco P = V; % in uscita il vettore stesso. return % ed esco dalla funzioneend

q = permuta(1:n-1); % PASSO INDUTTIVO: chiamata ricorsiva della funzionem = size(q,1); % calcolo la dimensione del vettore restituito dalla funzioneP = zeros(factorial(n),n); % inizializzazione della matrice contenente le permutazioni

Le permutazioni di n elementi sono n!.Le dimensioni di P saranno, quindi: [n!, n].

a b cV =





16

% STEP 1

P(1:m,:) = [n*ones(m,1) q];% n*ones(m,1) il primo elemento delle prime m righe di P è l’ultimo indice di V (ovvero n)% [n*ones(m,1) q] affianca all’ultimo indice le permutazioni dei restanti n-1 elementi (contenute in q)

0 0 0

0 0 0

0 0 0

0 0 0

0 0 0

0 0 0

P =

3 2 1

3 1 2

0 0 0

0 0 0

0 0 0

0 0 0

P =

m = 22 1

1 2

q =





17

% STEP 2-3

for i = n-1:-1:1 % procedo a ritroso tra gli indici di V t = q; t(t == i) = n; P((n-i)*m+1:(n-i+1)*m,:) = [i*ones(m,1) t];end

i = 2

3 2 1

3 1 2

2 3 1

2 1 3

0 0 0

0 0 0

P = 2 1

1 2

q =

3 1

1 3

t =

i = 1

3 2 1

3 1 2

2 3 1

2 1 3

1 2 3

1 3 2

P = 2 1

1 2

q =

t = 2 3

3 2





18

Sostituisco gli elementi di V all’interno di P in posizione degli indici corrispondenti.

P = V(P);

3 2 1

3 1 2

2 3 1

2 1 3

1 2 3

1 3 2

P = a b cV = c a b

c b a

b a c

b c a

a c b

a b c

V1(P) =





Esercizio 4

19

Scrivere un programma che legga le prime N parole presenti in file di testo e controlli se le parole lette sono palindrome o meno.

Lo script dovrà:-leggere una singola parola dal file,-controllare se è palindroma,-scrivere un file di testo che contenga solo le parole palindrome e le righe in cui queste si trovano nel file d’origine.





Esercizio 4 - Soluzione

20

Per capire se una parola è palidroma si procede ricorsivamente come segue:

Caso base:‣ (con esito positivo): se il vettore che contiene la parola è vuoto o è formato da un solo

carattere, il controllo termina con esito positivo;‣ (con esito negativo): se la prima e l’ultima lettera del vettore sono diverse tra loro,

termina con esito negativo.

Passo induttivo:‣ controllo se le restanti lettere del vettore (esclusa la prima l’ultima) formano a loro volta

una parola palindroma.






21

Analizziamo la funzione che controlla se una parola è palindroma o meno:

function esito = palindroma_check(parola) if (isempty(parola) || length(parola)==1) esito = 1;elseif (parola(1) == parola(end)) esito = palindroma_check(parola(2:end-1));else esito = 0;end

‣ caso base con esito positivo

‣ caso base con esito negativo

‣ passo induttivo

isempty(V) restituisce 1 se V è un vettore vuoto, 0 altrimenti.






22

Analizziamo ora lo script principale.

Definisco il numero di parole da controllare (lo si può anche chiedere in input) e:‣ apro il file di origine in lettura‣ apro il file di destinazione in scrittura

N = 1000; % Numero di lettere del dizionario che si vogliono controllare

fid_in = fopen('dizionario.txt', 'r');fid_out = fopen('solo_palindrome.txt', 'wt')

Successivamente dovrò leggere ciclicamente una parola dal file d’origine dizionario.txt, controllare se è palindroma o meno e in caso di esito positivo scriverla nel file di destinazione solo_palindrome.txt.






23

for ii = 1:N A = textscan(fid_in, '%s', 1); parola = char(A{1, 1}) esito = palindroma_check(parola); if (esito) fprintf(fid_out, '%6d\t%s\n', parola, ii); endend

Nel nostro caso, volendo leggere una sola parola, quindi una sola stringa poniamo N = 1.


textscan(fid, ‘format’, N) legge i dati dal file fid applicando il convertitore di formato ‘format’ (%s, %c, %d, etc...) N volte.





24

Provando a digitare whos A:Name Size Bytes Class Attributes

A 1x1 226 cell

si nota che A è una cella. All’interno di questa cella è contenuta la stringa.Per ottenere il contenuto di una cella si usano le parentesi graffe {} (così come si usano le parentesi tonde () per ottenere il contenuto di un array)Accedo alla cella con il comando A{1, 1}Convertire il contenuto da string (parola intera) a char (singole lettere).

Chiudo i file aperti e (facoltativo) visualizzo il file di destinazione .

fclose(fid_in);fclose(fid_out); open solo_palindrome.txt





Esercizio 5

25

Problema della Torre di Hanoi.Si consideri una tavoletta con tre pioli ed un certo numero di dischetti di diametro diverso infilati sullo stesso piolo in ordine di diametro decrescente, col dischetto più piccolo posto in cima.

L’obiettivo del gioco è ricomporre la stessa configurazione di dischetti su di un piolo diverso, spostando un disco alla volta da un piolo all’altro, con la restrizione che un dischetto non può mai essere appoggiato su di un altro di diametro inferiore.






26

Supponiamo di voler spostare la pila di tre dischi dal piolo 1 al piolo 3. Per farlo, occorre seguire i passaggi mostrati in figura.

Per spostare i dischetti dal piolo 1 al piolo 3, si usa il piolo 2 come supporto intermedio.- la pila con i due dischetti più piccoli è

stata spostata dal piolo 1 al piolo 2 (passaggi 1-3);

- si è spostato il piolo più grande dal piolo 1 al piolo 3 (passaggio 4);

- la pila formata dai due dischetti più piccoli è stata nuovamente spostata dal piolo 2 al piolo 3 (passaggio 5-7).






27

Formalizzando i passaggi possiamo dire che per spostare una pila di k dischetti da un piolo origine ad uno destinazione, si usa un terzo piolo come supporto intermedio.

‣spostare k dischetti da origine a destinazione:

‣spostare k-1 elementi da origine a supporto;

‣spostare il disco più grande da origine a destinazione;

‣spostare k-1 elementi da supporto a destinazione

Chiamiamo l’insieme dei tre passaggi:

hanoi(k, origine, destinazione, supporto)

Lo spostamento di k-1 elementi non è immediato ma prevede dei sottopassaggi. Questo accade se k-1 > 1. Se , invece la pila di dischi da spostare è formata da un solo disco (k-1 == 1), lo spostamento è diretto e non prevede sottopassaggi.






28

L’elenco di spostamenti precedenti si espande in:

spostare k dischetti da origine a destinazione:










hanoi(k-1, origine,...supporto, destinazione)

hanoi(k-1, supporto,...destinazione, origine)

}

}Si noti che i passaggi intermedi aggiuntivi (in verde) possono essere ricondotti alle tre operazioni base invertendo: nel primo caso destinazione con supporto; nel secondo caso origine con supporto.La serie di passaggi può essere ulteriormente espansa finché i passaggi intermedi prevedono lo spostamento di un solo disco.






29

Seguendo questa logica, il tutto può essere riassunto nella forma:

hanoi(k, origine, destinazione, supporto)

‣hanoi(k-1, origine, supporto, destinazione)‣spostare il disco più grande da origine a destinazione;‣hanoi(k-1, supporto, destinazione, origine)

La risoluzione della torre di Hanoi sarebbe estremamente complessa se non si potesse utilizzare la ricorsione.Grazie alla possibilità di richiamare una funzione all’interno della funzione stessa, la soluzione diventa estremamente semplice.function [] = hanoi(k, origine, destinazione, supporto) if (k<=0) return;else if (k > 1) hanoi(k-1, origine, supporto, destinazione); end

display(['sposta un disco dal piolo ' num2str(origine) ' al piolo ' num2str(destinazione)]);

if (k > 1) hanoi(k-1, supporto, destinazione, origine); endend


Documents

Matlab/Octave - Esercitazione 11 - Informatica Bvalente.dei.polimi.it/materiale/esercitazioni/matlab/esercitazione... · MATLAB/Octave - Esercitazione 11. Politecnico di Milano -