ALGORITMI IN LINGUAGGIO DI PROGETTO
PROBLEMA 1.
Date le età di tre persone, scrivere l’algoritmo in linguaggio di progetto per calcolare
l’età media delle persone.
DATI: età di tre persone
OBIETTIVO: comunicare età media delle tre persone
VARIABILI: eta1, eta2, eta3, media
programma ETAMEDIA
var eta1, eta2, eta3: intero
media: reale
inizio
{acquisizione delle età delle tre persone}
scrivi(‘Inserisci l’età della prima persona’)
leggi(eta1)
scrivi(‘Inserisci l’età della seconda persona’)
leggi(eta2)
scrivi(‘Inserisci l’età della terza persona’)
leggi(eta3)
{calcolo età media}
media = (eta1+eta2+eta3)/3
{comunicazione del risultato}
scrivi(‘L’età media delle tre persone è ‘+media)
fine
PROBLEMA 2.
Scrivere l’algoritmo in linguaggio di progetto che richieda in input la descrizione, la
quantità, il prezzo unitario di un articolo venduto e l’aliquota IVA, comunicando in
output la descrizione e il prezzo aumentato dell’IVA.
DATI: descrizione, quantità, prezzo unitario, IVA
OBIETTIVO: comunicare la descrizione e il prezzo aumentato dell’IVA
VARIABILI: descr, quant, prezzoU, IVA, prezzoFinale
programma PrezzoPiuIva
var descr: stringa
quant: intero
prezzoU, IVA, prezzoFinale: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Descrizione articolo:‘)
leggi(descr)
scrivi(‘Quantità venduta:’)
leggi(quant)
scrivi(‘Prezzo unitario in € dell’articolo venduto:’)
leggi(prezzoU)
scrivi(‘Aliquota IVA in %:’)
leggi(IVA)
{calcolo del prezzo aumentato dell’IVA}
prezzoFinale = (prezzoU * quant) + (prezzoU * quant * IVA)/100
{comunicazione della descrizione dell’articolo e del prezzo aumentato dell’IVA}
scrivi(‘Il prezzo aumentato dell’IVA dell’articolo ‘+descr+’ è ‘+prezzoFinale+’ €’)
fine
PROBLEMA 3.
Scrivere l’algoritmo in linguaggio di progetto che determini il numero di scatti
effettuati da un utente telefonico e l’ammontare della sua bolletta.
Vengono forniti in input i seguenti dati:
• Il numero di scatti emersi dalla lettura della bolletta precedente
• Il numero di scatti emersi dalla lettura della bolletta attuale
• Il costo dello scatto
Bisogna inoltre ricordare che per determinare il valore della bolletta occorre
aggiungere un canone fisso, il cui importo viene anch’esso fornito in input.
DATI: numero di scatti bolletta precedente, numero di scatti bolletta attuale, costo dello
scatto, canone fisso
OBIETTIVO: comunicare il numero di scatti effettuati dall’utente e l’ammontare della sua
bolletta
VARIABILI: scattibolprec, scattibolatt, costoscatto, canone, scattieff, costobol
programma CostoBolletta
var scattibolprec, scattibolatt, scattieff: intero
costoscatto, canone, costobol: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il numero degli scatti della bolletta precedente’)
leggi(scattibolprec)
scrivi(‘Inserisci il numero degli scatti della bolletta attuale’)
leggi(scattibolatt)
scrivi(‘Inserisci il costo dello scatto in €’)
leggi(costoscatto)
scrivi(‘Inserisci il valore del canone fisso in €’)
leggi(canone)
{calcolo del numero degli scatti effettuati dall’utente}
scattieff=scattibolatt-scattibolprec
{calcolo ammontare bolletta}
costobol=(scattieff * costoscatto)+canone
{comunicazione dei risultati}
scrivi(‘Il numero degli scatti effettuati è ‘+scattieff)
scrivi(‘L’ammontare della bolletta è ‘+costobol+’ €’)
fine
PROBLEMA 4.
Scrivere in linguaggio di progetto un algoritmo che permette di determinare il
volume e l’area della superficie del solido generato dalla rotazione di un giro
completo di un triangolo rettangolo intorno all’ipotenusa.
Ricordiamo che:
indicando con h l’altezza relativa all’ipotenusa, con IPO l’ipotenusa, con c1 il
cateto minore e con c2 il cateto maggiore del triangolo rettangolo, si ha:
area superficie solido = h × (c1+c2) × 3.14
volume solido = (h × h × IPO × 3.14) / 3
DATI: altezza relativa all’ipotenusa, ipotenusa, cateto minore, cateto maggiore
OBIETTIVO: comunicare volume e area della superficie del solido di rotazione
VARIABILI: h, IPO, c1, c2, area, volume
programma AreaVolume
var h, IPO, c1, c2, area, volume: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci la misura dell’altezza relativa all’ipotenusa’)
leggi(h)
scrivi(‘Inserisci la misura dell’ipotenusa’)
leggi(IPO)
scrivi(‘Inserisci la misura del cateto minore’)
leggi(c1)
scrivi(‘Inserisci la misura del cateto maggiore’)
leggi(c2)
{calcolo del volume e dell’area della superficie del solido}
area=h*(c1+c2)*3.14
volume=(h*h*IPO*3.14)/3
{comunicazione dei risultati}
scrivi(‘Volume= ‘+volume+’ , Area= ‘+area)
fine
PROBLEMA 5.
Vengono dati in input i risultati di un referendum:
Numero iscritti a votare
Numero votanti
Numero dei si
Numero dei no
Realizzare l’algoritmo che permette di determinare e comunicare:
• La percentuale dei votanti sul numero degli iscritti
• La percentuale dei si rispetto al numero dei votanti
• La percentuale dei no rispetto al numero dei votanti.
Esempio calcolo percentuale relativa alla prima richiesta del problema:
percentuale votanti = (numero votanti × 100) / numero iscritti
DATI: numero iscritti a votare, numero votanti, numero dei si, numero dei no
OBIETTIVO: comunicare la percentuale dei votanti sul numero degli iscritti, la percentuale
dei si rispetto al numero dei votanti, la percentuale dei no rispetto al numero dei
votanti
VARIABILI: NumIscritti, NumVotanti, NumSi, NumNo, percVotanti, percSi, percNo
programma Referendum
var NumIscritti, NumVotanti, NumSi, NumNo: intero
percVotanti, percSi, percNo: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il numero degli iscritti a votare ‘)
leggi(NumIscritti)
scrivi(‘Inserisci il numero dei votanti’)
leggi(NumVotanti)
scrivi(‘Inserisci il numero dei si’)
leggi(NumSi)
scrivi(‘Inserisci il numero dei no’)
leggi(NumNo)
{calcolo percentuali}
percVotanti=(NumVotanti*100)/NumIscritti
percSi=(NumSi*100)/NumVotanti
percNo=(NumNo*100)/NumVotanti
{comunicazione percentuali}
scrivi(‘La percentuale dei votanti sul numero degli iscritti è ‘+percVotanti+’ %’)
scrivi(‘La percentuale dei si rispetto al numero dei votanti è ‘+percSi+’ %’)
scrivi(‘La percentuale dei no rispetto al numero dei votanti è ‘+percNo+’ %’)
fine
PROBLEMA 6.
Realizzare in linguaggio di progetto l’algoritmo che permette di calcolare e
comunicare l’area totale di tre rettangoli, conoscendo le misure b1, b2, b3 delle tre
basi e le misure h1, h2, h3 delle tre altezze.
DATI: le misure delle basi e delle altezze dei tre rettangoli
OBIETTIVO: comunicare l’area totale dei tre rettangoli
VARIABILI: b1, b2, b3, h1, h2, h3, areatotale
programma AreaTotale3Rettangoli
var b1, b2, b3, h1, h2, h3, areatotale: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Base 1° rettangolo: ‘)
leggi(b1)
scrivi(‘Base 2° rettangolo: ‘)
leggi(b2)
scrivi(‘Base 3° rettangolo: ‘)
leggi(b3)
scrivi(‘Altezza 1° rettangolo: ‘)
leggi(h1)
scrivi(‘Altezza 2° rettangolo: ‘)
leggi(h2)
scrivi(‘Altezza 3° rettangolo: ‘)
leggi(h3)
{calcolo area totale dei tre rettangoli}
areatotale=(b1*h1)+(b2*h2)+(b3*h3)
{comunicazione del risultato}
scrivi(‘L’area totale dei tre rettangoli è ‘+areatotale)
fine
PROBLEMA 7.
Realizzare in linguaggio di progetto l’algoritmo che risolve il seguente problema:
Dati in input la base BC ed il lato obliquo AC di un triangolo isoscele ABC, calcolare
e comunicare l’area del triangolo e la misura dell’altezza BK relativa al lato obliquo
AC.
DATI: la base ed il lato obliquo del triangolo isoscele
OBIETTIVO: calcolare e comunicare l’area del triangolo e la misura dell’altezza relativa al
lato obliquo
VARIABILI: baseABC, latoObliquo, MetaBase, altezzaABC, area, AltRelLatObl
programma TriangoloIsoscele
var baseABC, altezzaABC, latoObliquo, MetaBase, area, AltRelLatObl: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci la misura in cm della base del triangolo isoscele ‘)
leggi(baseABC)
scrivi(‘Inserisci la misura in cm del lato obliquo del triangolo isoscele ‘)
leggi(latoObliquo)
{calcolo della misura della metà della base del triangolo}
MetaBase = baseABC / 2
{calcolo dell’altezza del triangolo, applicando il Teorema di Pitagora}
altezzaABC = radice quadrata((latoObliquo*latoObliquo)-(MetaBase*MetaBase))
{calcolo dell’area del triangolo}
area= MetaBase * altezzaABC
{calcolo dell’altezza relativa al lato obliquo}
AltRelLatObl = (2*area) / latoObliquo
{comunicazione dei dati di output}
scrivi(‘L’area del triangolo misura ‘+area+’ cm²’)
scrivi(‘L’altezza relativa al lato obliquo misura ‘+AltRelLatObl+’ cm’)
fine
PROBLEMA 8.
Dati in input due numeri, realizzare in linguaggio di progetto l’algoritmo che
permette di visualizzare in ordine crescente tali numeri.
DATI: due numeri
OBIETTIVO: visualizzare i due numeri in ordine crescente
VARIABILI: numero1, numero2
programma OrdineCrescente
var numero1, numero2: reale
inizio
{acquisizione dati di input}
scrivi(‘Inserisci il primo numero ‘)
leggi(numero1)
scrivi(‘Inserisci il secondo numero ‘)
leggi(numero2)
{ordinamento crescente dei due numeri e relativa visualizzazione}
SE (numero1<numero2)
ALLORA
scrivi(numero1+’ ; ‘+numero2)
ALTRIMENTI
scrivi(numero2+’ ; ‘+numero1)
FINE SE
fine
PROBLEMA 9.
Scrivere un algoritmo in linguaggio di progetto che permette di calcolare il prezzo
effettivo relativo all’acquisto di una certa merce, noti la quantità acquistata, il prezzo
unitario e la percentuale di sconto, tenendo presente che lo sconto viene applicato
soltanto per quantità superiori a un valore dato in input.
DATI: quantità di merce acquistata, prezzo unitario, percentuale di sconto, quantità di
merce prefissata
OBIETTIVO: comunicare il prezzo effettivo relativo all’acquisto della merce
VARIABILI: quantita, prezzoU, percsconto, quantitaPref, prezzoEff
programma AcquistoMerce
var quantita, quantitaPref: intero
prezzoU, percsconto, prezzoEff:reale
inizio
{acquisizione dati di input}
scrivi(‘Inserisci la quantità di merce acquistata ‘)
leggi(quantita)
scrivi(‘Inserisci la quantità di merce prefissata ‘)
leggi(quantitaPref)
scrivi(‘Inserisci il prezzo unitario in € ‘)
leggi(prezzoU)
scrivi(‘Inserisci la percentuale di sconto in % ‘)
leggi(percsconto)
{calcolo del prezzo effettivo in relazione alla quantità acquistata}
SE (quantita > quantitaPref)
ALLORA
prezzoEff = (prezzoU*quantita) - ( prezzoU*quantita*percsconto)/100
ALTRIMENTI
prezzoEff = prezzoU*quantita
FINE SE
{comunicazione del prezzo effettivo}
scrivi(‘Il prezzo effettivo relativo all’acquisto della merce è ‘+prezzoEff+’ €’)
fine
PROBLEMA 10.
Realizzare l’algoritmo in linguaggio di progetto che permette di verificare se un dato
numero è positivo, negativo o nullo
DATI: un numero
OBIETTIVO: comunicare se il numero è positivo, negativo o nullo
VARIABILI: numero
programma PosNegNul
var numero: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il numero’)
leggi(numero)
{verifica se il numero è positivo, negativo o nullo e relativa comunicazione}
SE (numero>0)
ALLORA
scrivi(‘Il numero è positivo’)
ALTRIMENTI
SE (numero<0)
ALLORA
scrivi(‘Il numero è negativo’)
ALTRIMENTI
scrivi(‘Il numero è nullo’)
FINE SE
FINE SE
fine
PROBLEMA 11.
Realizzare l’algoritmo in linguaggio di progetto che permette di risolvere il seguente
problema:
Su alcuni voli aerei il bagaglio fino a 20 Kg non paga. Oltre questo limite si deve
pagare per ogni Kg in più, il 2% della tariffa del biglietto aereo. Visualizzare il prezzo
totale del biglietto.
DATI: la tariffa del biglietto aereo e il peso del bagaglio
OBIETTIVO: calcolare e visualizzare il prezzo totale del biglietto
VARIABILI: pesobagaglio, tariffa, prezzototale, pesoInPiu, percTariffa, supplemento
programma BigliettoAereo
var pesobagaglio, tariffa, pesoInPiu, percTariffa, supplemento, prezzototale: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il peso in Kg del bagaglio’)
leggi(pesobagaglio)
scrivi(‘Inserisci la tariffa in € del biglietto’)
leggi(tariffa)
{controllo del peso del bagaglio e calcolo del prezzo totale del biglietto}
SE (pesobagaglio<=20)
ALLORA
prezzototale=tariffa
ALTRIMENTI
inizio
pesoInPiu=pesobagaglio-20
percTariffa=(tariffa*2)/100
supplemento=pesoInPiu*percTariffa
prezzototale=tariffa+supplemento
fine
FINE SE
{comunicazione del prezzo totale del biglietto}
scrivi(‘Il prezzo totale del biglietto è ‘+prezzototale+’ €’)
fine
PROBLEMA 12.
Realizzare l’algoritmo in linguaggio di progetto che permette di verificare se un
carattere digitato da tastiera corrisponde a:
o ‘S’ oppure ‘s’: visualizzare il messaggio ‘SI’;
o ‘N’ oppure ‘n’: visualizzare il messaggio ‘NO’;
o altro carattere: visualizzare il messaggio ‘ERRATO’
DATI: un carattere digitato da tastiera
OBIETTIVO: visualizzare il messaggio corrispondente
VARIABILI: car
programma VerificaCarattere
var car: carattere
inizio
{acquisizione dati di input}
scrivi(‘Digita un carattere sulla tastiera’)
leggi(car)
{controllo del carattere digitato e relativa comunicazione}
SE ((car == ‘S’) OR (car == ‘s’))
ALLORA
scrivi(‘SI’)
ALTRIMENTI
SE ((car == ‘N’) OR (car == ‘n’))
ALLORA
scrivi(‘NO’)
ALTRIMENTI
scrivi(‘ERRATO’)
FINE SE
FINE SE
Fine
PROBLEMA 13.
Scrivere in linguaggio di progetto un algoritmo che chieda un numero all’utente e
verifichi se questo è esterno all’intervallo [-5, +10] (ricordiamo che un numero è
esterno ad un intervallo se è minore di -5 ed è maggiore di +10): in questo caso
visualizzi il messaggio “Il dato è fuori dell’intervallo”, altrimenti visualizzi il
messaggio “OK”.
DATI: un numero
OBIETTIVO: verificare se un numero è esterno o interno ad un intervallo e visualizzare il
relativo messaggio
VARIABILI: numero
programma AppartenenzaIntervallo
var numero:reale
inizio
{acquisizione dati di input}
scrivi(‘Inserisci un numero per controllare se appartiene o no a [-5, +10]’)
leggi(numero)
{controllo appartenenza all’intervallo e visualizzazione messaggio relativo}
SE ((numero<-5) OR (numero>10))
ALLORA
scrivi(‘Il dato è fuori dell’intervallo’)
ALTRIMENTI
scrivi(‘OK’)
FINE SE
fine
PROBLEMA 14.
Scrivere in linguaggio di progetto un algoritmo che permette di risolvere il seguente
problema.
Un insegnante decide di valutare un test attribuendo un punteggio ad
ogni risposta esatta data, assegnando poi un giudizio in base al totale ottenuto,
secondo il seguente prospetto:
PUNTEGGIO
VALUTAZIONE
da 0 a 30
da 31 a 60
da 61 a 90
Insufficiente
Sufficiente
Buono
Acquisito quindi in input il punteggio del test, visualizzare la relativa valutazione.
DATI: il punteggio del test.
OBIETTIVO: Visualizzare la valutazione relativa al punteggio del test.
VARIABILI: punteggio
programma ValutazioneTest
var punteggio:reale
inizio
{acquisizione dati di input}
scrivi(‘Inserisci il punteggio attribuito al test’)
leggi(punteggio)
{assegnazione della valutazione al punteggio del test e relativa visualizzazione}
SE (punteggio<=30)
ALLORA
scrivi(‘Il giudizio assegnato al test è Insufficiente’)
ALTRIMENTI
SE (punteggio<=60)
ALLORA
scrivi(‘Il giudizio assegnato al test è Sufficiente’)
ALTRIMENTI
scrivi(‘Il giudizio assegnato al test è Buono’)
FINE SE
FINE SE
fine
PROBLEMA 15.
Scrivere un algoritmo in linguaggio di progetto che permette di risolvere il seguente
problema.
Per aumentare il numero di visitatori di una mostra, si decide di far pagare il
biglietto d’ingresso differenziato in base all’età. Precisamente:
Età
Prezzo del biglietto
Inferiore a 5 anni
Da 5 a 17 anni
Da 18 anni in poi
Gratuito
€3
€5
Data in input l’età, visualizzare l’importo del biglietto da pagare.
DATI: età del visitatore
OBIETTIVO: visualizzare l’importo del biglietto da pagare in base all’età
VARIABILI: eta
programma PrezzoBigliettoMostra
var eta: intero
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci l’età del visitatore’)
leggi(eta)
{assegnazione del prezzo del biglietto in base all’età e relativa visualizzazione}
SE (eta<5)
ALLORA
scrivi(‘Il biglietto è gratuito’)
ALTRIMENTI
SE (eta<=17)
ALLORA
scrivi(‘Il prezzo del biglietto è 3 € ’)
ALTRIMENTI
scrivi(‘Il prezzo del biglietto è 5 € ‘)
FINE SE
FINE SE
fine
PROBLEMA 16.
Scrivere un algoritmo in linguaggio di progetto che permette di risolvere il seguente
problema.
Una società immobiliare vende appartamenti al mare ai seguenti prezzi:
distanza fino 200 m
900 € al metro quadro
distanza da 201 m a 500 m
750 € al metro quadro
distanza oltre 500 m
500 € al metro quadro
Data la dimensione in metri quadri dell’appartamento e la distanza dal mare,
calcolare il prezzo dell’appartamento
DATI: dimensione in metri quadri dell’appartamento e distanza dell’appartamento dal mare
OBIETTIVO: determinare e comunicare il prezzo dell’appartamento
VARIABILI: dimensione, distanza, prezzo
programma PrezzoAppartamento
var dimensione: intero
distanza, prezzo: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci la dimensione in metri quadri dell’appartamento’)
leggi(dimensione)
scrivi(‘Inserisci la distanza in metri dell’appartamento dal mare’)
leggi(distanza)
{calcolo del prezzo dell’appartamento}
SE (distanza<=200)
ALLORA
prezzo=dimensione*900
ALTRIMENTI
SE (distanza<=500)
ALLORA
prezzo=dimensione*750
ALTRIMENTI
prezzo=dimensione*500
FINE SE
FINE SE
{comunicazione del prezzo dell’appartamento}
scrivi(‘Il prezzo dell’appartamento è di ‘+prezzo+’ €’)
fine
PROBLEMA 17.
Sul prezzo di un prodotto viene praticato lo sconto del 3% se costa meno di 500 €,
del 5% per prezzo uguale a 500 € e del 10% per prezzo superiore a 500 €.
Scrivere in linguaggio di progetto l’algoritmo che permette di calcolare il prezzo
effettivo che l’acquirente dovrà pagare.
DATI: prezzo del prodotto
OBIETTIVO: comunicare il prezzo effettivo (scontato) del prodotto
VARIABILI: prezzo, prezzoeff
programma PrezzoEffettivo
var prezzo, prezzoeff: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il prezzo in € del prodotto’)
leggi(prezzo)
{calcolo del prezzo effettivo del prodotto}
SE (prezzo<500)
ALLORA
prezzoeff=prezzo-((prezzo*3)/100)
ALTRIMENTI
SE (prezzo==500)
ALLORA
prezzoeff=prezzo-((prezzo*5)/100)
ALTRIMENTI
prezzoeff=prezzo-((prezzo*10)/100)
FINE SE
FINE SE
{comunicazione del prezzo effettivo del prodotto}
scrivi(‘Il prezzo effettivo del prodotto è ‘+prezzoeff+’ €’)
fine
PROBLEMA 18.
Dati in input tre numeri, realizzare in linguaggio di progetto l’algoritmo che
permette di visualizzare in ordine crescente tali numeri.
DATI: tre numeri
OBIETTIVO: visualizzare i tre numeri in ordine crescente
VARIABILI: numero1, numero2, numero3, appoggio (utilizzata per effettuare lo scambio
del contenuto di due variabili)
programma OrdineCrescenteTreNumeri
var numero1, numero2, numero3, appoggio: reale
inizio
{acquisizione dati di input}
scrivi(‘Inserisci il primo numero ‘)
leggi(numero1)
scrivi(‘Inserisci il secondo numero ‘)
leggi(numero2)
scrivi(‘Inserisci il terzo numero ’)
leggi(numero3)
{controllo del contenuto delle due variabili numero1 e numero2 ed eventuale scambio}
SE (numero1>numero2)
ALLORA
inizio
appoggio=numero1
numero1=numero2
numero2=appoggio
fine
FINE SE
{controllo del contenuto delle due variabili numero1 e numero3 ed eventuale scambio}
SE (numero1>numero3)
ALLORA
inizio
appoggio=numero1
numero1=numero3
numero3=appoggio
fine
FINE SE
{controllo del contenuto delle due variabili numero2 e numero3 ed eventuale scambio}
SE (numero2>numero3)
ALLORA
inizio
appoggio=numero2
numero2=numero3
numero3=appoggio
fine
FINE SE
{visualizzazione dei tre numeri in ordine crescente}
scrivi(‘Ordinamento crescente dei tre numeri: ‘+numero1+’ ; ‘+numero2+’ ; ‘+numero3)
fine
PROBLEMA 19.
Realizzare l’algoritmo in linguaggio di progetto che permette di risolvere il seguente
problema:
Leggere da input 2 numeri. Far eseguire mentalmente la somma all’utente e
comunicarla al computer. Far eseguire la somma al computer e confrontarla con
quella eseguita dall’utente. Se i risultati coincidono emettere il messaggio ‘Bravo, hai
indovinato al primo tentativo’; altrimenti emettere il messaggio ‘Hai sbagliato, prova
ancora’. Leggere il nuovo risultato: se è corretto visualizzare ‘Bravino, hai indovinato
al secondo tentativo’ altrimenti ‘Ripassa la matematica’.
DATI: due numeri e la loro somma
OBIETTIVO: verificare la bravura dell’utente e visualizzare un messaggio
VARIABILI: num1, num2, somUtente, somComputer
programma VerificaBravuraUtente
var num1, num2, somUtente, somComputer: reale
inizio
{acquisizione dei 2 numeri e della loro somma calcolata dall’utente}
scrivi(‘Inserisci il primo numero’)
leggi(num1)
scrivi(‘Inserisci il secondo numero’)
leggi(num2)
scrivi(‘Inserisci la somma dei due numeri’)
leggi(somUtente)
{calcolo della somma dei due numeri: esecutore il computer}
somComputer=num1+num2
{confronto dei due risultati e verifica della bravura dell’utente con messaggio}
SE (somUtente==somComputer)
ALLORA
scrivi(‘Bravo, hai indovinato al primo tentativo’)
ALTRIMENTI
inizio
scrivi(‘Hai sbagliato, prova ancora’)
scrivi(‘Inserisci nuovamente la somma dei due numeri’)
leggi(somUtente)
SE (somUtente==somComputer)
ALLORA
scrivi(‘Bravino, hai indovinato al secondo tentativo’)
ALTRIMENTI
scrivi(‘Ripassa la matematica’)
FINE SE
fine
FINE SE
fine
PROBLEMA 20.
Realizzare l’algoritmo in linguaggio di progetto che permette di risolvere il seguente
problema:
Un parcheggio ha la tariffa di 1 € per la prima ora di sosta e di 0.50 € per ogni ora
successiva. Conoscendo l’orario di entrata e di uscita di un’autovettura (espresso in
ore e minuti), emettere uno scontrino con l’ora di entrata, l’ora di uscita, il tempo di
durata della sosta e la relativa spesa.
DATI: l’orario di entrata (ore e minuti) e l’orario di uscita (ore e minuti)
OBIETTIVO: visualizzare l’orario di entrata (ore e minuti), l’orario di uscita (ore e minuti), il
tempo di durata della sosta (ore e minuti) e la spesa relativa al parcheggio
VARIABILI: OraEntrata, OraUscita, MinutiEntrata, MinutiUscita, OrarioEntrataMinuti,
OrarioUscitaMinuti, DurataSostaMinuti, OraDurataSosta, MinutiDurataSosta,
spesatariffa
programma SpesaParcheggio
var OraEntrata, OraUscita, MinutiEntrata, MinutiUscita, OrarioEntrataMinuti: intero
OrarioUscitaMinuti, DurataSostaMinuti, MinutiDurataSosta, OraDurataSosta: intero
spesatariffa: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci l’ora di entrata dell’autovettura nel parcheggio’)
leggi(OraEntrata)
scrivi(‘Inserisci i minuti di entrata dell’autovettura nel parcheggio’)
leggi(MinutiEntrata)
scrivi(‘Inserisci l’ora di uscita dell’autovettura dal parcheggio’)
leggi(OraUscita)
scrivi(‘Inserisci i minuti di uscita dell’autovettura dal parcheggio’)
leggi(MinutiUscita)
{trasformazione dell’ora e dei minuti di entrata in minuti}
OrarioEntrataMinuti = OraEntrata * 60 + MinutiEntrata
{trasformazione dell’ora e dei minuti di uscita in minuti}
OrarioUscitaMinuti = OraUscita * 60 + MinutiUscita
{calcolo in minuti del tempo di durata della sosta}
DurataSostaMinuti = OrarioUscitaMinuti - OrarioEntrataMinuti
{trasformazione del tempo di durata della sosta (espresso in minuti) in ore e minuti}
OraDurataSosta = DurataSostaMinuti DIV 60
MinutiDurataSosta = DurataSostaMinuti MOD 60
{valutazione durata sosta e calcolo tariffa parcheggio}
SE (DurataSostaMinuti<=60)
ALLORA
spesatariffa = DurataSostaMinuti / 60
ALTRIMENTI
inizio
DurataSostaMinuti = DurataSostaMinuti – 60
spesatariffa = 1 + ((DurataSostaMinuti * 0.50) / 60)
fine
FINE SE
{emissione scontrino}
scrivi(‘Orario entrata: ‘+OraEntrata+’ h ‘+MinutiEntrata+’ m’)
scrivi(‘Orario uscita: ‘+OraUscita+’ h ‘+MinutiUscita+’ m’)
scrivi(‘Durata sosta: ‘+OraDurataSosta+’ h ‘+MinutiDurataSosta+’ m’)
scrivi(‘Spesa parcheggio: ‘+spesatariffa+’ €’)
fine
PROBLEMA 21.
Scrivere in linguaggio di progetto l’algoritmo che permette di risolvere l’equazione
di 1° grado ax+b=0
DATI: i coefficienti a e b dell’equazione
OBIETTIVO: risolvere l’equazione, fornendo le relative comunicazioni
VARIABILI: a, b, x
programma EQUAZIONEax+b=0
var a, b, x: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il valore del coefficiente a dell’equazione’)
leggi(a)
scrivi(‘Inserisci il valore del coefficiente b dell’equazione’)
leggi(b)
{risoluzione dell’equazione e relative comunicazioni}
SE (a<>0)
ALLORA
inizio
x=-b/a
scrivi(‘L’equazione è determinata e la sua soluzione è x= ‘+x)
fine
ALTRIMENTI
SE (b==0)
ALLORA
scrivi(‘L’equazione è indeterminata, cioè ha infinite soluzioni’)
ALTRIMENTI
scrivi(‘L’equazione è impossibile, cioè non ha soluzioni’)
FINE SE
FINE SE
fine
PROBLEMA 22.
Realizzare in linguaggio di progetto l’algoritmo che permette di risolvere il seguente
problema:
Determinare se un anno fornito in input da tastiera è bisestile ed in caso affermativo
se è secolare.
DATI: l’anno che bisogna esaminare
OBIETTIVO: stabilire se l’anno è bisestile e in caso affermativo se è secolare
VARIABILI: anno, RestoBisestile, RestoSecolare
programma AnnoBisestile
var anno, RestoBisestile, RestoSecolare: intero
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci l’anno di cui si chiede se è bisestile’)
leggi(anno)
{calcolo del resto della divisione dell’anno per 4}
RestoBisestile = anno MOD 4
{calcolo del resto della divisione dell’anno per 100}
RestoSecolare = anno MOD 100
{controllo se l’anno è bisestile e relative comunicazioni}
SE (RestoBisestile==0)
ALLORA
inizio
scrivi(‘L’anno ‘+anno+’ è bisestile’)
{controllo se è anche secolare}
SE (RestoSecolare==0)
ALLORA
scrivi(‘ed è secolare’)
ALTRIMENTI
scrivi(‘e non è secolare’)
FINE SE
fine
ALTRIMENTI
scrivi(‘L’anno ‘+anno+’ non è bisestile’)
FINE SE
fine
PROBLEMA 23.
Realizzare l’algoritmo che permette di calcolare il quoziente della divisione di due
numeri inseriti da tastiera.
DATI: due numeri
OBIETTIVO: calcolare e comunicare il quoziente dei due numeri
VARIABILI: numero1, numero2, quoziente
programma QuozienteDivisione
var numero1, numero2, quoziente: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il dividendo della divisione’)
leggi(numero1)
scrivi(‘Inserisci il divisore della divisione’)
leggi(numero2)
{calcolo del quoziente e relative comunicazioni}
SE (numero2<>0)
ALLORA
inizio
quoziente=numero1/numero2
scrivi(‘Il quoziente tra ‘+numero1+’ e ‘+numero2+’ è ‘+quoziente)
fine
ALTRIMENTI
SE (numero1<>0)
ALLORA
scrivi(‘ERRORE! Non esiste un numero che moltiplicato per 0 da ‘+numero1)
ALTRIMENTI
scrivi(‘ERRORE! Ogni numero moltiplicato per 0 da come risultato 0’)
FINE SE
FINE SE
fine
PROBLEMA 24.
Un’impresa di trasporti calcola il costo di un trasporto aggiungendo, al costo fisso
di € 52, l’importo massimo tra il costo chilometrico (€ 0.62 al chilometro) e il costo
per il peso (€ 0.08 al quintale). Scrivere l’algoritmo in linguaggio di progetto che,
dati la lunghezza del viaggio e il peso della merce trasportata, calcoli il costo finale.
DATI: lunghezza del viaggio in chilometri e peso della merce trasportata in quintali.
OBIETTIVO: calcolo e comunicazione del costo finale
VARIABILI: LunghezzaViaggio, PesoMerce, ImportoAggiunto, CostoFinale
CostoChilometrico, CostoPeso
programma CostoTotale
var LunghezzaViaggio, PesoMerce, ImportoAggiunto, CostoFinale: reale
CostoChilometrico, CostoPeso: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci la lunghezza del viaggio in chilometri’)
leggi(LunghezzaViaggio)
scrivi(‘Inserisci il peso della merce trasportata in quintali’)
leggi(PesoMerce)
{calcolo del costo chilometrico e del costo per il peso}
CostoChilometrico = LunghezzaViaggio * 0.62
CostoPeso = PesoMerce * 0.08
{calcolo dell’importo aggiuntivo al costo fisso}
SE (CostoChilometrico>=CostoPeso)
ALLORA
ImportoAggiunto = CostoChilometrico
ALTRIMENTI
ImportoAggiunto = CostoPeso
FINE SE
{calcolo del costo finale e relativa comunicazione}
CostoFinale = 52 + ImportoAggiunto
scrivi(‘Il costo finale del trasporto è ‘+CostoFinale+’ €’)
fine
PROBLEMA 25.
Siano dati in input i dati relativi all’acquisto di una certa merce con:
⋅ codice merce;
⋅ descrizione;
⋅ quantità;
⋅ prezzo unitario;
⋅ tipo di pagamento (contanti o rateale).
Realizzare in linguaggio di progetto l’algoritmo che permette di calcolare e
visualizzare l’importo totale della merce sapendo che se il pagamento è in contanti il
prezzo va diminuito del 10%, se è rateale va aumentato del 15%.
DATI: codice della merce, descrizione merce, quantità acquistata, prezzo unitario, tipo di
pagamento
OBIETTIVO: calcolare e visualizzare l’importo totale della merce in base al tipo di
pagamento
VARIABILI: CodiceMerce, descrizione, TipoPagamento, quantita, PrezzoUnitario,
ImportoTotale
programma ImportoMerce
var CodiceMerce, descrizione, TipoPagamento: stringa
quantita, PrezzoUnitario, ImportoTotale: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Qual è il codice della merce? ’)
leggi(CodiceMerce)
scrivi(‘Qual è la sua descrizione? ’)
leggi(descrizione)
scrivi(‘Inserisci la quantità acquistata ’)
leggi(quantita)
scrivi(‘Inserisci il prezzo unitario in € ’)
leggi(PrezzoUnitario)
scrivi(‘Quale tipo di pagamento è stato utilizzato? contanti/rateale ‘)
leggi(TipoPagamento)
{calcolo dell’importo totale della merce}
SE (TipoPagamento==’contanti’)
ALLORA
ImportoTotale=PrezzoUnitario*quantita-((PrezzoUnitario*quantita*10)/100)
ALTRIMENTI
ImportoTotale=PrezzoUnitario*quantita+((PrezzoUnitario*quantita*15)/100)
FINE SE
{visualizzazione del dato di output del problema}
scrivi(‘L’importo totale della merce è di ‘+ImportoTotale+’ €’)
fine
PROBLEMA 26.
Realizzare un algoritmo in linguaggio di progetto che porga le domande di un
questionario all’utente e produca un prospetto con le risposte. Richiedere:
• nome
• attività (possibili risposte: studente, lavoratore, disoccupato)
Se la risposta precedente non è “disoccupato”, richiedere:
• la distanza in Km da percorrere ogni giorno per raggiungere la sede di studio o
di lavoro
• il mezzo utilizzato (possibili risposte: pubblico, privato)
Se la risposta precedente è “privato”, richiedere se viene utilizzata l’automobile
(possibili risposte: SI, NO).
DATI: il nome dell’utente, la sua attività, la distanza per raggiungere la sede di studio o
di lavoro, il mezzo di trasporto utilizzato, la risposta sull’utilizzo dell’automobile
OBIETTIVO: Realizzare il questionario per l’utente e visualizzare le risposte
VARIABILI: NomeUtente, AttivitaUtente, DistanzaSede, MezzoTrasporto, RispostaAuto
programma QUESTIONARIO
var NomeUtente, AttivitaUtente, MezzoTrasporto, RispostaAuto: stringa
DistanzaSede: reale
inizio
{acquisizione del nome e dell’attività dell’utente}
scrivi(‘Qual è il tuo nome? ‘)
leggi(NomeUtente)
scrivi(‘Qual è la tua attività? studente/lavoratore/disoccupato ‘)
leggi(AttivitaUtente)
{valutazione attività ed eventuale acquisizione della distanza e del mezzo}
SE (AttivitaUtente<>’disoccupato’)
ALLORA
inizio
scrivi(‘Quale distanza in Km percorri ogni giorno per raggiungere la sede di
studio o di lavoro? ‘)
leggi(DistanzaSede)
scrivi(‘Quale mezzo di trasporto utilizzi? pubblico/privato ‘)
leggi(MezzoTrasporto)
{valutazione mezzo ed eventuale acquisizione dell’utilizzo dell’automobile}
SE (MezzoTrasporto==’privato’)
ALLORA
inizio
scrivi(‘Utilizzi l’automobile? SI/NO ‘)
leggi(RispostaAuto)
fine
ALTRIMENTI
scrivi(‘Il questionario è terminato. ‘)
FINE SE
fine
ALTRIMENTI
scrivi(‘Il questionario è terminato. ‘)
FINE SE {conclusa la realizzazione del questionario}
{visualizzazione prospetto}
scrivi(NomeUtente+’ ‘+AttivitaUtente)
SE (AttivitaUtente<>’disoccupato’)
ALLORA
inizio
scrivi(‘Distanza dal luogo di lavoro o di studio: ‘+DistanzaSede+’ Km’)
SE (MezzoTrasporto==’pubblico’)
ALLORA
scrivi(‘Il mezzo di trasporto è ‘+MezzoTrasporto)
ALTRIMENTI
SE (RispostaAuto==’SI’)
ALLORA
scrivi(‘Mezzo di trasporto: ‘+MezzoTrasporto+’ (automobile)’)
ALTRIMENTI
scrivi(‘Mezzo di trasporto: ‘+MezzoTrasporto+’ (non automobile)’)
FINE SE
FINE SE
fine
FINE SE
fine
PROBLEMA 27.
Sapendo che una persona ha bisogno di un numero di calorie che dipende
dall’attività svolta, secondo la seguente tabella, dove i numeri si riferiscono al
fabbisogno orario:
ATTIVITA’
UOMO
DONNA
LEGGERA
42
36
MEDIA
46
40
PESANTE
54
46
MOLTO PESANTE
62
55
e, sapendo che a colazione bisognerebbe introdurre circa il 20% del fabbisogno
calorico giornaliero, realizzare un algoritmo in linguaggio di progetto che chieda
all’utente il sesso e il tipo di attività e, in base a questi dati, determini il fabbisogno
calorico giornaliero e quindi quello relativo alla colazione.
DATI: il sesso della persona e il tipo di attività svolta
OBIETTIVO: calcolare e comunicare il fabbisogno calorico giornaliero e quello relativo alla
colazione
VARIABILI: sesso, attivita, CalorieGiorno, CalorieColazione
COSTANTI: attivita1=’leggera’, attivita2=’media’, attivita3=’pesante’,
attivita4=’molto pesante’, cal1uomo=42, cal2uomo=46,
cal3uomo=54, cal4uomo=62, cal1donna=36, cal2donna=40,
cal3donna=46, cal4donna=55, perc=20
programma CorrettaAlimentazione
var sesso, attivita:stringa
CalorieGiorno, CalorieColazione: intero
attivita1=’leggera’; attivita2=’media’; attivita3=’pesante’; attivita4=’molto pesante’;
cal1uomo=42; cal2uomo=46; cal3uomo=54; cal4uomo=62; cal1donna=36; perc=20
cal2donna=4; cal3donna=46; cal4donna=55
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il sesso. Uomo/Donna’)
leggi(sesso)
scrivi(‘Inserisci il tipo di attività. Leggera/Media/Pesante/Molto pesante’)
leggi(attivita)
{valutazione sesso ed attività e calcolo fabbisogno calorico giornaliero}
SE (sesso==’Uomo’)
ALLORA
inizio
{calcolo relativo all’uomo}
SE (attivita==attivita1)
ALLORA
CalorieGiorno=cal1uomo*24
ALTRIMENTI
SE (attivita==attivita2)
ALLORA
CalorieGiorno=cal2uomo*24
ALTRIMENTI
SE (attivita==attivita3)
ALLORA
CalorieGiorno=cal3uomo*24
ALTRIMENTI
CalorieGiorno=cal4uomo*24
FINE SE
FINE SE
FINE SE
fine
ALTRIMENTI
inizio
{calcolo relativo alla donna}
SE (attivita==attivita1)
ALLORA
CalorieGiorno=cal1donna*24
ALTRIMENTI
SE (attivita==attivita2)
ALLORA
CalorieGiorno=cal2donna*24
ALTRIMENTI
SE (attivita==attivita3)
ALLORA
CalorieGiorno=cal3donna*24
ALTRIMENTI
CalorieGiorno=cal4donna*24
FINE SE
FINE SE
FINE SE
fine
FINE SE
{comunicazione fabbisogno calorico giornaliero}
scrivi(‘Il fabbisogno calorico giornaliero è di ‘+CalorieGiorno+’ calorie’)
{calcolo fabbisogno calorico a colazione e relativa comunicazione}
CalorieColazione = (CalorieGiorno * perc)/100
scrivi(‘Il numero di calorie necessarie per la colazione è ‘+CalorieColazione+’ calorie’)
fine
PROBLEMA 28.
Scrivere in linguaggio di progetto l’algoritmo che permette di risolvere il problema
di determinare la “normalità” del peso corporeo di un individuo, conoscendo il suo
peso e la sua altezza.
Dall’attività della FONDAZIONE UMBERTO VERONESI si ha:
si deve calcolare il BMI – BODY MASS INDEX, che si ottiene dividendo il peso,
espresso in chilogrammi, per l’altezza, espressa in metri, al quadrato, e quindi
esaminare la seguente tabella
BMI
< 18.5
18.5 – 24.9
25.0 – 29.9
>= 30.0
30.0 – 34.9
35.0 – 39.9
>= 40.0
STATO
sottopeso
normopeso
sovrappeso
obeso
obeso classe I
obeso classe II
obeso classe III
DATI: il peso dell’individuo espresso in chilogrammi e la sua altezza in metri
OBIETTIVO: stabilire lo stato corporeo dell’individuo, fornendo le relative comunicazioni
VARIABILI: peso, altezza, bmi
programma CalcoloBmi
var peso, altezza, bmi: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il peso espresso in Kg dell’individuo ‘)
leggi(peso)
scrivi(‘Inserisci l’altezza espressa in m dell’individuo ‘)
leggi(altezza)
{calcolo del BMI e relative valutazioni e comunicazioni}
bmi = peso / (altezza * altezza)
scrivi(‘Il BMI dell’individuo ha valore ‘+bmi+’ Kg / m² ‘)
SE (bmi<18.5)
ALLORA
scrivi(‘L’individuo è in sottopeso ‘)
ALTRIMENTI
SE (bmi<=24.9)
ALLORA
scrivi(‘L’individuo è in normopeso ‘)
ALTRIMENTI
SE (bmi<=29.9)
ALLORA
scrivi(‘L’individuo è in sovrappeso ‘)
ALTRIMENTI
SE (bmi<=34.9)
ALLORA
scrivi(‘L’individuo è un obeso di classe I ‘)
ALTRIMENTI
SE (bmi<=39.9)
ALLORA
scrivi(‘L’individuo è un obeso di classe II ‘)
ALTRIMENTI
scrivi(‘L’individuo è un obeso di classe III ‘)
FINE SE
FINE SE
FINE SE
FINE SE
FINE SE
fine
PROBLEMA 29.
Nel 1951 la ricercatrice italiana Rita Levi Montalcini scoprì una proteina, estratta
dalle ghiandole salivari del topo maschio, di nome nerve growth factor (fattore di
crescita nervosa), o NGF, che si rivelò un fattore di grande importanza per il
sistema nervoso periferico e centrale dell’uomo. I primi usi furono rivolti alle lesioni
della cornea: grazie all’inoculazione di NGF, in due mesi gli strappi sulla cornea
erano ricuciti. Recentemente l’NGF si è rivelato efficace nel trattamento delle
ulcerazioni croniche delle gambe in pazienti affetti da artrite reumatoide: la
seguente tabella (fonte: Istituto di Neurobiologia del CNR - Roma) mostra il tempo
necessario per la completa guarigione dell’ulcera trattata con NGF.
Periodo di trattamento in settimane
1
2
3
4
5
6
7
8
Riduzione dell’ulcera in %
20%
45%
50%
55%
60%
70%
80%
100%
In futuro secondo gli scienziati, sono fondate le speranze che l’NGF potrebbe
guarire da diabete, cancro, Parkinson, Alzheimer, sclerosi multipla e AIDS.
Analizzando la tabella, realizzare, in linguaggio di progetto, l’algoritmo che, dato in
input il periodo di trattamento in settimane di NGF, fornisca in output la percentuale
di riduzione dell’ulcera.
DATI: numero di settimane di trattamento con NGF
OBIETTIVO: comunicare la percentuale di riduzione dell’ulcera sulle gambe in base al
numero di settimane di trattamento con NGF
VARIABILI: NumeroSettimane
programma TrattamentoNGF
var NumeroSettimane: intero
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il numero di settimane di trattamento con NGF (intero da 1 a 8) ’)
leggi(NumeroSettimane)
{comunicazione percentuale riduzione dell’ulcera in base alle settimane di trattamento}
SE (NumeroSettimane==1)
ALLORA
scrivi(‘Le lesioni si sono ridotte del 20%’ )
ALTRIMENTI
SE (NumeroSettimane==2)
ALLORA
scrivi(‘Le lesioni si sono ridotte del 45% ‘)
ALTRIMENTI
SE (NumeroSettimane==3)
ALLORA
scrivi(‘Le lesioni si sono ridotte del 50% ‘)
ALTRIMENTI
SE (NumeroSettimane==4)
ALLORA
scrivi(‘Le lesioni si sono ridotte del 55% ‘)
ALTRIMENTI
SE (NumeroSettimane==5)
ALLORA
scrivi(‘Le lesioni si sono ridotte del 60% ‘)
ALTRIMENTI
SE (NumeroSettimane==6)
ALLORA
scrivi(‘Le lesioni si sono ridotte del 70% ‘)
ALTRIMENTI
SE (NumeroSettimane==7)
ALLORA
scrivi(‘Le lesioni si sono ridotte dell’ 80% ‘)
ALTRIMENTI
SE (NumeroSettimane==8)
ALLORA
inizio
scrivi(‘Le lesioni si sono ridotte del 100% ‘)
scrivi(‘Il paziente è completamente guarito ‘)
fine
ALTRIMENTI
scrivi(‘Errore sul numero di settimane inserito’)
FINE SE
FINE SE
FINE SE
FINE SE
FINE SE
FINE SE
FINE SE
FINE SE
fine
Il problema si può anche risolvere utilizzando il costrutto COMMUTA… invece del
costrutto SE…ALLORA…ALTRIMENTI…. Infatti si ha il seguente algoritmo, che
presenta sicuramente una struttura più compatta e semplice del precedente:
programma TrattamentoNGFbis
var NumeroSettimane: intero
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il numero di settimane di trattamento con NGF (intero da 1 a 8) ’)
leggi(NumeroSettimane)
{comunicazione percentuale riduzione dell’ulcera in base alle settimane di trattamento}
COMMUTA (NumeroSettimane)
inizio
CASO 1:
scrivi(‘Le lesioni si sono ridotte del 20%’ )
CASO 2:
scrivi(‘Le lesioni si sono ridotte del 45%’ )
CASO 3:
scrivi(‘Le lesioni si sono ridotte del 50%’ )
CASO 4:
scrivi(‘Le lesioni si sono ridotte del 55%’ )
CASO 5:
scrivi(‘Le lesioni si sono ridotte del 60%’ )
CASO 6:
scrivi(‘Le lesioni si sono ridotte del 70%’ )
CASO 7:
scrivi(‘Le lesioni si sono ridotte dell’ 80%’ )
CASO 8:
inizio
scrivi(‘Le lesioni si sono ridotte del 100% ‘)
scrivi(‘Il paziente è completamente guarito‘)
fine
IN CASO CONTRARIO:
scrivi(‘Errore sul numero di settimane inserito’)
fine
FINE COMMUTA
fine
PROBLEMA 30.
Scrivere in linguaggio di progetto l’algoritmo che risolve il seguente problema:
Per la vendita di un prodotto si deve applicare uno sconto progressivo in base al
numero di pezzi ordinati, secondo la seguente tabella:
Numero Pezzi Ordinati
Fino a 3
Fino a 5
Fino a 10
Più di 10
Percentuale Sconto
5%
10%
20%
30%
Determinare l’importo totale scontato.
DATI: il numero dei pezzi ordinati e il prezzo unitario del prodotto
OBIETTIVO: calcolare e comunicare l’importo totale scontato in base alla quantità ordinata
VARIABILI: NumeroPezzi, PrezzoUnitario, ScontoPrezzoUnitario, TotaleScontato
programma ImportoTotaleScontato
var NumeroPezzi: intero
PrezzoUnitario, ScontoPrezzoUnitario, TotaleScontato: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il numero dei pezzi ordinati ‘)
leggi(NumeroPezzi)
scrivi(‘Inserisci il prezzo unitario in € del prodotto ‘)
leggi(PrezzoUnitario)
{valutazione del numero dei pezzi ordinati e calcolo dello sconto sul prezzo unitario}
COMMUTA (NumeroPezzi)
inizio
CASO 1: CASO 2: CASO 3:
ScontoPrezzoUnitario=(PrezzoUnitario*5)/100
CASO 4: CASO 5:
ScontoPrezzoUnitario=(PrezzoUnitario*10)/100
CASO 6: CASO 7: CASO 8: CASO 9: CASO 10:
ScontoPrezzoUnitario=(PrezzoUnitario*20)/100
IN CASO CONTRARIO:
ScontoPrezzoUnitario=(PrezzoUnitario*30)/100
fine
FINE COMMUTA
{calcolo dell’importo totale scontato}
TotaleScontato=NumeroPezzi*(PrezzoUnitario-ScontoPrezzoUnitario)
{comunicazione dell’importo totale scontato}
scrivi(‘L’importo totale scontato in base alla quantità ordinata è di € ‘+TotaleScontato)
fine
PROBLEMA 31.
Tutte le informazioni all’interno di un elaboratore sono rappresentate come insiemi
di bit (contrazione di BInary digiT), poiché le cifre usate sono quelle binarie (cioè
con due soli possibili stati: “0” e “1”). Per comodità i bit vengono raggruppati in
gruppi di 8 e questo insieme prende il nome di byte. Nei moderni calcolatori la
quantità di informazioni gestite è notevole, dell’ordine di milioni di byte, per cui
risulta inadeguato esprimere tale capacità in semplici byte. Si usano per questo i
multipli del byte. Nella seguente tabella vengono mostrati i multipli del byte, la loro
sigla e la corrispondenza in byte.
MULTIPLI
kilobyte
megabyte
gigabyte
terabyte
petabyte
exabyte
zettabyte
yottabyte
SIGLA
kB
MB
GB
TB
PB
EB
ZB
YB
CORRISPONDENZA
1024 byte (circa 1000 byte)
1024 kbyte (circa 1000000 di byte)
1024 Mbyte (circa 1000000000 di byte)
1024 Gbyte
1024 Tbyte
1024 Pbyte
1024 Ebyte
1024 Zbyte
Scrivere in linguaggio di progetto l’algoritmo che permette all’utente di inserire in
input un multiplo del byte e di avere in output il suo valore corrispondente in byte.
DATI: un multiplo del byte.
OBIETTIVO: visualizzare il valore corrispondente del multiplo del byte.
VARIABILI: MultiploByte
programma MultiploInByte
var MultiploByte: stringa
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci un multiplo del byte. kB/MB/GB/TB/PB/EB/ZB/YB ‘)
leggi(MultiploByte)
{valutazione del multiplo e visualizzazione della sua corrispondenza in byte}
COMMUTA (MultiploByte)
inizio
CASO ‘kB’:
scrivi(‘kB corrisponde a circa 1000 byte ‘)
CASO ‘MB’:
scrivi(‘MB corrisponde a circa 1000000 di byte ‘)
CASO ‘GB’:
scrivi(‘GB corrisponde a circa 1000000000 di byte ‘)
CASO ‘TB’:
scrivi(‘TB corrisponde a circa 1000000000000 di byte ‘)
CASO ‘PB’:
scrivi(‘PB corrisponde a circa 1000000000000000 di byte ‘)
CASO ‘EB’:
scrivi(‘EB corrisponde a circa 1000000000000000000 di byte ‘)
CASO ‘ZB’:
scrivi(‘ZB corrisponde a circa 1000000000000000000000 di byte ‘)
CASO ‘YB’:
scrivi(‘YB corrisponde a circa 1000000000000000000000000 di byte ‘)
IN CASO CONTRARIO:
scrivi(‘ERRORE!! Hai commesso un errore nell’inserimento del multiplo ‘)
fine
FINE COMMUTA
fine
PROBLEMA 32.
Scrivere in linguaggio di progetto l’algoritmo che permette di risolvere il seguente
problema:
Siano dati in input due enunciati p e q e i loro valori di verità vero o falso. Il sistema
dovrà calcolare e fornire in output il valore di verità degli enunciati composti:
p and q, p or q, not p, not q. Si ricordi che: i connettivi logici and, or, not
rappresentano nell’algebra booleana rispettivamente la congiunzione logica o
prodotto logico, la disgiunzione inclusiva o somma logica, la negazione logica o
complemento.
DATI: due enunciati p e q e i loro valori di verità vero o falso
OBIETTIVO: calcolare e comunicare i valori di verità degli enunciati composti p and q,
p or q, not p, not q
VARIABILI: EnunciatoP, EnunciatoQ, ValVeritàP, ValVeritàQ, valveritàp, valveritàq,
valveritàpANDq, valveritàpORq, valveritàNOTp, valveritàNOTq
programma valori_di_George_Boole
var EnunciatoP, EnunciatoQ: stringa
ValVeritàP, ValVeritàQ: carattere
valveritàp, valveritàq, valveritàpANDq, valveritàpORq, valveritàNOTp: booleano
valveritàNOTq: booleano
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci l’enunciato p ‘)
leggi(EnunciatoP)
scrivi(‘Introduci il valore di verità (vero o falso) di p: V/F ‘)
leggi(ValVeritàP)
scrivi(‘Inserisci l’enunciato q ‘)
leggi(EnunciatoQ)
scrivi(‘Introduci il valore di verità (vero o falso) di q: V/F ‘)
leggi(ValVeritàQ)
{assegnazione del valore di verità alle variabili booleane valveritàp e valveritàq}
SE (ValVeritàP==’V’)
ALLORA
valveritàp=vero
ALTRIMENTI
valveritàp=falso
FINE SE
SE (ValVeritàQ==’V’)
ALLORA
valveritàq=vero
ALTRIMENTI
valveritàq=falso
FINE SE
{assegnazione del valore di verità alle variabili booleane valveritàpANDq e valveritàpORq}
valveritàpANDq = valveritàp and valveritàq
valveritàpORq = valveritàp or valveritàq
{assegnazione del valore di verità alle variabili booleane valveritàNOTp e valveritàNOTq}
valveritàNOTp = not valveritàp
valveritàNOTq = not valveritàq
{comunicazione dei valori di verità degli enunciati: “p and q”, “p or q”, “not p”, “not q”}
scrivi(‘Il valore di verità dell’enunciato composto “p and q” è ‘+valveritàpANDq)
scrivi(‘Il valore di verità dell’enunciato composto “p or q” è ‘+valveritàpORq)
scrivi(‘Il valore di verità dell’enunciato composto “not p” è ‘+valveritàNOTp)
scrivi(‘Il valore di verità dell’enunciato composto “not q” è ‘+valveritàNOTq)
fine
PROBLEMA 33.
Scrivere in linguaggio di progetto l’algoritmo che permette di risolvere il seguente
problema:
Realizzare un menù di scelta relativo ad argomenti di informatica, l’utente deve
effettuare in input una scelta ed il sistema deve fornire in output una breve
trattazione sull’argomento scelto.
DATI: un numero intero corrispondente alla scelta effettuata dall’utente
OBIETTIVO: visualizzare una breve trattazione sull’argomento scelto
VARIABILI: SceltaArgomento
programma SceltaDaMenù
var SceltaArgomento: intero
inizio
{visualizzazione per l’utente del menù di scelta dell’argomento}
scrivi(‘1. Sistema di elaborazione ‘)
scrivi(‘2. Componenti di un sistema di elaborazione‘)
scrivi(‘3. Componenti hardware ‘)
scrivi(‘4. CPU ‘)
scrivi(‘5. Memoria centrale ‘)
scrivi(‘6. Memorie di massa ‘)
scrivi(‘7. Periferiche di input ‘)
scrivi(‘8. Periferiche di output ‘)
scrivi(‘9. Il software ‘)
scrivi(’10. Software di base ‘)
scrivi(’11. Software applicativo ‘)
scrivi(’12. Software di programmazione ‘)
{acquisizione dei dati di input}
scrivi(‘Inserisci un intero tra 1 e 12 per scegliere un argomento del menù‘)
leggi(SceltaArgomento)
{valutazione della scelta e visualizzazione di una breve trattazione sull’argomento}
COMMUTA (SceltaArgomento)
inizio
CASO 1:
inizio
scrivi(‘Un sistema di elaborazione è un insieme di elementi che costituiscono’)
scrivi(‘un’unica entità per il perseguimento di elaborare dati e informazioni’)
fine
CASO 2:
inizio
scrivi(‘Un sistema di elaborazione ha due componenti. ‘)
scrivi(‘L’hardware (hard =”solido”, ware =”componente”) che’)
scrivi(‘è l’insieme delle componenti fisiche (meccaniche, elettriche, ‘)
scrivi(‘elettroniche, magnetiche e ottiche) che costituiscono l’elaboratore e ‘)
scrivi(‘il software (soft=”soffice”, ware=”componente”) che è la parte logica’)
scrivi(‘di un elaboratore, costituita dai programmi residenti nella memoria ’)
scrivi(‘del sistema o nei supporti di memorizzazione’)
fine
CASO 3:
inizio
scrivi(‘Le componenti hardware sono: CPU (Central Processing Unit, “unità’)
scrivi(‘centrale di elaborazione”), Memoria centrale, Memorie di massa, ‘)
scrivi(‘Periferiche di input, Periferiche di output.’)
fine
CASO 4:
inizio
scrivi(‘La CPU è il cervello dell’elaboratore in cui avvengono tutti i processi’)
scrivi(‘di elaborazione.’)
fine
CASO 5:
inizio
scrivi(‘La memoria centrale è un dispositivo elettronico che conserva le ‘)
scrivi(‘istruzioni per l’avvio del sistema e memorizza informazioni, istruzioni’)
scrivi(‘e dati per l’elaborazione’)
fine
CASO 6:
inizio
scrivi(‘Le memorie di massa sono supporti magneto-ottici-elettronici che ‘)
scrivi(‘permettono di memorizzare dati e programmi in modo permanente. ‘)
scrivi(‘Esempi sono: i nastri, gli hard disk, i CD, i DVD, le USB flash drive ‘)
scrivi(‘ ( o chiavette USB), le memory card.’)
fine
CASO 7:
inizio
scrivi(‘Le periferiche di input sono tutti quei dispositivi che consentono ‘)
scrivi(‘l’immissione dei dati e delle istruzioni dall’esterno all’interno ‘)
scrivi(‘dell’elaboratore. Esempi sono: la tastiera, il mouse, la track ball, ‘)
scrivi(‘il touchpad, lo scanner, il joystick, la webcam, la macchina ‘)
scrivi(‘fotografica digitale, i microfoni, la penna ottica, il touchscreen.’)
fine
CASO 8:
inizio
scrivi(‘Le periferiche di output sono tutti quei dispositivi che consentono’)
scrivi(‘la comunicazione all’esterno (emissione) dei dati elaborati, intermedi’)
scrivi(‘o finali. Esempi sono: il video, la stampante, il plotter, le casse ‘)
scrivi(‘acustiche, le cuffie e le auricolari, il touchscreen. ‘)
fine
CASO 9:
inizio
scrivi(‘Il software si suddivide in: software di base, software applicativo e’)
scrivi(‘software di programmazione’)
fine
CASO 10:
inizio
scrivi(‘Il software di base è l’insieme di programmi in grado di far ’)
scrivi(‘funzionare l’elaboratore, semplificando il lavoro dell’uomo e ‘)
scrivi(‘ottimizzando l’uso delle risorse di sistema. I programmi sono: il’)
scrivi(‘sistema operativo, gli editor e i compilatori.’)
fine
CASO 11:
inizio
scrivi(‘Il software applicativo è costituito dai programmi utilizzabili ’)
scrivi(‘dall’utente finale del sistema per espletare un lavoro. Esempi sono:’)
scrivi(‘MS Word, MS Excel, MS PowerPoint, MS Access,Adobe Illustrator,’)
scrivi(‘Macromedia Director ecc ‘)
fine
CASO 12:
inizio
scrivi(‘Il software di programmazione permette lo sviluppo di programmi,’)
scrivi(‘ mediante l’uso di codici specifici, per le esigenze più diverse. ‘)
fine
IN CASO CONTRARIO:
scrivi(‘Non hai inserito un numero relativo al menù di scelta dell’argomento’)
fine
FINE COMMUTA
fine
PROBLEMA 34.
Scrivere in linguaggio di progetto l’algoritmo che permette di risolvere il problema
precedente, aggiungendo la condizione che l’utente può ripetere quante volte vuole
la scelta di un argomento del menù.
E’ sufficiente inserire un costrutto iterativo, ad esempio la struttura iterativa
ESEGUI…MENTRE… Segue il seguente algoritmo:
DATI: un numero intero corrispondente alla scelta effettuata dall’utente e la risposta
(positiva o negativa) alla richiesta di voler effettuare un’altra scelta di un argomento del
menù
OBIETTIVO: visualizzare ad ogni richiesta una breve trattazione sull’argomento scelto
VARIABILI: SceltaArgomento, Risposta
programma SceltaDaMenù
var SceltaArgomento: intero
Risposta: stringa
inizio
ESEGUI
inizio
{visualizzazione per l’utente del menù di scelta dell’argomento}
scrivi(‘1. Sistema di elaborazione ‘)
scrivi(‘2. Componenti di un sistema di elaborazione‘)
scrivi(‘3. Componenti hardware ‘)
scrivi(‘4. CPU ‘)
scrivi(‘5. Memoria centrale ‘)
scrivi(‘6. Memorie di massa ‘)
scrivi(‘7. Periferiche di input ‘)
scrivi(‘8. Periferiche di output ‘)
scrivi(‘9. Il software ‘)
scrivi(’10. Software di base ‘)
scrivi(’11. Software applicativo ‘)
scrivi(’12. Software di programmazione ‘)
{acquisizione del numero intero corrispondente alla scelta da effettuare}
scrivi(‘Inserisci un intero tra 1 e 12 per scegliere un argomento del menù‘)
leggi(SceltaArgomento)
{valutazione della scelta e visualizzazione di una breve trattazione sull’argomento}
COMMUTA (SceltaArgomento)
inizio
CASO 1:
inizio
scrivi(‘Un sistema di elaborazione è un insieme di elementi che costituiscono’)
scrivi(‘un’unica entità per il perseguimento di elaborare dati e informazioni’)
fine
CASO 2:
inizio
scrivi(‘Un sistema di elaborazione ha due componenti. ‘)
scrivi(‘L’hardware (hard =”solido”, ware =”componente”) che’)
scrivi(‘è l’insieme delle componenti fisiche (meccaniche, elettriche, ‘)
scrivi(‘elettroniche, magnetiche e ottiche) che costituiscono l’elaboratore e ‘)
scrivi(‘il software (soft=”soffice”, ware=”componente”) che è la parte logica’)
scrivi(‘di un elaboratore, costituita dai programmi residenti nella memoria ’)
scrivi(‘del sistema o nei supporti di memorizzazione’)
fine
CASO 3:
inizio
scrivi(‘Le componenti hardware sono: CPU (Central Processing Unit, “unità’)
scrivi(‘centrale di elaborazione”), Memoria centrale, Memorie di massa, ‘)
scrivi(‘Periferiche di input, Periferiche di output.’)
fine
CASO 4:
inizio
scrivi(‘La CPU è il cervello dell’elaboratore in cui avvengono tutti i processi’)
scrivi(‘di elaborazione.’)
fine
CASO 5:
inizio
scrivi(‘La memoria centrale è un dispositivo elettronico che conserva le ‘)
scrivi(‘istruzioni per l’avvio del sistema e memorizza informazioni, istruzioni’)
scrivi(‘e dati per l’elaborazione’)
fine
CASO 6:
inizio
scrivi(‘Le memorie di massa sono supporti magneto-ottici-elettronici che ‘)
scrivi(‘permettono di memorizzare dati e programmi in modo permanente. ‘)
scrivi(‘Esempi sono: i nastri, gli hard disk, i CD, i DVD, le USB flash drive ‘)
scrivi(‘ ( o chiavette USB), le memory card.’)
fine
CASO 7:
inizio
scrivi(‘Le periferiche di input sono tutti quei dispositivi che consentono ‘)
scrivi(‘l’immissione dei dati e delle istruzioni dall’esterno all’interno ‘)
scrivi(‘dell’elaboratore. Esempi sono: la tastiera, il mouse, la track ball, ‘)
scrivi(‘il touchpad, lo scanner, il joystick, la webcam, la macchina ‘)
scrivi(‘fotografica digitale, i microfoni, la penna ottica, il touchscreen.’)
fine
CASO 8:
inizio
scrivi(‘Le periferiche di output sono tutti quei dispositivi che consentono’)
scrivi(‘la comunicazione all’esterno (emissione) dei dati elaborati, intermedi’)
scrivi(‘o finali. Esempi sono: il video, la stampante, il plotter, le casse ‘)
scrivi(‘acustiche, le cuffie e le auricolari, il touchscreen. ‘)
fine
CASO 9:
inizio
scrivi(‘Il software si suddivide in: software di base, software applicativo e’)
scrivi(‘software di programmazione’)
fine
CASO 10:
inizio
scrivi(‘Il software di base è l’insieme di programmi in grado di far ’)
scrivi(‘funzionare l’elaboratore, semplificando il lavoro dell’uomo e ‘)
scrivi(‘ottimizzando l’uso delle risorse di sistema. I programmi sono: il’)
scrivi(‘sistema operativo, gli editor e i compilatori.’)
fine
CASO 11:
inizio
scrivi(‘Il software applicativo è costituito dai programmi utilizzabili ’)
scrivi(‘dall’utente finale del sistema per espletare un lavoro. Esempi sono:’)
scrivi(‘MS Word, MS Excel, MS PowerPoint, MS Access,Adobe Illustrator,’)
scrivi(‘Macromedia Director ecc ‘)
fine
CASO 12:
inizio
scrivi(‘Il software di programmazione permette lo sviluppo di programmi,’)
scrivi(‘ mediante l’uso di codici specifici, per le esigenze più diverse. ‘)
fine
IN CASO CONTRARIO:
scrivi(‘Non hai inserito un numero relativo al menù di scelta dell’argomento’)
fine
FINE COMMUTA
{richiesta di voler effettuare un’altra scelta}
scrivi(‘Vuoi scegliere un altro argomento del menù? SI/NO’)
leggi(Risposta)
fine
MENTRE (Risposta==’SI’) {quindi,mentre la risposta è SI,l’utente può scegliere}
fine
PROBLEMA 35.
Come è stato fatto per il 34., estensione del 33., anche al problema 32., si può
aggiungere la condizione che l’utente può far eseguire quante volte vuole le
operazioni logiche tra due enunciati, nuovamente inseriti in input, insieme ai loro
valori di verità.
Si ha il seguente algoritmo, utilizzando sempre la struttura iterativa
ESEGUI…MENTRE…:
DATI: due enunciati p e q, i loro valori di verità vero o falso e la risposta (positiva o
negativa) alla richiesta di voler far effettuare le operazioni logiche con altri due
enunciati
OBIETTIVO: calcolare e comunicare i valori di verità degli enunciati composti p and q,
p or q, not p, not q, ad ogni richiesta dell’utente di far eseguire le operazioni logiche
tra due enunciati
VARIABILI: EnunciatoP, EnunciatoQ, ValVeritàP, ValVeritàQ, valveritàp, valveritàq,
valveritàpANDq, valveritàpORq, valveritàNOTp, valveritàNOTq, Risposta
programma valori_di_George_Boole_bis
var EnunciatoP, EnunciatoQ, Risposta: stringa
ValVeritàP, ValVeritàQ: carattere
valveritàp, valveritàq, valveritàpANDq, valveritàpORq, valveritàNOTp: booleano
valveritàNOTq: booleano
inizio
ESEGUI
inizio
{acquisizione dei due enunciati e dei rispettivi valori di verità}
scrivi(‘Inserisci l’enunciato p ‘)
leggi(EnunciatoP)
scrivi(‘Introduci il valore di verità (vero o falso) di p: V/F ‘)
leggi(ValVeritàP)
scrivi(‘Inserisci l’enunciato q ‘)
leggi(EnunciatoQ)
scrivi(‘Introduci il valore di verità (vero o falso) di q: V/F ‘)
leggi(ValVeritàQ)
{assegnazione del valore di verità alle variabili booleane valveritàp e valveritàq}
SE (ValVeritàP==’V’)
ALLORA
valveritàp=vero
ALTRIMENTI
valveritàp=falso
FINE SE
SE (ValVeritàQ==’V’)
ALLORA
valveritàq=vero
ALTRIMENTI
valveritàq=falso
FINE SE
{assegnazione del valore di verità alle variabili booleane valveritàpANDq e valveritàpORq}
valveritàpANDq = valveritàp and valveritàq
valveritàpORq = valveritàp or valveritàq
{assegnazione del valore di verità alle variabili booleane valveritàNOTp e valveritàNOTq}
valveritàNOTp = not valveritàp
valveritàNOTq = not valveritàq
{comunicazione dei valori di verità degli enunciati: “p and q”, “p or q”, “not p”, “not q”}
scrivi(‘Il valore di verità dell’enunciato composto “p and q” è ‘+valveritàpANDq)
scrivi(‘Il valore di verità dell’enunciato composto “p or q” è ‘+valveritàpORq)
scrivi(‘Il valore di verità dell’enunciato composto “not p” è ‘+valveritàNOTp)
scrivi(‘Il valore di verità dell’enunciato composto “not q” è ‘+valveritàNOTq)
{richiesta di voler far eseguire le operazioni logiche con altri due enunciati}
scrivi(‘Vuoi far eseguire le operazioni logiche con altri due enunciati? SI/NO’)
leggi(Risposta)
fine
MENTRE (Risposta==’SI’) {mentre la risposta è SI,le operazioni vengono rieseguite}
fine
PROBLEMA 36.
Scrivere in linguaggio di progetto l’algoritmo che permette di risolvere il seguente
problema:
Un grande capannone, di modello una piramide regolare, avente per base un
quadrato, ospita 500 senza tetto. Determinare l’altezza di tale capannone.
Si ricordi che, denotando con:
S – la lunghezza sul terreno dell’ombra del capannone, ottenuta quando il raggio
solare passa per il vertice della piramide;
s – la lunghezza dell’ombra di un bastone piantato verticalmente nel terreno, in
modo che: il raggio solare che passa per la cima di esso, l’ombra proiettata sul
terreno e il bastone stesso formino un triangolo rettangolo;
P – l’altezza del bastone;
l – il lato di base del capannone;
si ha:
h = altezza capannone = (P / s) * (S + (l / 2)) - METODO di TALETE
DATI: S, s, P, l
OBIETTIVO: determinare e comunicare l’altezza del capannone
VARIABILI: LungOmbraCapan, LungOmbraBastone, AltezzaBastone, LatoBase,
AltezzaCapan
programma Capannone
var LungOmbraCapan, LungOmbraBastone, AltezzaBastone, LatoBase: reale
AltezzaCapan: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci la lunghezza in metri dell’ombra del capannone’)
leggi(LungOmbraCapan)
scrivi(‘Inserisci la lunghezza in metri dell’ombra del bastone’)
leggi(LungOmbraBastone)
scrivi(‘Inserisci la misura in metri dell’altezza del bastone’)
leggi(AltezzaBastone)
scrivi(‘Inserisci la misura in metri del lato di base del capannone’)
leggi(LatoBase)
{calcolo e comunicazione dell’altezza del capannone}
AltezzaCapan=(AltezzaBastone / LungOmbraBastone)*(LungOmbraCapan+(LatoBase/2))
scrivi(‘L’altezza del capannone è di ‘+AltezzaCapan+’ metri’)
fine
PROBLEMA 37.
Scrivere in linguaggio di progetto l’algoritmo che risolve il seguente problema:
Si consideri un doppio piano inclinato, rappresentato graficamente da un triangolo
ABC, di base BC (orizzontale) e di inclinazioni AB e AC. L’inclinazione AC misura l1
e l’inclinazione AB misura l2. Un filo, portante tante sferette metalliche, di densità
uniforme, viene posto sulle due inclinazioni. La catena parte quindi da B, passa per
A e giunge a C. Si indichino inoltre con P1 e P2 i pesi rispettivi dei tratti AC e AB di
catena.
Dati in input i valori di l1, l2 e P2, stabilire quale valore deve avere P1 in modo tale
che la parte AC di catena possa fare equilibrio alla parte AB.
Si ha:
P1 = peso tratto AC di catena = P2 * (l1 / l2) - METODO di STEVINO
DATI: l1, l2, P2
OBIETTIVO: determinare il peso P1 del tratto AC in modo tale che la catena stia in
equilibrio sul doppio piano inclinato
VARIABILI: l1, l2, P1, P2
programma CatenaDiStevino
var l1, l2, P1, P2: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci la misura in metri del lato AC del doppio piano inclinato’)
leggi(l1)
scrivi(‘Inserisci la misura in metri del lato AB del doppio piano inclinato’)
leggi(l2)
scrivi(‘Inserisci il peso in grammi del tratto AB di catena’)
leggi(P2)
{calcolo del peso P1}
P1 = P2 * (l1 / l2)
{comunicazione del valore di P1}
scrivi(‘Il peso del tratto AC di catena, tale che la catena stia in equilibrio sul doppio
piano inclinato è di ‘+P1+’ grammi’)
fine
PROBLEMA 38.
Realizzare l’algoritmo in linguaggio di progetto che permette di risolvere il seguente
problema:
Su una ruota agiscono due forze F1 = 156.8 N e F2 in N, che tendono a farla ruotare
l’una in un verso e l’altra nel verso contrario. Il braccio della forza F1 è di 22 cm e
quello della forza F2 misura 110 cm. Dato in input il valore di F2, stabilire se con tale
forza la ruota è tenuta in equilibrio.
DATI: il valore in Newton della forza F2
OBIETTIVO: stabilire se, con tale forza, la ruota è tenuta in equilibrio
VARIABILI: F2, momenti (il momento di una forza è il prodotto della forza per il braccio)
COSTANTI: F1=156.8, b1=22, b2=110
programma RuotaInEquilibrio
var F2, momenti: reale
F1=156.8; b1=22; b2=110
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il valore della forza F2’)
leggi(F2)
{valutazione della forza F2 e relative comunicazioni}
momenti=F2 * b2 – F1 * b1
SE (momenti>0)
ALLORA
inizio
scrivi(‘La ruota non è in equilibrio, il valore della forza F2 deve essere inferiore’)
scrivi(‘Inserisci nuovamente il valore della forza F2’)
leggi(F2)
momenti=F2 * b2 – F1 * b1
SE (momenti<>0)
ALLORA
inizio
F2=(F1*b1)/b2
scrivi(‘La ruota non è ancora in equilibrio. Il valore esatto di F2 è ‘+F2+’ N’)
fine
ALTRIMENTI
scrivi(‘ Il valore della forza F2 ora è esatto, la ruota è in equilibrio’)
FINE SE
fine
ALTRIMENTI
SE (momenti<0)
ALLORA
inizio
scrivi(‘La ruota non è in equilibrio, il valore di F2 deve essere maggiore’)
scrivi(‘Inserisci nuovamente il valore della forza F2’)
leggi(F2)
momenti=F2 * b2 – F1 * b1
SE (momenti<>0)
ALLORA
inizio
F2=(F1*b1)/b2
scrivi(‘La ruota non è ancora in equilibrio. Il valore esatto di F2 è ‘+F2+’ N’)
fine
ALTRIMENTI
scrivi(‘Il valore della forza F2 ora è esatto, la ruota è in equilibrio’)
FINE SE
fine
ALTRIMENTI
scrivi(‘Bene! Il valore della forza F2 è esatto, la ruota è in equilibrio’)
FINE SE
FINE SE
fine
PROBLEMA 39.
Realizzare un algoritmo in linguaggio di progetto che permette di determinare una
coppia di classi contigue di numeri razionali che individui, con una
approssimazione di sette cifre decimali, la radice quadrata di un numero reale
assoluto r.
Risoluzione:
Le classi contigue saranno date mediante una successione di intervalli
“inscatolati”, contenuti uno dentro l’altro.
La ricerca del primo intervallo sarà realizzata con il costrutto iterativo
ESEGUI…MENTRE… che utilizza la variabile di controllo A, inizializzata a zero e che
si incrementa del valore h=1 mentre A²<r.
Se A² ≥ r, l’intervallo [a, b] viene così definito:
se A² = r, a=A e b=A+h;
se A² > r, a=A-h e b=A.
La ricerca degli intervalli successivi si ottiene nello stesso modo con h = h/10,
mediante il costrutto iterativo MENTRE…, la cui condizione h > 0.0000001 viene
controllata prima di ogni iterazione.
Gli intervalli sono numerati dalla variabile conteggio.
DATI: un numero reale assoluto r
OBIETTIVO: determinare e visualizzare una successione di intervalli “inscatolati”. L’ultimo
contiene la radice quadrata del numero reale r, con una approssimazione di sette
cifre decimali.
VARIABILI: conteggio, r, A, A1, a, b, h
programma classi_contigue
var conteggio: intero
r, A, A1, a, b, h: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Inserisci il numero reale assoluto r ‘)
leggi(r)
{inizializzazione delle variabili conteggio, a, h}
conteggio=1
a=0
h=1
{realizzazione e visualizzazione degli intervalli inscatolati}
MENTRE (h>0.0000001)
inizio
A=a
ESEGUI
inizio
A=A+h
fine
MENTRE (A² < r) {fine costrutto iterativo esegui…mentre…}
A1=A²
SE ( | A1 – r | < 0.0000001)
ALLORA
inizio
a=A
b=A+h
fine
ALTRIMENTI
inizio
a=A-h
b=A
fine
FINE SE
scrivi(‘Intervallo ‘+conteggio+’ [ ‘+a+’ , ‘+b+ ‘ ] ‘)
conteggio=conteggio+1
h=h/10
fine costrutto iterativo MENTRE
fine
Ad esempio, per r=7, l’algoritmo fornisce il seguente output:
Intervallo 1 [2.0000000, 3.0000000]
Intervallo 2 [2.6000000, 2.7000000]
Intervallo 3 [2.6400000, 2.6500000]
Intervallo 4 [2.6450000, 2.6460000]
Intervallo 5 [2.6457000, 2.6458000]
Intervallo 6 [2.6457500, 2.6457600]
Intervallo 7 [2.6457510, 2.6457520]
Intervallo 8 [2.6457513, 2.6457514].
Si ricordi che la radice quadrata di 7 è uguale a: 2.645751311064590590501615753639…
Nella stesura del precedente algoritmo, sono state utilizzate tre tipologie di strutture di
controllo: una struttura di sequenza e di selezione e due strutture iterative.
Per quanto riguarda l’uso delle strutture di controllo per la costruzione degli algoritmi, il
riferimento classico è il Teorema di BÖHM-JACOPINI (1966) che può essere così
formulato:
Un qualsiasi algoritmo può essere espresso usando esclusivamente le strutture di
sequenza, di selezione e di iterazione.
PROBLEMA 40.
Realizzare in linguaggio di progetto l’algoritmo che permette di determinare la
lunghezza della circonferenza, come elemento di separazione delle classi contigue
delle sue lunghezze per difetto e per eccesso.
Per la risoluzione si applica il metodo di Archimede, infatti si parte dal quadrato
inscritto e da quello circoscritto e si raddoppia via via il numero dei lati sino a
pervenire a poligoni di 8192 lati. Non si procede oltre gli 8192 lati in quanto se il
numero dei lati supera 10000, a causa degli errori di arrotondamento, i valori ricavati
risulterebbero errati.
DATI: il raggio della circonferenza
OBIETTIVO: calcolare e comunicare la lunghezza della circonferenza come elemento di
separazione delle classi contigue delle sue lunghezze per difetto e per eccesso.
Calcolare e comunicare inoltre la lunghezza della circonferenza con la formula
C=2 π r per confrontare i risultati ottenuti.
VARIABILI: raggio, latoPolinscritto, latoPolCircoscritto, apotemaPolinscritto,
perimetroPolinscritto, perimetroPolCircoscritto, lunghezzaCirconf,
numeroLatiPoligono
programma circonferenza
var numeroLatiPoligono: intero
raggio, latoPolinscritto, latoPolCircoscritto, apotemaPolinscritto: reale
perimetroPolinscritto, perimetroPolCircoscritto, lunghezzaCirconf: reale
inizio
{acquisizione dei dati di input}
scrivi(‘Digitare il raggio della circonferenza ‘)
leggi(raggio)
{inizializzazione a quattro del numero dei lati del primo poligono (quadrato)}
numeroLatiPoligono=4
{calcolo della misura del lato del quadrato inscritto}
latoPolinscritto=raggio*(radicequadrata(2))
{calcolo e comunicazione della lunghezza della circonferenza come elemento}
{separatore delle classi contigue delle lunghezze per difetto e per eccesso}
ESEGUI
inizio
{calcolo apotema poligono inscritto}
apotemaPolinscritto=radicequadrata(4*(raggio)²-(latoPolinscritto)²) / 2
{calcolo del lato del poligono circoscritto}
latoPolCircoscritto=raggio*(latoPolinscritto/apotemaPolinscritto)
{calcolo del perimetro del poligono inscritto}
perimetroPolinscritto=latoPolinscritto*numeroLatiPoligono
{calcolo del perimetro del poligono circoscritto}
perimetroPolCircoscritto=latoPolCircoscritto*numeroLatiPoligono
{visualizzazione del numero dei lati e del perimetro del poligono inscritto e circoscritto}
scrivi(‘Num.lati‘+numeroLatiPoligono+’Per.pol.inscr.’+perimetroPolinscritto+’Per.pol.circo.’
+perimetroPolCircoscritto)
{calcolo del lato del poligono inscritto ottenuto raddoppiando il numero dei lati}
latoPolinscritto=radicequadrata(2*(raggio)²-(raggio*radicequadrata((4*(raggio)²)+
-(latoPolinscritto)²)))
{calcolo del numero dei lati del poligono successivo}
numeroLatiPoligono=2*numeroLatiPoligono
fine
MENTRE (numeroLatiPoligono<=10000) {fine costrutto iterativo esegui…mentre…}
{calcolo della misura della lunghezza della circonferenza con la formula C=2 π r}
{per confrontare i risultati ottenuti}
lunghezzaCirconf=2*(3.1415927)*raggio
{visualizzazione della misura della lunghezza della circonferenza}
scrivi(‘Misura della circonferenza con la formula C=2 π r: ‘+lunghezzaCirconf)
scrivi(‘Come si vede i risultati ottenuti coincidono.’)
fine
Ad esempio, per raggio=0.5, l’algoritmo fornisce il seguente output:
Num.lati
4
Per.pol.inscr. 2.828427
Per.pol.circo. 4.000000
Num.lati
8
Per.pol.inscr. 3.061467
Per.pol.circo. 3.313708
Num.lati
16
Per.pol.inscr. 3.121445
Per.pol.circo. 3.182598
Num.lati
32
Per.pol.inscr. 3.136548
Per.pol.circo. 3.151725
Num.lati
64
Per.pol.inscr. 3.140331
Per.pol.circo. 3.144118
Num.lati
128
Per.pol.inscr. 3.141277
Per.pol.circo. 3.142224
Num.lati
256
Per.pol.inscr. 3.141514
Per.pol.circo. 3.141750
Num.lati
512
Per.pol.inscr. 3.141573
Per.pol.circo. 3.141632
Num.lati 1024
Per.pol.inscr. 3.141588
Per.pol.circo. 3.141602
Num.lati 2048
Per.pol.inscr. 3.141591
Per.pol.circo. 3.141595
Num.lati 4096
Per.pol.inscr. 3.141592
Per.pol.circo. 3.141593
Num.lati 8192
Per.pol.inscr. 3.141592
Per.pol.circo. 3.141592
Misura della circonferenza con la formula C=2 π r: 3.1415927
Come si vede i risultati ottenuti coincidono.