Guía de programación básica de turbo Pascal (página 2)

Eres libre de dar a la variable un nombre descriptivo.
Por ejemplo el nombre de variable telefono es obvio que
contendrá algún tipo de número de teléfono.

La sentencia CLRSCR, nos permite borrar la
pantalla antes de correr el programa.. Es
primordial limpiar la pantalla cada vez que iniciemos un
programa, para que no se vean líneas de programas
anteriores. Para que funcione debes colocar la unidad
CRT.

CRT es la primera unidad que trataremos y es la
encargada de gestionar (entre otras cosas) la pantalla en modo
texto. Para
acceder a cualquier unidad, se emplea la sentencia Uses
justo después de Program y antes de las
declaraciones de variables:

Write es la orden que permite escribir un texto
en pantalla. El conjunto de todo lo que se desee escribir se
indica entre paréntesis. Cuando se trata de un texto que
queremos que aparezca tal cual, éste se encierra entre
comillas (una comilla simple para el principio y otra para el
final).

Writeln, que es exactamente igual que
Write con la única diferencia de que después
de visualizar el mensaje, el cursor (la posición en la que
se seguiría escribiendo, marcada normalmente por una
rayita o un cuadrado que parpadea) pasa a la línea
siguiente, en vez de quedarse justo después del mensaje
escrito.

ReadLee un valor de
teclado y lo
almacena en la variable

Read (Identificador);

El identificador puede ser cualquier variable definida
previamente, NO puede ser una constante. Puede ser también
un conjunto de variables, separadas entre comas, en este caso se
guardara el primer valor dado antes del [Enter] en el primer
identificador proporcionado, luego el segundo y así
sucesivamente hasta el último identificador.

La diferencia en el uso de la instrucción Read
con respecto a ReadLn es que en la primera, si se le dan mas
datos de los
que se introducirán se guardan en un buffer y se
usarán en la siguiente instrucción Read o ReadLn
del programa, en cambio ReadLn
ignora todo dato posterior a los que esten definidos en la
instrucción.

En caso de que se le indique a Read o ReadLn que lea un
tipo específico de valor, y se le proporcione otro
diferente se generará un error y se detendrá la
ejecución del programa.

Operaciones básicas

Las operaciones
básicas en Turbo Pascal
están formadas por dos partes: el operador y los
operandos.

Un operador es el símbolo que le indica al
programa que operación realizará y los operandos
son los datos sobre los cuales se efectuará la
operación.

Los operadores de Turbo Pascal
son:

El tipo de datos que pascal regresa como resultado de
una operación dependerá del tipo de datos usados
como operandos. Por ejemplo, la suma de dos enteros da como
resultado otro entero, y la suma de dos números reales da
como resultado otro número real.

Operadores DIV y MOD

La división de dos números, sin importar
su tipo, dará como resultado un número real,
así que para dividir dos enteros, y obtener el resultado
como entero, Turbo Pascal ofrece el operador DIV, el cual da el
resultado entero de una división entre enteros, y el
operador MOD que regresa el residuo de una división de
enteros.

Su sintaxis es:

entero := dividendo DIV divisor

entero := dividendo MOD divisor

El siguiente programa es un ejemplo del uso de los
operadores aritméticos:

Operadores de
Relación

Los operadores relacionales nos sirven para
determinar la relación que tiene una expresión con
otra. Los operadores relacionales que manejaremos en
Pascal son los siguientes:

Sentencia
IF…THEN…ELSE

Esta expresión es utilizada para ejecutar una
sentencia en el caso que una condición establecida sea
verdadera, de lo contrario se podra ejecutar una sentencia
distinta. Su sintaxis es:

IF condición THEN instrucción ELSE
otro

Donde condición es la expresión que se
evaluará, en caso de ser verdadera se ejecutará la
sentencia dada como instrucción, en caso de que la
condición sea falsa se ejecutara la sentencia dada como
otro. Ejemplo:

En este pequeño programa la variable Contador se
incrementará desde 1 hasta 50, la sentencia condicional IF
verificará si es verdad que Contador es mayor a 10, de ser
así se escribirá en pantalla el valor de la
variable, de lo contrario se escribira en la pantalla un caracter
"*". Como el contador inicia desde 1, tenemos que se imprimiran
10 asteriscos antres del primer número, que será el
11, valor que si cumple la condición "Contador > 10"
(la hace verdadera).

La sección ELSE con su correspondiente sentencia
son opcionales y pueden omitirse en caso de no
necesitarse.

Sentencias IF
anidadas

Es posible utilizar en una expresión del tipo
IF..THEN..ELSE una sentencia compuesta como la sentencia a
ejecutarse en caso de que la condición sea verdadera,
así como en la sentencia posterior a un ELSE, de esta
forma podemos utilizar otra sentencia IF..THEN..ELSE dentro de la
anterior, para de esta forma evaluar varias condiciones una
dentro de otra. Ejemplo:

Ciclos FOR

El ciclo FOR repite una sentencia un determinado
número de veces que se indica al momento de llamar al
ciclo.

Lo que hace FOR es que incrementa una variable en uno
desde un valor inicial hasta un valor final ejecutando en cada
incremento la sentencia que se quiere repetir. Su sintaxis
es:

FOR identificador := inicio TO fin DO
instrucción;

Donde el identificador es la variable que se
incrementará, inicio es el primer valor que tendrá
dicha variable y fin es el valor hasta el cual se
incrementará la misma; instrucción es la sentencia
(sencilla o compuesta) que se ejecutará en cada incremento
de la variable.

El siguiente ejemplo escribe los números del 1 al
50 en pantalla. La variable utilizada es "Numero".

Una de las limitaciones de los ciclos FOR es que una vez
iniciado el ciclo se ejecutará el número de veces
predefinido sin posibilidad de agregar o eliminar
ciclos.

Es posible hacer que un ciclo cuente hacia atrás,
es decir que la variable en lugar de incrementarse se decremente.
Para ésto cambiamos la palabra TO por
DOWNTO, y colocamos el valor mayor a la izquierda y el
menor a la derecha.

Ejemplo:

Ciclos
WHILE

Los ciclos WHILE ofrecen la ventaja de que la
ejecución se realiza mientras se cumpla una
condición, por lo tanto es posible controlar el
número de repeticiones una vez iniciado el ciclo. Su
sintaxis es:

WHILE condición DO
instrucción

Donde condición es la condición que se
evaluará, mientras ésta sea verdadera se
ejecutará la instrucción, que es una sentencia
simple o compuesta.

Un programa que escriba los números
del 1 al 50, utilizando el ciclo WHILE se vería como
sigue:

Al final del programa la variable Numero guardará
el valor 51, que fué el valor que no cumplió con la
condición establecida en el ciclo WHILE.

Ciclos
REPEAT-UNTIL

Este tipo de ciclos es muy parecido a los ciclos WHILE,
la diferencia entre ambos es que en WHILE la condición se
evalúa al principio del ciclo, en cambio en REPEAT-UNTIL
se evalúa al final, lo que significa que en un ciclo
REPEAT-UNTIL la sentencia se ejecutará por lo menos una
vez, cosa que puede no ocurrir en el ciclo WHILE.
Ejemplo:

Para crear un buen programa es necesario dotarlo con
capacidad de desición con base en las variables o eventos definidos
por el programador, para que el programa sea aplicable en un
entorno más generalizado y no solo para un problema
específico.

Selecciones
CASE

Esta forma de control se
utiliza cuando se va a evaluar una expresión que puede
contener varios datos diferentes y en cada dato deberá
realizar una acción
especial. Por ejemplo, si se crea un menú con diferentes
opciones se realizará un determinado proceso para
cada acción, aunque la selección
por parte del usuario se haga desde el mismo lugar.

El siguiente programa ilustra el uso de la forma CASE,
el programa preguntará un número al usuario y lo
clasificará de acuerdo a su valor.

GOTO

La sentencia GOTO es una sentencia utilizada para
alterar el flujo del programa, es decir, para ir a ejecutar una
sentencia en un lugar diferente del programa y no la linea
siguiente.

El uso de GOTO no es aconsejable ya que destruye el
modelo de la
programación estructurada que es la que se
utiliza en Turbo Pascal, además se cuenta con las estructuras de
datos anteriores que hacen casi innecesario su uso.

Para utilizar este tipo de salto es necesario declarar
etiquetas, que no son otra cosa que el identificador que
marcará el lugar a donde se dirigirá el flujo del
programa al momento de usar el GOTO. La declaración de
etiquetas se hace antes que la de constantes y variables, la
palabra reservada para su declaración es LABEL. El
nombre de la etiqueta es un nombre de un identificador como
cualquier otro, pero al utilizarse debe terminar con dos puntos
":".

La sintaxis del comando es:

GOTO etiqueta;

Ejemplo:

Nota: normalmente se debe agregar la libreria CRT
, despues del PROGRAM, PARA poder usar el
comando CLRSCR, Que nos permite borrar la pantalla antes
de correr el programa.

Ejemplos.

Program Suma; {Ejemplo de un programa que
Suma}Uses CRT;Var    
A,B,Resultado:integer;Begin    
CLRSCR;     Write ('Ingrese primer
numero:');     Readln
(A);     Write ('Ingrese segundo
numero:');     Readln
(B);    
Resultado:=A+B;     Writeln ('El Resultado
es:',Resultado);     Readln;End.

***********************************************************

PROGRAM EJER2B;

USES CRT;

VAR x,y:REAL;

VAR suma,rest,mult:REAL;

VAR divi:REAL;

{suma, resta, multiplica y divide 2 numeros
reales}

BEGIN

WRITELN ('Este programa suma, resta,
multiplica y divide:');

WRITELN ('Escriba dos numeros
reales');

WRITELN (' ');

Read(x);

Read(y);

suma:=x + y;

rest:=x – y;

mult:=x * y;

divi:=x / y;

ClrScr;

WRITE ('SUMA:'); WRITELN
(suma:3:0);

WRITE ('RESTA:'); WRITELN
(rest:3:0);

WRITE ('MULTIPLICACION:'); WRITELN
(mult:3:0);

WRITE ('DIVISION:'); WRITE
(divi:5:2);

END.

******************************************************************

PROGRAM EJER4B;

USES CRT;

VAR base,altura:REAL;

VAR area:REAL;

BEGIN

{Este programa sirve para calcular el area
de un triangulo}

ClrScr;

WRITELN ('PARA CALCULAR EL AREA DE UN
TRIANGULO:');

WRITELN (' ');

WRITE ('ESCRIBE LA BASE: '); READLN
(base);

WRITE ('ESCRIBE LA ALTURA: '); READLN
(altura);

WRITELN (' ');

area:=(base * altura) / 2;

WRITE ('EL AREA DEL TRIANGULO ES: '); WRITE
(area:5:2);

END.

Program Saludo; Var    
nombre: string[20]; Begin     Writeln
('Introduce tu nombre, por favor');    
Readln (nombre);     Write ('Hola
',nombre);     Readln;End.

******************************************************

Program
AreaCirculo;Uses    
Crt;Const     pi = 3.1415927;
{Declaración de constante}Var    
area: Real; {Area del círculo}    
radio:
Integer; {Radio a teclear}Begin     Write
('Radio: ');     ReadLn
(radio);     area := pi * radio *
radio;     WriteLn ('Area: ',
area);End.

PROGRAM EJER10B;

USES CRT;

VAR a,b,c:REAL;

VAR resultado:REAL;

BEGIN

{Calcula la incognita positiva de una
ecuacion de 2º grado}

ClrScr;

WRITE ('Para calcular la incognita positiva
de una ecuacion');

WRITE (' de segundo grado escriba todas las
variables:');

WRITELN (' ');

WRITELN (' ');

WRITE ('Escriba a: '); READLN
(a);

WRITE ('Escriba b; '); READLN
(b);

WRITE ('Escriba c; '); READLN
(c);

WRITELN (' ');

resultado:=(-b +sqrt(sqr (b) –
4*a*c))/(2*a);

WRITE ('RESULTADO: ');
WRITE(resultado:5:2);

END.

PROGRAM EJER15B;

USES CRT;

VAR arista:REAL;

VAR area, volumen:REAL;

BEGIN

{Sirve para calcular el area y el volumen
de un tetraedro}

WRITELN ('PARA CALCULAR EL AREA Y VOLUMEN
DE UN TETRAEDRO: ');

WRITE ('ESCRIBA EL VALOR DE LA ARISTA: ');
READLN (arista);

WRITELN (' ');

area:= 2 * sqr(arista) *
sqrt(3);

volumen:= ((sqr(arista) * arista) / 3) *
sqrt(2);

WRITE ('AREA DEL OCTAEDRO: '); WRITELN
(area:5:2);

WRITE ('VOLUMEN DEL OCTAEDRO: '); WRITE
(volumen:5:2);

END.

Program
Numeros;Uses    
CRT;Var    
numero:integer;Begin    
CLRSCR;     Write ('Escriba un número:
');     Readln
(numero);     If numero>0
Then         
Writeln ('El número es positivo');    
Readln;End.

********************************************************

Program
Numeros;Uses    
CRT;Var    
numero:integer;Begin    
CLRSCR;     Write ('Escriba un número:
');     Readln
(numero);     If numero<0
Then         
Writeln ('El número es negativo')    
Else         
Writeln ('El número es positivo o
cero');     Readln;End.

**********************************************************

Program Mayor;Uses    
CRT;Var    
N1,N2,N3,NMayor:integer;Begin    
CLRSCR;     Write ('Ingrese primer
número: ');     Readln
(N1);     Write ('Ingrese segundo
número: ');     Readln
(N2);     Write ('Ingrese tercer
número: ');     Readln
(N3);     If (N1>=N2) And (N1>=N3)
Then;         
NMayor:=N1;     If (N2>=N1) And
(N2>=N3)
Then;         
NMayor:=N2;     If (N3>=N1) And
(N3>=N2)
Then;         
NMayor:=N3;     Writeln ('El numero mayor es:
',NMayor);     Readln;End.

Program
Area;Uses    

CRT;Var    
area,B,H:real;      i,num:integer;

Begin    
CLRSCR;    

Writeln ('¿Cuantas areas desea
calcular?');    

Readln
(num);    

For i:=1 To num
Do         

Begin              
Writeln ('Triangulo #:
',i);              

Writeln ('Ingrese base:
');              

Readln
(B);              

Write ('Ingrese altura:
');              

Readln
(H);         
    

area:=(B*H)/2;              

Writeln ('El Area es:
',area:8:4);         

End;    
Readln;End.

Program
Sumar;Uses    

CRT;Var    
N,num,cont,suma:integer;

Begin    
CLRSCR;    

Writeln ('¿Cuantas números
desea ingresar?');     

Readln (N);    
suma:=0;     For cont:=1 To N
Do         

Begin              

Write ('Ingrese numero:
')              

Readln
(num);              
suma:=suma+num;         

End;    

Writeln ('La suma total es: ',suma);
    

Readln;End.

PROGRAM EJER18B;

USES CRT;

VAR a,b,c:REAL;

VAR resultado1,resultado2:REAL;

BEGIN

{Calcula ecuaciones de
segundo grado}

ClrScr;

WRITE ('ESTE PROGRAMA SIRVE PARA CALCULAR
ECUACIONES ');

WRITELN ('DE SEGUNDO GRADO');

WRITELN (' ');

WRITELN ('Introduzca: a, b y c:
');

WRITELN (' ');

READLN (a);

READLN (b);

READLN (c);

resultado1:=(-b + sqrt(sqr(b) – 4*a*c)) /
(2*a);

resultado2:=(-b – sqrt(sqr(b) – 4*a*c)) /
(2*a);

WRITELN ('RESULTADO DE LA EXPRESION:
');

WRITE ('VALOR 1: '); WRITELN
(resultado1:5:2);

WRITE ('VALOR 2; '); WRITE
(resultado2:5:2);

END.

PROGRAM EJER22B;

USES CRT;

VAR horas, minutos,
segundos:INTEGER;

VAR cantidad:INTEGER;

BEGIN

ClrScr;

WRITE ('Escriba los segundos para
transformarlo a horas,');

WRITELN (' minutos y segundos');

READLN (cantidad); {Es el numero de
segundos que se introducen}

WRITELN ('');

horas:= cantidad div 3600;

minutos:= (cantidad mod 3600) div
60;

segundos:= (cantidad mod 3600) – (minutos *
60);

{Los segundos son: las horas – los minutos
pasados a segundos}

WRITELN ('EN ' ,cantidad, ' SEGUNDOS HAY:
');

WRITE (horas,' horas ',minutos,' minutos
',segundos,' segundos');

END.

Autor:

Omar Hernández

Mayo, 2009

República Bolivariana de Venezuela
Ministerio Del Poder Popular Para La Educación
Superior Municipio Carlos Arvelo Edo Carabobo

U.B.VMisión Sucre – Aldea
Tacarigua