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 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 (ab). 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 (resp2) 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 (RespAzar) 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 Mayor que < Menor que = 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 (resp2) 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 (resp2) 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;