BASIC
 
[È un linguaggio semplicissimo che puoi usare facilmente e ti consente di capire come opera software più sofisticato.  Puoi
anche preparare programmi che sviluppano calcoli ulteriori a quelli svolgibili con questi script e con WolframAlpha]
 
Metti il programma in "Source Code", clicca "Execute", se vuoi clicca "Show code".
 
10 INPUT T
20 K = 100/T
30 INPUT D
40 PRINT D*K
50 GOTO 30
             
10 INPUT "T = ? "; T
15 K = 100/T
20 PRINT "K = 100/T = ", K
30 INPUT "D = ? "; D
40 PRINT "D*K = ", D*K	
50 GOTO 30

Ricarica (o "Aggiorna") per introdurre ed eseguire un nuovo programma

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 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 di un programma come il seguente si possono ottenere l'uscita "Infinity" nel caso in cui il programma si trovi a fare la divisione 5/0, a indicare che se si dividesse un numero positivo per un numero piccolissimo si otterrebbe un numero grandissimo, e 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

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.  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
 


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 = ...

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

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 = 120

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 "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


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

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.75 
----------------------------------------------- 
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
# 17
Con 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
----------------------------------------------- 
01 ' Trucco per contare dei dati (conto fino a un numero con cui segno la fine;
02 ' qui ho preso 12345; poi prendo come nuovo n il numero a cui sono arrivato)
10 n = 50 : DIM x(n-1)
15 DATA 43,5,6,16,49,26,28,37,56,88,141,225,330,3,32,78,89,123,73,24,12,7,245
20 DATA 12345,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
25 for i=0 to n-1: READ x(i) : if x(i)=12345 then k = i
30 next
35 n = k :  print n+" dati"
40 for i=0 to n-1 : print x(i)+" "; : next : print ""

23 dati
43 5 6 16 49 26 28 37 56 88 141 225 330 3 32 78 89 123 73 24 12 7 245
----------------------------------------------- 
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 y = 2x e la curva y = -2x+1.5 ?


Capito dal grafico (fatto con WolframAlpha) che si incontrano tra 0 ed 1, posso usare questo semplice programmino [eventualmente introcudendo la riga  35 print m; : input " batti 'a capo' "; h$ ] 		      
5  print "soluzione di 2^x-(-2*x+1.5) = 0 tra 0 ed 1"
10 a = 0 : b = 1
15 m = a+(b-a)/2
20 x = a : gosub 1000 : gosub 500 : sa = segno
25 x = m : gosub 1000 : gosub 500 : sm = segno
30 if sa=sm then a = m else b = m
40 goto 15
500 segno=0 : if y>0 then segno = 1 
501 if y<0 then segno = -1
502 if segno=0 then gosub 600
503 return
600 print "x = "; m : END
1000 y = 2^x-(-2*x+1.5) : return

x = 0.1825542858240715
Con la riga 35 avrei anche le uscite:
0.5  batti 'a capo'  
0.25  batti 'a capo'  
0.125  batti 'a capo'  
0.1875  batti 'a capo'  
...
0.18255428582407152  batti 'a capo'  
0.18255428582407146  batti 'a capo'
x = 0.1825542858240715

Il metodo visto, utilizzato per risolvere l'equazione f(x)=0 in un intervallo [a,b] ai cui estremi f abbia valori di segno opposto, si chiama "bisezione".
Si procede calcolando il valore di f nel centro di [a,b],  restringendosi al mezzo intervallo nei cui estremi f ha valori di segno opposto;  a sua volta si calcola il valore di f al centro di questo nuovo intervallo e ci si restringe alla metà di esso nei cui estremi f ha segni opposti;  e così via.

   

----------------------------------------------- 
10 a = 0 : b = 3
15 n = 4321 : s = 0 : h = (b-a)/n
20 for j=1 to n : x = a+(j-1/2)*h : gosub 1000 : s=s+y : next
25 print "n = "; n ; " integrale = "; s*h
30 n = n*2 : s = 0 : h = (b-a)/n
35 for j=1 to n : x = a+(j-1/2)*h : gosub 1000 : s=s+y : next
40 print "n = "; n ; " integrale = "; s*h
45 n = n*2 : s = 0 : h = (b-a)/n
50 for j=1 to n : x = a+(j-1/2)*h : gosub 1000 : s=s+y : next
55 print "n = "; n ; " integrale = "; s*h
60 end
1000 y = ABS(x*(x-2)) : RETURN

n = 4321 integrale = 2.666666599728399
n = 8642 integrale = 2.6666666499282217
n = 17284 integrale = 2.666666662482534
L'integrale di |x·(x-2)| tra 0 e 3 è 2.666... = 8/3
Per il grafico posso ricorrere facilmente a WolframAlpha,  con
plot y = abs(x*(x-2)), 0 < x < 3   o
plot y = |x*(x-2)|, 0 < x < 3 		     
-----------------------------------------------
Spesso è comodo cercare, ad esempio, minimo e massimo di una funzione procedendo con una ricerca "a caso". Un esempio: 
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.5827001
Con 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