1. ESTRUCTURA BÁSICA DE UN PROGRAMA

1. ESTRUCTURA BÁSICA DE UN PROGRAMA PASCAL
Un programa escrito en Pascal tendrá generalmente la siguiente forma:
Program nombre_programa;uses ……;
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 práctica.
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
función que se le ha asignado). Después 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 serán utilizados en el programa. Las declaraciones
pueden ser (en este orden):
uses
const
type
var
procedure
function
La función "uses" se explicará más adelante, pero básicamente sirve
para incluir comandos extra a Turbo Pascal, para darle más
funcionalidad y ampliar sus capacidades. Habitualmente se usa de la
siguiente manera:
Program n;
uses CRT;
...
"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
número entero). Ej:
Const
PI = 3.141593;
LetraA = 'a';
"Type" declara un tipo especial de variable. Esto lo explicaré con
detalle más 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 *)
...
Recuerda que después de cada comando va un punto y coma (;), a menos
que el comando así lo especifique (como BEGIN, que JAMÁS lleva punto y
coma).
2. COMANDOS BÁSICOS
OK, ya sabemos como hacer las declaraciones en Pascal, pero ¿de qué
sirve si no sabemos como usarlas? Bueno, para eso están los comandos
en Pascal.
Lo primero es lo primero. ¿Cómo 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()
computador salta una línea después de escribir. Un ejemplo de
programa Pascal que escribiera un mensaje en la pantalla sería:
el
un
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 despliega: Yo me llamo Z4
2+2=4
Fíjense que el texto va entre comillas simples (''), mientras que los
números no. Las comillas hacen que Pascal considere todo eso como una
palabra y no como un número.
También puede ir, como se ve, una operación matemática 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 paréntesis. P. ej.:
Program Multiplicacion;
Var
a,b : Real; (* vamos a usar las variables a y b, así que las
declaramos *)
BEGIN
END.
Readln (a);
Readln (b);
Writeln (a*b);
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 Asignación ( := ). Y no, no es una carita. La
asignación se hace de la siguiente manera:
NombreVariable := Valor
Por ejemplo, si vamos a calcular la suma de dos números 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.
Nótese 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);
También, 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 número de decimales. Por ejemplo, (3.14:1:1) devolverá
(3.1).
3. TIPOS DE VARIABLES
Esto lo voy a explicar rápido. 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: número real, con decimales.
Single: ídem, más corto.
Double: ídem, más largo.
Extended: número real muy largo.
Comp: número real parecido a Double, más largo.
Boolean: valor lógico (verdadero o falso), 1=V, 0=F
Char: carácter (una sola letra, número o símbolo)
String: conjunto de letras, números 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
NO PUEDE
NO PUEDE
NO PUEDE
que NO PUEDE HABER DOS VARIABLES
HABER DOS VARIABLES CON EL MISMO
HABER DOS VARIABLES CON EL MISMO
HABER DOS VARIABLES CON EL MISMO
CON EL MISMO NOMBRE. Repito:
NOMBRE
NOMBRE
NOMBRE
(la razón es obvia)
Ah, otra cosa. Aquí se pueden declarar también los arrays "Arreglos").
Un array es un conjunto de variables que son la única excepción a la
regla anterior, ya que comparten el mismo nombre. Se diferencian por
un número que se denomina índice. Los arrays se declaran de cualquiera
de las siguientes formas:
Var
nombrearray: Array [a..b] of tipo;
o
Type
Var
Vector = Array [a..b] of tipo;
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 tendrán 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;
También 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 número (A5, A7, B9, Z13,
etc.) Se declaran igual que las otras, pero con la siguiente
modificación:
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 lógico, es decir, es correcto colocar lo siguiente:
Type
Matriz = Array [1..10]['a'..'z'] of Integer;
lo que nos dejaría algo parecido a Excel (con una letra y un número)
Aqui vemos algo nuevo ("Type"). Este comando declara un tipo especial
de variable. Por ejemplo, los arrays. Luego, en la sección Var, puedes
simplemente declarar el nombre del tipo especial que creaste. Otro
ejemplo sería:
Type
CadenaCorta = String[16];
Mes = 1..12;
Var
Palabra: CadenaCorta;
Actual: Mes;
Aquí se declara una variable de tipo "CadenaCorta"
"String" (conjunto de letras) con un tamaño máximo
una variable entera que tiene valores entre 1 y
tipos "subrango", modificaciones, limitaciones o
los valores de los otros tipos.
que es una variable
de 16 caracteres, y
12. Éstos son los
especificaciones a
Tambíen
se
pueden
declarar
los
tipos
enumerados,
que
son
identificadores que internamente toman un valor "secuencial", p. ej.:
Type
Estaciones = (primavera, verano, otoño, invierno);
Este ejemplo lo saqué de lapolitecnica.net.
Primavera será como el 0, Verano como el 1, etc.
4. CONDICIONES
Para
el
computador,
¿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. Condición IF
La forma general de la condición IF es la siguiente:
If (condición) then
begin
(* instrucciones *)
end;
donde (condición) es una comparación lógica 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 después de Then (entre begin y end;) serán ignoradas
si la condición es falsa.
Por ejemplo, si queremos ver si un número es mayor que 5, hacemos lo
siguiente:
Program Mayorque5;
var
a : byte;
BEGIN
Write ('Escriba un número: ');
Readln (a);
If (a>5) then
Writeln ('Es mayor que 5');
END.
Si es una sola instrucción, no es necesario colocar Begin ni End
separando las instrucciones. Nótese que End lleva punto y coma (end;).
Si queremos que cierto grupo de instrucciones se realize solo si la
condición es FALSA usamos la instrucción ELSE. Así:
If (condición) then
begin
(* esto solo se hará si la condición es verdadera *)
end
Else
begin
(* esto solo se hará si la condición es falsa *)
end;
¡El primer END no lleva punto y coma si está presente la instrucción
ELSE! Un ejemplo de IF-THEN-ELSE sería una ampliación del programa
anterior:
Program Mayoromenorque5;
Var
a : byte;
BEGIN
END.
Write ('Escriba un número: ');
Readln (a);
If (a>5) then
Writeln ('Es mayor que 5')
Else
Writeln ('Es igual o menor que 5');
Si queremos asegurarnos de que se cumplan varias condiciones en una
instrucción IF, usamos los operadores lógicos. Éstos son: And (Y), Or
(Y/O), Xor (O), Not (NO). Por ejemplo, si queremos asegurarnos de que
dos números 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 números 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 condición. Es decir que Not (a=b) es igual a (a<>b).
B. Condición 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
instrucción 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
(valor2):
...
(valorn):
End;
end;
begin
(* instrucciones *)
(* instrucciones *)
end;
begin
end
o
Case (variable) Of
(* instrucciones *)
(valor1):
begin
(valor2):
end;
begin
...
Else
(* instrucciones *)
(* instrucciones *)
end;
begin
end
(* instrucciones *)
End;
Nótese que el penúltimo 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 después de Else solo se ejecutarán si ninguno de los
valores es verdadero. También los valores se pueden agrupar si se
realiza la misma operación 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 instrucción muchas veces, sería ridículo
escribir, por ejemplo:
Writeln
Writeln
Writeln
Writeln
Writeln
Writeln
Writeln
Writeln
Writeln
Writeln
Writeln
Writeln
...
(5*1);
(5*2);
(5*3);
(5*4);
(5*5);
(5*6);
(5*7);
(5*8);
(5*9);
(5*10);
(5*11);
(5*12);
Para evitar eso se usan los ciclos, que repiten una instrucción o
grupo de instrucciones
tantas veces como se necesita. Los 3 ciclos básicos son los ciclos
While, Repeat y For.
Comencemos por lo más fácil:
A. Ciclo FOR
Este ciclo repite las instrucciones un número 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 podrían ser resumidas en:
For i:=1 to 12 do
Writeln (5*i);
(Recuerda que si hay una sola instrucción podemos omitir begin y end)
Un ejemplo de programa que usa un ciclo FOR es uno que calcule el
factorial de un número N.
El factorial de N (N!) se define como 1 * 2 * 3 * 4 * 5 * 6 * ... * N,
es decir el producto de
los N primeros números naturales. Aquí va:
Program factorial;
Label
1, 2;
Var
N, i, f : LongInt;
resp : Byte;
BEGIN
1:
Write ('Ingrese el número 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 usáramos DownTo, el resultado sería el mismo, pero tendríamos 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 (condición) Do
begin
(* instrucciones *)
end;
y
Repeat
(* instrucciones *)
Until (condición);
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 condición es falsa desde el principio, el ciclo no
se ejecuta ninguna vez.
En Repeat, el ciclo se ejecuta al menos una vez porque la condición
se comprueba al final.
2. En While, el ciclo se ejecuta mientras la condición sea verdadera;
en Repeat el ciclo se ejecuta mientras la condición 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 número al azar. Si lo adivina, aparece un mensaje
indicándolo; si no, el computador le indica al usuario si el número es
mayor o menor.
Para ello vamos a usar la función Random(n) que devuelve un número
entero entre 0 y n. Como es una función
de lo que podríamos llamar "Pascal extendido", es decir, una función
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 número entre cero y cien.');
Writeln ('Debes adivinarlo en el menor número de intentos posible. Te
daré pistas.');
Azar := Random (200);
Repeat
Readln (Resp);
If (Resp<Azar) then
Writeln ('Um... no. Más 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í, además de Repeat... Until usamos las funciones especiales
Random(), Randomize y Readkey(). Las
explicaré más abajo con detalle.
Un ejemplo de ciclo While sería 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 básicamente lo mismo, y cualquiera de
ellos se puede adaptar para cumplir la función de For.
6. OPERADORES Y FUNCIONES PREDEFINIDAS
(Explicación rápida otra vez. Bueno, esto es intuitivo)
Estos son los operadores que se usan en Pascal para operaciones
matemáticas:
+
Suma
Resta
*
Multiplicación
/
División real (si intentas dividir enteros con / te
dará error)
DIV
División entera (sin decimales, no sirve para reales)
^
Exponente (elevado a)
MOD
Resto de una división entera
Estos son los operadores lógicos (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 símbolos de agrupación 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)
:=
:
Asignación de valor
Declaración de variable
Estas son las funciones más comunes en Pascal:
Abs(x)
Valor absoluto (|x|)
Random(x)
Número al azar entre 0 y x (para que no se repitan usa
Randomize;)
Sqrt(x)
Raíz cuadrada de x
Trunc(x)
Parte entera de un número real x (Trunc(3.141593) = 3)
Frac(x)
Parte fraccionaria de un número real x (opuesto a
Trunc)
Round(x)
Redondea x (lo aproxima al entero más cercano)
Ord(x)
Código de una letra, p. ej. Ord('A') = 65
Chr(x)
Letra correspondiente al código, p. ej. Chr(65) = 'A'
Concat(s1,s2) Une las cadenas s1 y s2 en otra cadena
Length(s)
Muestra el tamaño 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)
Número irracional e (2.718281828...) elevado a x.
Int(x)
Parte entera del número x
Ln(x)
Logaritmo natural/neperiano del número x
Sqr(x)
Cuadrado de x
7. COMANDOS MISCELÁNEOS Y OTROS
Misceláneos:
Delay(n);
Hace una pausa de n milisegundos (requiere uses crt;)
Readkey;
Espera a que se presione una tecla, si se usa como
función le asigna
a la variable la tecla presionada, p. ej. A := Readkey;
(requiere uses crt;)
Randomize;
Reinicializa los números 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
PROCEDURE
BOOLEAN
FILE
WHILE
IF
CONST
BEGIN
CHAR
ARRAY
FOR
THEN
TYPE
END
STRING
BYTE
DO
ELSE
VAR
INTEGER
RECORD
REPEAT
TO
CASE
FUNCTION
REAL
SET
UNTIL
DOWNTO
8. PROCEDIMIENTOS Y FUNCIONES
Con estos términos... ejem, es decir, con esto termino.
Un procedimiento es un sub-programa independiente que cumple una
función específica 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 función 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 sería, um... Rescatemos el programa de
factoriales de más arriba.
Program factorial;
Label
1, 2;
Var
N, i, f : LongInt;
resp : Byte;
BEGIN
1:
Write ('Ingrese el número 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). Sería bastante tedioso, por decir lo menos,
reescribir el ciclo for varias veces. Pero, ¿y si hacemos una función?
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 están 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.
Fíjense 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).
También, si se fijan, para asignarle el valor a la función, se debe
usar como otra variable más.
Por ejemplo, la siguiente función daría siempre el valor 4 a una
variable:
Function Cuatro (): Byte;
begin
Cuatro := 4;
end;