LE ISTRUZIONI DI CONTROLLO
Le istruzioni di controllo servono per alterare l'esecuzione in sequenza delle
istruzioni del programma. Le prime versioni del Basic offrivano soltanto delle
forme rudimentali di istruzioni IF e l'istruzione GOTO numeroRiga che permette
di effettuare un salto ad un punto del programma successivo o precedente; pur
essendo questa istruzione ancora disponibile non è praticamente mai necessario
usarla. Infatti esistono varie istruzioni che permettono di codificare tutte le
strutture di controllo necessarie per la realizzazione di un algoritmo
strutturato e che rendono il programma molto più chiaro e comprensibile rispetto
all'uso del GOTO.
L'ISTRUZIONE IF THEN
L'istruzione IF THEN permette di codificare strutture condizionali di qualsiasi
complessità, anche nidificate. IF condizione1 THEN [bloccoIstruzioni1] [ELSEIF
condizione2 THEN [bloccoIstruzioni2]... [ELSE [bloccoIstruzioniN] END IF Ogni
blocco di istruzioni può comprendere qualsiasi altra istruzione, quindi anche
un'altra istruzione IF THEN. Se più istruzioni IF THEN sono nidificate una
dentro l'altra ogni ELSE (e ogni END IF) si riferisce all'ultimo IF THEN
incontrato.
LE CONDIZIONI E GLI OPERATORI RELAZIONALI E LOGICI
Le condizioni sono espressioni formate utilizzando gli operatori relazionali e
gli operatori logici. Gli operatori relazionali consentono di confrontare due
valori. Gli operatori definiti sono: = relazione di uguaglianza (da non
confondere con l'operatore di assegnazione) minore di > maggiore di >= maggiore
o uguale di = minore o uguale di > diverso da Se gli operatori relazionali
vengono utilizzati in espressioni che contengono anche operatori aritmetici,
vengono valutati sempre prima gli operatori aritmetici. Gli operatori logici
permettono di definire operazioni logiche. Gli operatori logici definiti sono:
NOT negazione AND congiunzione OR disgiunzione XOR OR esclusivo o disgiunzione
logica esclusiva EQV equivalenza IMP implicazione
+----------------------------------------------------------------+
¦PRIMA CONDIZ. ¦SECONDA CONDIZ. ¦PRIMA COND. XOR SECONDA CONDIZ. ¦
+--------------+----------------+--------------------------------¦
¦ vera ¦ vera ¦ falsa ¦
¦ vera ¦ falsa ¦ vera ¦
¦ falsa ¦ vera ¦ vera ¦
¦ falsa ¦ falsa ¦ falsa ¦
+--------------+----------------+--------------------------------¦
¦PRIMA CONDIZ. ¦SECONDA CONDIZ. ¦PRIMA COND. EQV SECONDA CONDIZ. ¦
+--------------+----------------+--------------------------------¦
¦ vera ¦ vera ¦ vera ¦
¦ vera ¦ falsa ¦ falsa ¦
¦ falsa ¦ vera ¦ falsa ¦
¦ falsa ¦ falsa ¦ vera ¦
+--------------+----------------+--------------------------------¦
¦PRIMA CONDIZ. ¦SECONDA CONDIZ. ¦PRIMA COND. IMP SECONDA CONDIZ. ¦
+--------------+----------------+--------------------------------¦
¦ vera ¦ vera ¦ vera ¦
¦ vera ¦ falsa ¦ falsa ¦
¦ falsa ¦ vera ¦ vera ¦
¦ falsa ¦ falsa ¦ vera ¦
+----------------------------------------------------------------+
I CONFRONTI TRA STRINGHE
I confronti con gli operatori relazionali possono essere fatti anche tra
variabili o costanti alfanumeriche; le stringhe vengono confrontate carattere
per carattere; il primo carattere diverso determina quale stringa preceda
l'altra, cioè sia minore. L'ordine tra i caratteri è determinato dall'ordine con
cui essi compaiono nella tabella di definizione del codice ASCII.
L'ISTRUZIONE SELECT
L'istruzione SELECT permette di codificare delle alternative multiple, cioè di
indicare quali istruzioni devono essere eseguite per valori diversi di una
stessa variabile. SELECT CASE espressioneTest CASE elencoespressioni1
[bloccoistruzioni1] CASE elencoespressioni2 [bloccoistruzioni2]... CASE ELSE [bloccoistruzioniN]
END SELECT EspressioneTest è un'espressione di tipo numerico o alfanumerico, i
cui valori vengono testati nelle parti CASE per stabilire quali istruzioni
eseguire. In ogni parte CASE vengono indicate una o più espressioni con valori
dello stesso tipo di quella usata come test. Le espressioni delle parti CASE
possono avere i formati: espressione [,espressione] espressione TO espressione
IS operatoreRelazionale espressione Con la prima forma vengono indicati singoli
valori, con la seconda forma intervalli di valori, mentre con la terza forma
viene indicata la relazione che deve essere soddisfatta dai valori. ESEMPI Le
istruzioni dalla 150 alla 260 del programma 5, costituite da una serie di IF
THEN, possono essere sostituite con un'istruzione SELECT. SELECT CASE
OPERAZIONE$ CASE "+" RISULTATO = NUMERO1 + NUMERO2 CASE "-" RISULTATO = NUMERO1
- NUMERO2 CASE "*" RISULTATO = NUMERO1 * NUMERO2 CASE "/" RISULTATO = NUMERO1 /
NUMERO2 END SELECT
L'ISTRUZIONE ON ... GOTO
Nelle prime versioni di Basic l'unico modo possibile per codificare
un'alternativa multipla era l'istruzione ON ... GOTO. Questa istruzione è ancora
disponibile ma non è mai necessario usarla; è sempre preferibile usare
l'istruzione SELECT. Anche l'istruzione SELECT comunque può sempre essere
sostituita da una o più istruzioni IF THEN. ON espressione% GOTO elencorighe In
base al valore dell'espressione viene effettuato un salto ad una delle righe
specificate nell'elenco; se l'espressione ha valore 1 viene effettuato un salto
al primo numero di riga indicato, se ha valore 2 viene effettuato un salto al
secondo numero di riga indicato e così via. PROGRAMMA 5 - LE QUATTRO OPERAZIONI
Questo programma permette di eseguire a scelta una delle quattro operazioni
aritmetiche, inserendo il simbolo dell'operazione richiesta e gli operandi su
cui eseguire l'operazione. Descrizione delle variabili
+----------------------------------------------------------------+
¦ NOME ¦ TIPO ¦ I/O ¦ SIGNIFICATO ¦
+-----------+-------------+------------------+-------------------¦
¦OPERAZIONE ¦alfanumerico ¦ input/output ¦ simbolo della ¦
¦ ¦ ¦ ¦ operazione da ¦
¦ ¦ ¦ ¦ eseguire ¦
¦ NUMERO1 ¦numero reale ¦ input/output ¦ primo operando ¦
¦ NUMERO2 ¦numero reale ¦ input/output ¦ secondo operando ¦
¦RISULTATO ¦numero reale ¦ output ¦ risultato della ¦
¦ ¦ ¦ ¦ operazione ¦
+----------------------------------------------------------------+
Flow chart Programma 5 (prima parte)
Flow chart Programma 5 (seconda parte) Pseudocodifica (vedi Figura)
1 inizio
2 emissione menu
3 emissione richiesta operazione scelta
4 lettura OPERAZIONE
5 emissione richiesta primo operando
6 lettura NUMERO1
7 emissione richiesta secondo operando
8 lettura NUMERO2
9 se OPERAZIONE = "+" allora
10 RISULTATO = NUMERO1 + NUMERO2
11 fine se
12 se OPERAZIONE = "-" allora
13 RISULTATO = NUMERO1 - NUMERO2
14 fine se
15 se OPERAZIONE = "*" allora
16 RISULTATO = NUMERO1 * NUMERO2
17 fine se
18 se OPERAZIONE = "/" allora
19 RISULTATO = NUMERO1 / NUMERO2
20 fine se
21 emissione NUMERO1 OPERAZIONE NUMERO2 "=" RISULTATO
22 fine
2 Stampa del menu; un menu è un elenco delle scelte che si
possono fare. In questo caso le voci del menu saranno quattro, una per ogni
operazione; ogni voce potrebbe essere scelta con un numero o una lettera
abbinati, ma in questo frangente è preferibile associare ad ogni operazione il
simbolo dell'operazione stessa. Le scelte possibili sono comunque fissate dal
programmatore e devono essere facilmente individuabili dall'utente. Nel
programma bisogna poi stabilire quali istruzioni devono essere eseguite per ogni
possibile scelta. 4 Il programma si arresta dopo aver stampato il menu e
richiesto all'utente la voce da eseguire; l'utente deve inserire uno dei simboli
previsti dal menu, quindi uno dei quattro simboli di operazione, scegliendo così
quale operazione eseguire. 5-8 Con queste istruzioni vengono richiesti e
inseriti gli operandi. da 9 a 20 Queste istruzioni condizionali servono a
individuare il simbolo inserito e ad eseguire l'operazione corrispondente; così
se è stato inserito il + viene eseguita l'addizione, se è stato inserito il -
viene eseguita la sottrazione e così via. Sono strutture condizionali con un
solo ramo e una sola istruzione. N.B. L'utente inserisce un solo simbolo, ma il
programma deve prevedere che cosa fare per ciascuno dei quattro simboli; così le
strutture condizionali sono quattro. 21 La stampa del risultato può essere fatta
in modo unico per tutte le operazioni. Invece del solo risultato viene stampata
l'operazione eseguita (primo operando, simbolo di operazione, secondo operando)
con il risultato dopo il simbolo di =. L'uguale è tra apici perché è costante ma
il simbolo di operazione varia secondo l'operazione eseguita ed è contenuto
nella variabile OPERAZIONE. Programma in Basic
10 REM Esecuzione delle quattro operazioni aritmetiche
20 PRINT "LE QUATTRO OPERAZIONI"
30 PRINT
40 PRINT TAB(10); "+ ADDIZIONE"
50 PRINT TAB(10); "- SOTTRAZIONE"
60 PRINT TAB(10); "* MOLTIPLICAZIONE"
70 PRINT TAB(10); "/ DIVISIONE"
80 PRINT
90 PRINT "Operazione scelta"
100 INPUT OPERAZIONE$
110 PRINT "Inserire il primo operando"
120 INPUT NUMERO1
130 PRINT "Inserire il secondo operando"
140 INPUT NUMERO2
150 IF OPERAZIONE$ = "+" THEN
160 RISULTATO = NUMERO1 + NUMERO2
170 END IF
180 IF OPERAZIONE$ = "-" THEN
190 RISULTATO = NUMERO1 - NUMERO2
200 END IF
210 IF OPERAZIONE$ = "*" THEN
220 RISULTATO = NUMERO1 * NUMERO2
230 END IF
240 IF OPERAZIONE$ = "/" THEN
250 RISULTATO = NUMERO1 / NUMERO2
260 END IF
270 PRINT NUMERO1; " "; OPERAZIONE$;" "; NUMERO2; "= ";
RISULTATO
280 END da 40 a 70 Stampa del menu; le scritte vengono posizionate a
colonna 10 per mezzo dell'istruzione TAB. 90-100 Bisogna inserire il simbolo
relativo all'operazione scelta; i simboli possibili sono + - * e /. Se si
inserisce un carattere diverso da questi non viene eseguita nessuna operazione
perché non si entra in alcuna delle quattro strutture condizionali, ma la riga
270 che stampa il risultato viene eseguita comunque e si ha così un risultato
senza senso. Bisognerebbe quindi aggiungere un controllo sulla validità del
simbolo inserito. da 110 a 140 Inserimento degli operandi; si tratta di numeri
reali. 150 L'istruzione IF permette di codificare la struttura condizionale; non
c'è l'ELSE perché la struttura condizionale in questo caso è formata da un solo
ramo. 170 L'istruzione END IF indica la fine della prima istruzione IF. 180 Se
il simolo di operazione è + viene eseguita l'addizione. da 180 a 260 Le altre
strutture condizionali per eseguire sottrazione, moltiplicazione e divisione.
N.B. Non sarebbe stato possibile scrivere RISULTATO = NUMERO1 OPERAZIONE NUMERO2
per eseguire l'operazione corrispondente! Sarebbe stato possibile sostituire a
questi quattro IF l'istruzione SELECT CASE. 270 Stampa del risultato; i punti e
virgola servono per stampare un dato subito dopo l'altro; gli spazi tra
virgolette servono per lasciare uno spazio tra un dato e l'altro; se i numeri
sono positivi vengono lasciati due spazi perché uno rimane bianco al posto del
segno + che non viene stampato.
+----------------------------------------------------------------+
¦ Esempi di esecuzione ¦
¦ ¦
¦ LE QUATTRO OPERAZIONI ¦
¦ ¦
¦ + ADDIZIONE ¦
¦ - SOTTRAZIONE ¦
¦ * MOLTIPLICAZIONE ¦
¦ / DIVISIONE ¦
¦ ¦
¦ Operazione scelta ¦
¦ ? + ¦
¦ Inserire il primo operando ¦
¦ ? 54 ¦
¦ Inserire il secondo operando ¦
¦ ? 270 ¦
¦ 54 + 270 = 324 ¦
+----------------------------------------------------------------+
Commenti Il programma potrebbe causare un errore di esecuzione se si sceglie il
simbolo della divisione e si inserisce 0 come secondo numero; la divisione per 0
è un'operazione impossibile, quindi il programma si arresta con la segnalazione
dell'errore. Non è bene lasciare che nel programma si possano verificare queste
situazioni; il programma dovrebbe quindi essere completato con le istruzioni che
permettono di individuare questa condizione e di segnalarla. Nel programma n. 10
viene controllato questo caso ed è inoltre possibile eseguire più operazioni una
dopo l'altra senza dover lanciare ogni volta il programma come si deve invece
fare in questo caso.
LE ISTRUZIONI PER LA CODIFICA DEI CICLI WHILE E UNTIL
Per la codifica dei cicli WHILE e UNTIL sono disponibili diversi formati di
istruzioni. L'istruzione WHILE...WEND permette di codificare il ciclo WHILE.
WHILE condizione [bloccoistruzioni] WEND Il ciclo viene ripetuto mentre la
condizione è verificata; l'uscita dal ciclo si ha quando la condizione diventa
falsa. Il test viene valutato prima di entrare nel ciclo. L'istruzione DO...LOOP
che ammette due diversi formati, equivalenti, permette di codificare sia il
ciclo WHILE che il ciclo UNTIL. Il formato generale è: DO [{WHILE|UNTIL}
condizione] [bloccoistruzioni] LOOP oppure DO [bloccoistruzioni] LOOP [{WHILE|UNTIL}
condizione] Le istruzioni DO WHILE condizione [bloccoistruzioni] LOOP DO [bloccoistruzioni]
LOOP WHILE condizione sono equivalenti, e permettono di codificare un ciclo
WHILE; il ciclo viene ripetuto mentre la condizione è verificata; l'uscita dal
ciclo si ha quando la condizione diventa falsa. Il test viene valutato prima di
entrare nel ciclo. Le istruzioni DO UNTIL condizione [bloccoistruzioni] LOOP DO
[bloccoistruzioni] LOOP UNTIL condizione sono equivalenti e permettono di
codificare un ciclo UNTIL; il ciclo viene ripetuto se la condizione è falsa;
appena la condizione risulta vera si ha l'uscita dal ciclo. Il test viene
valutato solo dopo la prima esecuzione delle istruzioni del ciclo.
SUGGERIMENTI
Pur essendo equivalenti le forme DO WHILE condizione DO [bloccoistruzioni] [bloccoistruzioni]
LOOP WHILE condizione DO UNTIL condizione DO [bloccoistruzioni] [bloccoistruzioni]
LOOP LOOP UNTIL condizione è preferibile usare la forma DO WHILE condizione [bloccoistruzioni]
LOOP per il ciclo WHILE, e la forma DO [bloccoistruzioni] LOOP UNTIL condizione
per il ciclo UNTIL. In questo modo si ricorda anche formalmente che nel ciclo
while la condizione viene provata prima di entrare nel ciclo, mentre nel ciclo
until viene provata soltanto dopo aver già eseguito una volta le istruzioni del
ciclo. E' possibile anche la forma DO [bloccoistruzioni] LOOP senza condizione
di uscita; in tal caso il blocco di istruzioni deve contenere l'istruzione EXIT,
generalmente condizionata da un'istruzione IF, per garantire l'uscita dal ciclo.
Questa forma comunque è poco leggibile ed è preferibile sostituirla sempre con
uno dei formati descritti precedentemente. PROGRAMMA 6 - INDOVINARE UN NUMERO
PER TENTATIVI Questo programma è un gioco; il computer "pensa" un numero e il
giocatore deve indovinare di che numero si tratta procedendo per tentativi; il
computer fornisce delle indicazioni precisando se il numero da indovinare è più
alto o più basso di quello inserito dal giocatore. Il numero "pensato" dal
computer viene prodotto da una funzione di generazione di numeri casuali o
random. Descrizione delle variabili
+----------------------------------------------------------------+
¦ NOME ¦ TIPO ¦ I/O ¦ SIGNIFICATO ¦
+-----------+-------------+------------------+-------------------¦
¦ RISPOSTA ¦alfanumerico ¦ input ¦ risposta alla ¦
¦ ¦ ¦ ¦ domanda di ¦
¦ ¦ ¦ ¦ continuazione ¦
¦ MASSIMO ¦numero intero¦ input ¦ massimo numero ¦
¦ ¦ ¦ ¦ possibile ¦
¦ NUMERO ¦numero intero¦ output ¦ numero da ¦
¦ ¦ ¦ ¦ indovinare ¦
¦ TENTATIVI ¦numero intero¦ output ¦ numero dei ¦
¦ ¦ ¦ ¦ tentativi ¦
¦ ¦ ¦ ¦ effettuati per ¦
¦ ¦ ¦ ¦ indovinare il ¦
¦ ¦ ¦ ¦ numero ¦
¦ PROVA ¦numero intero¦ input ¦ tentativo di ¦
¦ ¦ ¦ ¦ indovinare ¦
+----------------------------------------------------------------+
Flow chart Programma 6 (prima parte)
Flow chart Programma 6 (seconda parte) Pseudocodifica (vedi Figure)
1 inizio
2 inzializzazione dei numeri random
3 emissione richiesta massimo numero
4 lettura MASSIMO
5 emissione richiesta di giocare
6 lettura RISPOSTA
7 mentre RISPOSTA = "S"
8 NUMERO = numero casuale compreso tra 0 e MASSIMO
9 TENTATIVI = 0
10 emissione limiti valori (0 e MASSIMO)
11 ripeti
12 emissione richiesta numero
13 lettura PROVA
14 TENTATIVI = TENTATIVI + 1
15 se PROVA NUMERO allora
16 emissione messaggio "Troppo basso"
17 fine se
18 se PROVA > NUMERO allora
19 emissione messaggio "Troppo alto"
20 fine se
21 finché PROVA = NUMERO
22 emissione messaggio "Indovinato" e
TENTATIVI
23 emissione richiesta di continuare a giocare
24 lettura RISPOSTA
25 fine mentre
26 fine 2 I numeri random non sono veramente casuali, ma sono il
prodotto di un algoritmo; il valore iniziale fornito all'algoritmo determina la
serie di numeri casuali da produrre; se il valore fornito è sempre lo stesso
viene prodotta sempre la stessa serie di numeri; questa istruzione serve quindi
per inizializzare l'algoritmo di generazione dei numeri casuali. 3-4 Con queste
istruzioni viene richiesto il massimo numero possibile; il numero pensato dovrà
essere compreso tra 0 e il valore inserito; essendo MASSIMO un numero intero, il
numero più grande possibile è 32767. 5-6 Rispondendo N a questa domanda il
programma termina senza proporre nessun numero. Poiché si entra nel ciclo while
soltanto se la condizione è vera il programma termina anche se si inserisce
qualsiasi altro carattere diverso da S. (Si noti S maiuscolo; anche il carattere
s minuscolo farebbe terminare il programma; per rendere valido anche questo
carattere bisogna modificare la condizione in mentre RISPOSTA = "S" o RISPOSTA =
"s" 8 Generazione del numero casuale compreso tra 0 e il numero inserito. 9 La
variabile TENTATIVI è un contatore, posto inizialmente a zero, che permette di
contare i tentativi fatti per indovinare il numero. da 11 a 21 Il programma
chiede di inserire un numero finché il numero inserito è uguale al numero
generato dal programma; conviene usare un ciclo until perché il giocatore dovrà
sempre inserire almeno un numero per indovinare. 12-13 Il giocatore deve
inserire il numero che ritiene il computer abbia "pensato". Deve essere un
numero intero compreso tra 0 e il numero massimo inserito all'inizio del
programma. da 15 a 17 Se il numero inserito è più basso di quello generato dal
programma viene emesso il messaggio "troppo basso". da 18 a 20 Se il numero
inserito è più alto di quello generato dal programma viene emesso il messaggio
"troppo alto. T indispensabile per gestire questo caso usare un'altra struttura
condizionale e non la parte ELSE della struttura precedente. Infatti se si
scrivesse se PROVA NUMERO allora emissione messaggio "Troppo basso" altrimenti
emissione messaggio "Troppo alto" fine se verrebbe emesso il messaggio "troppo
alto" anche quando il giocatore riesce ad indovinare il numero. 22 Quando il
giocatore ha indovinato il numero, compare il messaggio che lo avverte
precisando quanti tentativi ha dovuto fare per riuscire. 23-24 Dopo aver
indovinato, viene chiesto al giocatore se vuole giocare ancora; se la risposta è
S il programma continua dalla riga 8, generando un altro numero, altrimenti
termina. Programma in Basic
10 REM "Gioco di indovinare un numero per tentativi"
20 RANDOMIZE
30 PRINT "Inserire il massimo numero possibile"
40 INPUT MASSIMO%
50 PRINT "Vuoi giocare?(S/N)"
60 INPUT RISPOSTA$
70 DO WHILE RISPOSTA$ = "S"
80 NUMERO% =
INT((MASSIMO% + 1) * RND)
90 TENTATIVI% = 0
100 PRINT "Indovina il numero che ho pensato tra
0 e"; MASSIMO%
110 DO
120 PRINT "Quale numero?"
130 INPUT PROVA%
140 TENTATIVI% = TENTATIVI% + 1
150 IF PROVA% NUMERO% THEN
160 PRINT "Troppo basso"
170 END IF
180 IF PROVA% > NUMERO% THEN
190 PRINT "Troppo alto"
200 END IF
210 LOOP UNTIL PROVA% = NUMERO%
220 PRINT "Hai indovinato con"; TENTATIVI%; "
tentativi"
230 PRINT
240 PRINT "Vuoi giocare ancora?(S/N)"
250 INPUT RISPOSTA$
260 LOOP
270 END 20 Questa istruzione inizializza il generatore di numeri
casuali; poiché non viene precisato nel programma il valore da utilizzare come
seme del generatore il programma si arresta e chiede al giocatore di inserire un
numero compreso tra -32768 e 32767. Per evitare che il programa chieda al
giocatore questo numero si poteva sfruttare il valore fornito dall'orologio del
sistema. 30 Per la codifica del ciclo while si poteva usare anche l'istruzione
WHILE ... WEND oppure scrivere la condizione dopo LOOP alla riga 260; la forma
usata è però preferibile perché ricorda che la condizione viene testata prima di
entrare nel ciclo. 80 RND è la funzione che genera un numero casuale; i numeri
generati sono compresi tra 0 e 1; l'espressione INT(MASSIMO% + 1) * RND) serve a
fare in modo che il numero sia compreso tra 0 e il valore contenuto nella
variabile MASSIMO%, inserito dal giocatore all'inizio del programma. 110 Inizio
del ciclo UNTIL che si conclude alla riga 210. La condizione di uscita dal ciclo
poteva essere scritta anche in questa riga; la forma usata è però preferibile
perché ricorda che la condizione viene testata solo dopo aver eseguito il ciclo
una volta.
+----------------------------------------------------------------+
¦ Esempi di esecuzione ¦
¦ ¦
¦ Seme numeri casuali (da -32768 a 32767)? 72 ¦
¦ Vuoi giocare?(S/N) ¦
¦ ? S ¦
¦ Inserire il massimo numero possibile ¦
¦ ? 100 ¦
¦ Indovina il numero che ho pensato tra 0 e 100 ¦
¦ Quale numero? ¦
¦ ? 30 ¦
¦ Troppo basso ¦
¦ Quale numero? ¦
¦ ? 60 ¦
¦ Troppo basso ¦
¦ Quale numero? ¦
¦ ? 90 ¦
¦ Troppo alto ¦
¦ Quale numero? ¦
¦ ? 80 ¦
¦ Troppo basso ¦
¦ Quale numero? ¦
¦ ? 85 ¦
¦ Troppo basso ¦
¦ Quale numero? ¦
¦ ? 88 ¦
¦ Troppo basso ¦
¦ Quale numero? ¦
¦ ? 89 ¦
¦ Hai indovinato con 7 tentativi ¦
¦ Vuoi giocare ancora?(S/N) ¦
¦ N ¦
+----------------------------------------------------------------+
Commenti Per indovinare facilmente il numero proposto dal computer si può
sfruttare la strategia della ricerca dicotomica. Supponendo che il massimo
numero possibile sia 100 e che il numero pensato dal computer sia 68 si potrebbe
procedere in questo modo: inserire come primo tentativo la metà del massimo
numero possibile, cioè 50; il programma risponderà "troppo basso"; tutti i
numeri minori di 50 sono così già esclusi dalla ricerca; il numero da indovinare
dovrà quindi essere compreso tra 50 e 100; si può inserire a questo punto il
valore che sta nel mezzo di questo intervallo, cioè 75; il programma risponderà
"troppo alto"; sapremo così che il numero cercato è compreso tra 50 e 75; si può
quindi procedere sempre allo stesso modo inserendo 63; il programma risponderà
"troppo basso" restringendo l'intervallo di ricerca ai numeri compresi tra 63 e
75; inserendo 69 il programma risponderà "troppo alto" e si saprà che il numero
deve essere compreso tra 63 e 69, e con un altro paio di tentativi si riuscirà
ad indovinare. Non è importante che il numero inserito sia la metà esatta
dell'intervallo in cui è compreso il numero da indovinare (questo a volte
potrebbe costringere a noiosi calcoli mentali); l'importante è che sia vicino
alla metà in modo da poter escludere ad ogni tentativo metà dei valori
possibili.
L'ISTRUZIONE FOR NEXT
L'istruzione FOR NEXT permette di codificare il ciclo FOR. FOR contatore =
inizio TO fine [STEP incremento] [bloccoistruzioni] NEXT [contatore
[,contatore].. ] Il contatore deve essere una variabile numerica; il valore
iniziale deve essere minore del valore finale se l'incremento è positivo,
viceversa deve essere maggiore se l'incremento è negativo. Se l'incremento non è
specificato viene assunto uguale a 1. Più istruzioni FOR NEXT possono essere
nidificate; in questo caso il nome della variabile contatore deve essere diverso
per ogni istruzione FOR. Dopo la parola NEXT il contatore può essere indicato o
omesso; se viene omesso, il NEXT si riferisce al FOR indicato per ultimo; si
possono specificare più contatori per chiudere con un solo NEXT più cicli FOR
nidificati. In ogni caso se più cicli FOR sono nidificati bisogna specificare
prima il NEXT per il ciclo più interno e per ultimo il NEXT per il ciclo più
esterno. ESEMPI Cicli FOR nidificati; il programma stampa ad ogni ripetizione
gli indici dei due cicli FOR nidificati per evidenziare come procede
l'esecuzione. FOR I% = 1 TO 3 FOR J% = 1 TO 2 PRINT I%,J% NEXT J%,I% Fissato I a
1, J varia da 1 a 2; poi viene incrementato I al valore 2 e J varia di nuovo da
1 a 2; poi I raggiunge il valore 3 e J varia di nuovo ad 1 a 2 producendo in
output:
1 1
1 2
2 1
2 2
3 1
3 3
PROGRAMMA 7 - STAMPA DELLA TAVOLA PITAGORICA
Questo programma stampa la tavola pitagorica, cioè la famosa tavola delle tabelline.
E' possibile scegliere quanti valori devono comparire nelle righe e nelle colonne; normalmente la tavola pitagorica viene proposta per i numeri fino a 10 ma con questo programma si potrà scegliere un numero inferiore o superiore.
Descrizione delle variabili
+----------------------------------------------------------------+
¦ NOME ¦ TIPO ¦ I/O ¦ SIGNIFICATO ¦
+-----------+-------------+------------------+-------------------¦
¦ N ¦numero intero¦ input ¦ampiezza della ta- ¦
¦ ¦ ¦ ¦vola pitagorica ¦
¦ I, J ¦numeri interi¦ interni ¦numeri sulla riga ¦
¦ ¦ ¦ ¦colonna considerata¦
¦ VALORE ¦numero intero¦ output ¦valore nella ¦
¦ ¦ ¦ ¦casella della ¦
¦ ¦ ¦ ¦tavola pitagorica ¦
+----------------------------------------------------------------+
Flow chart Programma 7a (prima parte)
Flow chart Programma 7a (seconda parte)
Pseudocodifica (vedi Figure)
1 inizio 2 emissione richiesta ampiezza tavola
pitagorica 3 lettura N 4 per I da 1 a N con passo 1 5 per J da 1 a N con passo 1
6 VALORE = I * J 7 emissione VALORE 8 fine per 9 emissione ritorno a capo riga
10 fine per 11 fine 2-3 Viene richiesto il numero di righe e di colonne della
tavola pitagorica; il numero massimo per ottenere una stampa facilmente
leggibile dipende dal numero di posizioni occupate; utilizzando quattro
posizioni per ogni valore della tavola e fornendo l'output a video (80 colonne)
il numero massimo è 20; mandando l'output alla stampante e utilizzando un
formato di stampa per esempio a 132 colonne si può arrivare fino a 33. da 4 a 10
Vengono utilizzati due cicli FOR nidificati per calcolare i valori della tavola
pitagorica e stamparli in forma tabellare. 4 Inizio del primo ciclo FOR; il
ciclo viene ripetuto N volte. 5 Inizio del secondo ciclo FOR; il ciclo viene
ripetuto N volte per ogni valore di I (e quindi in totale N * N volte). L'indice
dei due cicli deve essere diverso poiché i cicli sono uno interno all'altro. 6
Ciascun valore della tavola è dato dal prodotto del numero di riga per il numero
di colonna. 9 Tutti i valori calcolati dal ciclo FOR più interno vengono
stampati sulla stessa riga ottenendo una riga della tavola pitagorica; prima di
incrementare l'indice del ciclo FOR più esterno si effettua un posizionamento a
una nuova riga. Programma in Basic 10 REM Tavola Pitagorica 20 PRINT "Inserire
l'ampiezza della tavola pitagorica" 30 INPUT N% 40 PRINT 50 FOR I% = 1 TO N% 60
FOR J% = 1 TO N% 70 VALORE% = I% * J% 80 PRINT USING ""; VALORE%; 90 NEXT J% 100
PRINT 110 NEXT I% 120 END
50 Inizio del ciclo FOR più esterno che si chiude alla riga 110. 60 Inizio del ciclo FOR più interno che si chiude alla riga 90. 80 Stampa di un valore della tavola; con l'istruzione PRINT USING si fa in modo che ogni valore occupi esattamente quattro posizioni in modo da incolonnare i valori e da lasciare uno spazio libero tra un valore e l'altro. 90 Fine del ciclo FOR interno; viene incrementato J e l'esecuzione prosegue dalla riga 60 (se J non è diventato maggiore di N). 110 Fine del ciclo FOR esterno; viene incrementato I e l'esecuzione prosegue dalla riga 50 (se I non è diventato maggiore di N).
+----------------------------------------------------------------+
¦ Esempi di esecuzione ¦
¦ ¦
¦ Inserire l'ampiezza della tavola pitagorica ¦
¦ ? 10 ¦
¦ ¦
¦ 1 2 3 4 5 6 7 8 9 10 ¦
¦ 2 4 6 8 10 12 14 16 18 20 ¦
¦ 3 6 9 12 15 18 21 24 27 30 ¦
¦ 4 8 12 16 20 24 28 32 36 40 ¦
¦ 5 10 15 20 25 30 35 40 45 50 ¦
¦ 6 12 18 24 30 36 42 48 54 60 ¦
¦ 7 14 21 28 35 42 49 56 63 70 ¦
¦ 8 16 24 32 40 48 56 64 72 80 ¦
¦ 9 18 27 36 45 54 63 72 81 90 ¦
¦ 10 20 30 40 50 60 70 80 90 100 ¦
¦ ¦
¦ La rappresentazione grafica della tavola pitagorica può essere ¦
¦ migliorata aggiungendo opportune intestazioni. ¦
¦ La tavola diventa molto più comprensibile stampando i fattori ¦
¦ considerati per ogni riga e colonna. ¦
+----------------------------------------------------------------+
Flow chart Programma 7b Pseudocodifica (vedi Figura)
1 inizio
2 emissione richiesta ampiezza tavola pitagorica
3 lettura N
4 per J da 1 a N con passo 1
5 emissione J
6 fine per
7 emissione ritorno a capo riga
8 per I da 1 a N con passo 1
9 emissione I
10 per J da 1 a N con passo 1
11 VALORE = I * J
12 emissione VALORE
13 fine per
14 emissione ritorno a capo riga
15 fine per
16 fine
da 4 a 6 Stampa della riga con i fattori. Come indice di questo ciclo può essere usata indifferentemente la variabile J o la variabile I, o una variabile con qualsiasi altro nome. 9 Stampa della colonna con i fattori; la stampa di ogni fattore viene fatta nel ciclo FOR esterno, prima dell'inizio del ciclo di stampa dei valori calcolati per quella riga. Programma in Basic
10 REM Tavola Pitagorica
20 PRINT "Inserire l'ampiezza della tavola pitagorica"
30 INPUT N%
40 PRINT
50 PRINT " ";
60 FOR J% = 1 TO N%
70 PRINT USING "
"; J%; 80 NEXT J% 90 PRINT 100 PRINT 110 FOR I% = 1 TO N% 120 PRINT USING " "; I%; 130 PRINT " "; 140 FOR J% = 1 TO N% 150 VALORE% = I% * J% 160 PRINT USING " "; VALORE%; 170 NEXT J% 180 PRINT 190 NEXT I% 200 END 50 Queste spaziature servono per posizionare i fattori sopra alle colonne con i valori. da 60 a 80 Ciclo per la stampa della riga di intestazione con i fattori. 90 Questa istruzione PRINT serve per andare a capo dopo la stampa dei fattori; la successiva per lasciare una riga vuota. 120 Stampa del fattore della colonna che occupa due posizioni. 130 Spaziatura di due caratteri prima di iniziare la stampa della riga dei valori della tavola.
+----------------------------------------------------------------+
¦ Esempi di esecuzione ¦
¦ ¦
¦ Inserire l'ampiezza della tavola pitagorica ¦
¦ ? 10 ¦
¦ ¦
¦ 1 2 3 4 5 6 7 8 9 10 ¦
¦ ¦
¦ 1 1 2 3 4 5 6 7 8 9 10 ¦
¦ 2 2 4 6 8 10 12 14 16 18 20 ¦
¦ 3 3 6 9 12 15 18 21 24 27 30 ¦
¦ 4 4 8 12 16 20 24 28 32 36 40 ¦
¦ 5 5 10 15 20 25 30 35 40 45 50 ¦
¦ 6 6 12 18 24 30 36 42 48 54 60 ¦
¦ 7 7 14 21 28 35 42 49 56 63 70 ¦
¦ 8 8 16 24 32 40 48 56 64 72 80 ¦
¦ 9 9 18 27 36 45 54 63 72 81 90 ¦
¦ 10 10 20 30 40 50 60 70 80 90 100 ¦
+----------------------------------------------------------------+
Flow chart Programma 5 (prima parte)
Flow chart Programma 5 (seconda parte) Pseudocodifica (vedi Figura)
Flow chart Programma 6 (prima parte)
Flow chart Programma 6 (seconda parte) Pseudocodifica (vedi Figure)
Flow chart Programma 7a (prima parte)
Flow chart Programma 7b Pseudocodifica (vedi Figura)
Flow chart Programma 7a (seconda parte)
