La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

DIMOSTRAZIONI PER INDUZIONE La dimostrazione per induzione è una tecnica per provare che un asserto S(n) vale per tutti gli interi n maggiori di un certo.

Presentazioni simili


Presentazione sul tema: "DIMOSTRAZIONI PER INDUZIONE La dimostrazione per induzione è una tecnica per provare che un asserto S(n) vale per tutti gli interi n maggiori di un certo."— Transcript della presentazione:

1

2 DIMOSTRAZIONI PER INDUZIONE La dimostrazione per induzione è una tecnica per provare che un asserto S(n) vale per tutti gli interi n maggiori di un certo limite inferiore. Supposto vero lasserto la dimostrazione consiste in: individuare un caso base, il minimo valore di n, diciamo k, per cui si dimostra lasserto S(k) dimostrare il passo induttivo, cioè che per ogni n k, dove S(k) è la base induttiva, S(n) implica S(n+1) o equivalentemente supposto vero S(n) dimostriamo che è vero S(n+1). Esempio Vogliamo dimostrare che S(n): caso base Poniamo n=0 avremo che è quindi dimostrato vero

3 Il membro sinistro può essere riscritto come Avendo supposto vero lasserto Sostituiamo b) in a) a) b) passo induttivo Dobbiamo ora dimostrare che c.v.d.

4 RICORSIVITA Algoritmo ricorsivo Un algoritmo è ricorsivo quando per trovare la soluzione ad un dato problema fa uso della soluzione trovata per lo stesso problema presentato in una versione più ridotta.

5 ESEMPIO Problema del Massimo Comun Divisore (MCD o GCD) Dati due numeri interi m ed n trovare il più grande intero positivo che divide sia m che n. Soluzioni possibili Scomposizione in fattori primi Algoritmo di Euclide

6 N R R R R M MCD= R ALGORITMO DI EUCLIDE

7 Pseudo codice IF M e/o N sono valori che rappresentano una soluzione valida THEN GCD valore della soluzione (M o N) ELSE GCD GCD(N, M MOD N)

8 PROGRAM Euclide; VAR M,N:integer; BEGIN writeln('Assegna M e N '); read(M);read(N); writeln('Il MCD e'':= ',MCD(M,N)); readln END. FUNCTION MCD(M,N:integer):integer; VAR Resto:integer; BEGIN Resto:=M MOD N; WHILE Resto<>0 DO BEGIN M:=N; N:=Resto; Resto:=M MOD N END; MCD:=N END; FUNCTION GCD(M,N:integer):integer; BEGIN IF N=0 THEN GCD:=M ELSE GCD:=GCD(N,M MOD N) END; writeln('Il GCD e'':= ',GCD(M,N));

9 GCD(66,48) N=0? No GCD(48,18) GCD(18,12) N=0? No GCD(12,6) N=0? No GCD(6,0) N=0? No N=0? Si GCD6 GCD(6,0) GCD Turbo Pascal Version 7.0 Assegna M e N **push** GCD(66,48) **push** GCD(48,18) **push** GCD(18,12) **push** GCD(12,6) **pop** N= 0 **pop** N= 6 **pop** N= 12 **pop** N= 18 Il GCD e':= 6 FUNCTION GCD(M,N:integer):integer; BEGIN IF N=0 THEN GCD:=M ELSE BEGIN writeln(**push** GCD(',M,',',N,')'); writeln; GCD:=GCD(N,M MOD N); writeln(**pop** N= ',M MOD N) END END; GCD:=GCD(N, M MOD N)

10 Ogni algoritmo ricorsivo deve essere tale che durante i passi della ricorsione, cioè della riduzione del problema, si giunge sempre ad una soluzione. Questa soluzione è detta CASE BASE o STOPPING CASE. Nel caso del GCD il CASE BASE è il caso in cui N=0. CASE BASE : è una soluzione per un algoritmo ricorsivo per la quale non sono necessarie ulteriori chiamate ricorsive. Ogni algoritmo ricorsivo, per essere valido, richiede almeno un CASE BASE. Il meccanismo di gestione delle chiamate ricorsive è quello dello stack, si fa cioè ricorso alla tecnica LIFO ed è chiamato Run-time stack.

11 Un esempio di ricorsione per accumulazione Problema Si vuole calcolare la potenza Nma del numero reale Xre. Soluzione Base Case Ricorsione FUNCTION PotenzaN(Xre:real,N:integer):real; BEGIN IF N=0 THEN PotenzaN :=1 ELSE PotenzaN:= Xre*PotenzaN(Xre,N-1); END;

12 PotenzaN(0.9,3) N=0? No PotenzaN(0.9,2) PotenzaN(0.9,1) N=0? No PotenzaN(0.9,0) PotenzaN(0.9,1) N=0? No N=0? Si PotenzaN 1 PotenzaN 0.9* PotenzaN(0.9,3) FUNCTION PotenzaN(Xre:real,N:integer):real; BEGIN IF N=0 THEN PotenzaN :=1 ELSE writeln(**push**,N); PotenzaN:= Xre*PotenzaN(Xre,N-1); writeln(**pop**,N); END; Turbo Pascal Version 7.0 Assegna Xre e N **push** 3 **push** 2 **push** 1 **pop** 1 **pop** 2 **pop** elevato a 3 e'= 0.729

13 COME FUNZIONA LA RICORSIVITA PROCEDURE(p 1,…., p k ) Case base ? NO allora applica PROCEDURE(p 1,…., p k ) Case base ? NO allora applica PROCEDURE(p* 1,…., p* k ) Case base ? SI allora applica la soluzione a Applica la soluzione a PROCEDURE(p 1,…., p k ) Case base ? NO allora applica Applica la soluzione a Dove (p i 1,…., p i k ) sono problemi ridotti del problema precedente

14 IF i parametri fanno riferimento a un Case Base THEN risolvi il problema ELSE usa i valori dei parametri per un problema ridotto CHIAMA LA PROCEDURA O FUNZIONE PER RISOLVERE IL PROBLEMA RIDOTTO Possiamo dire che è stato applicato il metodo del DIVIDE ET IMPERA

15 Un algoritmo iterativo consiste in un unico processo che ripete le stesse identiche operazioni molte volte. Un algoritmo ricorsivo consiste in un numero finito di processi aperti uno dopo laltro e posti in uno stack. Non appena si chiude un processo subito si sale nello stack e si chiude il processo immediatemente precedente e così via di seguito.

16 Per scrivere un algoritmo ricorsivo bisogna soddisfare le seguenti condizioni: 1. Esiste almeno un case base la cui soluzione è banale 2. Tutti i sottoproblemi devono poter essere risolti in termini di versioni ridotte di uno stesso problema 3. Le azioni applicate per la soluzione di un problema ridotto portano sempre alla soluzione di un problema più grande 4. In funzione di quanto sia grande il problema iniziale deve essere sempre possibile trovare almeno un case base nel corso della elaborazione del problema originale.

17 DIMOSTRAZIONE PER INDUZIONE Vogliamo dimostrare che S(n): a) caso base Poniamo n=1 avremo che è quindi dimostrato vero Avendo supposto vero lasserto sostituiamo in b) il valore che si ottiene da a) passo induttivo Dobbiamo ora dimostrare che b) q.e.d.

18 caso base Poniamo GCD(M,0)=M passo induttivo Dobbiamo ora dimostrare che GCD(M,N)=GCD(N, M MOD N) Supponiamo GCD(M,N)=X allora M=hX e N=zXdove h e z sono interi essendo N=M MOD N questo implica per definizione che M=kN+N dove k è un intero ma N=zX allora M=kN+zXinoltre N=M=hX quindi M=khX+zX=(kh+z)X=wX essendo allora sia M che N divisibili per X questo è il GCD(M,N) DIMOSTRAZIONE PER INDUZIONE DELLA CORRETTEZZA DELLALGORTIMO RICORSIVO PER IL GCD

19 caso base Poniamo GCD(M,0)=M passo induttivo Dobbiamo ora dimostrare che GCD(M,N)=GCD(N, M MOD N) Supponiamo GCD(M,N)=X allora M=hX e N=zXdove h e z sono interi M=kN+N dove k è un intero allora M=kN+zXinoltre N=M=hX quindi M=khX+zX=(kh+z)X=wX essendo allora sia M che N divisibili per X questo è il GCD(M,N)q.e.d. ma N=zX essendo N=M MOD N questo implica per definizione che

20 Un algoritmo ricorsivo deve essere completo, deve cioè sempre esistere una soluzione qualunque sia linput. La completezza dipende dal dominio su cui si definisce lalgoritmo. Esempio: PotenzaN se definito sugli interi non è completo perché non funziona per gli interi negativi (infatti N-1 per N negativo non raggiunge mai lo 0). Diventa completo se il domino di definizione è quello dei numeri interi positivi. Stack Infinito Si genera quando per un qualche input di un algoritmo ricorsivo non si raggiunge mai il CASE BASE.

21 Esempio Dato un testo scritto su un file e formato da più righe leggerlo e riscriverlo in ordine inverso rispetto alle righe. Es. La Vispa Teresa avea tra lerbetta a volo sorpresa gentil farfalletta a volo sorpresa avea tra lerbetta La Vispa Teresa Pseudo-codice reset(Teresa) InvertiRighe (Teresa)

22 PROCEDURE MostraRigheInvertite (VAR Teresa:text); BEGIN StoreDisplay(Teresa) END; PROGRAM InvertiRighe(Teresa,output); VAR Teresa:text; PROCEDURE StoreDisplay(VAR Teresa:text); {procedura ricorsiva: la prima linea letta è lultima mostrata a video} BEGIN ……….. END; { BODY } BEGIN reset(Teresa); MostraRigheInvertite END.

23 *push* La vispa Teresa *push* avea tra l'erbetta *push* a volo sorpresa *push* gentil Farfalletta *pop* gentil Farfalletta *pop* a volo sorpresa *pop* avea tra l'erbetta *pop* La vispa Teresa PROGRAM InvertiRighe(output,FInput); CONST LungMax=80; {massima lunghezza permessa alle stringhe } TYPE Stringa=STRING[LungMax]; VAR FInput: text; PROCEDURE StoreDisplay(VAR FInput:text); VAR Rigo: Stringa; BEGIN IF NOT eof(FInput) THEN BEGIN readln(FInput,Rigo); writeln('*push* ',Rigo); StoreDisplay(FInput); writeln(' *pop* ',Rigo) END END; PROCEDURE MostraRigheInvertite(VAR FInput:text); BEGIN StoreDisplay(FInput) END; {BODY } BEGIN assign(FInput,'C:\TP\ESEMPI\TERESA.TXT'); reset(FInput); MostraRigheInvertite(FInput); readln END. base case

24 From - Thu Aug 26 07:09: Return-Path: Received: from di.unito.it (pianeta.di.unito.it) by sole.cib.na.cnr.it (4.1/SMI-4.1) id AA29055; Sun, 1 Aug 99 06:10: Received: from cs.CS.NMSU.Edu by di.unito.it (8.9.1a/SMI-INFODIP) id FAA23820; Sun, 1 Aug :50: (MET DST) Received: from cs.nmsu.edu [ ]) by cs.CS.NMSU.Edu (8.8.6/8.8.6) with ESMTP id VAA27225; Sat, 31 Jul :53: (MDT) Sender: Message-Id: Date: Sat, 31 Jul :53: From: Enrico Organization: Laboratory for Logic & Databases X-Mailer: Mozilla 4.05 [en] (X11; I; Linux i686) Mime-Version: 1.0 To: Subject: Research Assistantships at NMSU Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit X-UIDL: b0fa9065af5ad288d1475b519b3ad95b Status: U X-Mozilla-Status: 0001 Applications are invited for several Research Assistant Positions in the Laboratory for Logic and Databases of the Dept. of Computer Science at New Mexico State University.

25 From - Thu Aug 26 07:09: Return-Path: X-Mozilla-Status: messaggio From - Thu Aug 28 09:09: Return-Path: X-Mozilla-Status: messaggio

26 ElaboraTesto(Rigo) Pseudo codice IF Not eof(InFile) THEN readln(Finput,Rigo) ElaboraTesto(Rigo)

27 ALTRI ESEMPI Supponiamo di avere 3 lettere a b c. Vogliamo sapere quante permutazioni si possono fare con questi 3 caratteri. - ci sono 3 maniere per scegliere quale lettera mettere in terza posizione (genericamente n) abc acb cba - per ognuna delle 3 scelte precedenti ci sono 2 maniere diverse per scegliere la lettere da mettere in seconda posizione in totale 3*2 (genericamente n*(n-1)) abc bac acb cab cbabca - per ognuna delle 6 scelte precedenti cè 1 sola maniera per scegliere la lettere da mettere in prima posizione in totale 3*2*1 (genericamente n*(n-1)…..*1) abc bac acb cab cbabca FATTORIALE

28 FUNCTION Fattoriale(N:integer):integer; VAR Count, Product: integer; BEGIN Product:=1; FOR Count:=2 TO N DO Product:=Product*Count; Fattoriale:=Product END; FUNCTION Fattoriale (N:integer):integer; BEGIN IF N=0 THEN Fattoriale:=1 ELSE Fattoriale:=N*Fattoriale(N-1) END;

29 FUNCTION Sommatoria (N:integer):integer; BEGIN IF N=0 THEN Sommatoria:=1 ELSE Sommatoria :=N+Sommatoria(N-1) END; Sommatoria dei primi N interi positivi 1. La somma dei primi 0 interi positivi vale La somma dei primi N interi positivi è uguale alla somma dei primi N-1 interi più N.

30 Quando si applica un processo ricorsivo tipo quello della accumulazione bisogna assicurarsi che i valori accumulati nelle relative variabili siano correttamente passati da un processo allaltro. Inoltre il valore assunto da una variabile in un processo ricorsivo non deve essere distrutto dal lancio di un altro processo ricorsivo. Di qui la necessità di passare le variabili utilizzando la chiamata per VAR. Esempio: Fare la somma dei primi N interi positivi e mostrare le somme parziali ogni M passi. Pseudo-codice IF N=0 THEN scrivi un messaggio Somma 0 ELSE ShowSums(N-1, M, Sum) Somma Somma+N IF N MOD M=0 THEN scrivi N e Somma

31 PROGRAM SommaRicorsiva(inputoutput); VAR Nin,Min,Sumout:integer; PROCEDURE ShowSums(N,M:integer; VAR Sum:integer); VAR Temp:integer; BEGIN IF N=0 THEN BEGIN writeln(' Somme parziali '); Sum:=0 END ELSE BEGIN ShowSums(N-1,M,Sum); Sum:=Sum+N; Temp:=N MOD M; IF N MOD M=0 THEN writeln('La somma dei primi ',N:1,' numeri e'' = ',Sum:1,'.') END END; BEGIN writeln(' Assegna N e M '); readln(Nin); readln(Min); writeln(' N M Sum'); ShowSums (Nin,Min,Sumout); writeln('La somma dei primi ',Nin:1,' numeri e'' = ', Sumout:1,'.'); END.

32 Assegna N e M 7 2 N M Sum push** push** push** push** push** push** push** Somme parziali pop** pop** La somma dei primi 2 numeri e' = 3. pop** pop** La somma dei primi 4 numeri e' = 10. pop** pop** La somma dei primi 6 numeri e' = 21. pop** La somma dei primi 7 numeri e' = 28.

33 Esempio con due CASE BASE Problema: Assegnare agli elementi dellArray di interi Ints, dei numeri compresi nellintervallo 1..TotalAssigned. Ogni numero viene dato da tastiera. Il processo di lettura cessa o quando si introducono tutti i numeri concessi (MaxElements) oppure quando si introduce un numero negativo. Subito dopo si effettua lassegnazione. In questo caso i CASE BASE possibili sono due: abbiamo letto il massimo numero possibile di valori abbiamo letto un numero negativo In entrambi i casi la lettura deve terminare e si effettua lassegnazione

34 Pseudo-Codice {Indichiamo con Left quanti numeri positivi è ancora possibile assegnare e con Temp il valore letto } IF Left = 0 THEN gestisci il CASE BASE N°1 ELSE read(Temp) IF Temp<=0 THEN gestisci il CASE BASE N°2 ELSE istruzioni prima della ricorsione FillIn(Left-1,TotalAssigned,Ints) istruzioni dopo la ricorsione TotalAssigned = 0 TotalAssigned = TotalAssigned + 1 Ints[TotalAssigned ] Temp Temp< = 0

35 PROGRAM CaseBase2(input,output); CONST MaxElements=4; TYPE IntsArray=ARRAY[1..MaxElements] OF integer; VAR Ints:IntsArray; Left, TotalAssigned, I:integer; PROCEDURE FillIn(Left:integer; VAR TotalAssigned:integer; VAR Ints:IntsArray); VAR Temp: integer; BEGIN IF Left=0 THEN BEGIN readln; writeln('Non possono essere letti altri valori. '); TotalAssigned:=0; END ELSE BEGIN read(Temp); IF Temp <=0 THEN BEGIN writeln('E'' stato introdotto un numero negativo. '); TotalAssigned:=0; END ELSE BEGIN FillIn(Left-1, TotalAssigned,Ints); TotalAssigned:= TotalAssigned+1; Ints[TotalAssigned]:=Temp END END;

36 {BODY} BEGIN writeln('Inizia inserzione dati max= ',MaxElements); writeln; FillIn(MaxElements,TotalAssigned,Ints); writeln(' ARRAY '); FOR I:=1 TO TotalAssigned DO writeln(Ints[I]); readln END. Inizia inserzione dati max= 4 Left TotalAssigned 1 push** push** push** push** 1 0 Non possono essere letti altri valori. pop** 1 0 pop** 2 1 pop** 3 2 pop** 4 3 ARRAY Inizia inserzione dati max= 4 Left TotalAssigned 11 push** push** E' stato introdotto un numero negativo. pop** 3 0 pop** 4 1 ARRAY 12 11

37 Alcuni suggerimenti Fatti importanti come si passano i valori di variabili a-usare una chiamata per valore per determinare se il CASE BASE è verificato b-se il processo ricorsivo è di tipo per accumulazione usare la chiamata per VAR per la variabile di accumulazione c-usare una variabile locale se il suo valore è istanziato allinterno del processo ricorsivo per cui ad ogni passo della ricorsione riprende il valore di partenza PROCEDURE FillIn(Left:integer; VAR TotalAssigned:integer; VAR Ints:IntsArray); VAR Temp: integer;

38 lordine con cui le istruzioni vengono eseguite, se prima o dopo la chiamata ricorsiva A-se una o più istruzioni riducono la dimensione del problema esse devono precedere la chiamata ricorsiva B- se una o più istruzioni necessitano del risultato della ricorsione vanno b- poste dopo la chiamata ricorsiva ElaboraTesto(Rigo) Pseudo codice IF Not eof(InFile) THEN readln(Finput,Rigo) ElaboraTesto(Rigo) BEGIN read(Temp); IF Temp <=0 THEN BEGIN writeln('E'' stato introdotto un numero negativo. '); TotalAssigned:=0; END ELSE BEGIN FillIn(Left-1, TotalAssigned,Ints); TotalAssigned:= TotalAssigned+1; Ints[TotalAssigned]:=Temp END

39 PROCEDURE FillIn(Left:integer; VAR TotalAssigned:integer; VAR Ints:IntsArray); VAR Temp: integer; BEGIN IF Left=0 THEN BEGIN writeln('Non mettere altri valori. '); TotalAssigned:=0; END ELSE BEGIN read(Temp); IF Temp <=0 THEN BEGIN writeln('E'' stato introdotto un negativo. '); TotalAssigned:=0; END ELSE BEGIN FillIn(Left-1, TotalAssigned,Ints); TotalAssigned:= TotalAssigned+1; Ints[TotalAssigned]:=Temp END END; PROCEDURE FillIn2(Left:integer; VAR Ints:IntsArray); VAR Temp: integer; BEGIN IF Left<>0 THEN BEGIN FillIn(Left-1,Ints); read(Temp); Ints[Left]:=Temp END END; PROCEDURE FillIn3(Left:integer; VAR Ints:IntsArray); VAR Temp: integer; BEGIN IF Left<>0 THEN BEGIN read(Temp); FillIn(Left-1,Ints); Ints[Left]:=Temp END END; FillIn1 10 push** 5 20 push** 4 30 push** 3 40 push** 2 50 push** 1 pop** 1 pop** 2 pop** 3 pop** 4 pop** 5 ARRAY FillIn2 push** 5 push** 4 push** 3 push** 2 push** 1 pop** 1 10 pop** 2 20 pop** 3 30 pop** 4 40 pop** 5 50 ARRAY FillIn3 push** 5 10 push** 4 20 push** 3 30 push** 2 40 push** 1 50 pop** 1 pop** 2 pop** 3 pop** 4 ARRAY

40 FillIn1 10 push** 5 20 push** 4 30 push** 3 40 push** 2 50 push** 1 pop** 1 pop** 2 pop** 3 pop** 4 pop** 5 ARRAY FillIn2 push** 5 push** 4 push** 3 push** 2 push** 1 pop** 1 10 pop** 2 20 pop** 3 30 pop** 4 40 pop** 5 50 ARRAY FillIn3 push** 5 10 push** 4 20 push** 3 30 push** 2 40 push** 1 50 pop** 1 pop** 2 pop** 3 pop** 4 ARRAY

41 Ricorsione non lineare = più di una chiamata ricorsiva per blocco Per capire bene come opera una ricorsione non lineare si traccia un albero che mostra la storia dello stack. Ricorsione lineare = al massimo una chiamata ricorsiva per blocco

42 Esempio PROGRAM TreeExample(output); PROCEDURE C(N:integer); BEGIN IF N>0 THEN C(N-1) END; PROCEDURE B; BEGIN C(1) END; PROCEDURE A; BEGIN B END; {BODY} BEGIN A; C(1); writeln(Fine) END. Esecuzione 1 main chiama A ; 2 A chiama B; 3 B chiama C(1); 4 C(1) chiama C(0); 5 C(0) ritorna C(1); 6 C(1) ritorna B; 7 B ritorna A; 8 A ritorna al main; 9 main chiama C(1); 10 C(1) chiama C(0); 11 C(0) ritorna C(1); 12 C(1) ritorna main; 13 main chiama writeln(Fine) 14 writeln(Fine) PROCEDURE APROCEDURE BPROCEDURE C(1) PROCEDURE C(0) MAIN PROCEDURE C(1) PROCEDURE C(0) MAIN

43 main chiama A A chiama B B chiama C(1) C(1) chiama C(0) C(0) ritorna a C(1) C(1) ritorna a B B ritorna A A ritorna a main main chiama C(1) C(1) chiama C(0) C(0) ritorna a C(1) C(1) ritorna a main main chiama Fine Fine PROGRAM TreeExample(output); PROCEDURE C(N:integer); BEGIN IF N>0 THEN BEGIN writeln('C(',N,') chiama C(',N-1,')'); C(N-1); writeln(' C(',N-1,') ritorna a C(',N,')') END END; PROCEDURE B; BEGIN writeln('B chiama C(1)'); C(1); writeln(' C(1) ritorna a B') END; PROCEDURE A; BEGIN writeln('A chiama B'); B; writeln('B ritorna A') END; BEGIN writeln('main chiama A'); A; writeln('A ritorna a main'); writeln('main chiama C(1)'); C(1); writeln('C(1) ritorna a main'); writeln('main chiama Fine'); writeln('Fine'); readln END.

44 mainC(0) ritorna a C(1) C(1) ritorna a BB ritorna A A ritorna a main C(1) ritorna a mainC(0) ritorna a C(1) main chiama A A A chiama B B B chiama C(1) C(1) C(1) chiama C(0) C(0) Fine ritorna a main main chiama C(1) C(1) C(1) chiama C(0) C(0) main chiama Fine writeln

45 main A B C(1) C(0) C(1) C(0) writeln

46 Regole per costruire lalbero della storia dello stack 1. Ogni albero deve avere una radice principale 2. Lalbero è fatto di nodi che rappresentano i processi che sono eseguiti ad un certo passo. Ogni nodo rappresenta esattamente un processo. Se è necessario si mettono etichette che indicano il processo. 3. Un ramo dellalbero rappresenta una chiamata e un ritorno di un processo rispetto ad un altro. Se ci sono più processi ricorsivi si indicano in ordine a partire da sinistra. 4. Ogni nodo è visitato una sola volta (push e pop) e nessun processo può terminare se prima non sono terminati tutti quelli che ha chiamato.

47 NullString {ritorna una la stringa nulla ''.} ConvertSysString {converte una stringa rappresentata in un qualche sistema nella stringa equivalente di type StringADT} ReadCh {legge i caratteri di una stringa da un file e se supera la lunghezza prefissata o trova eoln restituisce un carattere sentinella} ReadString {legge la stringa da un file escludendo eventuali caratteri sentinella} ReadlnString {legge una stringa da una linea di un file predeterminato} Ach {ritorna il carattere N-esimo di una stringa } StrLength {ritorna la lunghezza della stringa} WriteString {scrive una stringa in un file} WritelnString {scrive una stringa in un file seguita da un } LowerCase {trasforma le maiuscole in minuscole} StrEqual {ritorna TRUE se due stringhe hanno gli stessi caratteri e la stessa lunghezza} StrExtract {copia una stringa di una predeterminata lunghezza a partire da una determinata posizione in una stringa di output} StartPos {Ritorna la posizione di partenza di una data sub-stringa nell'ambito di una preassegnata stringa} StrLessThan {ritorna TRUE se la prima stringa precede alfabeticamente la seconda} ChConcat {concatena un singolo carattere ad una stringa} StrConcat {concatena due stringhe} StrRemove {rimuove un predeterminato numero di caratteri a partire da una certa posizione di una stringa di input/output} StrInsert {inserisce un predeterminata stringa di caratteri a partire da una certa posizione in una variabile stringa.} ScriviSTringa {scrivi la stringa} OPERATORI SULLE STRINGHE

48 UNIT Stringa; INTERFACE CONST MaxLength=80; TYPE SysString=STRING[MaxLength]; StringADT=RECORD Chars:ARRAY[1.. MaxLength] OF char; Len:0.. MaxLength END;

49 FUNCTION StartPos(Substr, SearchStr:StringADT):integer; {Ritorna la posizione di partenza di una data sub-stringa Substr nell'ambito di una preassegnata SearchStr stringa} VAR SLen, {numero di caratteri della sub-stringa} Pos: integer; {posizione di partenza della sub-stringa} Found: Boolean; CandStr: StringADT;{sub-stringa candidata } BEGIN SLen:=SubStr.Len; Found:=FALSE; Pos:=1; WHILE NOT (SearchStr.Len+1-Pos>SLen) AND NOT Found DO BEGIN StrExtract(SearchStr,Pos,SLen,CandStr); IF StrEqual(CandStr,SearchStr) THEN Found:=TRUE ELSE Pos:=Pos+1 END; IF Found THEN StratPos:=Pos ELSE StratPos:=0 END; StringADT=RECORD Chars:ARRAY[1.. MaxLength] OF char; Len:0.. MaxLength END;

50 PROCEDURE StrExtract(InStr:StringADT; Start, TotalChs:integer; VAR OutStr: StringADT); {copia da una stringa di input InStr una stringa di una predeterminata lunghezza TotalChs a partire da una determinata posizione Start in una stringa di output OutStr } VAR InStrPos,{Posizione di un carattere nella stringa di input} OutStrPos:integer;{Posizione di un carattere nella stringa di output} BEGIN WITH OutStr DO BEGIN IF Start > InStr.Len THEN{controlla che il punto di partenza non sia fuori stringa} Len:=0 ELSE IF TotalChs > InStr.Len+1-Start THEN Len:=InStr.Len+1-Start ELSE Len:=TotalChs; InStrPos:=Start; FOR OutStrPos:=1 TO Len DO BEGIN Chars[OutStrPos]:=InStr.Chars[InStrPos]; InStrPos:=InStrPos+1 END END; StringADT=RECORD Chars:ARRAY[1.. MaxLength] OF char; Len:0.. MaxLength END;

51 FUNCTION StrEqual(Instr1, Instr2:StringADT):boolean; {ritorna TRUE se le stringhe Instr1 e Instr2 hanno gli stessi caratteri e la stessa lunghezza} VAR Pos, TotalChars:integer; StillEqual:boolean; BEGIN IF Instr1.Len<>Instr2.Len THEN StillEqual:= FALSE ELSE StillEqual:= TRUE; TotalChars:= Instr1.Len; Pos:=1; WHILE NOT(Pos>TotalChars) AND StillEqual DO IF Minuscole(InStr1.Chars[Pos])<> Minuscole(InStr2.Chars[Pos]) THEN StillEqual:= FALSE ELSE Pos:=Pos+1; StrEqual:=StillEqual END; FUNCTION Minuscole(Ch:char):char; BEGIN IF Ch IN [A..Z] THEN Minuscole:=chr(ord(Ch)+ord(a)-ord(A)) ELSE Minuscole:=ch END;

52 PROCEDURE ReadlnString (Sentinel:char; VAR OutStr:StringADT;VAR InFile:text); {legge una stringa da una linea di un file predeterminato} VAR Ch:char; BEGIN WITH InString DO BEGIN Len:=0; WHILE NOT eoln(InFile) AND NOT (Len=MaxLength) DO BEGIN Read(Infile,Ch); Len:=Len+1; Chars[Len]:=Ch; END END;

53 From - Thu Aug 26 07:09: Return-Path: Received: from di.unito.it (pianeta.di.unito.it) by sole.cib.na.cnr.it (4.1/SMI-4.1) id AA29055; Sun, 1 Aug 99 06:10: Received: from cs.CS.NMSU.Edu by di.unito.it (8.9.1a/SMI-INFODIP) id FAA23820; Sun, 1 Aug :50: (MET DST) Received: from cs.nmsu.edu [ ]) by cs.CS.NMSU.Edu (8.8.6/8.8.6) with ESMTP id VAA27225; Sat, 31 Jul :53: (MDT) Sender: Message-Id: Date: Sat, 31 Jul :53: From: Enrico Organization: Laboratory for Logic & Databases X-Mailer: Mozilla 4.05 [en] (X11; I; Linux i686) Mime-Version: 1.0 To: Subject: Research Assistantships at NMSU Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit X-UIDL: b0fa9065af5ad288d1475b519b3ad95b Status: U X-Mozilla-Status: 0001 Applications are invited for several Research Assistant Positions in the Laboratory for Logic and Databases of the Dept. of Computer Science at New Mexico State University.

54 ElaboraTesto(Rigo) Pseudo codice IF Not eof(InFile) THEN readln(Finput,Rigo) ElaboraTesto(Rigo)

55 Problema Nel 1228 messer Leonardo Pisano si pose il seguente problema: posta una coppia di conigli in un recinto supponiamo che questa coppia dopo un mese genera unaltra coppia, questa a sua volta dopo un altro mese ne genera unaltra e contemporaneamente anche le precedenti generano altre coppie. Dopo un anno, cioè dopo 12 mesi quanti conigli ci saranno nel recinto? 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233

56 Esempio I numeri di Fibonacci definiti ricorsivamente. N=1 :Fib(N) 1 N=0 :Fib(N) 0 N>=2 :Fib(N) Fib(N-2)+FIB(N-1) FUNCTION Fibonacci(N:integer):integer; {ritorna lN-esimo numero di Fibonacci} BEGIN IF N=0 THEN Fibonacci:=0 ELSE IF N=1 THEN Fibonacci:=1 ELSE Fibonacci:= Fibonacci(N-2) + Fibonacci(N-1) END.

57 Ricorsione lineare: al più una chiamata ricorsiva nellambito di uno stesso processo ricorsivo. Ricorsione non lineare: più di una chiamata ricorsiva nellambito di uno stesso processo ricorsivo. main F(3) F(1)F(2) Fibonacci(3) main F(3) F(1) F(2) F(4) F(2) Fibonacci(4)

58 Complessità dellalgoritmo per il calcolo dei numeri di Fibonacci E stato dimostrato che per N abbastanza grande la complessità di F(N), cioè il numero di chiamate ricorsive, è circa O(1.61 N ) N1,61^N1 MFLOP 1 TERAFLOP ,01sec ,13minuti ,10ore anni ,45348E+27anni7,45E+27

59 main F(3) F(1) F(2) F(4) F(2) Fibonacci(6) F(5) F(3) F(6) F(1) F(2) F(3) F(4) F(2) F(1)

60 PROGRAM ContaCall(output); VAR Calls:real; No:integer; FUNCTION Fibonacci(N:integer; VAR Calls:real):real; {ritorna l'N-esimo numero di Fibonacci} BEGIN Calls:=Calls+1; IF N=0 THEN Fibonacci:=0 ELSE IF N=1 THEN Fibonacci:=1 ELSE Fibonacci:= Fibonacci(N-2,Calls) + Fibonacci(N-1,Calls) END; {BODY} BEGIN FOR No:=1 TO 40 DO BEGIN Calls:=0; IF No MOD 5=0 THEN writeln('Fibonacci(',No:1,') = ', Fibonacci(No,Calls):20:0,' chiamate= ',Calls:20:0) END; readln END.

61 Fibonacci(5) = 3 chiamate= 9 Fibonacci(10) = 34 chiamate= 109 Fibonacci(15) = 377 chiamate= 1219 Fibonacci(20) = 4181 chiamate= Fibonacci(25) = chiamate= Fibonacci(30) = chiamate= Fibonacci(35) = chiamate= Fibonacci(40) = chiamate=

62 Per ridurre da O (1.61 N ) a O(N) la complessità di calcolo per i numeri di Fibonacci invece di chiamare ricorsivamente la procedura di calcolo per ogni nodo dellalbero dello stack depositiamo i risultati di ogni computazione in un array e li richiamiamo, senza più calcolarli ogni volta che ne abbiamo bisogno. Detto FibNos larray in cui si depositano i numeri parziali possiamo costruire una procedura ricorsiva alla seguente maniera: CASE BASE Quando N=2 allora poni FibNos[2] 1 FibNos[1] 0 CHIAMATA RICORSIVA FibNos[N] FibNos[N-2] +FibNos[N-1]

63 Pseudo Codice IF N= THEN FibNos[2] 1 FibNos[1] 0 ELSE FibNos[N] FibNos[N-2] + FibNos[N-1] Svantaggio Per N grande possiamo avere un errore di stack overflow

64 PROGRAM ContaCallVeloce(output); {calcola l'N-esimo numero di Fibonacci in O(N) } CONST MaxFib=50; TYPE FibNoArr=ARRAY[1..MaxFib] OF real; VAR FibNos:FibNoArr; VAR No:integer; PROCEDURE SetFibNo(N:integer; VAR FibNos:FibNoArr); {ritorna l'N-esimo numero di Fibonacci} BEGIN IF N=2 THEN BEGIN FibNos[2]:=1; FibNos[1]:=1 END ELSE BEGIN SetFibNo(N-1,FibNos); FibNos[N]:=FibNos[N-2] + FibNos[N-1] END END; {BODY} BEGIN FOR No:=1 TO 40 DO BEGIN IF No MOD 5=0 THEN BEGIN SetFibNo(No,FibNos); writeln('Fibonacci(',No:1,') = ',No,FibNos[No]:20:0) END END; readln END. SetFibNo(4) SetFibNo(3) SetFibNo(2) F(3) F(1) F(2) F(4) F(2) FibNo[4] FibNo[3] FibNo[2] FibNo[1]

65 ALGORITMI DI RICERCA LINEARE Problema: Cercare tra i valori contenuti in un Array un preassegnato valore. Esempio: Data una lista di N numeri verificare se esiste un preassegnato Valore. Condizioni di uscita: - la ricerca è finita se nessun elemento uguale a quello cercato esiste - la ricerca è finita se almeno un elemento uguale a quello cercato è stato trovato Partire dallultimo elemento della lista e risalire fino in cima nella ricerca dellelemento.

66 Soluzione: Gestire opportunamente lindice dellarray in cui sono contenuti gle elementi su cui fare la ricerca I criteri per stabilire il nuovo valore da attribuire allindice possono essere i più diversi. E però importante che una volta stabilito che un elemento individuato da un certo indice non è quello cercato questo elemento non venga più esaminato. Algoritmo 10.2 Indice NumeroTotaleElementi Trovato false WHILE NOT (Indice=0) AND NOT Trovato DO IF UnArray[Indice]= ValoreCercato Trovato true ELSE Indice Indice-1

67 Poiché ad ogni passo della ricerca eliminiamo un elemento il massimo numero di passi è pari al numero di elementi. Indicatore:=CercaIndice(Nome, NumeroElementi,ValoreCercato); IF Indicatore<>0 THEN BEGIN write(ValoreCercato, è stato trovato nella posizione,Indicatore:2); END ELSE write(ValoreCercato, non è stato trovato );

68 FUNCTION CercaIndice(VAR Nome: NomeArray; NumeroElementi:integer; ValoreCercato:NomeStringa):integer; VAR Indice:integer; Trovato: boolean; BEGIN WHILE NOT (Indice=0) AND NOT Trovato DO IF Nome[Indice]=ValoreCercato THEN Trovato:= true ELSE Indice:= Indice-1; CercaIndice:= Indice END.

69 Ricerca ricorsiva Pseudo codice FUNCTION Indice (VAR UnArray; Chiave; SubRange):IType IF terminato THEN Indice 0 ELSE prendi un Candidato IF UnArray[Candidato] = Chiave THEN Indice Candidato ELSE rivedi il SubRange riducendo le dimensioni del problema Indice Indice(UnArray, Chiave, SubRangeRidotto) Indice Indice(UnArray, Chiave, SubRangeIniziale) ESPRESSIONE RICORSIVACASE BASE 2 CASE BASE 1

70 Caratteristiche di una ricerca ricorsiva Gli array passati al blocco ricorsivo vengono chiamati per VAR. Una chiamata ricorsiva implica sempre una riduzione del sub range di possibili candidati. Quindi nellintestazione è presente almeno un parametro che rappresenta il subrange di elementi. Il valore del parametro in ogni istante di computazione è funzione di un qualche subrange candidato locale. Questa espressione i cui valori devono rappresentare una riduzione del subrange candidato viene calcolata e al successivo processo di ricerca i valori vengono applicati. La condizione di terminazione è espressa in termini dei parametri del subrange candidato. Questa condizione rappresenta il CASE BASE quando non restano altri subrange candidati alla ricerca. Laltro CASE BASE si ha quando la ricerca ha buon esito, quando cioè Array[Candidate] coincide con Chiave.

71 Una funzione di Search linaeare può essere del tipo Linear(UnArray, Chiave, TotalElements) dove si presuppone che il subrange di candidati sia tra 1.. TotalElements. Esempio Supponiamo di avere un Array di record Studenti, di operare su un subrange che vada 1..NumeroStudenti. Uno dei campi del record supponiamo sia MATRICOLA. Su questo campo vogliamo fare delle ricerche. Una chiamata di funzione tipica è Indice:=Linear(Studenti; MatrCercata; NumeroStudenti) FUNCTION Linear (VAR Studenti: StudenteRecord; MatrCercata;StringaNome; NumeroStudenti :integer):integer; BEGIN IF N=0 THEN Linear:= 0 ELSEIF Studenti[N].Matricola=MatrCercata THEN Linear:=N ELSE Linear:=Linear(Studenti; MatrCercata; NumeroStudenti-1) END; ESPRESSIONE RICORSIVA CASE BASE 2CASE BASE 1 RICERCA LINEARE

72 TYPE Stringa20 = STRING[20] RisultatiArray=ARRAY[1..TotaleProve] OF integer; AnagraficaRecord = RECORD Cognome, Nome : Stringa20 END; DataRecord = RECORD Giorno, Mese, Anno : integer END; StudenteRecord = RECORD Anagrafe:AnagraficaRecord; Nascita:DataRecord; Matricola:StringaNome; AnnoCorso:StringaNome; Risultati:RisultatiArray; Media:real; END; Studente AnagrafeNascitaMatricola CognomeNomeAnnoMeseGiorno AnnoCorsoRisultatiMedia

73 RICERCA BINARIA Data una lista di N elementi ordinati cercare se tra essi esiste un determinato elemento. Dividiamo gli elementi ordinati in due parti. Quello che cerchiamo può appartenere o alla prima o alla seconda parte, essendo tutti gli elementi ordinati. Dividiamo la parte scelta ancora in due e applichiamo ancora il ragionamento precedente. Lalgoritmo termina o quando lultimo elemento rimasto dalle successive suddivisioni è uguale a quello cercato, oppure quando lintervallo rimasto non è più suddivisibile il che implica che il nostro elemento non appartiene alla lista.

74 Basso 1 Alto ElementiTotali WHILE NOT (Basso<=Alto) DO Metà (Basso+Alto) DIV 2 IF Interi[Metà ]< ValoreCercato THEN Basso Metà+1 ELSE Alto Metà-1 IF Alto<= ElementiTotali THEN IF Interi[Basso]=Valore Cercato THEN Indice Basso ELSE Indice 0 ELSE Indice 0

75 Una funzione di Search binario ha bisogno di due parametri per individuare il subrange: Lo e Hi. Lindice candidato per la nuova ricerca è dato da: Mid (Lo+Hi) DIV 2 1° CASE BASE è dato quando Lo>Hi 2° CASE BASE è dato quando lelemento cercato è stato trovato La chiamata iniziale è del tipo Binary(UnArray, Chiave, 1, TotalElements)

76 Pseudo Codice FUNCTION Binary(VAR UnArray; Chiave; Lo, Hi):TipoIndice; IF Lo>Hi THEN Binary 0 ELSE Mid (Lo+Hi) DIV 2 IF UnArray[Mid]=Chiave THEN Binary Mid ELSE IF UnArray[Mid]

77 Esempio Supponiamo di avere un Array di record Studenti, ordinato per Matricola, di operare su un subrange che vada 1..NumeroStudenti. Una chiamata di funzione tipica è Binary Binary(UnArray, Chiave, 1, UltimoElemento) FUNCTION Binary (VAR Studenti: StudenteRecord; MatrCercata:StringaNome; Lo, Hi :integer) :integer VAR Mid:integer; BEGIN IF Lo>Hi THEN Binary := 0 ELSE BEGIN Mid (Lo+Hi) DIV 2 IF Studenti[Mid].Matr=MatrCercata THEN Binary := Mid ELSE IF Studenti[Mid].Matr

78 Problema Scrivere una funzione ricorsiva che ritorna vero se gli elementi di UnArray di interi, con valori assegnati nel subrange 1..TotElem, sono in ordine crescente. Obiettivo ricerca un elemento che sia fuori ordine in un dato subrange. Riduciamo di volta in volta il subrange fino a quando in questo resta un solo elemento allora vuol dire che la ricerca è finita e la risposta è TRUE. Se invece si verifica che è vera lespressione UnArray[N-1]>UnArray[N] questo significa che è stato trovato un elemento non in ordine e la funzione ritorna FALSE.

79 FUNCTION Ordinato(VAR UnArray:IntsArray; N:integer):boolean; BEGIN IF N=1 THEN Ordinato:= TRUE ELSE IF UnArray[N-1] > UnArray[N] THEN Ordinato:= FALSE ELSE Ordinato:=Ordinato(UnArray,N-1)

80 FUNCTION Minimo(VAR UnArray:IntsArray; Candidato,N:integer):integer; BEGIN IF N=0 THEN Minimo:= Candidato ELSE IF UnArray[N] < UnArray[Candidato] THEN Minimo:= Minimo(UnArray, N, N-1) ELSE Minimo:= Minimo(UnArray,Candidato,N-1) Dato un Array di interi cercare in quale posizione si trova il numero più piccolo. Iniziamo con lipotesi che lultimo elemento dellArray sia il minimo e ricorsivamente risaliamo larray.

81 INSERTION SORT Ordinamento per inserimento E lalgoritmo più intuitivo. Se ad esempio si ha un mazzo di carte non ordinato possiamo ordinarlo scorrendo le carte una alla volta e inserendo ogni carta immediatamente dopo la carta più piccola tra quelle che la precedono. Supponiamo che il primo elemento sia già ordinato. Pseudo-codice FOR PostoSuccessivo 2 TO UltimoElemento DO sposta tutti gli elementi maggiori di Interi[PostoSuccessivo ] di un posto in avanti e metti Interi[PostoSuccessivo ] nella sua giusta posizione

82 Algoritmo Supponiamo di essere al passo j. Confrontiamo il valore dellelemento di Interi[j] con i suoi predecessori. Se chi lo precede ha un valore più elevato lo spostiamo di un posto in avanti. Se incontriamo nella posizione i un valore più basso allora poniamo in Interi[i+1] Interi[j]. Interi[1] UltimoElemento Tutti ordinatiNon ancora ordinati Inserisci tra questi due elementi Interi[PostoSuccessivo] 33

83 Pseudo-codice Temp Interi[PostoSuccessivo] Posizione PostoSuccessivo-1 WHILE Interi[Posizione ] > Temp DO Interi[Posizione+1] Interi[Posizione] Posizione Posizione -1 Potrebbe succedere che uno degli elementi sia più piccolo di tutti e che quindi noi, risalendo la lista cerchiamo di confrontarlo con lelemento posto in Interi[0] provocando così un crash. Per evitare questo definiamo il range dellarray Interi variabile tra 0..UltimoElemento e ogni volta che scegliamo un valore per eseguire i confronti lo memorizziamo temporaneamente in Interi[0], così che se esso fosse il più piccolo di tutti comunque verrebbe posto in Interi[0+1]

84 PostoSuccessivo [0][1][2][3][4][5][6][7] [0][1][2][3][4][5][6][7] [0][1][2][3][4][5][6][7] [0][1][2][3][4][5][6][7]

85 [0][1][2][3][4][5][6][7] [0][1][2][3][4][5][6][7] N° confronti: (n-1)+(n-2)+…+1=(n-1)*n/2

86 PROCEDURE InsertionSort(VAR Interi: ArrayInteri); VAR PostoSuccessivo, Posizione: 0..UltimoElemento; BEGIN FOR PostoSuccessivo:=2 TO UltimoElemento DO BEGIN Interi[0]:=Interi[PostoSuccessivo]; Posizione:= PostoSuccessivo-1; WHILE Interi[Posizione]>Interi[0] DO BEGIN Interi[Posizione+1]:= Interi[Posizione]; Posizione:=Posizione-1 END; Interi[Posizione+1]:=Interi[0] END END;

87 MERGE - SORT Un algoritmo di sort classico ha in genere una complessità di calcolo pari a O(N 2 ). Vediamo un algoritmo che, fondato sul criterio del DIVIDE ET IMPERA ha una complessità più bassa. Il merge-sort è fondato sul principio ricorsivo di ridurre il problema di partenza di un fattore 2 e nessun processo ricorsivo attivato viene fatto più di una volta.

88

89 Complessità del MERGE-SORT I nodi dellalbero di sort sono log N. Per ogni nodo si fa un sort in i*N/i passi dove i rappresenta la profondità del nodo iN° passi 11*N 22*N/2 44*N/4 88*N/8 jj*N/j …….. log Nlog N*N/log N totale N*log N

90 Pseudo codice PROCEDURE SortIt(Lo,Hi:IType; VAR AnArray:ArrayType); usa i valori degli indici in input (Lo,Hi) per dividere AnArray in due subarray (inferiore e superiore) IF gli indici del subarray inferiore implicano un array ordinabile THEN SortIt(usa come indici quelli del subarray inferiore,AnArray) IF gli indici del subarray superiore implicano un array ordinabile THEN SortIt(usa come indici quelli del subarray superiore,AnArray) SortIt(1, TotalElement, AnArray)

91 Si parte con la richiesta di ordinare gli elementi dellarray compresi tra 1 e TotalEments, si riduce poi questo intervallo attraverso Lo e Hi fino a quando nel subarray non resta che un elemento. Questo è ovviamente ordinato e quindi si attiva la catena pop. Per dividere i Subarrays usiamo una variabile locale Mid. Questi Subarrays saranno prima sorted o poi merged. BASE CASE si ha quando i due subarrays sono ridotti ad una sola variabile cioè sono banalmente ordinati. Quando si arriva al Base Case allora si attiva il processo di Merge tra i due arrays adiacenti rimasti. Se invece siamo in presenza di subarrays con più di un elemento questo implica che il subarray deve essere ordinato.

92 Sort(7,8) Sort(5,6) Sort(5,8) Sort(3,4) Sort(1,2) Sort(1,4) Sort(1,8)

93 PROCEDURE Merge(Lo, Mid, Hi: integer; VAR AnArray:ArrayType); BEGIN END; PROCEDURE SortIt(Lo, Hi: integer; VAR AnArray:ArrayType); VAR Mid:integer; BEGIN Mid:=(Lo+Hi) DIV 2; IF Lo

94 Mid (Lo+Hi) DIV 2 IF Lo < Mid THEN SortIt(Lo, Mid, AnArray) LoHiMid 184 LoHiMid Mid (Lo+Hi) DIV 2 IF Mid+1 < Hi THEN SortIt(Mid+1, Hi, AnArray ) Sort(7,8) Sort(5,6) Sort(5,8) Sort(3,4) Sort(1,2) Sort(1,4) Sort(1,8)

95 Una maniera per verificare se la procedura SortIt funziona bene è quella di scrivere la procedura di merge, con le seguenti scritte di controllo. PROCEDURE Merge(Lo, Mid, Hi:integer; VAR AnArray:ArrayType) BEGIN write(Subrange del 1° Merge (,Lo:1,..,Mid:1,)); write(Subrange 2° Merge (,Mid+1:1,..,Hi:1,)); write(Subrange Ordinato (,Lo:1,..,Ni:1,)); END;

96 PROCEDURE Update(VAR AnArray:ArrayType; VAR CandidateI:integer; VAR NewElements:ElementType); BEGIN NewElement:=AnArray[CandidateI]; CandidateI:= CandidateI+1 END; PROCEDURE Merge(Lo, Mid, Hi: integer; VAR AnArray:ArrayType); VAR Temp: ArrayType; I, I1, I2 :integer; BEGIN I1:=Lo; I2:=Mid+1; FOR I:=Lo TO Hi IF I1 > Mid THEN Update(AnArray, I2, Temp[I]) ELSE IF I2 > Hi THEN Update(AnArray, I1, Temp[I]) ELSE IF AnArray[I1] < AnArray[I2] THEN Update(AnArray, I1, Temp[I]) ELSE Update(AnArray, I2, Temp[I]) FOR I:=Lo TO Hi DO AnArray[I]:=Temp[I] END;

97 I1=Lo I2=Mid+1 I=Lo I1>MidI2>Hi A(I1)

98 I1=Lo I2=Mid+1 I=Lo I1>MidI2>Hi A(I1)

99 Svantaggi del Merge-Sort Necessita di un vettore di appoggio Effettua gli spostamenti anche se il vettore di partenza è già ordinato

100 Esercizio La Torre di Hanoi. Dati tre pioli verticali e n dischi di dimensioni decrescenti infilati nel primo piolo trasferire tutti i dischi sul secondo piolo, in maniera da mantenere lordine decrescente, dal basso verso lalto, adoperando un terzo piolo di appoggio. Algoritmo 1 - sposta i primi n-1 dischi dal piolo 0 al piolo 2 rispettando lordine 2 - sposta lultimo disco dal piolo 0 al piolo sposta i primi n-1 dischi dal piolo 2 al piolo 1 rispettando lordine

101 Descrivere il processo ricorsivo implementato nel seguente programma PROGRAM TorreDiHanoi (output); TYPE piolo=0..2; VAR i, nmossa: integer; PROCEDURE muovi(disco:integer; sorgente, destinazione:piolo); BEGIN nmossa:=nmossa+1; writeln(nmossa:3, ' muovi il disco ',disco:2, ' da',sorgente:2, ' a', destinazione:2) END; PROCEDURE Hanoi(n:integer; sorgente, destinazione, ausiliario:piolo); BEGIN IF n=1 THEN muovi(1,sorgente, destinazione) ELSE BEGIN Hanoi(n-1,sorgente, ausiliario, destinazione); muovi(n,sorgente, destinazione); Hanoi(n-1, ausiliario, destinazione,sorgente) END END; BEGIN FOR i:=2 TO 4 DO BEGIN nmossa:=0; writeln(' '); writeln(' mossa per',i:3,' dischi'); Hanoi(i,0,1,2); readln END END.

102 CONSIGLI PER LA PROGETTAZIONE DI ALGORITMI RICORSIVI 1 – Assicurarsi di aver preso in considerazione tutti i possibili base case Ad esempio nel caso del Fattoriale non avevamo tenuto conto del caso di N<0 FUNCTION Fattoriale (N:integer):integer; BEGIN IF N=0 THEN Fattoriale:=1 ELSE Fattoriale:=N*Fattoriale(N-1) END;

103 PROCEDURE Hanoi(n:integer; sorgente, destinazione, ausiliario:piolo); BEGIN IF n=1 THEN muovi(1,sorgente, destinazione) ELSE BEGIN write( Prima della chiamata ) Hanoi(n-1,sorgente, ausiliario, destinazione); muovi(n,sorgente, destinazione); Hanoi(n-1, ausiliario, destinazione,sorgente) END END; Un processo ricorsivo può essere diviso in 5 parti, non necessariamente tutte presenti BEGIN nmossa:=0; writeln(' '); writeln(' mossa per',i:3,' dischi'); Hanoi(i,0,1,2); readln END 4. La chiamata ricorsiva vera e propria 1. Istruzioni eseguite prima che un nuovo processo inizi Viene eseguita ogni volta che cè la chiamata ricorsiva 2. Istruzioni eseguite quando si incontra un base case Assegnano in genere valori alla soluzione banale del base case. 3. Istruzioni eseguite prima che unaltra chiamata ricorsiva venga fatta Eventualmente aggiorna i valori per la successiva chiamata 5. Istruzioni eseguite dopo la chiamata ricorsiva Eventualmente aggiorna i valori per la successiva chiamata

104

105 Esercizio La function per trovare la combinazione di M oggetti presi N alla volta può essere rappresentata dalla funzione ricorsiva C(M,0)=1 C(M,M)=1 C(M,N)=C(M-1,N)+C(M-1,N-1) Scrivere la funzione. FUNCTION Combinazioni(M,N:integer):integer; BEGIN IF M


Scaricare ppt "DIMOSTRAZIONI PER INDUZIONE La dimostrazione per induzione è una tecnica per provare che un asserto S(n) vale per tutti gli interi n maggiori di un certo."

Presentazioni simili


Annunci Google