BASIC APASCALADO: Trabalhemos para pensar melhor...

--------- INTRODUCAO ----------------------------

Nos velhos tempos do  ZX81  sentia-me  muito bem a fazer programação a  martelo.  
Mas,  quando comecei a meter programas compridos no  SPECTRUM, vi aquilo a ficar 
complicado  e  nao  sabia  para onde me virar.

Entao  comecei  a   inventar   maneiras	de facilitar as coisas. Acabei afinal por 
 descobrir que não estava a programar em  BASIC;  o  que  eu estava a fazer era PASCAL!

A  seguir  apresenta-se  um  exemplo  de  um programa em PASCAL básico e a sua versão 
em BASIC apascalado.  Começa-se  por  fazer   o   programa principal  e  depois,  vão-se 
 desenvolvendo	as rotinas.

Observa bem  estas  versões  e  descobre  as vantagens do basic apascalado.

--------- ALGORITMO -----------------------------

calcular factorial (entrada arg; saida factorial |
		|  f <- 1
		|
		|  enquanto arg > 1
		|    |
		|    |  f <- f * arg
		|    |  arg <- arg - 1
		|    |
		|
		|  factorial <- f
		|

----------- programa em PASCAL básico ---------------

PROGRAM factoriais (INPUT,OUTPUT);
VAR
  limite,
  argumento,
  factorial	:INTEGER;

  PROCEDURE calcular_factorial;
  BEGIN
    factorial := 1;
    WHILE argumento > 1 DO
      BEGIN
	factorial := factorial * argumento;
	argumento := argumento - 1;
      END {while}
  END; { calcular_factorial }

  PROCEDURE escrever_factoriais;
  VAR   arg  :INTEGER;  { para o argumento poder ser alterado no calculo }
  BEGIN
    WRITELN;
    FOR arg := limite DOWNTO 0 DO
      BEGIN
	argumento := arg;
        WRITE('fact(',argumento,') = ');
	calcular_factorial;
	WRITELN(factorial)
      END {for}
    END; { escrever_factoriais }
	
  PROCEDURE ler_limite;
  BEGIN
    REPEAT
      WRITE('maximo argumento = ');
      READLN(limite)
      UNTIL (limite >= 0) AND (limite < 12)
  END; { ler_limite }

  PROCEDURE introducao;
  BEGIN
    WRITELN;
    WRITELN('LISTA DECRESCENTE DE FACTORIAIS');
    WRITELN('para exemplificar programacao apascalada em BASIC'); 
    WRITELN
  END; { introducao }

BEGIN { programa principal }
  introducao;
  ler_limite;
  escrever_factoriais
END. { main prog }

--------- programa em BASIC apascalado ---------------------------------------

  10
  50 REM PROGRAM factoriais (Keyboard,Screen)
  90
 100 REM --- VARIAVEIS ---
 110 CLEAR
 120 LET limite = 0 : REM maximo argumento para a lista de factoriais
 130 LET argumento = 0 : REM argumento para calcular o factorial
 140 LET factorial = 0 : REM factorial do argumento
 150
 160 LET w = 0 : REM ciclos diversos de nivel 1
 170 LET y = 0 : REM ciclo auxiliar de nivel 2 (dentro do ciclo de nivel1)
 290
 300 REM --- ROTINAS ---
 310 LET prog principal = 500
 320 LET introducao = 1000
 330 LET ler limite = 1500
 340 LET escrever factoriais = 2000
 350 LET calcular factorial = 2500
 490
 500 REM --- prog principal ---
 510 GO SUB introducao
 520 GO SUB ler limite
 530 GO SUB escrever factoriais
 540 STOP
 580 REM fim de prog principal
 590
1000 REM --- introducao ---
1010 PRINT
1020 PRINT "LISTA DECRESCENTE DE FACTORIAIS"
1030 PRINT "para exemplificar programacao apascalada em BASIC" 
1040 PRINT
1050 RETURN : REM introducao
1490
1500 REM --- ler limite ---
1510 FOR w=0 TO 1 STEP 1E-9 : REM REPEAT
1520	PRINT "maximo argumento = ";
1530	INPUT limite : PRINT limite
1540 IF (limite >= 0) AND (limite < 12) THEN LET w=1 
1550 NEXT w : REM UNTIL legal
1590 RETURN : REM ler limite
1990
2000 REM --- escrever factoriais ---
2010 PRINT
2020 FOR w=limite TO 0 STEP -1
2030	LET argumento=w
2040	PRINT "fact(",argumento,") = ";
2050	GO SUB calcular factorial
2060	PRINT factorial
2070 NEXT w
2090 RETURN : REM escrever factoriais
2490
2500 REM --- calcular factorial ---
2510 LET factorial=1
2520 FOR y=NOT(argumento > 1) TO 0 STEP 0 : REM WHILE arg>1 
2530	LET factorial=factorial*argumento
2540	LET argumento=argumento-1
2550 IF argumento > 1 THEN NEXT y : REM while end
2590 RETURN : REM  calcular factorial
2990
-----------------------------
ZE OLIVEIRA zarsoft(a)clix.pt
-----------------------------