Ricorsione - Vincenzo Grassi (Uniroma2)

Dipartimento di Ingegneria Civile e Fondamenti di Informatica – prof. V.
Grassi
Ingegneria Informatica
Fondamenti di informatica
Ricorsione
Ricorsione
n Obiettivi di apprendimento
■ generali
■ introdurre una nuova strategia di soluzione
■ casi di studio
■ conteggio percorsi alternativi
■ ...
2
Dipartimento di Ingegneria Civile e Fondamenti di Informatica – prof. V. Grassi
Le funzioni aiutano a gestire la complessità
n Si può scrivere un programma come un’unica grande funzione? SI’,

ma diventa sempre più DIFFICILE!
n Al crescere della dimensione del programma, cresce la sua complessità
n Suddividere in funzioni, distribuire le responsabilità

■ ogni funzione è responsabile di “una sola cosa”
n più semplice individuare il punto in cui operare modifiche

n più semplice verificare la correttezza
divide et impera
3
Le funzioni supportano l’astrazione
n Nascondono i dettagli
■ possiamo quindi ignorarli
n Aiutano a scrivere nuovi programmi, riusando funzioni fidate
4
Le funzioni facilitano il testing
n Possiamo controllare la correttezza di singoli pezzi, invece che soltanto

di tutto l’insieme
n Se ogni singolo pezzo funziona correttamente, è più probabile che

anche il tutto funzioni
■ … anche se non è detto (è integration testing: controllo che i vari pezzi si
integrino bene tra loro)
.
Obiettivo del testing di funzioni: Fiducia
n Sei consapevole di che cosa dovrebbe fare la funzione ?

■ Ti è veramente chiaro ?
n La funzione fa quello che ti aspetti faccia?
n Per ogni possibile input ?
■ Punto cruciale: puoi scordarti come la

funzione lavora, e assumere soltanto che
la funzione fa quello che deve fare?
6
Riassunto: perchè usare funzioni
1. Si nascondono dettagli, che possono così essere ignorati.

2. Rende chiaro dove introdurre cambiamenti.
3. Semplifica il testing.
4. Aiuta a scrivere nuovi programmi, riusando funzioni utili e fidate.
Ricorsione: fiducia + riuso
n Ricorsione: decomposizione di un problema in termini di se stesso
■ decomposizione “circolare”
■ … funziona ??!?
■ uno dei punti chiave è: avere fiducia …
8
Nascita di una soluzione ricorsiva: DownUp
Immaginiamo di avere una funzione downUp
>>> downUp("Hello")
Hello
ello
llo
lo
o
lo
llo
ello
Hello
1. Astrazione procedurale
n Decomporre il problema in porzioni piccole a sufficienza da poter

essere risolte facilmente da una funzione.
n Riusare quanto più possibile.
10
downUp() per parole di un carattere
def downUp1(word):
# @param word : string
assert len(word) == 1
print word
n Ovviamente, funziona:
>>> downUp1("A")
A
11
downUp() per parole di 2 caratteri
n Riusiamo downUp1() dato che lo abbiamo già.
def downUp2(word):
print word
downUp1(word[1:])
print word
>>> downUp2("it")
it
t risultato prodotto dalla chiamata downUp1("t")
it
>>> downUp2("me")
me
e risultato prodotto dalla chiamata downUp1("e")
me
12
downUp() per parole di 3 caratteri

def downUp3(word):
print word
downUp2(word[1:]) Riuscite a vedere uno
print word schema generale?
>>> downUp3("pop")
pop
risultato prodotto op
dalla chiamata p risultato prodotto dalla chiamata downUp2("op")
downUp1("p") op
pop
>>> downUp3("top")
top
op
p
op
top 13
downUp(): tentativo di schema generale di soluzione
n schema per fare il downup di una qualunque parola:

■ stampa parola
■ downup di: parola meno il suo primo carattere
■ stampa parola
def downUpTest(word):
print word
downUpTest(word[1:])
print word
14
Inizia bene, ma poi …

def downUpTest(word):
print word
downUpTest(word[1:])
print word
>>> downUpTest("hello")
hello Una funzione è stata chiamata così tante
ello volte che la memoria disponibile per
gestire le varie chiamate viene esaurita.
llo
lo
o
...
RuntimeError: maximum recursion depth exceeded
Please check line …
15
Bisogna trovare il modo di arrestarsi
def downUp(word):
if len(word)==1 :
print word Se c’è un solo carattere nella
else : parola, stampalo e STOP!
print word
downUp(word[1:])
print word
16
Ora funziona
>>> downUp("Hello")
Hello
ello
llo
lo
o
lo
llo
ello
Hello
17
Funziona ?
>>> downUp('')
...
RuntimeError: maximum recursion depth exceeded
Please check line …
def downUp(word):
if len(word)<=1 :
print word
else :
print word
downUp(word[1:])
print word
18
Esercizio
n Provate a realizzare (in forma ricorsiva) upDown
>>> upDown("Hello")
Hello
Hell
Hel
He
H
He
Hel
Hell
Hello
19
Altri esempi
T(n)
1
2
• area di T(n) ?
.
. ...
n
1 2 … n – area di T(n) = nx1 + area di T(n-1)
?!?
definizione circolare?
• prodotto dei primi n numeri interi ? (“fattoriale di n” ➨ n ! )
– n! = n x (n - 1)! ?!?
20
Uscita dalla circolarità
n area di T(n) ? via di fuga dalla

“circolarità”
■ se n = 0 ➨ area T(n) = 0
■ se n > 0 ➨ area T(n) = n + area T(n-1)
n fattoriale di n ?
■ se n = 0 ➨ n! = 1
■ se n > 0 ➨ n! = n x (n-1)!
21
Codifica Python
definizione nome e parametri funzione
def areaT(n) : def areaT(n) :
# @param n : int # @param n : int
# @return int # @return int
if n==0 : if n==0 :
“via di fuga” return 0
else : else : chiamata ricorsiva
“ricorsione” return n + areaT(n-1)
def fatt(n) def fatt(n)

# @param n : int # @param n : int
if n==0 : if n==0 :
"via di fuga” return 1
else : else :
“ricorsione” return n*fatt(n-1)
22
• elementi chiave delle soluzioni viste

– una soluzione ricorsiva fa riferimento a se stessa, ma in modo più
semplice
• negli esempi visti, da n a n-1
– esiste almeno un caso che viene risolto direttamente
• negli esempi visti, n = 0
– la ricorsione ci avvicina al caso risolto direttamente
23
Dietro le quinte
§ Comprendere “come funziona” la ricorsione
1. Tracciamento
2. Il metodo dei “piccoli elfi”
24
1. Tracciamento
n >>> downUp("Hello")
■ len(word) è maggiore di 1, quindi stampiamo word
n Hello
■ Ora chiamiamo downUp(“ello”) def downUp(word):
■ Ancora più di un carattere, quindi stampiamo # @param word : string
n ello if len(word)<=1 :
■ Ora chiamiamo downUp(“llo”) print word
■ Ancora più di un carattere, quindi stampiamo else :
n llo print word
■ Ora chiamiamo downUp(“lo”) downUp(word[1:])
■ Ancora più di un carattere, quindi stampiamo print word
n lo
■ Ora chiamiamo downUp(“o”)
■ ORA C’E’ UN SOLO CARATTERE! STAMPALO E STOP!
n o
25
Percorso a ritroso
■ downUp(“lo”) ora continua dopo la chiamata a downUp(“o”), perciò stampa
di nuovo e termina.
n lo
■ downUp(“llo”) continua a sua volta (dopo downUp(“lo”))
■ stampa e termina.
n llo
■ downUp(“ello”) continua a sua volta.
■ stampa e termina.
n ello
■ Alla fine, l’ultima istruzione della downUp(“Hello”) può essere eseguita.
n Hello
def downUp(word):
if len(word)<=1 :
print word
else :
print word
downUp(word[1:])
print word 26
Altro tracciamento
n area di T(n)
def areaT(n) :
■ se n = 0 ➨ area T(n) = 0
# @param n: int
■ se n > 0 ➨ area T(n) = n + area T(n-1) # @return int
if n==0 :
return 0
area_T(4) = 4 + area_T(3)
else :
6 area_T(3) = 3 + area_T(2) return n + areaT(n-1)
3
area_T(4) = 10 1
0
area_T(0) = 0
via d’uscita
2. I “piccoli elfi” (*)
n Punto cruciale da comprendere:

■ Ci possono essere più copie in esecuzione di una stessa funzione, ognuna
con un input differente.
■ Quando una di queste funzioni termina, le altre continuano ancora la loro
esecuzione.
n Un modo per aiutare la comprensione: usare la metafora del “piccolo

elfo” per rappresentare una funzione in esecuzione
■ provatelo su voi stessi
28
Istruzioni per gli “elfi” (funzione downUp()):
n Avvicinati alla lavagna e accetta una parola come input.

(p. es., scritta su un cartoncino)
n Se la tua parola è di un solo carattere, scrivila sullo “schermo”

(p. es., la lavagna) e hai finito! Fermati e torna al tuo posto.
n Altrimenti…
■ Scrivi la tua parola sullo “schermo”
■ Recluta un altro elfo
■ Dagli come input la tua parola meno il primo carattere (usando un altro
cartoncino)
■ Aspetta (vicino alla lavagna) finchè l’elfo che hai reclutato ha finito.
■ Scrivi di nuovo la tua parola sullo “schermo”.
■ Hai finito! (puoi tornare al tuo posto)
29
Una soluzione ricorsiva non è insostituibile !
n Soluzioni non ricorsive:
def areaT(n) :
# @param n : int
# @return int
area = 0 def areaT(n) :
for i in range(1, n+1) : # @param n : int
area = area+i # @return int
return area return n*(n+1)/2
def fatt(n)
# @param n : int
# @return int
fn=1
for i in range(1, n+1) :
fn = fn*i
return fn
30
… ma può aiutare
n Un problema “complesso”
n Numero di percorsi su una griglia di strade (Manhattan-like)
■ quanti percorsi minimi differenti da A a B?
■ minimi: aventi la minima lunghezza possibile
– ogni segmento tra due incroci ha lunghezza unitaria
■ calcolarlo in modo non ricorsivo? provate …
1 2 3 4 … i …
1 …
A
2 …
3
.
. . . . …
. . . .
j
…
. B
.
31
La ricorsione all’opera
n Ragionare “ricorsivamente” tutti i possibili

percorsi da A
a B2
1 2 3 4 … i …
1 …
A
2 …
3
.
. . . . …
. . . . B2
j
…
. B1 B
.
tutti i possibili
percorsi da A
a B1 32
La ricorsione all’opera (cont.)
n ogni possibile percorso da A a B o passa per B1 o per B2

■ mai per entrambi
caso generale
num. percorsi da A a B =
(num. percorsi da A a B1) + (num. percorsi da A a B2)
1 2 3 4 … i …
soluzione diretta
1 …
se A e B sono sulla stessa A B
2 …
“riga” o sulla stessa
“colonna” 3
.
. . . …
allora .
. . . .
(num. percorsi da A a B) = 1 j
…
. B B
.
33
Codifica Python
coordinate di A
def numOfPaths(ia, ja, ib, jb) :
# @param ia, ja, ib, jb : int coordinate di B
# @return int
if ia>ib or ja>jb :
coordinate mal definite
else:
if (ia==ib or ja==jb) :
soluzione diretta
else :
caso generale

# @param ia, ja, ib, jb : int
# @return int
if ia>ib or ja>jb :
else:
if ia==ib or ja==jb :
return 1
else:
34
caso generale
Codifica Python

# @param ia, ja, ib, jb : int
# @return int
if ia>ib or ja>jb :
else:
if ia==ib or ja==jb :
return 1
else: coordinate di B1
return ( numOfPaths(ia, ja, ib-1, jb) +
numOfPaths(ia, ja, ib, jb-1) )
coordinate di B2
if ia>ib or ja>jb :
print "ill defined coordinates"
return 0
else: ...
35
Un esercizio di ricorsione
– operazioni aritmetiche su numeri naturali usando solo le operazioni di
incremento e decremento di 1
• somma (x, y )
– x = 0 ⇒ somma (x, y ) = y (soluzione diretta)
– x > 0 ⇒ somma (x, y ) = somma (x-1, y ) +1 (caso generale)
• prodotto (x, y )
– x = 0 ⇒ prodotto (x, y ) = 0 (soluzione diretta)
– x > 0 ⇒ prodotto (x, y ) = somma(prodotto (x-1, y ), y) (caso generale)
def somma(x, y) : def prodotto(x, y) :

# @param x, y : int # @param x, y : int
assert x>=0 and y>=0 assert x>=0 and y>=0
if (x==0) : if (x==0) :
return y return 0
else : else :
return somma(x-1, y) + 1 return somma(prodotto(x-1, y), y)
36
Pensare ricorsivamente : elementi chiave
■ per risolvere un problema complesso, risolvere prima lo stesso

problema in un caso un po’ più semplice
■ assicurarsi che questo processo termini su un caso risolvibile

direttamente
■ concentrarsi su come risolvere il problema iniziale a partire dalla

soluzione del caso un po’ più semplice
37
Esempio
§ Problema: riconoscimento di stringhe palindrome

§ esempi di stringhe palindrome
§ Anilina
§ ingegni
§ Etna gigante
§ i topi non avevano nipoti
§ Avida di vita desiai ogni amore vero ma ingoiai sedativi da diva
§ …
§ Obiettivo: costruire una funzione ricorsiva per verificare se una stringa

è palindroma
38
Costruzione di una soluzione ricorsiva
• passo 1 : costruire un problema un po’ più semplice

– più semplice ➔ stringa più corta
– di solito, varie possibilità ➔ vari modi per ridurre la stringa iniziale
• rimuovere il primo carattere
• rimuovere l’ultimo carattere
• rimuovere il primo e l’ultimo carattere
• rimuovere un carattere dal mezzo della stringa
• spezzare la stringa in due metà
– quale sembra più efficace?
39
• efficacia della “semplificazione” al passo 1 = capacità di supportare la

definizione del ...
• passo 2 : risolvere il problema iniziale a partire da quello semplificato
– spezzare la stringa in due metà: efficace?
– "ingegni" ➔ "inge" "gni"
– che cosa facciamo delle due metà?
– rimuovere il primo e l’ultimo carattere: efficace?

– "ingegni" ➔ "ngegn" : se la stringa di partenza è palindroma lo è anche
quella di arrivo
– buona semplificazione
caso generale
una stringa è palindroma se :
• il primo e l’ultimo carattere sono uguali
• la stringa ottenuta rimuovendo il primo e l’ultimo carattere è palindroma
40
• rimane il ...
• passo 3 : “uscita” dalla ricorsione

– casi semplici risolvibili direttamente
– cosa è un “caso semplice” ?
• in generale, un caso a cui non è applicabile la procedura di
semplificazione del passo 2
– ➔ nel caso delle stringhe palindrome :
• stringa di un carattere
• stringa di zero caratteri
• (stringhe di due o più caratteri si riducono, alla fine, a uno di questi
due casi)
– ➨ quale dei due?
soluzione diretta
una stringa di zero o un carattere è palindroma
41
def isPalindrome(s) :
# @param s : string
# @return bool soluzione diretta
if len(s) <= 1 :
return True
elif s[0] == s[len(s)-1] : ultimo carattere
primo carattere
shorter = s[1:len(s)-1] stringa “semplificata”
return isPalindrome(shorter)
else : caso generale
return False
• nota bene : questa soluzione verifica la palindromia “stretta” !!!

(spazi bianchi, maiuscole/minuscole, segni di interpunzione ...
sono significativi)
42
variante
# @param s : string
# @return bool
soluzione diretta if len(s) <= 1 :
return True
else:
return s[0] == s[len(s)-1] and isPalindrome(s[1:len(s)-1])
# @param s : string
caso generale
# @return bool
if len(s) <= 1 :
return True
elif s[0] == s[len(s)-1] :
shorter = s[1:len(s)-1]
return isPalindrome(shorter)
else :
return False 43
Problema: le torri di Hanoi
n Trasferire i dischi dalla colonna A alla colonna C (utilizzando

eventualmente la colonna B)
■ si può spostare un solo disco alla volta
■ non si può mai poggiare un disco più grande su uno più piccolo
44
Problema: le torri di Hanoi
n Soluzione con 3 dischi
n Scrivere una funzione che determina le mosse da fare con n dischi

■ per qualunque n ≥ 1
45
Efficienza della ricorsione
• ricorsione: tecnica efficace per ideare una soluzione, ma ...

• … la soluzione ideata può essere inefficiente
• caso di studio: successione di Fibonacci

– f1 = 1
– f2 = 1
– fn = fn-1 + fn-2
• 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...
def fib(n) :
• codifica Python # @param n : int
in forma # @return int
ricorsiva : assert (n>=0)
if n==0 :
return 0
elif n <= 2 : return 1
else : return fib(n - 1) + fib(n - 2) 46
• è una realizzazione efficiente?

– provare ad eseguire fib(n) per n crescente ...
• quante “operazioni” per calcolare fn usando fib(n) ?

– proporzionale a 2n (si può dimostrare)
– quanto tempo per eseguire 2n operazioni ?
• calcolatore in grado di eseguire 1012 operazioni/sec (1 Teraflop)

– T(n): tempo per eseguire 2n operazioni
– T(20) : 10-6 sec
– T(30) : 10-3 sec
– T(40) : 1 sec
– T(50) : 20 min
– T(60) : 13 giorni
– T(70) : 36.5 anni
– T(80) : 3.7 x 1013 anni
48
• NOTA: un essere umano ci metterebbe qualche minuto per calcolare fn

(per valori di n “ragionevoli”)
– che cosa causa la “inefficienza” di fib(n) ?
fib(6)
+
3
fib(5) fib(4)
+ +
2
fib(4) fib(3) fib(3) fib(2)
+ + +
fib(3) fib(2) fib(2) fib(1) fib(2) fib(1) 1

+
fib(2) fib(1) 1 1 1 1 1
1 1
49
• codifica Python in forma def fib(n) :

iterativa : # @param n : int
– è quello che faremmo # @return int
noi con carta e penna if (n <= 2) :
return 1
fold = 1
fold2 = 1
for i in range(3, n+1) :
fnew = fold + fold2
fold2 = fold
fold = fnew
return fnew
• è sempre possibile risolvere in modo iterativo un problema risolto

ricorsivamente? ➨ SI
• … però: soluzioni ricorsive spesso sono più facili da ideare
“L’iterazione è umana, la ricorsione divina.”

(L. Peter Deutsch)
50
Che cosa abbiamo appreso
n Obiettivi di apprendimento
■ generali
■ introdurre una nuova strategia di soluzione
■ casi di studio
■ conteggio percorsi alternativi
■ ...
51
Appendice 1: codifica di stringhe+formato

The old brown fox runs
rappresentazione ["The old brown fox runs", ["bold", 0, 6], ["italics", 5, 12]]
n Formato generale della rappresentazione (sintassi):

■ à si legge “è rappresentato come”
■ | si legge “oppure”
testo con stile à [testo, formato, …, formato]
testo à string una o più volte
formato à [stile, inizio, fine]
stile à “italics” | “plain” | “bold” | “underlined”
inizio à integer
52
fine à integer
Esprimere la sintassi usando la ricorsione
n Formato generale della rappresentazione (sintassi):

■ à si legge “è rappresentato come”
■ | si legge “oppure”
testo con stile à [testo, lista_formato]

testo à string definizione ricorsiva
lista_formato à formato | formato, lista_formato
formato à [stile, inizio, fine]
stile à “italics” | “plain” | “bold” | “underlined”
inizio à integer
fine à integer
53
Costruire un analizzatore sintattico
n Input: una rappresentazione

■ una lista, nel nostro caso
n Output: risultato dell'analisi
■ sintatticamente corretta?
■ scorretta?
analizza( ["questo e' un testo con stile", [0, 2,"bold"], [5, 8, "italics"]] ) = ?
analizza( [“questo e' un testo con stile”, [0, 2], [5, 8, "italics"]] ) = ?
analizza( ["questo e' un testo con stile", [0, "bold"], [5, 8, "italics"]] ) = ?
analizza( [[0, 3, "bold"], [5, 8, "italics"]] ) = ?

54
Appendice 2: compressione/decompressione di
stringhe basata su RLE
n decompressione :
■ funzione di avvio
def unzip(string) :
# @param string: str; string to be decompressed
# @return str; the decompressed string
if len(string) == 0 :
return ""
else:
return unzipState0(string,"")
59
ASF per decompressione : stato 0
def unzipState0(s, unzipStr) :

# @param s: str; (remaining) string to be decompressed
# @param unzipStr: str; (partial) decompressed string
# @return str; the unzipped string
if len(s) == 0 :
return unzipStr
elif s[0].isdigit() :
count = s[0]
return unzipState1(s[1:], unzipStr, count)
else : # s[0] is not a digit
unzipStr = unzipStr+s[0]
return unzipState0(s[1:], unzipStr)
60
ASF per decompressione : stato 1
def unzipState1(s, unzipStr, count) :

# @param s: str; (remaining) string to be decompressed
# @param unzipStr: str; (partial) decompressed string
# @param count: str; digits accumulator
# @return str; the unzipped string
if len(s) == 0 :
return unzipStr
elif s[0].isdigit() :
count = count+s[0]
return unzipState1(s[1:], unzipStr, count) auto-ricorsione
else : # s[0] is not a digit
unzipStr = unzipStr + int(count)*s[0]
return unzipState0(s[1:], unzipStr) mutua ricorsione
61
compressione/decompressione di stringhe basata su RLE
n compressione :
■ provate a realizzare l'ASF ...
62

Ricorsione - Vincenzo Grassi (Uniroma2)

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Ricorsione - Vincenzo Grassi (Uniroma2)

Caricato da

Copyright:

Formati disponibili

Dipartimento di Ingegneria Civile e Fondamenti di Informatica – prof. V.

Le funzioni aiutano a gestire la complessità

n Si può scrivere un programma come un’unica grande funzione? SI’,

n Suddividere in funzioni, distribuire le responsabilità

n più semplice individuare il punto in cui operare modifiche

Le funzioni supportano l’astrazione

n Aiutano a scrivere nuovi programmi, riusando funzioni fidate

Le funzioni facilitano il testing

n Possiamo controllare la correttezza di singoli pezzi, invece che soltanto

n Se ogni singolo pezzo funziona correttamente, è più probabile che

Obiettivo del testing di funzioni: Fiducia

n Sei consapevole di che cosa dovrebbe fare la funzione ?

■ Punto cruciale: puoi scordarti come la

Riassunto: perchè usare funzioni

1. Si nascondono dettagli, che possono così essere ignorati.

Ricorsione: fiducia + riuso

n Ricorsione: decomposizione di un problema in termini di se stesso

Nascita di una soluzione ricorsiva: DownUp

 Immaginiamo di avere una funzione downUp

n Decomporre il problema in porzioni piccole a sufficienza da poter

downUp() per parole di un carattere

downUp() per parole di 2 caratteri

n Riusiamo downUp1() dato che lo abbiamo già.

downUp() per parole di 3 caratteri

downUp(): tentativo di schema generale di soluzione

n schema per fare il downup di una qualunque parola:

Inizia bene, ma poi …

Bisogna trovare il modo di arrestarsi

n Provate a realizzare (in forma ricorsiva) upDown

• prodotto dei primi n numeri interi ? (“fattoriale di n” ➨ n ! )

Uscita dalla circolarità

n area di T(n) ? via di fuga dalla

■ se n > 0 ➨ area T(n) = n + area T(n-1)

def fatt(n) def fatt(n)

• elementi chiave delle soluzioni viste

§ Comprendere “come funziona” la ricorsione

2. I “piccoli elfi” (*)

n Punto cruciale da comprendere:

n Un modo per aiutare la comprensione: usare la metafora del “piccolo

Istruzioni per gli “elfi” (funzione downUp()):

n Avvicinati alla lavagna e accetta una parola come input.

n Se la tua parola è di un solo carattere, scrivila sullo “schermo”

Una soluzione ricorsiva non è insostituibile !

n Soluzioni non ricorsive:

n Ragionare “ricorsivamente” tutti i possibili

La ricorsione all’opera (cont.)

n ogni possibile percorso da A a B o passa per B1 o per B2

def numOfPaths(ia, ja, ib, jb) :

def numOfPaths(ia, ja, ib, jb) :

def somma(x, y) : def prodotto(x, y) :

Pensare ricorsivamente : elementi chiave

■ per risolvere un problema complesso, risolvere prima lo stesso

■ assicurarsi che questo processo termini su un caso risolvibile

■ concentrarsi su come risolvere il problema iniziale a partire dalla

§ Problema: riconoscimento di stringhe palindrome

§ Obiettivo: costruire una funzione ricorsiva per verificare se una stringa

Costruzione di una soluzione ricorsiva

• passo 1 : costruire un problema un po’ più semplice

• efficacia della “semplificazione” al passo 1 = capacità di supportare la

– rimuovere il primo e l’ultimo carattere: efficace?

• passo 3 : “uscita” dalla ricorsione

• nota bene : questa soluzione verifica la palindromia “stretta” !!!

Problema: le torri di Hanoi

Immaginiamo di avere una funzione downUp