Puoi provare ad eseguire il programma copiando e incollando quanto segue:
10 PRINT "Introduci il totale"; 20 INPUT tot 30 PRINT "Introduci il numero delle persone che pagano" 40 INPUT N 50 PRINT "Ciascuno paga "; tot/N 60 GOTO 30 |
Quando compare "?" invece che cliccare [ok] puoi premere "a capo".
Ricarica (o "Aggiorna") per introdurre ed eseguire un nuovo programma
Questa è una versione equivalente:
10 INPUT "Introduci il totale "; tot 30 PRINT "Introduci il numero delle persone che pagano" 40 INPUT N 50 PRINT "Ciascuno paga "; tot/N 60 GOTO 30 |
Qualche spiegazione. Ogni riga del programma è preceduta da un numero intero (0, 1, 2, ..., 10,..., 200, ...) che rappresenta l'ordine di esecuzione. Nelle istruzioni di INPUT puoi far precedere la varibile di input ("tot" o "N" nell'esempio) da un commento racchiuso tra " e seguito da un punto e virgola.
I comandi (INPUT, PRINT, ...) possono essere scritti in maiuscolo o minuscolo. Come variabili si possono usare singole lettere o più lettere, eventualmente seguite da una o più cifre; nel caso delle varibili le dimensioni contano: x e X sono considerate variabili diverse.
Dopo PRINT si possono mettere più uscite, separate da ";" per averle appiccicate, separate da "," per avere separate da alcuni caratteri:
10 print 2;30;4 2304
20 print 2,30,4 2 30 4
| Nel caso di un programma come quello a fianco (in cui "SQR" indica la "radice quadrata") si piò ottenere l'uscita "Infinity" quando il programma si trova a fare la divisione 5/0, a indicare che se si dividesse un numero positivo per un numero piccolissimo si otterrebbe un numero grandissimo. Si ottiene l'uscita "NaN", che sta per "non è un numero", quando si trova di fronte al calcolo di 0/0. |
10 INPUT "x = ? "; x 20 PRINT "x/(SQR(4)-2) = ", x/(SQR(4)-2) 30 GOTO 10 |
Di fronte al programma 10 PRIMT 2+3 compare un messaggio che inizia con "ERROR" a indicare che si è scritto un comando in modo errato.
| In una riga si possono inserire più comandi, separati da un due punti (:). Si possono utilizzare come input ed output oltre ai numeri anche "testi", ossia sequenze di lettere, racchiuse tra virgolette ("). Se una variabile viene usata per memorizzare un testo occorre che il suo nome finisca con $. Posso concatenere più uscite usando un "+" o un ";". Posso usare anche ",", con effetti diversi: | 10 a$ = "2"+"3" : b = 3/4 20 PRINT "pippo" + a$ + "; " + b  |
 |
Un'altra istruzione importante: IF ... THEN ... ("se ... allora ..."). Vediamo anche come si scrivono "≠", "≥" e "≤" ?
10 input "A = "; A 20 input "B = "; B 30 if A <> B then print "A diverso da B" 40 if A >= B then print "A maggiore o uguale a B" 50 if A <= B then print "A minore o uguale a B" 60 if A > B then print "A maggiore di B" 70 if A < B then print "A minore di B" 80 if A = B then print "A uguale a B" 90 goto 10 |
L'elevamento alla potenza nei comandi viene indiato con "^". Nelle uscite una potenza di 10 viene indicata facendo precedere l'esponente da "e". Anche nell'intodurre un numero come input si può usare questa notazione. Esempi:
10 print 10^24, 10^-20 -> 1e+24 1e-20
10 input x : print x -> Introduco 10.5e3 Ottengo 10500
Di seguito sono indicate le principali parole chiave della versione del BASIC che stiamo usando, cioè le parole "riservate" che in tale linguaggio si utilizzano per indicare comandi, funzioni, … Le parole chiave possone essere scritte sia in maiuscolo che in minuscolo. Sono riportati anche vari esempi d'uso (clicca, qui sotto, la parola chiave per accedere ai relativi esempi). Altri esempi sono riportati più avanti.
Classe Parole chiave comprese nella classe -------------------------------- ------------------------------------- Controllo del flusso END, FOR...NEXT, IF...THEN..ELSE del programma GOSUB...RETURN, GOTO, WHILE...WEND Commenti REM (o ') Dichiarazione di costanti e va- DATA, DIM, READ riabili, assegnazione di valori Periferica di input/output CLS, INPUT, PRINT Elaborazione delle stringhe ASC, CHR$, INSTR, LEFT$, LEN MID$, RIGHT$, STR$, STRING$, VAL Esecuzione di calcoli ^ , ABS, ASC, COS, INT, RND, SIN SQR, TAN, < > =, OR, AND, true/false |
05 I=1 10 A = RND : PRINT A; 15 IF A > 1/2 THEN PRINT " > 1/2" ELSE PRINT " < 1/2" 20 I = I+1 : IF I=11 THEN END 35 GOTO 10 0.3309791684150696 < 1/2 0.9956300258636475 > 1/2 0.9195851683616638 > 1/2 0.33149659633636475 < 1/2 0.731931746006012 > 1/2 0.05961799621582031 < 1/2 0.17708414793014526 < 1/2 0.4606109857559204 < 1/2 0.889754593372345 > 1/2 0.2006514072418213 < 1/2
05 REM i primi 10 interi positivi, e quelli dispari 10 for i=1 to 10 : print i+" "; : next 20 print 30 for i=1 to 10 step 2: print i+" "; : next 1 2 3 4 5 6 7 8 9 10 1 3 5 7 9
05 ' pari o dispari? 10 input "N = "; N 20 if N/2 = int(N/2) then gosub 50 else gosub 60 30 goto 10 50 print " numero pari" : return 60 print " numero dispari" : return N = 0 numero pari N = 31 numero dispari N = 17 numero dispari N = 12 numero pari N = ... 10 input "k = "; k 20 gosub 100 : print "il segno di k e' "; sgn 30 goto 10 100 if k=0 then sgn = 0 else sgn = k/abs(k) 110 return ' viene calcolato il segno di k; abs = valore assoluto k = 45 il segno di k e' 1 k = -12 il segno di k e' -1 k = 0 il segno di k e' 0
Dopo IF, WHILE, ... se vuoi mettere più comandi mettili in una riga a cui rinviare con un GOSUB.
10 PRINT "Introduci un qualunque numero" 15 OK=1 20 WHILE OK=1 30 INPUT "N = "; N 40 IF N/2 = INT(N/2) THEN risp$ = "pari" ELSE risp$ = "dispari" 50 PRINT risp$ 60 INPUT "batti 1 per altro numero, 0 per smettere "; OK 70 WEND Introduci un qualunuque numero N = 17 dispari batti 1 per altro numero, 0 per smettere 1 N = 20 pari batti 1 per altro numero, 0 per smettere ...
10 DATA 1,2,3,4,5,6,7,8,9,10 20 READ a,b,c,d,e 30 PRINT a+b+c+d+e 40 READ a,b,c,d,e 50 PRINT a+b+c+d+e 15 40
10 ' Come contare una quantita' di dati messi in DATA 20 data 1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5 30 data 1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5 40 for i=1 to 1000 : read x : cls : print i; : next 65O, meglio, mettendo un dato "strano" alla fine:
10 ' trucco per contare i dati: metto un dato "strano" alla fine 20 data 1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5 30 data 1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5 40 data 13579 50 n=0 : ok=1 : while ok=1 : read x : if x=13579 then ok=0 else n=n+1 : wend 60 print n ' ho contato i dati; sono n 65Vedi anche più avanti
05 ' la somma e il prodotto di 5 numeri 10 dim x(4) 15 ' le varibili indiciate partono dall'indice 0; quindi per 5 dati bastano x(0),...,x(4) 20 for i=0 to 4 : input x(i): next 30 sum=0 : prod=1 40 for i=0 to 4 : sum=sum+x(i) : prod=prod*x(i) : next 50 print "somma = "; sum; ", prodotto = "; prod ? 1 ? 2 ? 3 ? 4 ? 5 somma = 15, prodotto = 120Ovviamente, avrei potuto usare solo x(1),...,x(5):
10 dim x(5) 20 for i=1 to 5 : input x(i): next 30 sum=0 : prod=1 40 for i=1 to 5 : sum=sum+x(i) : prod=prod*x(i) : next 50 print "somma = "; sum; ", prodotto = "; prod
10 INPUT "x = ";x : INPUT "y = ";y 20 PRINT "radice quadrata di x^2+y^2 = "; SQR(x^2+y^2) 30 GOTO 10 x = 3 y = 4 radice quadrata di x^2+y^2 = 5 x = 4 y = 5 radice quadrata di x^2+y^2 = 6.4031242374328485
10 INPUT "introduci A e premi 'a capo' "; A
20 y = 1
30 y = (y + A/y) /2 : print y;" ";
40 input "smetto? (1 SI', 0 NO) "; R
50 if R = 0 then goto 30 else goto 10
introduci A e premi 'a capo' 3
2 smetto? (1 SI', 0 NO) 0
1.75 smetto? (1 SI', 0 NO) 0
1.7321428571428572 smetto? (1 SI', 0 NO) 0
1.7320508100147274 smetto? (1 SI', 0 NO) 0
1.7320508075688772 smetto? (1 SI', 0 NO) 0
1.7320508075688772 smetto? (1 SI', 0 NO)
√3 = 1.732050807568877210 INPUT "x = ";x 20 PRINT "valore assoluto di x = "; ABS(x) 30 PRINT "parte intera di x = "; INT(x) 40 PRINT "arrotondamento agli interi = "; INT(x+1/2) 50 PRINT "arrotondamento ai centesimi = "; INT(x*100+1/2)/100 60 PRINT "arrotondamento alle centinaia x = "; INT(x/100+1/2)*100 70 GOTO 10 x = 12345.6789 valore assoluto di x = 12345.6789 parte intera di x = 12345 arrotondamento agli interi = 12346 arrotondamento ai centesimi = 12345.68 arrotondamento alle centinaia x = 12300
01 ' LEN = lunghezza di una frase, LEFT$(frase,i) carattere i-mo di 02 ' frase da sinistra, RIGHT$(frase,i) carattere i-mo da destra 10 PRINT "Inversione delle lettere di una frase" 15 INPUT "Premi a capo "; x$ 20 CLS 30 INPUT "Scrivi la frase "; frase$ 40 PRINT : PRINT "La frase inverita: "; 50 FOR lettera = 1 TO LEN(frase$) 60 PRINT LEFT$(RIGHT$(frase$,lettera),1); 70 NEXT
05 ' La funzione VAL produce il numero all'inizio di una frase 10 INPUT "batti una frase iniziante con dei numeri "; x$ 20 PRINT VAL(x$) 30 GOTO 10 batti una frase iniziante con dei numeri 75 per 180 75 batti una frase iniziante con dei numeri 12.45 = 1245/100 12.45
05 ' ASC produce la codifica numerica (codice ASCII) di un carattere
06 ' CHR$ produce il carattere corrispondente ad una codifica numerica
10 INPUT "batti un carattere "; x$ : PRINT ASC(x$) : PRINT CHR$(ASC(x$)) : GOTO 10
batti un carattere a
97
a
batti un carattere b
98
b
batti un carattere 0
48
0
batti un carattere 1
49
1
10 print asc("A"), asc("a"), asc("Z"), asc("z"), asc("a")-asc("A")
65 97 90 122 32
10 input "frase "; frase$
20 input "minuscolo (1) o maiuscolo(2) "; d
30 frase2$=""
40 for c=1 to len(frase$) : a$ = mid$(frase$, c, 1) ' carattere c-esimo di frase$
50 if d=2 and asc(a$) > 96 and asc(a$) < 123 then a$ = chr$(asc(a$)-32)
60 if d=1 and asc(a$) > 64 and asc(a$) < 91 then a$ = chr$(asc(a$)+32)
70 frase2$ = frase2$ + a$
80 next : print frase2$ : goto 10
frase Chi sei? Babbo Natale?
minuscolo (1) o maiuscolo(2) 1
chi sei? babbo natale?
frase Chi sei? Babbo Natale?
minuscolo (1) o maiuscolo(2) 2
CHI SEI? BABBO NATALE?
05 ' INSTR(f1,f2) trova dove inizia la sottofrase f2 in f1 10 INPUT "Frase = "; frase$ : INPUT "sotto frase = "; frase1$ 20 PRINT INSTR(frase$, frase1$) 30 GOTO 10 Frase = Che bella giornata! sotto frase = ella 6 Frase = Che bella giornata! sotto frase = essa 0
05 ' STR$ trasforma un numero in una stringa 10 INPUT x 20 PRINT x+x 30 PRINT STR$(x)+STR$(x) 40 GOTO 10 ? 50 100 5050 ? 4.5 9 4.54.5
10 INPUT "Frase = "; frase$ 20 INPUT "Sottofrase dal posto iniziale "; j : INPUT "avanti di "; n 30 PRINT MID$(frase$, j, n) 40 GOTO 10 Frase = Che bella giornata! Sottofrase dal posto iniziale 5 avanti di 9 bella gio
10 text$ = "A" + STRING$(20, "1") + "B" 20 PRINT text$ A11111111111111111111B
10 GOSUB 1000 20 INPUT "gradi = "; gradi 30 PRINT "radianti = "; gradi/180*PI 40 GOTO 20 1000 PI = 3.1415926535897932 RETURN gradi = 90 radianti = 1.5707963267948966 gradi = 360 radianti = 6.283185307179586 gradi = 45 radianti = 0.7853981633974483 gradi = 180 radianti = 3.141592653589793
10 GOSUB 1000 20 INPUT "gradi = "; gradi 30 PRINT "seno = "; SIN(gradi/180*PI) 40 PRINT "coseno = "; COS(gradi/180*PI) 50 PRINT "tangente = "; TAN(gradi/180*PI) 69 PRINT "Devi arrotondare con 2 cifre in meno i risultati" 70 GOTO 20 1000 PI = 3.1415926535897932 RETURN gradi = 30 seno = 0.49999999999999994 coseno = 0.8660254037844387 tangente = 0.5773502691896257 Devi arrotondare con 2 cifre in meno i risultati
10 ' area del poligono P1, P2, ...Pn 20 ' prova con (11,8),(3,13),(1,3),(7,8) 30 n = 4 : for i=1 to n : input "introduci x, poi introduci y "; x(i), y(i) : next 40 area = (y(n)+y(1))*(x(n)-x(1)) 50 for i=1 to n-1 : area = area+(y(i)+y(i+1))*(x(i)-x(i+1)) : next 60 print "area = "; area/2
introduci x, poi introduci y 11 8 introduci x, poi introduci y 3 13 introduci x, poi introduci y 1 3 introduci x, poi introduci y 7 8 area = 35 |  |
10 input "x = "; x : input "y = "; y 20 print "x < y, x > y, x = y, x >= y, x <= y" 30 print x < y, x > y, x = y, x >= y, x <= y 40 goto 10 x = 2 y = 3 x < y, x > y, x = y, x >= y, x <= y true false false false true x = 2 y = 2 x < y, x > y, x = y, x >= y, x <= y false false true true true x = 4.5 y = 3 x < y, x > y, x = y, x >= y, x <= y false true false true false 10 input "nome 1 "; nome1$ : input "nome 2 "; nome2$ 20 print "nome 1 < nome 2 ? "; 30 print nome1$ < nome2$ 40 goto 10 nome 1 paolo nome 2 maria nome 1 < nome 2 ? false nome 1 luigi nome 2 sara nome 1 < nome 2 ? trueInvece delle uscite true e false (come quelle ottenute con la riga 20 del programma sottostante), in alcuni casi si hanno 1 e 0 (come con le righe 25 e 30); 1 e 0 nei programmi si possono usare anche come "vero" e "falso" (vedi le righe 40 e 50).
10 A = 0>1 : B = 1>0 15 print "stampa di A e di B, stampa di A or B, stampa di A and B" 20 print A, B 25 print A or B 30 print A and B 40 V=1 : if V then print "vero" else print "falso" 50 V=0 : if V then print "vero" else print "falso" stampa di A e di B, stampa di A or B, stampa di A and B stampa di A e di B, stampa di A or B, stampa di A and B false true 1 0 vero falso
10 print "A: x e' maggiore di 2 e x e' minore di 5" 20 print "B: x e' minore di 0 o x e' maggiore di 3" 30 input "x "; x 40 if x > 2 and x < 5 then print "A: vero "; else print "A: falso "; 50 if x < 0 or x > 3 then print "B: vero" else print "B: falso" 60 goto 30 A: x e' maggiore di 2 e x e' minore di 5 B: x e' minore di 0 o x e' maggiore di 3 x 3 A: vero B: falso x 1 A: falso B: falso x -2 A: falso B: vero 10 input "x = "; x : input "y = "; y 20 if (x>0 and y>0) or (x<0 and y<0) or (x=0 and y=0) then print "segno uguale" else print "segno diverso" 30 goto 10 x = 3 y = 2 segno uguale x = 3 y = -2 segno diverso x = 0 y = 0 segno uguale
Altri ESEMPI
05 ' Calcolo senza tener conto delle priorita' tra le operazioni 10 INPUT "numero "; x : u$=STR$(x) 20 INPUT "operazione (+,-,*,/,^ o =) "; op$; : u$=u$+" "+op$ : op$=" "+op$+" " 25 ' Ho aggiunto spazi bianchi ai simboli di operazione 40 IF op$=" + " THEN goto 100 50 IF op$=" - " THEN goto 110 60 IF op$=" * " THEN goto 120 70 IF op$=" / " THEN goto 130 80 IF op$=" ^ " THEN goto 140 90 print "Calcolo a catena "+u$+" "+ x : print "" : goto 10 100 INPUT "numero "; y : u$=u$+" "+STR$(y) : x=x+y : print x : goto 20 110 INPUT "numero "; y : u$=u$+" "+STR$(y) : x=x-y : print x : goto 20 120 INPUT "numero "; y : u$=u$+" "+STR$(y) : x=x*y : print x : goto 20 130 INPUT "numero "; y : u$=u$+" "+STR$(y) : x=x/y : print x : goto 20 140 INPUT "numero "; y : u$=u$+" "+STR$(y) : x=x^y : print x : goto 20 numero 20 operazione (+,-,*,/,^ o =) * numero 5 100 operazione (+,-,*,/,^ o =) / numero 40 2.5 operazione (+,-,*,/,^ o =) + numero 11.5 14 operazione (+,-,*,/,^ o =) ^ numero 2 196 operazione (+,-,*,/,^ o =) = Calcolo a catena 20 * 5 / 40 + 11.5 ^ 2 = 196 Invece il calcolo usuale (che tiene conto delle priorità) di 20 * 5 / 40 + 11.5 ^ 2 - che equivale a ( (20 * 5) / 40 ) + (11.5 ^ 2) - avrebbe dato: 10 PRINT 20 * 5 / 40 + 11.5 ^ 2 134.75A differenza di altre applicazioni questa versione del Basic non dà priorità a "^" rispetto a "*"; conviene mettere sempre le parentesi in questi casi:
10 print "2*3^2 = " 2*3^2; ", 2*(3^2) = "; 2*(3^2) 2*3^2 = 36, 2*(3^2) = 18-----------------------------------------------
05 ' Istogramma avente per colonne i 5 dati 127,585,430,1256,148 06 ' Posso modificare lung per avere istogrammi di divesa lunghezza 10 lung=80 : n=5 15 dim dati(n-1) 25 dati(0)=127 : dati(1)=585 : dati(2)=430: dati(3)=1256 : dati(4)=148 30 max=0 : totale = 0 35 for i=0 to n-1 : totale = totale+dati(i) : next 40 for i=0 to n-1 45 p = INT(dati(i)/totale*lung+0.5) 50 s="|" : for k=1 to p : s=s+"#" : next 55 print s + " " + dati(i) 60 next |#### 127 |################## 585 |############## 430 |####################################### 1256 |##### 148 05 ' Istogramma avente per colonne i 5 dati 127,585,430,1256,148 06 ' Posso modificare lung per avere istogrammi di divesa lunghezza 10 lung=150 : n=5 15 dim dati(n-1) 25 dati(0)=127 : dati(1)=585 : dati(2)=430: dati(3)=1256 : dati(4)=148 30 max=0 : totale = 0 35 for i=0 to n-1 : totale = totale+dati(i) : next 40 for i=0 to n-1 45 p = INT(dati(i)/totale*lung+0.5) 50 s="|" : for k=1 to p : s=s+"#" : next 55 print s + " " + dati(i) 60 next |####### 127 |################################## 585 |######################### 430 |########################################################################## 1256 |######### 148 05 'ISTOGRAMMA morti nel 2006 per eta' negli intervalli delimitati da 0, 5, 10,..., 105, 110 10 lung = 400 : n = 22 : DIM x(n-1) 15 DATA 43,5,6,16,23,26,28,37,56,88,141,225,350,518,814,1245,1771,2027,1643,727,195,17 20 for i=0 to n-1: READ x(i) : next 25 tot = 0 : for i=0 to n-1 : totale = totale+x(i) : next 30 for i=0 to n-1 35 p = INT(x(i)/totale*lung+0.5) 40 s="|" : for k=1 to p : s=s+"#" : next 45 print s + " " + x(i) 50 next |## 43 | 5 | 6 |# 16 |# 23 |# 26 |# 28 |# 37 |## 56 |#### 88 |###### 141 |######### 225 |############## 350 |##################### 518 |################################# 814 |################################################## 1245 |####################################################################### 1771 |################################################################################# 2027 |################################################################## 1643 |############################# 727 |######## 195 |# 17Con lo script isto/diagramma:
05 ' mettiamo in ordine i seguenti (24) numeri 10 DATA 43, 5, 36, 16, 23,126, 28, 37, 56,88 15 DATA 141,225,350,518, 7,643,727,195,17, 8 20 DATA 1210, 83, 409, 345 25 n = 24 : dim x(n-1) : for i=0 to n-1: READ x(i) : next 30 for i=0 to n-1 : print x(i)+" "; : next : print "" 35 ' man mano se trovo un numero piu' piccolo lo metto in testa 40 for i=0 to n-1 : for j=i to n-1 45 if x(j) < x(i) then gosub 100 50 next : next 55 for i=0 to n-1 : print x(i)+" "; : next 60 end 100 c=x(i) : x(i)=x(j) : x(j)=c : return 110 ' ho scambiato x(i) e x(j) 43 5 36 16 23 126 28 37 56 88 141 225 350 518 7 643 727 195 17 8 1210 83 409 345 5 7 8 16 17 23 28 36 37 43 56 83 88 126 141 195 225 345 350 409 518 643 727 1210-----------------------------------------------
10 ' Trucco per contare i dati: metto un dato "strano", ad es. 13579, alla fine 20 DATA 43,5,6,16,49,26,28,37,56,88,141,225,330,3,32,78,89,123,73,24,12,7,245 21 DATA 13579 30 n=0 : ok=1 : while ok=1 : read x : if x=13579 then ok=0 else n=n+1 : wend 40 print n ' ho contato i dati; sono n 23 10 n=23 : dim dat(n) 20 data 43,5,6,16,49,26,28,37,56,88,141,225,330,3,32,78,89,123,73,24,12,7,245 30 for i=1 to n : read dat(i) : next 40 min=dat(1) : max=dat(1) : sum=0 50 for i=1 to n : sum=sum+dat(i) 60 if dat(i) < min then min = dat(i) 65 if dat(i) > max then max = dat(i) 70 next : print "min = "; min; " max = "; max; " media = "; sum/n min = 3 max = 330 media = 75.47826086956522-----------------------------------------------
10 print "soluzioni di a*x^2 + b*x + c = 0" 20 input "a = "; A : input "b = "; B : input "c = "; C 30 abc = B*B-4*A*C : if abc<0 then goto 100 40 if abc=0 then goto 200 50 k1 = -B/(A+A)+SQR(abc)/(2*A): k2 = -B/(A+A)-SQR(abc)/(2*A) 60 print "soluzioni: "; k1, k2 : goto 20 100 print "b^2-4*a*c = "; abc; " < 0. Nessuna soluzione." : goto 20 200 print "b^2-4*a*c = 0; 1 soluzione: "; -B/(A+A) : goto 20 soluzioni di a*x^2 + b*x + c = 0 a = 2 b = -1 c = -1 soluzioni: 1 -0.5 a = 2 b = -1 c = 0.125 b^2-4*a*c = 0; 1 soluzione: 0.25 a = 2 b = -1 c = 1 b^2-4*a*c = -7 < 0. Nessuna soluzione.
Lo script equazioni risolve in modo simile altre equazioni: vedi la figura seguente (equazioni più complesse sono risolubili con WolframAlpha).
05 PRINT "introduco P1,P2,P3,... e ho via la distanza P1P2, P1P2P3, ..." 10 L = 0 : INPUT "x = "; x1 : INPUT "y = "; y1 20 INPUT "x = "; x2 : INPUT "y = "; y2 30 L = L + SQR((x2-x1)^2+(y2-y1)^2) 40 PRINT "lunghezza = "; L; : INPUT " Continuo ? (s/n) "; r$ 50 IF r$="s" THEN GOTO 60 ELSE GOTO 5 60 x1=x2 : y1=y2 : GOTO 20
introduco P1,P2,P3,...; via via ho P1P2, P1P2P3, ... x = -1.5 y = 0 x = 0 y = -2 lunghezza = 2.5 Continuo ? (s/n) s x = 1.5 y = 0 lunghezza = 5 Continuo ? (s/n) s x = 0 y = 2 lunghezza = 7.5 Continuo ? (s/n) s x = -1.5 y = 0 lunghezza = 10 Continuo ? (s/n) n |  |
05 ' Lancio una moneta equilibrata 200 volte. 06 ' Qual e' la probabilita' di ottenere 100 testa? 07 ' Provo 10 mila, 20 mila e 30 mila volte 10 n=10^4 : x=0 : for i=0 to n 15 testa=0 : for j=0 to 200 20 if RND>0.5 then testa = testa+1 25 next 30 if testa=100 then x=x+1 35 next : print x/n*100 40 for i=0 to n 45 testa=0 : for j=0 to 200 50 if RND>0.5 then testa = testa+1 55 next 60 if testa=100 then x=x+1 65 next : print x/(n+n)*100 70 for i=0 to n 75 testa=0 : for j=0 to 200 80 if RND>0.5 then testa = testa+1 85 next 90 if testa=100 then x=x+1 95 next : print x/(n+n+n)*100 5.88 5.86 5.576666666666666 La probabilità è circa del 5.6%-----------------------------------------------
| Dove si incontrano la curva Capito dal grafico (fatto con WolframAlpha) che si incontrano tra 0 ed 1, posso usare questo semplice programmino [eventualmente introcudendo la riga |
 |
10 print "soluzione di 2^x-(-2*x+1.5) = 0 tra 0 ed 1" 15 a = 0 : b = 1 20 n = 0 25 m = a+(b-a)/2 30 n=n+1 : x = a : gosub 1000 : gosub 500 : sa = segno 35 x = m : gosub 1000 : gosub 500 : sm = segno 40 if sa = sm then a = m else b = m 50 goto 25 500 segno=0 : if y>0 then segno = 1 501 if y<0 then segno = -1 502 if segno=0 or n = 60 then gosub 600 503 return 600 print "x = "; m : print "- - - - - - - - - - - -" : END 1000 y = 2^x-(-2*x+1.5) : return soluzione di 2^x-(-2*x+1.5) = 0 tra 0 ed 1 x = 0.1825542858240715 - - - - - - - - - - - -Con la riga 45 avrei anche le uscite:
soluzione di 2^x-(-2*x+1.5) = 0 tra 0 ed 1 0.5 n=1 batti 'a capo' 0.25 n=2 batti 'a capo' 0.125 n=3 batti 'a capo' 0.1875 n=4 batti 'a capo' ... 0.18255428582407152 n=53 batti 'a capo' 0.18255428582407146 n=54 batti 'a capo' x = 0.1825542858240715
Il metodo visto, utilizzato per risolvere l'equazione f(x)=0 in un intervallo |  |
10 a = -1 : b = 1 : d = b-a 20 n=4 : gosub 400 : print "n = "; n ; " integrale = "; I 30 n=n*2: gosub 400: print "n = "; n ; " integrale = "; I 40 n=n*2: gosub 400: print "n = "; n ; " integrale = "; I 50 n=n*2: gosub 400: print "n = "; n ; " integrale = "; I 60 n=n*2: gosub 400: print "n = "; n ; " integrale = "; I 100 end 400 h=d/n: s=0: for j=1 to n: x=a+(j-1/2)*h: gosub 500: s=s+y: next: I=s*h: return 500 y = sqr(1-x^2) : return
n = 4 integrale = 1.629683664318002 n = 8 integrale = 1.5919646103059533 n = 16 integrale = 1.5783434656491544 n = 32 integrale = 1.5734759039632609 n = 64 integrale = 1.571745701341119 |
 | |
| L'animazione a fianco illustra il procedimento nel caso in cui la funzione F da integrare nell'intervallo Posso aumentare n (partendo da un numero a 4 cifre) ed aggiungere la stampa della variazione tra una approssimazione e la successiva per rendermi conto della velocità con cui ci si avvicina al risultato "esatto": |
10 a = -1 : b = 1 : d = b-a 20 n=4321 : gosub 400 : print "n = "; n ; " integrale = "; I 30 I0=I: n=n*2: gosub 400: print "n = "; n ; " integrale = "; I; " variaz.= ";I-I0 40 I0=I: n=n*2: gosub 400: print "n = "; n ; " integrale = "; I; " variaz.= ";I-I0 50 I0=I: n=n*2: gosub 400: print "n = "; n ; " integrale = "; I; " variaz.= ";I-I0 60 I0=I: n=n*2: gosub 400: print "n = "; n ; " integrale = "; I; " variaz.= ";I-I0 70 I0=I: n=n*2: gosub 400: print "n = "; n ; " integrale = "; I; " variaz.= ";I-I0 80 I0=I: n=n*2: gosub 400: print "n = "; n ; " integrale = "; I; " variaz.= ";I-I0 100 end 400 h=d/n: s=0: for j=1 to n: x=a+(j-1/2)*h: gosub 500: s=s+y: next: I=s*h: return 500 y = sqr(1-x^2) : return n = 4321 integrale = 1.5707980416799694 n = 8642 integrale = 1.5707969331078167 variaz.= -0.000001108572152741516 n = 17284 integrale = 1.570796541160566 variaz.= -3.919472506552779e-7 n = 34568 integrale = 1.570796402584901 variaz.= -1.385756649430192e-7 n = 69136 integrale = 1.5707963535907532 variaz.= -4.8994147849867886e-8 n = 138272 integrale = 1.5707963362686501 variaz.= -1.732210308524884e-8 n = 276544 integrale = 1.570796330144368 variaz.= -6.12428219248784e-9
| Le variazioni successive sono circa un terzo della precedente. Quindi possiamo prevedere che il valore scenderà di 1/3 + 1/3/3 + ...
ossia di circa 0.44 volte l'ultima variazione ossia di circa -3e-9. Posso prendere 1.570796330-0.000000003 = 1.570796327. Con WolframAlpha posso controllare che questa è un'approssimazione di π/2. Potrei procedere con n maggiori ma mi conviene fermarmi per evitare eventuali errori di arrotondamento: in tutti i problemi concreti servono meno di 10 cifre. |  |
10 a = 0 : b = 3 : d = b-a ... 500 y = ABS(x*(x-2)) : return n = 4321 integrale = 2.666666599728399 n = 8642 integrale = 2.6666666499282217 variaz.= 5.0199822521079795e-8 n = 17284 integrale = 2.666666662482534 variaz.= 1.255431225644088e-8 n = 34568 integrale = 2.6666666656205797 variaz.= 3.138045823192215e-9 n = 69136 integrale = 2.6666666664051637 variaz.= 7.845839533615617e-10 n = 138272 integrale = 2.6666666666012984 variaz.= 1.9613466406553925e-10 n = 276544 integrale = 2.6666666666503493 variaz.= 4.9050985495568966e-11
L'integrale di |x·(x-2)| tra 0 e 3 è 2.666... = 8/3
| Per il grafico posso ricorrere facilmente a WolframAlpha, con |  |
 |
Analogamente si può calcolare la derivata di una funzione F in un punto Q: basta calcolare
la pendenza della retta passante tra il punto del grafico di F di ascissa Q-h e quello di ascissa Q+h per valori di h che tendono a 0.
Vedi la figura a fianco. Troviamo ad esempio la derivata di F: x → (1+x^2)/(1+x^3) in Q = 2: |
10 Q = 2 : h = 0.01 20 for i=1 to 10 30 gosub 200 : print D : h=h/2 40 next 90 end 100 y = (1+x^2)/(1+x^3): return 200 x=Q-h : gosub 100 : y1=y : x=Q+h : gosub 100 : y2=y : D = (y2-y1)/(2*h) : return
-0.2963008229309505 -0.2962974279763775 -0.2962965792176364 -0.29629636702681594 -0.2962963139788499 -0.29629630071692503 -0.29629629740171026 -0.2962962965725069 -0.2962962963636073 -0.2962962963096061 | Potrei aumentare il numero delle uscite, ma devo stare attento a quando incominciano gli errori di arrotodamento.
Se avessi messo "for i=1 to 16" avrei ottenuto anche le uscite seguenti, ma mi sarei subito reso conto che l'ultima non seguiva l'andamento delle altre: -0.29629629630107956
-0.29629629631244825
-0.29629629630107956
-0.29629629625560483
-0.29629629625560483
-0.29629629643750377
|
05 ' min e max della funzione definita in 1000 10 a = -1 : b = 2 : h=b-a 15 x=a : gosub 1000 : fa=y : x=b : gosub 1000 : fb=y 20 min = fa : max = fb : x1=a : x2=b 25 if fa > fb then min = fb : max = fa : x1=b : x2=a 30 for i=1 to 10^6 : x = RND*h+a : gosub 1000 35 if y < min then gosub 1001 40 if y > max then gosub 1002 45 next 50 print "min="+min+" x="+xmin: print "max="+max+" x="+xmax : END 1000 y = 9*sin(x-1)-x^3 : return 1001 min=y : xmin=x : x1=x : return 1002 max=y : xmax=x : x2=x : return min=-8.852992318037892 x=-0.490509569644928 max=0.9879560565027785 x=1.582704246044159 ripeto min=-8.852992318038371 x=-0.4905104637145996 max=0.9879560564804764 x=1.5827046036720276 cambio a = -0.6 : b = -0.4 min=-8.852992318039329 x=-0.490510094165802 min=-8.852992318039334 x=-0.4905100703239441 cambio a = 1.5 : b = 1.6 max=0.9879560566264289 x=1.5827001154422762 max=0.9879560566264276 x=1.582700127363205 Concludendo tra -1 e 2 9*sin(x-1)-x^3 ha: min = -8.852992318 in -0.4905101 max = 0.9879560566264 in 1.5827001Con WolframAlpha:
05 ' I primi numeri di Armstrong: numeri di k cifre uguali alla somma delle cifre elevata alla k 10 n=1 : for a=1 to 9 15 if a=a^n then print a;" "; 20 next 25 n=2 : for a=1 to 9 : for b=0 to 9 30 if a*10+b = a^n+b^n then print a;b;" "; 35 next : next 40 n=3 : for a=1 to 9 : for b=0 to 9 : for c=0 to 9 45 if a*100+b*10+c = a^n+b^n+c^n then print a;b;c;" "; 50 next : next : next 55 n=4: for a=1 to 9: for b=0 to 9: for c=0 to 9: for d=0 to 9 60 if a*1000+b*100+c*10+d = a^n+b^n+c^n+d^n then print a;b;c;d;" "; 65 next : next : next : next 70 n=5: for a=1 to 9: for b=0 to 9: for c=0 to 9: for d=0 to 9: for e=0 to 9 75 if a*10000+b*1000+c*100+d*10+e = a^n+b^n+c^n+d^n+e^n then print a;b;c;d;e;" "; 80 next : next : next : next : next 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 Ad esempio 407 = 4^3+0^3+7^3 = 64+49*7 = 64+343
10 for n=0 to 10
20 x = 1/(2^n) : gosub 100 : print "y(" + x + ") = "+ y
30 next
40 end
100 y = (sin(x)-x)/(x^3) : return
y(1) = -0.1585290151921035
y(0.5) = -0.16459569116637596
y(0.25) = -0.16614660771053202
y(0.125) = -0.16653650676342124
y(0.0625) = -0.16663411761069824
y(0.03125) = -0.16665852883500065
y(0.015625) = -0.16666463217325145
y(0.0078125) = -0.16666615804024332
y(0.00390625) = -0.16666653950960608
y(0.001953125) = -0.16666663487558253
y(0.0009765625) = -0.16666665871161968
Il limite di (sin(x)-x)/(x^3) per x -> 0 è -1/6
10 for n=6 to 16
20 x = 10^n : gosub 100 : print "y("+ x + ") = " + y
30 next
40 end
100 y = (1+x)^(1/5)-x^(1/5) : return
y(1000000) = 0.0000031697851170520153
y(10000000) = 5.023772651213676e-7
y(100000000) = 7.96214294496167e-8
y(1000000000) = 1.261914661654373e-8
y(10000000000) = 1.9999930600533844e-9
y(100000000000) = 3.169873252772959e-10
y(1000000000000) = 5.0249582272954285e-11
y(10000000000000) = 7.958078640513122e-12
y(100000000000000) = 1.2505552149377763e-12
y(1000000000000000) = 2.2737367544323206e-13
y(10000000000000000) = 0
Il limite di 5√(1+x)- 5√x per x -> ∞ è 0
-----------------------------------------------
10 PI = 3.1415926535897932 20 input "gradi = "; gradi 30 PRINT "pendenza = "; TAN(gradi/180*PI)*100+"%" 40 GOTO 20 gradi = 10 pendenza = 17.632698070846498% gradi = 30 pendenza = 57.735026918962575% gradi = 89.99 pendenza = 572957.7893128936%Con lo script calcoli:
10 print "Numeri primi <= N (Introduci N < 8000 per non attendere troppo)" 20 input "N = "; n : print 1+" "; : posti=1 30 for m = 2 to n 40 ' m e' primo se la divisione per ogni k < m non e' esatta 50 k=2 : OK=1 60 while OK=1 70 OK=-1 : if k < m then OK=OK+1 90 if m/k <> INT(m/k) then OK=OK+1 100 IF OK = 1 then k=k+1 110 wend 120 if k = m then GOSUB 200 ' m e' primo 130 if posti=25 then GOSUB 210 140 next 150 print "" : goto 20 200 posti = posti+1 : print k+" "; : return 210 print "" : posti=1 : return Numeri primi <= N (Introduci N < 8000 per non attendere troppo) N = 500 1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499-----------------------------------------------
10 print "Divisori primi di N" 20 input "N = "; n 30 d=2 : v=1 : m=n : d1=1 40 while d <= m 50 if m/d = INT(m/d) then gosub 200 else d=d+1 60 wend 90 print v : goto 20 200 v=v+" "+d : m = m/d : d1 = d : return N = 30 1 2 3 5 N = 1000 1 2 2 2 5 5 5 N = 12345 1 3 5 823 N = 123456789 1 3 3 3607 3803-----------------------------------------------
10 ' Contiamo i dati (altezze arrotondate ai cm di un gruppo di ragazzi) 20 data 168, 183, 186, 184, 176, 184, 184, 188, 184, 181, 188, 182, 178, 170 21 data 180, 184, 175, 186, 188, 167, 179, 178, 178, 189, 189, 181, 175, 178 22 data 183, 170, 176, 184, 186, 181, 173, 176, 185, 190, 167, 175, 167, 185 23 data 173, 189, 187, 177, 170, 183, 189, 172, 175, 180, 181, 184, 174, 170 24 data 172 25 data 13579 ' metto un dato "strano", ad es. 13579, alla fine 30 n=0 : ok=1 : while ok=1 : read x : if x=13579 then ok=0 else n=n+1 : wend 40 print n ' ho contato i dati; sono n 57
10 ' Calcoliamo l'altezza media 20 data 168, 183, 186, 184, 176, 184, 184, 188, 184, 181, 188, 182, 178, 170 21 data 180, 184, 175, 186, 188, 167, 179, 178, 178, 189, 189, 181, 175, 178 22 data 183, 170, 176, 184, 186, 181, 173, 176, 185, 190, 167, 175, 167, 185 23 data 173, 189, 187, 177, 170, 183, 189, 172, 175, 180, 181, 184, 174, 170 24 data 172 30 n=57: somma=0 : for i=1 to n : read x : somma=somma+x : next 40 m = somma/n : print "l'alezza media e' "; m 50 print "arrotondando ai millimetri: "; INT(m*10+1/2)/10 l'alezza media e' 179.59649122807016 arrotondando ai millimetri: 179.6
Questo esempio da un'idea di come un programma statistico (come lo script "calcolatrice") possa contare quanti sono i dati introdotti:
10 input "numero intero positivo "; N ' lo trasformo in base DUE 15 ' cifra delle unita' = resto della divisione intera per 2, D = risultato intero 20 D = INT(N/2) : R = N-D*2 : U = R : L=1 : D1=D 25 ' cifre successive = resto della divisione del nuovo D per 2 30 WHILE L> 0 40 D=INT(D1/2) : R = D1-D*2 : U=R+" "+U : L=D : D1=D 50 WEND 60 IF N=0 THEN U=0 70 IF N=1 THEN U=1 80 PRINT N+" in base DUE : "+U : GOTO 10 numero intero positivo 4 4 in base DUE : 1 0 0 numero intero positivo 5 5 in base DUE : 1 0 1 numero intero positivo 64 64 in base DUE : 1 0 0 0 0 0 0 numero intero positivo 67 67 in base DUE : 1 0 0 0 0 1 1 numero intero positivo 123456789 123456789 in base DUE : 1 1 1 0 1 0 1 1 0 1 1 1 1 0 0 1 1 0 1 0 0 0 1 0 1 0 1-----------------------------------------------
10 input "quanti dadi lancio? "; N 20 s=0 : for i=1 to N : x=int(rnd*6+1) : print x+" "; : s=s+x : next 30 if N>1 then print " somma = "; s else print 40 goto 10 quanti dadi lancio? 1 3 quanti dadi lancio? 2 3 4 somma = 7 quanti dadi lancio? 2 5 5 somma = 10 quanti dadi lancio? 3 4 4 1 somma = 9 quanti dadi lancio? 3 4 6 3 somma = 13-----------------------------------------------
10 dim x(2,2) : dim y(2,2) : dim z(2,2) : dim w(2,2)
20 for i=1 to 2 : for j=1 to 2 : print "x("; i; "," ; j; ")= "; : input x(i,j): next : next
30 for i=1 to 2 : for j=1 to 2 : print "y("; i; "," ; j; ")= "; : input y(i,j): next : next
40 print "x =" : for i=1 to 2 : for j=1 to 2 : print x(i,j);" "; : next : print : next
50 print "y =" : for i=1 to 2 : for j=1 to 2 : print y(i,j);" ";: next : print : next
60 for i=1 to 2 : for j=1 to 2 : z(i,j)=x(i,j)+y(i,j): next : next
70 for i=1 to 2 : for j=1 to 2
80 w(i,j)=0: for k=1 to 2: w(i,j)=w(i,j)+x(i,k)*y(k,j): next
90 next : next
100 print "x+y =" : for i=1 to 2 : for j=1 to 2 : print z(i,j);" "; : next : print : next
110 print "x*y =" : for i=1 to 2 : for j=1 to 2 : print w(i,j);" "; : next : print : next
120 goto 20
x(1,1)= ? 2
x(1,2)= ? 3
x(2,1)= ? -4
x(2,2)= ? 1
y(1,1)= ? 2
y(1,2)= ? -3
y(2,1)= ? 5
y(2,2)= ? -2
x =
2 3
-4 1
y =
2 -3
5 -2
x+y =
4 0
1 -1
x*y =
19 -12
-3 10
-----------------------------------------------
10 for i=0 to 8 : x = 10^i
15 print "x = "; x
20 print " 1/(sqr(x^2+1)+x) = "; 1/(sqr(x^2+1)+x)
25 print " sqr(x^2+1)-x = "; sqr(x^2+1)-x
30 next
x = 1
1/(sqr(x^2+1)+x) = 0.4142135623730951
sqr(x^2+1)-x = 0.41421356237309515
x = 10
1/(sqr(x^2+1)+x) = 0.04987562112089027
sqr(x^2+1)-x = 0.049875621120889946
...
x = 1000000
1/(sqr(x^2+1)+x) = 4.999999999998749e-7
sqr(x^2+1)-x = 5.00003807246685e-7
x = 10000000
1/(sqr(x^2+1)+x) = 4.999999999999987e-8
sqr(x^2+1)-x = 5.029141902923584e-8
x = 100000000
1/(sqr(x^2+1)+x) = 5e-9
sqr(x^2+1)-x = 0
La seconda presenta la differenza tra due termini - √(x2+1) e x - che al crescere di x tendono ad assumere
valori sempre più vicini per cui si ottengono risultati man mano meno precisi.
Il calcolo "esatto" (per x = 100000000) con WolframAlpha:
|
Come misurare la lunghezza di una curva? Consideriamo ad esempio la lughezza della curva raffigurata a fianco. È il grafico di una funzione, ma potrebbe trattarsi di una curva descritta come L'idea è semplice: suddividere l'intervallo [a,b] in tanti intervallini [a,t1], [t1,t2], ..., [tn,b] e calcolare la lunghezza della poligonale che congiunge punti in cui t vale a, t1, t2, ..., tn, b. Facendo crescere il numero degli intervallini approssimiamo man mano meglio la lunghezza della curva. Ecco sotto il programmino che calcola la lunghezza della curva a fianco. |  |
10 a=-2 : b=2 : L1=0 20 input "numero passi: "; n : e = (b-a)/n : L=0 30 for i=1 to n : t1=a+(i-1)*e : t2=a+i*e 40 t=t1 : gosub 100 : x1=x : y1=y : t=t2 : gosub 100 : x2=x : y2=y 50 L = L+sqr((x1-x2)^2+(y1-y2)^2) : next 60 print L : goto 20 100 x = t : y = t^3-2*t : return numero passi: 4 13.026466151931759 numero passi: 5000 13.501661154274576 numero passi: 10000 13.501661528734912 numero passi: 20000 13.501661622350092Posso tranquillamente prendere 13.501662 come approssimazione della lunghezza.
10 a=-2 : b=2 : L1=0 20 input "numero passi: "; n : e = (b-a)/n : L=0 30 for i=1 to n : t1=a+(i-1)*e : t2=a+i*e 40 t=t1 : gosub 100 : x1=x : y1=y : t=t2 : gosub 100 : x2=x : y2=y 50 L = L+sqr((x1-x2)^2+(y1-y2)^2) : next 60 print L;" variazione = "; L-L1 : L1=L : goto 20 100 x = t : y = t^3-2*t : return numero passi: 50000 13.501661648562154 variazione = 13.501661648562154 numero passi: 100000 13.501661652306938 variazione = 3.744784038417492e-9 numero passi: 200000 13.501661653242754 variazione = 9.358167574191611e-10 numero passi: 400000 13.501661653477074 variazione = 2.3431923068528704e-10 numero passi: 800000 13.501661653535493 variazione = 5.841904737735604e-11 numero passi: 1600000 13.501661653550164 variazione = 1.467093113660667e-11 numero passi: 3200000 13.50166165355453 variazione = 4.366285111245816e-12La stampa delle variazioni mi fa capire come varia l'andamento delle uscite in questo caso: ogni volta che raddoppio n la variazione si divide circa per 4, fino all'ultima delle uscite precedenti, quando diventano proponderanti gli errori di approssimazione. Mi fermo e prendo come approssimazione della lunghezza 13.501661653555.