Risolvere un problema¶

Risolvere problemi è una delle principali attività della nostra vita. Insegnare metodi efficaci per risolvere probremi dovrebbe essere uno dei principali obiettivi del nostro insegnamento.

Metodi di soluzione di problemi¶

Risolvere problemi è un’attività complessa quindi non esiste il metodo di soluzione dei problemi.

La geometria della tartaruga può aiutarci a imparare i metodi “top down” e “bottom up”.

Top Down¶

È il metodo più razionale, va dalla soluzione del problema generale alla soluzione delle sue componenti. È adatto alla ricerca delle soluzioni di un problema complesso, si presta bene all’uso in gruppi dove il lavoro viene suddiviso in parti. Ma partiamo con un esempio.

Il problema¶

Voglio far disegnare a Tartaruga una casetta con porte finestre e camino. Qualcosa che assomigli a questo:

L’analisi¶

Prima di scrivere un programma che disegni la casetta, dobbiamo analizzarlo. L’analisi consiste nel suddividere il problema in parti più semplici e ripetere questa operazione in modo ricorsivo finché si arriva a parti elementari. Nel nostro caso una possibile analisi è:

Nell’analisi dobbiamo anche precisare: * Le dimensioni delle varie parti, nel nostro caso: un quadretto = 10 passi; * La posizione dove parte e dove arriva Tartaruga, normalmente queste due posizioni devono coincidere. * Un nome per ogni parte.

Grafo ad albero¶

Osservazione: l’analisi fatta in questo modo ha prodotto un oggetto che è studiato dalla matematica: un grafo ad albero.

Le varie parti della casetta costituiscono i nodi.

Le frecce costituiscono i rami.

Il nodo da cui parte tutto l’albero si chiama radice.

I nodi da cui non parte alcun ramo si chiamano foglie.

La soluzione¶

Fatta l’analisi possiamo iniziare a scrivere il nostro programma:

# 13 giugno 2014
# Daniele Zambelli
# Casetta

# lettura delle librerie
import pyturtle as pt          # legge la libreria 'pyturtle' chiandola 'pt'

# programma principale
foglio = pt.TurtlePlane()      # crea un paese delle tartarughe
tina = pt.Turtle()             # crea una tartaruga

foglio.mainloop()              # rende attiva la finestra

Lo eseguiamo per assicurarci che non ci siano errori, ma già ci aspettiamo che non faccia un gran ché.

Passiamo a costruire la casetta, avendo deciso di seguire il metodo Top - Down, partiamo dal problema generale per scendere verso le varie componenti.

Quindi per prima cosa scriviamo la procedura casetta. Dall’analisi vediamo che è composta da due parti: * facciata, * tetto,

La funzione dovrà disegnare la facciata, poi spostarsi e disegnare il tetto, ma non è finita, poi ritornare dove era partita:

def casetta():
    """Disegna una casetta."""
    facciata()
    # sposta tina nella posizione adatta per disegnare il tetto
    tetto()
    # rimetti a posto tina

Guardando l’analisi non è difficile trovare quali istruzioni vanno scritte al posto dei commenti.

Il programma diventa:

# 13 giugno 2014
# Daniele Zambelli
# Casetta

# lettura delle librerie
import pyturtle as pt          # legge la libreria 'pyturtle' chiandola 'pt'

def casetta():
    """Disegna una casetta."""
    facciata()
    tina.left(90)
    tina.forward(50)
    tina.right(90)
    tetto()
    tina.left(90)
    tina.back(50)
    tina.right(90)

# programma principale
foglio = pt.TurtlePlane()      # crea un paese delle tartarughe
tina = pt.Turtle()             # crea una tartaruga

foglio.mainloop()              # rende attiva la finestra

Lo eseguiamo... che delusione, non disegna proprio niente. Come mai?

Abbiamo definito casetta ma non abbiamo chiesto a Python di eseguire questa funzione, facciamolo:

# 13 giugno 2014
# Daniele Zambelli
# Casetta

# lettura delle librerie
import pyturtle as pt          # legge la libreria 'pyturtle' chiandola 'pt'

def casetta():
    """Disegna una casetta."""
    facciata()
    tina.left(90)
    tina.forward(50)
    tina.right(90)
    tetto()
    tina.left(90)
    tina.back(50)
    tina.right(90)

# programma principale
foglio = pt.TurtlePlane()      # crea un paese delle tartarughe
tina = pt.Turtle()             # crea una tartaruga
casetta()                      # disegna una casetta

foglio.mainloop()              # rende attiva la finestra

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)

<ipython-input-12-9945567f031a> in <module>()
     20 foglio = pt.TurtlePlane()      # crea un paese delle tartarughe
     21 tina = pt.Turtle()             # crea una tartaruga
---> 22 casetta()                      # disegna una casetta
     23
     24 foglio.mainloop()              # rende attiva la finestra


<ipython-input-12-9945567f031a> in casetta()
      8 def casetta():
      9     """Disegna una casetta."""
---> 10     facciata()
     11     tina.left(90)
     12     tina.forward(50)


<ipython-input-6-1639e4a1c7a9> in facciata()
     40     """Disegna la facciata della casetta."""
     41     contorno()
---> 42     interno()
     43
     44 def contorno():


NameError: name 'interno' is not defined

Accidenti, otteniamo un errore!

L’ultima riga del messaggio di errore ci dà un’indicazione: facciata non è definita... Già, potevamo aspettarcelo, gli abbiamo insegnato a fare casetta ma non a fare facciata.

Rimettiamoci al lavoro e definiamo la nuova funzione. facciata risulta più semplice dato che le due parti da cui è composta hanno la stessa partenza, quindi non servono spostamenti intermedi. Aggiungiamo questa nuova funzione ed eseguiamo il programma:

# 13 giugno 2014
# Daniele Zambelli
# Casetta

# lettura delle librerie
import pyturtle as pt          # legge la libreria 'pyturtle' chiandola 'pt'

def casetta():
    """Disegna una casetta."""
    facciata()
    tina.left(90)
    tina.forward(50)
    tina.right(90)
    tetto()
    tina.left(90)
    tina.back(50)
    tina.right(90)

def facciata():
    """Disegna la facciata della casetta."""
    contorno()
    interno()

# programma principale
foglio = pt.TurtlePlane()      # crea un paese delle tartarughe
tina = pt.Turtle()             # crea una tartaruga
casetta()                      # disegna una casetta

foglio.mainloop()              # rende attiva la finestra

Facendoci guidare dagli errori che man mano otteniamo, possiamo procedere a completare il programma.

Prima di procedere possiamo aggiungere 3 funzioni di supporto: quadrato(lato), triangolo(lato), rettangolo(base, altezza):

Otteniamo ancora un errore, ma finalmente tina si è degnata di disegnare qualcosa.

L’interno della facciata è il più complesso sarà qualcosa di questo tipo:

def interno():
    """Dsegna l'interno della facciata."""
    # spostati in avanti
    # disegna la porta
    # spostati indietro e in alto senza tracciare segni
    # disegna le finestre
    # ritorna dove eri partita senza tracciare segni

Facendociguidare dagli errori, completiamo il disegno della casetta.

Il programma completo¶

# 13 giugno 2014
# Daniele Zambelli
# Casetta

# lettura delle librerie
import pyturtle as pt          # legge la libreria 'pyturtle' chiandola 'pt'

def quadrato(lato):
    """Fa disegnare a tina un quadrato dato il lato."""
    for cont in range(4):      # ripete 4 volte il blocco seguente
        tina.forward(lato)     # va avanti di lato passi
        tina.left(90)          # gira a sinistra di 90 gradi

def triangolo(lato):
    """Fa disegnare a tina un triangolo equilatero dato il lato."""
    for cont in range(3):      # ripete 3 volte il blocco seguente
        tina.forward(lato)     # va avanti di lato passi
        tina.left(120)         # gira a sinistra di 120 gradi

def rettangolo(base, altezza):
    """Fa disegnare a tina un rettangolo dato i lati."""
    for cont in range(2):
        tina.forward(base)
        tina.left(90)
        tina.forward(altezza)
        tina.left(90)

def casetta():
    """Disegna una casetta."""
    facciata()
    tina.left(90)
    tina.forward(50)
    tina.right(90)
    tetto()
    tina.left(90)
    tina.back(50)
    tina.right(90)

def facciata():
    """Disegna la facciata della casetta."""
    quadrato(5)                 # contorno
    interno()

def interno():
    """Dsegna l'interno della facciata."""
    tina.forward(20)            # spostati in avanti
    rettangolo(10, 20)          # disegna la porta
    tina.up()                   # spostati indietro e in alto
    tina.back(10)               # senza tracciare segni
    tina.left(90)
    tina.forward(30)
    tina.right(90)
    tina.down()
    finestre()                  # disegna le finestre
    tina.up()                   # ritorna dove eri partita
    tina.back(10)               # senza tracciare segni
    tina.right(90)
    tina.forward(30)
    tina.left(90)
    tina.down()

def finestre():
    """Disegna la porta della casetta."""
    quadrato(10)                # una finestra
    tina.up()                   # spostamento
    tina.forward(20)
    tina.down()
    quadrato(10)                # l'atra finestra
    tina.up()                   # ritorna dove eri partito
    tina.back(20)
    tina.down()

def tetto():
    """Disegna il tetto."""
    triangolo(50)               # falde del tetto
    tina.left(60)
    tina.forward(10)
    tina.left(30)
    camino()                    # camino
    tina.right(30)
    tina.back(10)
    tina.right(60)

def camino():
    """Disegna il camino."""
    tina.forward(20)            # avanti
    tina.right(90)
    tina.forward(7)
    tina.right(90)
    tina.forward(5)
    tina.back(5)                # ritorna per la stessa strada
    tina.left(90)
    tina.back(7)
    tina.left(90)
    tina.back(20)

# programma principale
foglio = pt.TurtlePlane()       # crea un paese delle tartarughe
tina = pt.Turtle()              # crea una tartaruga
casetta()                       # disegna una casetta

foglio.mainloop()               # rende attiva la finestra

Bottom up¶

Il metodo Bottom-up parte dalla stessa analisi, arriva allo stesso risultato (programma), ma segue un percorso diverso.

Invece che scrivere la funzione principale (radice) e farsi guidare dagli errori, si può partire dalla diverse componenti (foglie) realizzarle una alla volta ontrollando che rispondano alle specifiche dell’analisi e metterle insieme per ottenere il risultato desiderato.