GUA DE COMANDOS DE TURBO PASCAL

================================
OK, supongo que ya todos saben que Pascal es un lenguaje de programacin y
todo eso, as que no me voy a detener a explicarlo. Esta gua tiene como
propsito explicar de forma simple todos los comandos y funciones bsicos del
lenguaje Pascal, de tal manera que se tenga la capacidad de crear un programa
simple para el computador con resultados rpidos.
1. ESTRUCTURA BSICA DE UN PROGRAMA PASCAL
Un programa escrito en Pascal tendr generalmente la siguiente forma:
Program nombre_programa;
BEGIN
(* comandos *)
END.
Program, como se ve, contiene el nombre del programa y sirve para identificarlo.
Fuera de eso, no nos vamos a detener en lo que significa ya que no tiene ninguna
otra utilidad prctica.
BEGIN y END. (con el punto) marcan el inicio y el final del programa. De hecho,
estas dos instrucciones marcan un "bloque" que es un conjunto de instrucciones
que tienen dependencia entre s (un programa necesita todas las instrucciones
entre BEGIN y END para cumplir la funcin que se le ha asignado). Despus veremos
otras instrucciones que requieren el uso de BEGIN y END.
Entre Program y BEGIN puede haber otros comandos, llamados declaraciones. Estos
comandos muestran todas las variables, constantes y valores que sern utilizados
en
el programa. Las declaraciones pueden ser (en este orden):
uses
label
const
type
var
procedure
function
La funcin "uses" la explicar ms adelante, pero bsicamente sirve para incluir
comandos extra a Turbo Pascal, para darle ms funcionalidad y ampliar sus
capacidades.
Habitualmente se usa de la siguiente manera:
Program n;
uses CRT;
...
"Label" marca las "etiquetas" en el programa. Estas "etiquetas" son como
"letreros" que
indican a Pascal "aqu hay tal cosa". Esto sirve si quieres "saltar" a ese cdigo,
por
ejemplo si quieres que cierta parte del programa no se ejecute. Para ello se usa
Goto.
Label se usa de esta manera:
Label 1, 2, 3, a, b, c, hola;
Cualquier palabra, excepto una palabra reservada, se puede usar como etiqueta.
"Const" declara una constante. Es un valor que recibe un nombre; este valor no
puede ser
cambiado por todo el programa. A diferencia de las variables, no es necesario
especificar
su tipo (p. ej. decir que es un nmero entero). Ej:
Const PI = 3.141593;
LetraA = 'a';
"Type" declara un tipo especial de variable. Esto lo explicar con detalle ms
abajo.
"Var" declara una variable, es decir, reserva el espacio en el computador para
poder ocupar
esa variable. TODAS LAS VARIABLES DEBEN SER DECLARADAS! Si no, el compilador de
Pascal les
arrojar un error y el programa no funcionar.
Se usa as:
var nombrevar: tipo;
Por ejemplo:
var a, b, c : integer; (* declara 3 variables enteras *)
d : char; (* declara una variable que puede almacenar una sola letra *)
...
"Procedure" y "Function" las explicar ms adelante.
Recuerda que despus de cada comando va un punto y coma (;), a menos que el
comando
as lo especifique (como BEGIN, que JAMS lleva punto y coma).
2. COMANDOS BSICOS
OK, ya sabemos como hacer las declaraciones en Pascal, pero de qu sirve si no
sabemos
como usarlas? Bueno, para eso estn los comandos en Pascal.
Lo primero es lo primero. Cmo queremos que el usuario sepa que queremos que haga
algo?
Bueno, para eso usaremos el comando Write() o Writeln() que escriben un mensaje en
la
pantalla del computador.
Write y Writeln se usan de la siguiente manera:
Write(lo que sea);
La principal diferencia entre ambas es que al usar Writeln() el computador salta
una
lnea despus de escribir. Un ejemplo de un programa Pascal que escribiera un
mensaje
en la pantalla sera:
Program mensaje;
(* no vamos a usar variables, as que no hay declaraciones *)
BEGIN
Write ('Yo me llamo Z');
Writeln (4);
Write ('2+2=');
Writeln (2+2);
END.
Eso entrega:
Yo me llamo Z4
2+2=4
Fjense que el texto va entre comillas simples (''), mientras que los nmeros no.
Las
comillas hacen que Pascal considere todo eso como una palabra y no como un nmero.
Tambin puede ir, como se ve, una operacin matemtica en Write y Writeln. P. ej.:
Writeln (3*(4+5)-1);
Resultado: 26
Para que el computador reciba datos debemos usar el comando opuesto, que es Read()
(o
Readln() ). Este comando espera a que se escriba el valor o los valores pedidos y
luego
lo ingresa a la variable especificada entre parntesis. P. ej.:
Program Multiplicacion;
Var
a,b : Real; (* vamos a usar las variables a y b, as que las declaramos *)
BEGIN
Readln (a);
Readln (b);
Writeln (a*b);
END.
Si queremos, podemos en el intertanto asignar el resultado a otra variable para
guardarlo,
si necesitamos usarlo otra vez. Esto se hace con el operador Asignacin ( := ). Y
no, no
es una carita. La asignacin se hace de la siguiente manera:
NombreVariable := Valor
Por ejemplo, si vamos a calcular la suma de dos nmeros y luego mostrar su
promedio, usamos
el siguiente programa:
Program Promedio;
Var
a,b,prom : Real;
BEGIN
Readln (a,b);
prom := a+b;
Writeln (prom);
Writeln (prom/2);
END.
Ntese que Read() y Write() se pueden compartir entre varias variables. Por
ejemplo, para
leer 3 variables DEL MISMO TIPO, podemos usar:
Readln (a);
Readln (b);
Readln (c);
o, simplemente:
Readln (a, b, c);
Y si queremos escribirlas separadas por un espacio, podemos poner:
Writeln (a,' ',b,' ',c);
Tambin, si escribimos una variable real con Write() vamos a obtener algo as
como:
3.14000000000000E+00
Para prevenir eso, colocamos la variable real de la siguiente forma:
Writeln (variable:1:n);
donde n es el nmero de decimales. Por ejemplo, (3.14:1:1) devolver (3.1).
3. TIPOS DE VARIABLES
Esto lo voy a explicar rpido. Al usar
var nombre : tipo;
debemos especificar el tipo de la variable, el cual puede ser:
Byte: entero corto natural, entre 0 y 255.
ShortInt: entero corto con signo, entre -128 y 127.
Integer: entero con signo, entre -32768 y 32767.
Word: entero natural, entre 0 y 65535.
LongInt: entero largo con signo, entre -2147483648 a 2147483647.
Real: nmero real, con decimales.
Single: dem, ms corto.
Double: dem, ms largo.
Extended: nmero real largusimo.
Comp: nmero real parecido a Double, ms largo.
Boolean: valor lgico (verdadero o falso), 1=V, 0=F
Char: carcter (una sola letra, nmero o smbolo)
String: conjunto de letras, nmeros y signos con espacio para 255 caracteres.
Estos dos ltimos, al asignarles un valor, ste se debe escribir entre comillas
simples, por ejemplo:
Letra := 'a' (* Letra es Char *)
Nombre := 'Karen' (* Nombre es String *)
Recuerda que NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE. Repito:
NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE
NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE
NO PUEDE HABER DOS VARIABLES CON EL MISMO NOMBRE
(la razn es obvia)
Ah, otra cosa. Aqu se pueden declarar tambin los arrays ("Arreglos"). Un array
es un conjunto de variables que son la nica excepcin a la regla anterior, ya que
comparten el mismo nombre. Se diferencian por un nmero que se denomina ndice.
Los
arrays se declaran de cualquiera de las siguientes formas:
Var
nombrearray: Array [a..b] of tipo;
o
Type
Vector = Array [a..b] of tipo;
Var
nombrearray: Vector;
El array contendr n variables, yendo de A hasta B. Por ejemplo, si declaras:
Type
Vector = Array [1..5] of Integer;
las variables de tipo Vector tendrn 5 elementos enteros (1, 2, 3, 4, 5).
Un array se usa de la misma manera que una variable normal, pero debes especificar
el ndice del elemento que deseas ver, por ejemplo, en el array "X" de tipo
Vector, si
quieres ver el tercer elemento debes usar:
Writeln (X[3]);
y para modificarlo:
X[3] := 4;
Tambin se pueden crear arrays de dos ndices (dos dimensiones) que se pueden
representar
como una tabla, por ejemplo las de Excel, que tienen un ndice como letra y un
ndice como
nmero (A5, A7, B9, Z13, etc.) Se declaran igual que las otras, pero con la
siguiente
modificacin:
Type
Matriz = Array [a..b][x..y] of tipo;
...
y para ocuparlas:
CualquierMatriz[3][5] := algo;
En los ndices se puede colocar cualquier tipo de secuencia que siga un orden
lgico, es
decir, es correcto colocar lo siguiente:
Type
Matriz = Array [1..10]['a'..'z'] of Integer;
lo que nos dejara algo parecido a Excel (con una letra y un nmero)
Aqui vemos algo nuevo ("Type"). Este comando declara un tipo especial de variable.
Por ejemplo, los arrays. Luego, en la seccin Var, puedes simplemente declarar el
nombre
del tipo especial que creaste. Otro ejemplo sera:
Type
CadenaCorta = String[16];
Mes = 1..12;
Var
Palabra: CadenaCorta;
Actual: Mes;
Aqu se declara una variable de tipo "CadenaCorta" que es una variable "String"
(conjunto de
letras) con un tamao mximo de 16 caracteres, y una variable entera que tiene
valores entre 1
y 12. stos son los tipos "subrango", modificaciones, limitaciones o
especificaciones a los
valores de los otros tipos.
Tamben se pueden declarar los tipos enumerados, que son identificadores que
internamente toman
un valor "secuencial", p. ej.:
Type
Estaciones = (primavera, verano, otoo, invierno);
Este ejemplo lo saqu de lapolitecnica.net. Para el computador, Primavera ser
como el 0, Verano
como el 1, etc.
4. CONDICIONES
Qu pasa si quieres que el programa decida algo por su cuenta? Para eso usamos
las condiciones,
que son consultas o comparaciones que hace el computador, y devuelven un valor
verdadero o falso.
Hay dos tipos de condiciones: IF y CASE OF.
A. Condicin IF
La forma general de la condicin IF es la siguiente:
If (condicin) then
begin
(* instrucciones *)
end;
donde (condicin) es una comparacin lgica que puede ser verdadera o falsa, como:
< menor que
> mayor que
= igual a (SIN dos puntos)
>= mayor o igual que
<= menor o igual que
<> distinto a
Las instrucciones despus de Then (entre begin y end;) sern ignoradas si la
condicin es
falsa.
Por ejemplo, si queremos ver si un nmero es mayor que 5, hacemos lo siguiente:
Program Mayorque5;
var
a : byte;
BEGIN
Write ('Escriba un nmero: ');
Readln (a);
If (a>5) then
Writeln ('Es mayor que 5');
END.
Si es una sola instruccin, no es necesario colocar Begin ni End separando las
instrucciones.
Ntese que End lleva punto y coma (end;).
Si queremos que cierto grupo de instrucciones se realize solo si la condicin es
FALSA usamos
la instruccin ELSE. As:
If (condicin) then
begin
(* esto solo se har si la condicin es verdadera *)
end
Else
begin
(* esto solo se har si la condicin es falsa *)
end;
El primer END no lleva punto y coma si est presente la instruccin ELSE!
Un ejemplo de IF-THEN-ELSE sera una ampliacin del programa anterior:
Program Mayoromenorque5;
Var
a : byte;
BEGIN
Write ('Escriba un nmero: ');
Readln (a);
If (a>5) then
Writeln ('Es mayor que 5')
Else
Writeln ('Es igual o menor que 5');
END.
Si queremos asegurarnos de que se cumplan varias condiciones en una instruccin
IF, usamos
los operadores lgicos. stos son: And (Y), Or (Y/O), Xor (O), Not (NO). Por
ejemplo, si
queremos asegurarnos de que dos nmeros sean positivos antes de hacer algo,
usamos:
If (a>0) and (b>0) then
...
Si a es negativo o b es negativo, no har nada, porque se requiere que ambos
nmeros sean
positivos. Si queremos asegurarnos de que al menos uno es positivo, colocamos Or
en vez de
And. Si queremos asegurarnos de que uno y solo uno es positivo, usamos Xor (Or
exclusivo).
Not niega la condicin. Es decir que Not (a=b) es igual a (a<>b).
B. Condicin CASE OF
Si tenemos un grupo de instrucciones IF muy largo en que se compare varias veces
la misma
variable, quiz convenga cambiarlo por la instruccin Case Of. Por ejemplo:
(* estado civil *)
If (Codigo=1) then
Estado:='Soltero';
If (Codigo=2) then
Estado:='Casado';
If (Codigo=3) then
Estado:='Viudo';
If (Codigo=4) then
Estado:='Divorciado';
...
Si tenemos que ver por 30, 40 o 50 valores, no creo que alguien tenga la paciencia
como para
escribir IF, THEN, etc., 30, 40 o 50 veces. En vez de eso es mejor usar Case Of de
la siguiente
forma:
Case (variable) Of
(valor1): begin
(* instrucciones *)
end;
(valor2): begin
(* instrucciones *)
end;
...
(valorn): begin
(* instrucciones *)
end
End;
o
Case (variable) Of
(valor1): begin
(* instrucciones *)
end;
(valor2): begin
(* instrucciones *)
end;
...
Else
begin
(* instrucciones *)
end
End;
Ntese que el penltimo End no lleva punto y coma. Esto ocurre porque hay dos
instrucciones
End juntas.
Viendo esto, podemos cambiar el ejemplo del estado civil que vimos anteriormente
por:
Case Codigo of
1: Estado:='Soltero';
2: Estado:='Casado';
3: Estado:='Viudo';
4: Estado:='Divorciado';
End;
Las instrucciones despus de Else solo se ejecutarn si ninguno de los valores es
verdadero.
Tambin los valores se pueden agrupar si se realiza la misma operacin para varios
valores. P. ej.:
Case n of
1,2,3: Writeln ('Menor que 4');
4: Writeln ('Igual que 4');
Else
Writeln ('Mayor que 4');
End;
5. CICLOS
Si se va a repetir una misma instruccin muchas veces, sera ridculo escribir,
por ejemplo:
Writeln (5*1);
Writeln (5*2);
Writeln (5*3);
Writeln (5*4);
Writeln (5*5);
Writeln (5*6);
Writeln (5*7);
Writeln (5*8);
Writeln (5*9);
Writeln (5*10);
Writeln (5*11);
Writeln (5*12);
...
Para evitar eso se usan los ciclos, que repiten una instruccin o grupo de
instrucciones
tantas veces como se necesita. Los 3 ciclos bsicos son los ciclos While, Repeat y
For.
Comencemos por lo ms fcil:
A. Ciclo FOR
Este ciclo repite las instrucciones un nmero fijo de veces, aumentando o
disminuyendo una
variable que cuenta cada vez que se repiten las instrucciones. Se usa de la
siguiente manera:
For variable := valorinicial To valorfinal Do
begin
(* instrucciones *)
end;
o
For variable := valorinicial DownTo valorfinal Do
begin
(* instrucciones *)
end;
Esto har que se repitan las instrucciones hasta que la variable tenga un valor
igual o mayor
a valorfinal. Ir aumentando de 1 en 1 o disminuyendo de 1 en 1 dependiendo de si
se usa To o
DownTo, a partir del valor valorinicial. Por ejemplo, las instrucciones Writeln
que vimos
anteriormente podran ser resumidas en:
For i:=1 to 12 do
Writeln (5*i);
(Recuerda que si hay una sola instruccin podemos omitir begin y end)
Un ejemplo de programa que usa un ciclo FOR es uno que calcule el factorial de un
nmero N.
El factorial de N (N!) se define como 1 * 2 * 3 * 4 * 5 * 6 * ... * N, es decir el
producto de
los N primeros nmeros naturales. Aqu va:
Program factorial;
Label 1, 2;
Var N, i, f : LongInt;
resp : Byte;
BEGIN
1:
Write ('Ingrese el nmero deseado');
Readln(N);
f := 1;
For i := 1 to N do
f := f * i;
Writeln (N,'! = ',f);
2:
Write ('Desea ejecutar nuevamente el programa? [1=S/2=No]');
Readln (resp);
If (resp<1) or (resp>2) then
Goto 2;
If (resp=1) then
Goto 1;
END.
Si usramos DownTo, el resultado sera el mismo, pero tendramos que cambiar lo
siguiente:
For i := 1 to N do
por
For i := N DownTo 1 do
B. Ciclo WHILE y Ciclo REPEAT
Los ciclos While y Repeat habitualmente se usan cuando no se sabe con exactitud la
cantidad de veces
que se va a repetir el proceso. La estructura de stos es:
While (condicin) Do
begin
(* instrucciones *)
end;
y
Repeat
(* instrucciones *)
Until (condicin);
A diferencia de los otros ciclos, si se dan cuenta, Repeat no lleva begin ni end.
Las principales diferencias entre Repeat y While son dos:
1. En While, si la condicin es falsa desde el principio, el ciclo no se ejecuta
ninguna vez.
En Repeat, el ciclo se ejecuta al menos una vez porque la condicin se
comprueba al final.
2. En While, el ciclo se ejecuta mientras la condicin sea verdadera; en Repeat el
ciclo se ejecuta
mientras la condicin sea falsa.
Un ejemplo de cada uno ahora.
El ejemplo de Repeat va a ser un programa que espera a que el usuario adivine un
nmero al azar. Si lo
adivina, aparece un mensaje indicndolo; si no, el computador le indica al usuario
si el nmero es mayor
o menor.
Para ello vamos a usar la funcin Random(n) que devuelve un nmero entero entre 0
y n. Como es una funcin
de lo que podramos llamar "Pascal extendido", es decir, una funcin extra de
Pascal, debemos incluirla
en el programa con uses crt;.
Program Adivina;
Uses CRT;
Var
Azar, Resp, Intentos : Integer;
BEGIN
Randomize;
Writeln ('Yo voy a pensar un nmero entre cero y cien.');
Writeln ('Debes adivinarlo en el menor nmero de intentos posible. Te dar
pistas.');
Azar := Random (200);
Repeat
Readln (Resp);
If (Resp<Azar) then
Writeln ('Um... no. Ms alto.');
If (Resp>Azar) then
Writeln ('Demasiado.');
Intentos := Intentos + 1;
Until (Resp=Azar);
Writeln ('Lo lograste!');
Writeln ('Te cost ',Intentos,' intentos');
Writeln ('Presiona cualquier tecla');
Readkey;
END.
Aqu, adems de Repeat... Until usamos las funciones especiales Random(),
Randomize y Readkey(). Las
explicar ms abajo con detalle.
Un ejemplo de ciclo While sera simular un bucle for, como por ejemplo mostrar la
tabla del 4.
Program Whileofor;
Var
K : Byte;
BEGIN
K:=1; (* valor inicial *)
While (K<=10) do
Begin
Writeln ('4*',K,'=',4*K);
K:=K+1;
End;
END.
De hecho, Repeat y While son bsicamente lo mismo, y cualquiera de ellos se puede
adaptar para cumplir la
funcin de For.
6. OPERADORES Y FUNCIONES PREDEFINIDAS
(Explicacin rpida otra vez. Bueno, esto es intuitivo)
Estos son los operadores que se usan en Pascal para operaciones matemticas:
+ Suma
- Resta
* Multiplicacin
/ Divisin real (si intentas dividir enteros con / te dar error)
DIV Divisin entera (sin decimales, no sirve para reales)
^ Exponente (elevado a)
MOD Resto de una divisin entera
Estos son los operadores lgicos (ven si algo es verdadero o falso):
> Mayor que
< Menor que
= Igual a
<= Menor o igual a
>= Mayor o igual a
<> Distinto
AND Y (A Y B = V ssi A = V y B = V)
OR Y/o (A O B = V si A = V y/o B = V)
XOR O exclusivo (A Ox B = V ssi A distinto de B)
NOT No ((No V) = F, (No F) = V)
Estos son los smbolos de agrupacin y de orden en Pascal:
(* *) Comentario (lo escrito dentro no afecta al programa)
{ } Comentario
( ) Separa valores, p. ej. K(1)
[ ] Indica ndice de algo (un array)
:= Asignacin de valor
: Declaracin de variable
Estas son las funciones ms comunes en Pascal:
Abs(x) Valor absoluto (|x|)
Random(x) Nmero al azar entre 0 y x (para que no se repitan usa Randomize;)
Sqrt(x) Raz cuadrada de x
Trunc(x) Parte entera de un nmero real x (Trunc(3.141593) = 3)
Frac(x) Parte fraccionaria de un nmero real x (opuesto a Trunc)
Round(x) Redondea x (lo aproxima al entero ms cercano)
Ord(x) Cdigo de una letra, p. ej. Ord('A') = 65
Chr(x) Letra correspondiente al cdigo, p. ej. Chr(65) = 'A'
Concat(s1,s2) Une las cadenas s1 y s2 en otra cadena
Length(s) Muestra el tamao de una cadena, ej: Length('Alvaro') = 6
Arctan(x) Convierte x a radianes
Sin(x) Seno de x
Cos(x) Coseno de x
Exp(x) Nmero irracional e (2.718281828...) elevado a x.
Int(x) Parte entera del nmero x
Ln(x) Logaritmo natural/neperiano del nmero x
Sqr(x) Cuadrado de x
7. COMANDOS MISCELNEOS Y OTROS
Miscelneos:
Delay(n); Hace una pausa de n milisegundos (requiere uses crt;)
Readkey; Espera a que se presione una tecla, si se usa como funcin le
asigna
a la variable la tecla presionada, p. ej. A := Readkey;
(requiere uses crt;)
Randomize; Reinicializa los nmeros aleatorios para que no se repitan al usar
Random()
(requiere uses crt;)
ClrScr; Borra la pantalla (requiere uses crt;)
Goto lugar; Salta a la etiqueta de nombre lugar.
Palabras reservadas (no se pueden usar como nombres de variables):
PROGRAM CONST TYPE VAR FUNCTION
PROCEDURE BEGIN END INTEGER REAL
BOOLEAN CHAR STRING RECORD SET
FILE ARRAY BYTE REPEAT UNTIL
WHILE FOR DO TO DOWNTO
IF THEN ELSE CASE
8. PROCEDIMIENTOS Y FUNCIONES
Con estos trminos... ejem, es decir, con esto termino.
Un procedimiento es un sub-programa independiente que cumple una funcin
especfica dentro del
programa. Tiene sus propias variables, como un programa aparte. Se declara con
Procedure, de la
siguiente forma:
Program programa;
...
Procedure nombre(argumento1: tipo; argumento2: tipo...);
begin
(* instrucciones *)
end;
BEGIN
...
nombre(argumentos);
...
END.
El END del procedimiento lleva punto y coma! Que no se te olvide.
Una funcin es algo muy parecido al procedimiento, pero devuelve un valor, as que
se le puede
llamar desde una variable. Se declara igual que un procedimiento, pero con un
cambio importante:
Function nombre(argumento1: tipo...) : TIPO;
begin
...
nombre := algo;
end;
...
BEGIN
variable := nombre(x);
...
Es decir, se debe indicar si el valor que entrega es Integer, Byte, etc.
Un ejemplo de ambos comandos sera, um... Rescatemos el programa de factoriales de
ms arriba.
Program factorial;
Label 1, 2;
Var N, i, f : LongInt;
resp : Byte;
BEGIN
1:
Write ('Ingrese el nmero deseado');
Readln(N);
f := 1;
For i := 1 to N do
f := f * i;
Writeln (N,'! = ',f);
2:
Write ('Desea ejecutar nuevamente el programa? [1=S/2=No]');
Readln (resp);
If (resp<1) or (resp>2) then
Goto 2;
If (resp=1) then
Goto 1;
END.
Supongamos que nos piden calcular el coeficiente binomial de n y k (n sobre k).
Este valor, usado
en combinatoria, se define como:
/n\ n!
| | = ----------
\k/ k!(n-k)!
Es decir, factorial de n dividido por el producto del factorial de k y del
factorial de (n - k).
Sera bastante tedioso, por decir lo menos, reescribir el ciclo for varias veces.
Pero, y si hacemos
una funcin? Aqu va:
Program CoeficienteBinomial;
Label 1, 2;
Var n, k, resp: Integer;
n_sobre_k: LongInt;
Procedure Prompt (texto:String; var valor:Integer);
begin
Write (texto,' ');
Readln (valor);
end;
Function Factorial (n: Integer): LongInt;
var
f: LongInt; (* solo declaramos aqu las que no estn en los argumentos *)
i: Integer;
begin
f := 1;
For i := 1 to N do
f := f * i;
Factorial := f
end;
BEGIN
1:
Prompt('Ingrese N:', n);
Prompt('Ingrese K:', k);
n_sobre_k := Factorial(n) DIV (Factorial(k) * Factorial(n-k));
Writeln ('El valor de N sobre K es: ', n_sobre_k);
2:
Prompt('Desea ejecutar nuevamente el programa? [1=S/2=No]', resp);
If (resp<1) or (resp>2) then
Goto 2;
If (resp=1) then
Goto 1;
END.
Fjense en varias cosas. Por ejemplo, en el procedimiento Prompt, colocamos VAR
antes del
argumento valor. Eso es para que el procedimiento pueda modificar el valor de la
variable "valor"
(qu redundante).
Tambin, si se fijan, para asignarle el valor a la funcin, se debe usar como otra
variable ms.
Por ejemplo, la siguiente funcin dara siempre el valor 4 a una variable:
Function Cuatro (): Byte;
begin
Cuatro := 4;
end;
Eso es todo.
FIN