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 utilizaados
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
i = (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