Esercizi diagrammi di flusso, esercizi sulla selezione

Esercizi diagrammi di flusso – In questa lezione propongo alcuni esercizi sui diagrammi di flusso utilizzando l’istruzione di selezione, cioè l’istruzione se (if).

Esercizi diagrammi di flusso – Primo algoritmo

Il biglietto di ingresso ad un museo ha le seguenti tariffe. Per i bambini di età inferiore a 6 anni l’ingresso è gratuito (opzione 1), per gli studenti 8 euro (opzione 2), per i pensionati 10 euro (opzione 3), per tutti gli altri 15 euro (opzione 4). Creare un programma in cui l’utente inserisce un numero tra 1 e 4 e viene comunicato il prezzo relativo all’opzione scelta. Se il numero non è un’opzione valida viene mostrato un messaggio di errore (tipo il numero non corrisponde a nulla!).

Quindi in questo caso l’unico input da prendere è la variabile opzione che può avere il valore 1, 2, 3 oppure 4. Se si inserisce qualsiasi altro numero si visualizza un messaggio di errore.

Allora saranno necessari quattro if annidati in quanto dobbiamo considerare anche il caso in cui il numero non è tra 1 e 4.

Schematizziamo dunque la soluzione:

– se opzione vale 1 allora il biglietto è gratis.

Banner Pubblicitario

– se opzione vale 2 allora il biglietto costa 8 euro.

– se opzione vale 3 allora il biglietto costa 10 euro.

– se opzione vale 4 allora il biglietto costa 12 euro.

– altrimenti si visualizza opzione non valida.

Potete scaricare il diagramma di flusso al seguente link: Costo biglietto.

Per chi volesse consultarla, allego anche la pseudo-codifica:

PROG main
    IN op
    IF op==1
        OUT "Gratis"
    ELSE //if op==1
        IF op==2
            OUT "Paghi 8 euro"
        ELSE //if op==2
            IF op==3
                OUT "Paghi 10 euro"
            ELSE //if op==3
                IF op==4
                    OUT "Paghi 15 euro"
                ELSE //if op==4
                    OUT "Opzione non valida"
                END IF //op==4
            END IF //op==3
        END IF //op==2
    END IF //op==1
END PROG //main

Secondo algoritmo

Un insegnante decide di valutare il test di uno studente attribuendo un punteggio a ogni risposta esatta e assegnando un giudizio in base al punteggio totale ottenuto, secondo il seguente prospetto: da 0 a 30 insufficiente, da 31 a 60 sufficiente, da 61 a 90 buono e da 91 a 100 ottimo.
Dopo aver acquisito il punteggio ottenuto dallo studente nel test, si visualizzi in output il giudizio secondo le fasce di punteggio stabilite nella tabella sopra.

Quindi prendiamo in input la variabile p che sta per punteggio e controlliamo se:

Banner pubblicitario

– p è minore di 0 – Dato non valido

– p è minore o uguale a 30 – Insufficiente (N.B Facciamo senza a controllare se p è maggiore di 0 perché è scontato).

– p è minore o uguale a 60 – Sufficiente (N.B Facciamo senza a controllare se p è maggiore di 30 perché è scontato).

– p è minore o uguale a 90 – Buono (N.B Facciamo senza a controllare se p è maggiore di 60 perché è scontato).

– p è minore o uguale a 100 – Ottimo (N.B Facciamo senza a controllare se p è maggiore di 90 perché è scontato).

– altrimenti (se p è maggiore di 100) il dato non è valido.

Per risolvere l’algoritmo in questo modo sono necessari 5 if annidati.

Potete scaricare il diagramma di flusso al seguente link: punteggio.

Presento anche la pseudo – codifica per chi la volesse consultare:

PROG main
    IN p
    IF p<0
        OUT "dato non valido"
    ELSE //if p<0
        IF p<=30
            OUT "insufficiente"
        ELSE //if p<=30
            IF p<=60
                OUT "sufficiente"
            ELSE //if p<=60
                IF p<=90
                    OUT "buono"
                ELSE //if p<=90
                    IF p<=100
                        OUT "ottimo"
                    ELSE //if p<=100
                        OUT "Dato non valido"
                    END IF //p<=100
                END IF //p<=90
            END IF //p<=60
        END IF //p<=30
    END IF //p<0
END PROG //main

Più avanti svilupperemo tanti altri esercizi sui diagrammi di flusso.

Lezione precedente: algoritmo sulle figure equivalenti

Lezione successiva: altri esercizi sui diagrammi di flusso