Hemos visto que para escribir algo usaremos la orden "write". Entre paréntesis se indica lo que queremos mostrar. Si se trata de un texto que queremos escribir "tal cual", lo encerraremos además entre comillas, pero en ocasiones no desearemos que se escriba de forma literal, sino que el ordenador analice una cierta expresión y nos muestre su resultado. Por ejemplo, podemos realizar una suma de la siguiente forma:
(* Suma calculada *)
program Suma1;
begin
write(5+2);
end.
(* Resultado:
7
*)
A partir de ahora, nuestros programas de ejemplo, seguirán (siempre que sea posible) el esquema anterior: comenzarán con un comentario que recuerde su cometido, incluirán la palabra "program" al principio, seguida del cuerpo del programa, y terminarán con un nuevo comentario, que muestre lo que aparecería en pantalla al ejecutar el programa. No incluirán la orden "readLn;" al final, que, como hemos visto en el apartado 0.4, podría ser necesaria si usas Lazarus para que no se cierre la ventana sin que dé tiempo a leer su contenido.
Ejercicio propuesto 1.1.1: Crea un programa que calcule la suma de 23 y 38.
Ejercicio propuesto 1.1.2: Crea un programa que muestre el resultado de sumar 123456 y 789012.
Pero realmente hay más: con una misma orden "write" se pueden escribir varios datos, separados por comas. Por ejemplo, podemos escribir una operación matemática y su resultado con una única orden "write", así:
(* Suma detallada y calculada *)
program Suma2;
begin
write('5+2=', 5+2);
end.
(* Resultado:
5+2=7
*)
Ejercicio propuesto 1.1.3: Crea un programa que muestre la operación "1234 + 5486" y su resultado.
Ejercicio propuesto 1.1.4: Crea un programa que muestre la operación "5486 - 1234" y su resultado.
Ya sabemos que podemos escribir varios datos en una misma línea, bien usando dos órdenes "write" consecutivas, o bien con una única orden "write" que tenga varios datos separados por comas. Pero es frecuente que nos interese escribir datos en líneas distintas. Es fácil: en vez de "write" usaremos "writeLn", y el curso bajará a la línea siguiente de pantalla cuando termine de escribir:
(* Suma y avance de linea *)
program SumaWriteLn;
begin
write('Un ejemplo');
writeLn(' de suma:');
writeLn('5+2=', 5+2);
end.
(* Resultado:
Un ejemplo de suma:
5+2=7
*)
Ejercicio propuesto 1.2.1: Crea un programa que escriba "Hola" y, en la línea siguiente, tu nombre.
Ejercicio propuesto 1.2.2: Crea un programa que muestre la suma de 78 y 41 y, en la línea siguiente, su diferencia.
Ya hemos visto que podemos sumar con el símbolo "+" y restar con "-". La división también es fácil, con la barra de división: "/". La multiplicación puede parecer un poco menos intuitiva, porque se realiza con el "asterisco" ("*").
(* Operaciones aritmeticas (1) *)
program Operaciones1;
begin
writeLn('5+2=', 5+2);
writeLn('5-2=', 5-2);
writeLn('5/2=', 5/2);
writeLn('5*2=', 5*2);
end.
(* Resultado:
5+2=7
5-2=3
5/2=2.5000000000000000E+0000
5*2=10
*)
Ejercicio propuesto 1.3.1: Crea un programa que muestre el producto de 56 y 39.
Ejercicio propuesto 1.3.2: Crea un programa que calcule la multiplicación de 12345 por 98765.
Ejercicio propuesto 1.3.3: Crea un programa que muestre el resultado de dividir 12345 entre 974.
Como los datos del ejemplo anterior eran números enteros (sin cifras decimales), los resultados también son números enteros, excepto para la división, que sí tendrá cifras decimales, y aparece en un formato "raro". Dentro de poco veremos cómo mejorarlo.
Si queremos sólo la parte de la división, deberemos usar la palabra "div", mientras que con "mod" podemos obtener el resto de la división, de la siguiente manera:
(* Operaciones aritmeticas (2) *)
program Operaciones2;
begin
writeLn('7 div 2 = ', 7 div 2);
writeLn('7 mod 2 = ', 7 mod 2);
end.
(* Resultado:
7 div 2 = 3
7 mod 2 = 1
*)
Ejercicio propuesto 1.3.4: Crea un programa que muestre la división entera (sin decimales) de 12345 entre 974.
Ejercicio propuesto 1.3.5: Crea un programa que calcule la multiplicación de 12345 por 98765.
La operación "módulo" (mod) nos será mucho más útil de lo que parece: comprobando el resto de dividir un número entre 2 podemos saber si es par, comprobando el resto entre 10 o cualquier otro número podemos comprobar si es múltiplo de éste. La usaremos con una cierta frecuencia... dentro de poco...
También podemos realizar operaciones entre bits, que quizá te resulten todavía demasiado avanzadas si aún no has estudiado nada sobre el sistema binario de numeración, pero mencionaremos las ideas básicas, porque más adelante nos serán útiles en algunos casos puntuales.
Operación |
Resultado |
Sintaxis |
Ejemplo |
Complemento |
Cambiar 0 por 1 y viceversa |
not |
not 1100 = 0011 |
Producto lógico |
1 sólo si los 2 bits son 1 |
and |
1101 and 1011 = 1001 |
Suma lógica |
1 si al menos uno de los bits es 1 |
or |
1101 or 1011 = 1111 |
Suma exclusiva |
1 sólo si los 2 bits son distintos |
xor |
1101 xor 1011 = 0110 |
Desplazamiento a la izquierda |
Desplaza y rellena con ceros |
shl |
1101 shl 2 = 110100 |
Desplazamiento a la derecha |
Desplaza y rellena con ceros |
shr |
1101 shr; 2 = 0011 |
Un programa que los probase podría ser:
(* Operaciones a nivel de bit *)
program OpBits;
begin
writeLn('El complemento de 67 es: ', not 67);
writeLn('El producto lógico de 67 y 33 es: ', 67 and 33);
writeLn('Su suma lógica es: ', 67 or 33);
writeLn('Su suma lógica exclusiva es: ', 67 xor 33);
writeLn('Desplacemos a a la izquierda: ', 67 shl 1);
writeLn('Desplacemos a a la derecha: ', 67 shr 1);
end.
La respuesta que obtendremos es la siguiente:
El complemento de 67 es: -68 El producto lógico de 67 y 33 es: 1 Su suma lógica es: 99 Su suma lógica exclusiva es: 98 Desplacemos a a la izquierda: 134 Desplacemos a a la derecha: 33
Para comprobar que es correcto, podemos convertir al sistema binario esos dos números y seguir las operaciones paso a paso (insisto, puedes saltarte este apartado si no has estudiado el sistema binario, porque no es algo que vayamos a usar con frecuencia así que no necesitas dominarlo):
67 = 0100 0011
33 = 0010 0001
En primer lugar complementamos "a", cambiando los ceros por unos:
1011 1100 = -68
Después hacemos el producto lógico de A y B, multiplicando cada bit, de modo que 1*1 = 1, 1*0 = 0, 0*0 = 0
0100 0011 and 0010 0001 = 0000 0001 = 1
Después hacemos su suma lógica, sumando cada bit, de modo que 1+1 = 1, 1+0 = 1, 0+0 = 0
0100 0011 or 0010 0001 = 0110 0011 = 99
La suma lógica exclusiva devuelve un 1 cuando los dos bits son distintos: 1 xor 1 = 0, 1 xor 0 = 1, 0 xor 0 = 0
0100 0011 xor 0010 0001 = 0110 0010 = 98
Desplazar los bits una posición a la izquierda es como multiplicar por dos:
0100 0011 shl 1 = 1000 0110 = 134
Desplazar los bits una posición a la derecha es como dividir entre dos:
0100 0011 shr 1 = 0010 0001 = 33
Ejercicio propuesto 1.3.6: Crea un programa que, para los números 133 y 7, calcule: su producto lógico, su suma lógica, su suma exclusiva, el complemento del segundo, el resultado de desplazar el segundo dos veces a la izquierda y el resultado de desplazar el primero dos veces a la derecha.
Casi ningún programa real trabajará con datos prefijados. Lo habitual es que nuestros datos de partida los introduzca el usuario del programa, o se lean de un fichero o una base de datos, o se descarguen de Internet...
En todos esos casos, necesitaremos un "espacio" donde guardar esos datos. Eso es lo que llamaremos "una variable". Cada "variable" necesitará un nombre (por ejemplo, "x") y un tipo de datos, para que nuestro ordenador sepa cuánto espacio necesitará reservarle. El primer tipo de datos que usaremos será un número entero, que se designará con la palabra en inglés "integer".
Usaremos la palabra "var" para indicar que vamos a "declarar variables, algo que deberemos hacer antes de que comience el programa en sí. Ya dentro del cuerpo del programa, podremos dar un valor a la variable usando la expresión := (un símbolos de "dos puntos" y otro de "igual", seguidos, sin espacios entre medias), así:
(* Primer ejemplo de "variables" *)
program Var1;
var
x: integer;
begin
x := 5;
writeLn('x vale ', x);
end.
(* Resultado:
x vale 5
*)
Podemos utilizar más de una variable, y entonces todas ellas se declararían en el bloque "var":
(* Segundo ejemplo de "variables" *)
program Var2;
var
x: integer;
y: integer;
begin
x := 5;
y := 8;
writeLn('x vale ', x);
writeLn('y vale ', y);
writeLn('Su suma es ', x+y);
end.
(* Resultado:
x vale 5
y vale 8
Su suma es 13
*)
Si varias variables son del mismo tipo (por ahora es nuestro caso, porque sólo conocemos el tipo "integer"), podríamos declarar todas ellas a la vez, separadas por comas, para que el programa quede un poco más compacto, así:
(* Tercer ejemplo de "variables" *)
program Var3;
var
x,y: integer;
begin
x := 5;
y := 8;
writeLn('x vale ', x);
writeLn('y vale ', y);
writeLn('Su suma es ', x+y);
end.
(* Resultado:
x vale 5
y vale 8
Su suma es 13
*)
Por supuesto, las variables pueden tener nombres más largos, y eso algo que generalmente será conveniente aprovechar, para que nuestros programas sean tan legibles como sea posible:
(* Cuarto ejemplo de "variables" *)
program Var4;
var
numero, doble: integer;
begin
numero := 6;
writeLn('El numero es ', numero);
doble := numero * 2;
writeLn('Y su doble es ', doble);
end.
(* Resultado:
El numero es 6
Y su doble es 12
*)
Ejercicio propuesto 1.4.1: Crea un programa que defina una variable llamada "numero1" y otra llamada "numero2". La primera tendrá el valor 14 y la segunda el valor 37. Guarda su multiplicación en una variable llamada "producto" y luego muestra el valor de dicha multiplicación en pantalla.
Ejercicio propuesto 1.4.2: Crea una variable "n", que tenga el valor 123, y muestra el valor de la variable en pantalla. Ahora cambia su valor por 145 y comprueba que realmente se ha modificado. Finalmente, muestra el resultado de multiplicar esa variable por 7
Si queremos que el valor de la variable lo introduzca el usuario, usaremos la orden "readLn", abreviatura de "read" (leer) y "Line" (línea, porque se leerá hasta el final de línea, hasta que pulsemos Intro):
(* Datos introducidos por el usuario, 1 *)
program ReadLn1;
var
numero, doble: integer;
begin
write('Introduce un numero: ');
readLn(numero);
doble := numero * 2;
writeLn('Su doble es ', doble);
end.
(* Ejemplo de ejecucion:
Introduce un numero: 7
Su doble es 14
*)
Ejercicio propuesto 1.5.1: Crea un programa que pida un número al usuario y muestre su triple. Debe usar una única variable llamada "n".
Ejercicio propuesto 1.5.2: Crea un programa que pida dos números enteros y muestre su suma, usando variables llamadas "n1", "n2" y "suma".
Ejercicio propuesto 1.5.3: Crea un programa que pida dos números enteros y muestre su suma, diferencia, producto división del primero entre el segundo, y división del segundo entre el primero, usando dos variables llamadas "primerNumero" y "segundoNumero".
Ejercicio propuesto 1.5.4: Pide dos números al usuario y muestra su división entera (el primer número entre el segundo) y el resto de dicha división. Usa los nombres de variables que quieras.
Como curiosidad, también existe la orden "read", que no lee hasta el final de línea, sino hasta el siguiente espacio en blanco. Sólo tiene sentido utilizarla en el caso (poco habitual) de que queramos que el usuario introduzca varios valores en una misma línea, separados por espacios en blanco. Normalmente, si pedimos datos al usuario, querremos que los introduzca de uno en uno, y en ese caso será preferible usar "readLn".