Introduccion Al Pascal

ALGORTMICA Y PROGRAMACIN
Introduccin al Pascal
PASCAL
Es un lenguaje de alto nivel, fuertemente tipeado (se debe definir el tipo de todos los datos), de propsito general, compilable, estructurado y procedimental.
Un lenguaje compilable significa que todo programa ser deber pasar por los siguientes
pasos:
a) Ser escrito en un editor de texto (en un formato ASCII)
b) Luego lo toma el Compilador comprueba que todas las instrucciones del programa estn escritas siguiendo la sintaxis de PASCAL. Si todo es correcto lo traduce a Lenguaje de Mquina (Assembler).
c) Pasa posteriormente al Linkeador (o montador), une los distintos mdulos que
pueden componer un programa, unifica los cdigos de los distintos subprogramas, y de los datos. Pasndolo por ltimo a cdigo de mquina.
TIPOS DE DATOS
Los diferentes objetos de informacin con los que un programa Pascal trabaja se conocen colectivamente como datos. Todos las datos tienen un tipo asociado con ellos. Un dato
puede ser un simple carcter, tal como 's', un valor entero tal como 35 o un nmero real tal como 1415,92. Una operacin de suma no tiene sentido con caracteres, slo con nmeros. Por
consiguiente, si el compilador detecta una operacin de suma de dos caracteres, normalmente
producir un error. Incluso entre tipos numricos, la operacin de suma se almacena de modo
distinto. Esto se debe a que nmeros enteros y reales se almacenan de modos diferentes. A
menos que el programa conozca el tipo de datos, si es un valor entero a real, no puede ejecutar correctamente la operacin de suma.
La asignacin de tipos a los datos tiene dos objetivos principales:
1. Detectar errores de operaciones en programas
2. Determinar cmo ejecutar las operaciones
Pascal se conoce como lenguaje "fuertemente tipeado" (strongly.typed) o de tipos fuertes. Esto significa que todos las datos utilizados deben tener sus tipos declarados explcitamente y el lenguaje limita la mezcla de tipos en las expresiones. Pascal detecta muchos errores de
programacin antes que el programa se ejecute. La ventaja de los lenguajes de tipos fuertes
(ricos en tipos de datos) es que se gasta menos esfuerzo en la depuracin de programa, ya
que el compilador detecta muchos de esos errores
El tipo de un dato determina la naturaleza del conjunto de valores que puede tomar una
variable. Otro concepto importante a tener en cuenta es la representacin interna de los nmeros, o al menos el espacio de memoria ocupado por una variable de un tipo dado.
La unidad de medida de la capacidad de memoria, como ya hemos visto es el byte (octeto). Un byte se compone de ocho cifras binarias (bits) que pueden tomar cada una el valor 0
1.
Ordinales
Integer
Boolean
Char
Enumerado
Subrango
No Ordinales
Reales
Tipos Simple
Datos Estticos
String
Array
Registro
Tipos de Datos
-1-
Tipos Estructurado
Conjunto
Archivo
Tipos procedimientos
Datos Dinmicos
Procesos
Tipos Punteros
Tipos Enteros
Tipo
byte
integer
longint
shortint
word
Rango
0 .. 255
-32768 .. 32767
-247483648 .. 24748367
-128 .. 127
0 .. 65535
Formato
1 Byte
2 Bytes
4 Bytes
1 Byte
2 Bytes
El tipo integer se almacena en memoria como 2 (dos) bytes, el bit de mayor peso de los
dos bytes es el bit de signo. Se puede separar un entero en sus dos bytes utilizando las funciones internas Hi y Lo
Hi devuelve el byte de mayor peso de los dos bytes de memoria
Lo devuelve el byte de menor peso
Nmeros Reales
Tipo
real
single
double
extended
comp
Rango
2.9x10-39 .. 1.7x1038
1.5x10-45 .. 3.4x1038
5.0x10-324 .. 1.7x10308
1.9x10-4932 .. 1.1x104932
-(263 +1)
.. 263 +1
Cifras
11-12
7-8
15-16
19-20
19-20
bytes
6
4
8
10
8
Tipos carcter (Char)

El tipo char es un tipo de datos que puede contener un solo carcter. Cada uno de estos
caracteres puede ser expresado gracias al cdigo ASCII ampliado.
Ejemplo
A a b * 5
Se le puede asignar a una constante un carcter por medio de su cdigo
#65
equivale a
chr(65)
equivale A
#26 o ^Z
cierre del archivo
#27
tecla ESC
#13
tecla ENTER
Tipos lgicos (boolean)
El tipo lgico (boolean) es, al igual que el carcter, parte de ISO Pascal estndar. Los valores de tipo lgico pueden tomar slo das valores posibles: true (verdadero) y false (falso). Al
igual que el tipo char, el tipo boolean es un tipo ordinal, que significa que tiene un nmero fijo
de posibles valores que existen en un orden definido. Una variable lgica ocupa slo un byte en
memoria. Los valores lgicas son de tipo ordinal, y sus relaciones son:
false < true
-2-
Tipos de datos definidos por el usuario
Todos los tipos de datos estudiados hasta ahora son de tipo simple, predefinidos por Turbo Pascal y listos para utilizar. Sin embargo, uno de los aspectos ms potentes de Turbo Pascal es su capacidad para crear estructuras de datos a partir de estos datos simples. Los datos
estructurados aumentan la legibilidad de los programas y simplifican su mantenimiento.
Los tipos de datos definidas por el usuario se clasifican en:
q Escalares definidos por el usuario (enumerado y subrango)
q Registros
q Arrays
q Conjunto (set).
q Archivo (file).
q Puntero
q Procedimiento
Estos tipos de datos se vern en sucesivas clases.
Tipo cadena (string)
Un tipo string (cadena) es una secuencia de caracteres de cero o ms caracteres correspondientes al cdigo ASCII, escrito en una lnea sobre el programa y encerrada entre apstrofos.
El tratamiento de cadenas es una caracterstica muy potente de Turbo Pascal que no
contiene ISO Pascal estndar, aunque tiene mucha similitud con el tipo packed array.
Ejemplos
'Turbo'
'Ests de acuerdo'
#13#10
,
Notas
Una cadena sin nada entre las apstrofos se llama cadena nula o cadena vaca
La longitud de una cadena es el nmero de caracteres encerrados entre los apstrofos.
CONSTANTES
Una constante es un valor que no puede cambiar durante la ejecucin del programa, recibe un valor en el momento de la compilacin del programa y este valor no puede ser modificado.
Las constantes pueden ser
constantes literales
constantes con nombres o declaradas
constantes expresin (slo en la versin 5.0)
constantes de tipos (tipeadas)
Las constantes deben ser declaradas antes de su utilizacin y pueden ser enteros o reales,
caracteres o cadenas de caracteres, conjuntos o arrays, e inclusive de tipo enumerado
Constantes literales
Una constante literal es un valor de cualquier tipo que se utiliza como tal.
VolumenEsfera := 4/3 * Pi * Radio * Radio * Radio,
4 y 3 son constantes literales de valores 4 y 3.
Constantes con nombres
Son constantes que se identifican por un nombre y el valor asignado.
Formato
const
-3-
identificador = valor,
Ejemplos
const
Pi = 3.141592;
DosPi = 2 * Pi;
Direccion = $06;
caracter = 'B';
cuenta = 625;
Epsilon = 1E-4;
Esc = #27;
CRLF = ^M^J;
{lee un valor real}

{ representa valor hexadecimal }
{ es un carcter }
{ lee un entero }
{ lee un real }
{ carcter de control }
{ secuencia CR/LF. retorno de carro/avance de lineal }
En Pascal estndar, la declaracin de constantes se sita inmediatamente despus de la

cabecera Program. En Turbo Pascal no es obligatoria la situacin anterior, pero si recomendable.
VARIABLES
Las variables son objetos cuyo valor puede cambiar durante la ejecucin del programa. El
cambio se produce mediante sentencia ejecutables.
Todas las variables de un programa Pascal deben ser declaradas antes de ser usadas
Declaraciones
var
variable1 : tipo1;
variable2 : tipo2;
.........................
.........................
variableN : tipoN;
Ejemplos
NumeroEmpleado
: Integer;
Horas
: real;
Tasas
: real;
Edad
: Integer;
Apellidos
: string [30];
Letra1, Letra2, Letra3 : char;
Num1, Num2
: integer;
{ nmero de empleado }
{ horas trabajadas }
{ tasa horaria }
{ edad del empleado }
{ apellidos del empleado }
Notas
Es buena prctica de programacin utilizar nombres de variables significativas que
sugieren lo que ellas representan, ya que esto hace al programa ms legible y fcil
de comprender, tambin es buena prctica incluir breves comentarios que indiquen
cmo se utiliza la variable. Un comentario es cualquier frase encerrada entre llaves
{ } o bien entre signos (*, *)
SENTENCIAS
Las sentencias describen las acciones algortmicas que pueden ser ejecutadas. En general las sentencias se clasifican en, ejecutables (especifican operaciones de clculos aritmticos
y entradas/salidas de datos) y no ejecutables (no realizan acciones concretas, ayudan a la legibilidad del programa, pero no afectan en la ejecucin del Programa). Las sentencias ejecutables aparecen en el cuerpo del programa a continuacin de la palabra reservada Begin
-4-
LA SENTENCIA DE ASIGNACION
La sentencia de asignacin se utiliza para asignar (almacenar) valores o variables. La
asignacin es una operacin que sita un valor determinado en una posicin de memoria. La
operacin de asignacin se representa en pseudocdigo con el smbolo '', para denotar que
el valor situado a su derecha se almacena en la variable situada a la izquierda
Formato
Variable expresin
variable
identificador vlido declarado anteriormente
expresin variable, constante o una expresin o frmula a evaluar
En Pascal el operador '-' se sustituye por el smbolo := , que se denomina operador de asignacin
Variable := expresin
El valor de expresin se asigna a la variable.
Precaucin
El tipo de expresin debe ser del mismo tipo que el de la variable.
Ejemplos
A :=16 ;
Inicial := 'LJ;
Interruptor :=true;
N1 := N2;
N1 := N1 + 5;
Car := #70;
cir F
16 se asigna a la variable A
se asigna LJ a la variable Inicial
se asigna el valor true. (verdadero) a Interruptor
el valor de la variable N1 se cambia por el valor de la variable N2
el valor de la variable N1 se incrementa en 5
se asigna a la variable Car el carcter 70 del cdigo ASCII, es de-
EXPRESIONES Y OPERACIONES ARITMETICAS

Las variables y constantes estudiadas anteriormente se pueden procesar utilizando operaciones y funciones adecuadas a sus tipos En este punto se examinarn las expresiones y
operaciones que se utilizan con datos numricos.
Operadores aritmticos: +, -, *, /
Los operadores aritmticos (+,-, *) pueden ser utilizados con tipos enteros o reales. Si
ambos son enteros, el resultado es entero; si alguno de ellos es real, el resultado es real.
2+3 = 5
2+3.0 = 5.0
Operadores aritmticos div y mod
Solo se pueden utilizar con enteros, la salida es otro entero. Div devuelve el valor de
la divisin entera y Mod da el resto de la divisin entera.
17 DIV 5 3
17 MOD 5 2
Reglas de expresiones (prioridad)
Se respeta las mismas prioridades del lgebra.
-5-
OPERACIONES ENTRADA/SALIDA
Los datos se pueden almacenar en memoria de tres formas diferentes: asociados con
constantes, asignados a una variable con una sentencia de asignacin o una sentencia de lectura. Ya se han examinado las dos primeras. El tercer mtodo, la sentencia de lectura, es el
ms indicado si se desea manipular diferentes datos cada vez que se ejecuta el problema.
Adems, la lectura de datos permite asignar valores desde dispositivos hasta archivos externos
(por ejemplo, un teclado o una unidad de disco) en memoria se denomina operacin de entrada
o lectura.
A medida que se realizan clculos en un programa, se necesitan visualizar los resultados
Esta operacin se conoce como operacin de salida o de escritura.
En los algoritmos las instrucciones de entrada/salida escritas en pseudocdigo son:
leer (listas de variables entrada)
leer (v. z, x)
escribir (listas de variables salida)
escribir (a, b, c)
En Pascal todas las operaciones de entrada/salida se realizan ejecutando unidades de

programa especiales denominadas procedimientos de entrada/salida que forman parte del
compilador Pascal y sus nombres son identificadores estndar:
Procedimientos de entrada Read ReadLn procedimientos de salida Write WriteLn
La escritura de resultados (salida)
Los programas para ser tiles deben proporcionar informacin de salida (resultados) Esta
salida toma informacin de la memoria y la sita (almacena) en: la pantalla, en un dispositivo
de almacenamiento (disco duro o flexible), o en un puerto de E/S (puertos serie para comunicaciones o impresoras, normalmente paralelos)
Procedimiento WriteLn
El propsito de WriteLn es escribir (visualizar) informacin en la pantalla
Formato
WriteLn (tem, tem..): 1
tem es el objeto que desea visualizar: un valor literal (entero, real, un carcter una cadena, o
un valor lgicotrue o false). una constante con nombre, una variable, o una llamada a funcin
Cuando se ejecuta el procedimiento WriteLn, se visualizan todos los elementos en el orden dado y en la misma lnea. Al terminar de visualizar toda la lnea, el cursor avanza (salta) al
comienzo de la siguiente lnea.
Procedimiento Write
Como se ha dicho, despus de ejecutar el procedimiento WriteLn, el cursor avanza (salta)
al comienzo de la siguiente lnea. Si se desea que el cursor quede en la misma lnea se debe
utilizar el procedimiento Write.
Formatos de salida
Turbo Pascal permiten controlar en cierta medida las instrucciones de salida que presentan resultados. Es posible especificar el nmero de posiciones del campo de escritura. Para los
nmeros reales es posible precisar el nmero de decimales deseado.
Se pueden utilizar especificadores de formato de campo para definir dicha anchura.
x := 265.7892
WriteLn(x :10 :4);
265.7892
-6-
WriteLn(x :10 :2);
WriteLn(x :6 :4);
x := 14;
WriteLn(x :4);
x:=14.00;
WriteLn(x :4);
cade := AB
WriteLn(cade :4);
265.79
265.7892
0. 14E+02
14
AB
Lo anteriormente expresado es vlido para el proceso WRITE

Impresin de resultados (salidas a impresora)
Las salidas a pantalla se obtienen mediante los procedimientos Write y WriteLn. Si se
desea enviar resultados a otro dispositivo, es preciso especificar el nombre del archivo como
primer argumento de las instrucciones Write y WriteLn. Para poder realizar la operacin de enviar salidas a la impresora, en lugar de a la pantalla, se necesita la unidad Printer.
Printer define un archivo llamado lst y asocia este archivo al puerto de comunicaciones
LPTI (impresora) del DOS. Se pueden enviar datos a la impresora, incluyendo lst en las instrucciones Write y WriteLn.
Es preciso, sin embargo, definir previamente en la seccin uses la unidad printer.
Ejemplo
uses
Printer
var
.........................
begin
.........................
Write (Lst, 'el .......................... )
WriteLn (Lst, 'pl............ )
.........................
end.
Este programa imprime en la impresora:
Regla
Siempre que desee escribir en impresora, deber incluir en su programa la lnea
uses printer
y luego aadir en cada sentencia Write/WriteLn la palabra lst
La entrada de datos (lectura)
Los datos que se pueden leer son: enteros, reales, caracteres o cadenas. No se puede
leer un boolean o un elemento de tipo enumerado.
Los datos estructurados, arrays, registros o conjuntos, no se pueden leer globalmente y
se suele recurrir a disear procedimientos especficos.
Los procedimientos de lectura son Read y ReadLn.
Formato
-7-
Read (var1, var2, ...);
ReadLn (var1, var2, ...);
var igual que WRITE
La entrada de datos desde el teclado se hace un valor cada vez. Las instrucciones
ReadLn y Read esperan hasta que se pulsa la tecla ENTER (RETURN) antes de asignar un
valor a la variable.
Ejemplo
ReadLn (Nombre);
ReadLn (Horas);
Read (Tasas)
El usuario debe introducir los datos de entrada en el orden en que aparecen las instrucciones read,
Diferencias entre Read y ReadLn
En Read, despus de pulsar la tecla ENTER , el cursor permanece inmediatamente
despus del ltimo carcter introducido. En ReadLn, el cursor se enva al principio de la siguiente lnea, tras pulsar la tecla ENTER .
No es aconsejable ingresar ms de un dato por instruccin.
OPERACIONES BSICAS DE UTILIDAD
En este punto se describen dos utilidades:
Clrscr
limpieza o borrado de la pantalla
GotoXY
movimiento del cursor
El borrado (limpieza) de la pantalla: Clrscr

Las rdenes o procedimientos que podr utilizar a partir de ahora: Clrscr y GotoXY, aunque posteriormente se volvern a mencionar. Ambos procedimientos pertenecen a la unidad
winCrt.
La orden (procedimiento) Clrscr borra (limpia) la pantalla (ventana actual) y sita el cursor
en la esquina superior izquierda. Turbo Pascal considera las coordenadas de la esquina superior izquierda :1,1.
Para poder utilizar Clrscr, deber declarar en la clusula uses la unidad WinCrt.
Regla
Es una buena costumbre utilizar en todos los programas la unidad WinCrt, mediante
la clusula uses; ello permite el uso de Clrscr y GotoXY, entre otras rutinas de utilidad.
Movimiento del cursor
La orden (procedimiento) GotoXY mueve el cursor a la posicin x, y, donde x es la columna (contando de izquierda a derecha) e y es la fila (contando de arriba-abajo).
GotoXY (x, y)
La esquina superior izquierda es 1.1. GotoXY requiere el uso de la unidad WinCrt.
-8-
EL ESTILO DE PROGRAMACIN
El buen estilo de programacin es, sin lugar a duda, una de las caractersticas ms notables que debe tener un programador. Un programa con buen estilo es ms fcil de leer, de corregir -si contiene un error- y de mantener. Aunque la experiencia proporciona el estilo, existen
una serie de reglas que se recomiendan seguir desde el principio del aprendizaje en programacin.
Sangrado (indentacin)
Aunque los programas escritos en Pascal no exigen reglas estrictas en su escritura, es
prctica habitual realizar sangrado en los bloques y unidades de programas fundamentales
Comentarios
La legibilidad de los programas aumenta considerablemente utilizando comentarios. Un
comentario es un texto explicativo ms o menos largo, situado en el programa e ignorado por el
compilador. Los comentarios no se consideran (son invisibles) en la fase de compilacin y ejecucin, pero de importancia primordial en las fases de anlisis, puesta a punto y mantenimiento.
Los comentarios son una parte importante de la documentacin de un programa, ya que
ayudan al programador y a otras personas a la comprensin del programa. No es raro encontrar programas en los cuales los comentarios ocupan ms sitio, incluso, que las propias instrucciones.
Formato
{comentario}
(* comentario *)
Cualquiera de los dos formatos pueden ser utilizados indistintamente. Los comentarios
pueden aparecer en una sola lnea de programa, al final de una lnea despus de una sentencia, o embebido en una sentencia. En general se debe incluir en las diferentes partes de un
programa, pero con la condicin de que sean significativos. Se deben evitar comentarios superfluos o redundantes, como
A := B-C
(el valor de B-C se asigna a A)
cuyo significado es evidente.

Es conveniente situar comentarios en la cabeza que al menos especifiquen:
q . el nombre del programador,
q . la fecha de la versin actual,
q . una breve descripcin de lo que hace el programa
El siguiente programa ilustra modos de especificar comentarios.
program Prueba;
(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
{programa escrito por : Juan Prez
}
{Fecha :
}
{Versin :
}
{Nombre del archivo :
}
{Este programa permite listar direcciones postales}
(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
const
Es posible anidar comentarios con delimitadores de tipo diferentes, pero no es posible
con delimitadores del mismo tipo. El programador puede tener libertad para los comentarios.
-9-
{
un comentario puede extenderse
en varias lneas o paginas de programas}
{comentarios anidados (* como este caso *)}
Lneas en blanco
Otro medio de hacer un programa ms legible es dejar lneas en blanco entre partes importantes o que estn lgicamente separados. Es muy frecuente dejar lneas en blanco entre la
cabecera y la seccin de declaraciones, entre sus diferentes partes, as como entre los procedimientos y funciones, entre s y con el programa principal, etc.
Eleccin de nombres de identificadores significativos
Las variables, constantes e incluso nombres de subprogramas y programas deben ser
significativos para orientar al usuario sobre lo que representan: x, As, JJ no son identificadores
significativos.
Salario := Horas * SalarioHoras;
Nomina_Mayor >= 10000;
Nombre_Apellidos = 'Mortimer';
Los nombres es conveniente que comiencen con una letra mayscula, y si son largos es
preferible utilizar palabras compuestas o con subrayado.
Evitar puntos y comas superfluos
Antes de las palabras end y until se puede suprimir el separador punto y coma. Los puntos y comas espurios pueden afectar al mal funcionamiento de un programa.
Lneas de programa mayores de 80 caracteres
El editor Turbo permite escribir lneas de hasta 126 caracteres de longitud, aunque en la
pantalla slo se ven 80 columnas a la vez. Utilizando las teclas HOME (Inicio), END (Fin) y de
movimiento de cursor se puede desplazar el texto a izquierda y derecha.
Alinear operaciones (o separadores) en lneas consecutivas
Cuando diferentes lneas consecutivas contienen el mismo operador (o separador), es
buena prctica alinear estos smbolos utilizando blancos si es necesario.
for j := 1 to 10 do (operador =)
begin
Prueba := Random;
Total := Total + Prueba;
Valor [j]:= Prueba;
WriteLn ('Estrella errante')
end;
Blancos no significativos
q
Poner un espacio en cada lado de un operador

if A = B then
Encontrado := true;
representa un blanco
- 10 -
q
Incluir un espacio despus de los signos de puntuacin: coma, punto y coma, dos puntos.
Otras reglas de escritura

q
q
q
q
Poner cada sentencia en una lnea distinta.

Las palabras reservadas program, const, var, procedure, function, uses, begin, end
deben ir en lneas distintas.
Si una sentencia contina en otra lnea, se deben sangrar la(s) lnea(s) siguientes.
Insertar lneas en blanco antes de la seccin const, var, uses, procedure, function y el
begin del programa principal; y en cualquier segmento o bloques de sentencias significativas.
Utilizar espacios entre los elementos de una sentencia para hacerla ms legible.
PUESTA A PUNTO DE PROGRAMAS

En esta seccin se incluirn: Tcnicas de resolucin de problemas y de programacin (diseo de programas), errores tpicos de programacin y estilo de programacin.
Tcnicas de programacin (diseo de programas)
1. Los programas no pueden considerarse correctos hasta que han sido validados
utilizando un rango amplio de datos de test.
2. Los programas deben ser legibles y comprensibles.
3. Utilizar comentarios significativos que describan el propsito de un programa o
segmentos de programas, as como elementos importantes de programas, variables, funciones, etc.
4. Etiquetar todas las salidas producidas por un programa
5. Los programas deben ser eficientes. Por ejemplo, clculos innecesarios: Se deben evitar calcular dos veces cualquier variable.
6. Programas generales y flexibles. Deben ser relativamente fciles de modificar
para solucionar un problema similar sin necesidad de cambiar mucho el programa. El uso de las constantes limita la flexibilidad.
7. Antes de utilizar variables, asegurarse de que son inicializadas por el programa.
8. En programacin interactiva, incluya siempre una lnea con un mensaje de aviso
al usuario cuando desee introducir datos.
9. Los programas deben hacer -en general- siempre "eco" de la entrada.
Antes de escribir un programa en Pascal se deben seguir los pasos:
q
q
Anlisis del programa (entrada, salida, datos auxiliares y proceso).

Diseo del algoritmo (con preferencia pseudocdigo), siguiendo -esencialmenteel mtodo descendente.
Errores tpicos de programacin

1. Las constantes reales deben tener al menos un dgito antes y al menos un dgito
despus del punto decimal.
2. Las constantes de cadena deben estar encerradas entre apstrofos (simples comillas). Un apstrofo se representa con un par de apstrofos 'Kant"s'.
3. Los parntesis dentro de expresiones deben concordar. Tantos parntesis a izquierda como a derecha.
4. La divisin entera se representa por div y la real por /.
5. Las multiplicaciones deben ser indicadas por *.
6. Puntos y comas (ausencia, exceso, superfluos).
7. Debe haber un punto detrs del end final de cada programa.
8. Todos los identificadores deben ser declarados.
- 11 -
9. Todas las variables estn inicialmente indefinidas (Turbo Pascal no sigue esta regla -inicializa a cero o cadena vaca-, pero es conveniente la inicializacin).
10. Un signo igual (=) se utiliza en declaraciones de constantes o como signo igual. El
operador := se utiliza en sentencias de asignacin. No confundir = con := (ojo,
programadores de BASIC).
11. Los problemas que implican nmeros de tipo real no pueden utilizar
test/comparaciones para comprobar exactitud de igualdad o desigualdad (= o < >
). Como los nmeros estn aproximados en la computadora, no tiene sentido la
igualdad/desigualdad.
12. Es buena idea verificar errores tales como divisin por cero y races cuadradas de
nmeros negativos dentro de un programa.
Estilo de programacin
q
Un programa Turbo Pascal se prepara con el editor. Despus de teclear el programa completo se sale al men principal y se compila el programa. Si hay errores, se vuelve al editor; en caso contrario, se guarda y ejecuta.
Los errores de un programa pueden ser: sintaxis, en tiempo de ejecucin y lgicos.
La planificacin de un programa comienza con el anlisis del problema [especificaciones

de entrada y salida (E/S), el proceso necesario para producir la salida desde la entrada] y sigue
con el algoritmo (pseudocdigo). Especialmente en programas grandes, seguir el diseo descendente y refinamiento sucesivo. A continuacin debe realizarse la documentacin externa, la
escritura del programa con toda la documentacin interna (comentarios) necesaria.
Ejemplo:
Se ingresan dos nmeros enteros, obtener su suma.
ANLISIS
Qu ingresa?
Dos nmeros enteros
Qu sale?
Otro nmero entero
Qu vincula la entrada con la salida?
La operacin suma
Pseudocdigo
Inicio
Leo A (entero)
Leo B (entero)
Obtengo C como suma de A y B
Imprimo C
Fin
Cdigo Pascal
program Sumas;
(* Este es el primer programa en PASCAL
*)
(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *****)
(* programa escrito por : Juan Prez de la Sierra
*)
(* Fecha : 2 de agosto de 2000
*)
(* Versin : 01
*)
(* Nombre del archivo : Sumas
*)
- 12 -
(* Este programa permite sumar dos nmeros enteros
*)
(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *-***)
uses
Wincrt; (* declaraciones de unidades *)
const
Enter = #13; (* declaraciones de constantes *)
(* type *) (* en este programa no hay declaraciones de tipos *)
var
(* definicin de las variables *)

A, B, C : Integer;
begin (* Comienzo del programa *)

ClrScr; (* limpio la pantalla *)
(* Ingreso de datos *)
Write ('Ingrese el primer valor ');
ReadLn(A);
Write ('Ingrese el segundo valor ');
ReadLn(B);
(* Clculo de los resultados *)
C := A + B;
(* Salida de la informacin *)
WriteLn ('El resultado es = ', C:6);
(* Esta estructura se ver en prximas clases *)
Repeat
Until Readkey = Enter
end. (* Fin del programa *)
Nota
En el ejemplo tenemos una tpica estructura secuencial sin condiciones, ni ciclos repetitivos, como se vern en el prximos ejemplos
Las estructuras secuenciales son aquellas donde todas las instrucciones se ejecutan una
despus de la otra.
En ellas no hay repeticin ni ejecucin de un grupo seleccionado.
Un problema tpico de este tipo de estructura es el siguiente.
Ejemplo:
Un comerciante requiere un programa que realice las siguientes tareas: Se ingresa el
costo de un producto, a dicho costo le debe agregar un 30% de ganancia y al valor as
obtenido incrementarle un 21% por IVA. El programa deber sacar por pantalla el costo
del producto, el precio final, y el valor del impuesto.
Pseudocdigo
Inicio
Definir constantes
Leer el costo
Calcular el costo ms el 30%
Calcular el valor del impuesto
- 13 -
Calcular el Precio
Imprimir Costo
Imprimir Impuesto
Imprimir Precio
Fin
Cdigo Pascal
program Primer_Ejemplo;
(* Este es el primer programa en PASCAL
*)
(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ****
(* programa escrito por : Juan Prez de la Sierra
*)
(* Fecha : 2 de agosto de 2000
*)
(* Versin : 04
*)
(* Nombre del archivo : Iva_Calculado
*)
(* Este programa permite calcular el precio final de un producto *)
(* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
*)
uses
Wincrt; (* declaraciones de unidades *)
const
gan = 30.0;
iva = 21.0;
var
(* declaraciones de las constantes *)
(* definicin de las variables *)

costo : real;
costo1, impuesto, precio : real;
begin (* Comienzo del programa *)

clrscr;
(* Limpieza de pantalla *)
write ('Ingrese el costo: ');
(* Salida de mensaje *)
readln (costo);
(* Ingreso del dato *)
costo1 := costo * (1 + gan/100); (* Clculo de la ganancia *)
impuesto := costo1 * (iva /100); (* Clculo del impuesto *)
precio := costo1 + impuesto;
(* Clculo del precio final *)
writeln ('Costo : ', costo);
(* Salida de mensaje y variable *)
writeln ('Impuesto : ', impuesto); (* Idem anterior *)
writeln ('Precio : ', precio); (* Idem anterior *)
end.
(* Fin del programa *)
Documentacin de un programa
La documentacin de un programa, es el conjunto de todos los pasos, documentos necesarios para la creacin y mantenimiento de un programa. El primer documento que tiene que
existir en un programa es la solicitud del mismo, quien, porqu y para que lo solicita. El segundo es el contrato, sin un contrato no existe ningn proyecto de nada. En el queda especificado,
el quien solicita el proyecto, el quien se hace responsable de su ejecucin, el porque solicita
el proyecto, el cuanto va a costar ($), el cuando va a estar listo, el como se pagar, que lo
que se va a entregar.
La documentacin se clasifica en documentacin interna y externa
a) Documentacin Interna: esta compuesta por los comentarios que le colocamos
en el interior del programa fuente. Como dicho programa nunca se entrega (a
- 14 -
menos que por contrato se especifique lo contrario), esta documentacin es
privada.
b) Documentacin Externa: Como se dice comienza con la solicitud y continua
con el contrato. Se subdivide esta documentacin en pblica y privada.
1. Privada: esta compuesta por todos aquellos documentos que solo esta en el
dominio de la empresa que crea el programa. Esta compuesta por algoritmos matemticos en que se basa el programas, diagramas de bloques, diagramas de estructuras, mdulos, manuales internos.
2. Pblica: esta compuesta por los manuales del usuario.
Estructuras de Programacin
Todo programa puede ser escrito utilizando solamente tres tipos de estructuras de control
secuenciales
selectivas
repetitivas
Las estructuras de tipo secuencial se han visto en el prctico anterior.

En esta practica veremos los otros dos tipos de estructuras.
Selectivas: Las estructuras selectivas se utilizan para tomar decisiones lgicas; de ah
que se suelan denominar estructuras de decisin o alternativas.
Son dos la sentencia if y la sentencia case.
If esta sentencia, es considerada de alternativa doble ( si se cumple cierta condicin entonces ... , sino .... / If ...... then ...... else..... ).
Pseudocdigo en espaol
Cdigo se programa
si <condicin>
if <condicin>
entonces < accin S1>
then < accin S1>
sino <accin S2 >
else < accin S2>
Ejemplos:
a) Se leen dos valores enteros A, B. Si A es mayor que B se realiza la suma de
ambos, caso contrario, se hace el producto.
- 15 -
Pseudocdigo del programa
nombre seleccin1(program);
declaraciones (uses)
WinCrt;
variables (var);
A (valor que ingresa) : entero;
B (valor que ingresa) : entero;
R (resultado de la oper.): entero
funciones(function);
procedimientos (procedure);
inicio (begin);
limpieza(limpia la pantalla);
ingreso;
alternativa (decisin A>B):
resultado (salida resultados):
fin(end.)
Como se puede ver tenemos varios procedimientos ya vistos. Por lo tanto solo se desarrollara el pseudocdigo y el estructurado de alternativa, y todo lo que de l dependa.
algoritmo alternativa
Pseudocdigo del alternativa
procedimiento alternativa
inicio (begin);
si A > B
entonces R A + B
sino R Prod (A, B)
fin(end;)
El cdigo del procedimiento es:
procedure alternativa; {* determina si A es o no mayor que B y hace los clculos correspondientes *}
begin {* comienzo de alternativa *}
if A > B
then
R := A + B
else
R := Prod (A,B); {* llamado a la funcin *}
end; {* fin de alternativa *}
Ntese que se defini una funcin Prod (A, B), veremos como se trabaja con ellas.
algoritmo Prod
Pseudocdigo de Prod
funcin Prod ( A, B : enteros)entero
inicio (begin);
Prod A * B
fin(end;)
- 16 -
function Prod ( A, B: integer ): integer; {* obtiene el producto entre dos valores
enteros *}
begin {* comienzo de Prod *}
Prod := A * B;
end; {* fin de Prod *}
Quedndonos el programa de la siguiente manera.
Program Seleccion_1; {* Este es el primer programa con estructuras de seleccin y funciones *}
uses
Wincrt; {* declaraciones *}
{const}
{* no hay constantes *}
var
A, B : integer; {* valores que ingresan *}
R: integer; {* salida de la operacin *}
function Prod ( A, B: integer ): integer; {* obtiene el producto entre dos valores enteros *}
Prod := A * B;
procedure limpieza; {* comienzo de limpieza de la pantalla *}
begin
ClrScr;
end; {* fin de limpieza de la pantalla *}
procedure ingreso; {* comienzo del ingreso de datos *}
begin
write ('Ingrese A '); {* ingreso de variable A *}
readln (A);
write ('Ingrese B '); {* ingreso de variable B *}
readln (B);
end; {* fin del ingreso de datos *}
if A > B
then
R := A + B
else
procedure resultado; {* comienzo la impresin de los resultados *}
Var H :char;
begin
writeln ( 'Resultado = ', R);
writeln ( 'Presione cualquier tecla ');
readln (H); {* esta instruccin y la anterior son para dar tiempo para ver resultados *}
end; {* fin de la impresin de los resultados *}
- 17 -
begin
limpieza;
ingreso;
alternativa;
resultado;
end.
{* llamado al procedimiento limpieza *}

{* llamado al procedimiento ingreso *}
{* llamado al procedimiento alternativa *}
{* llamado al procedimiento resultado *}
b) Se leen dos valores enteros A, B. Si A es mayor que B se realiza la suma de

ambos y se imprime un cartel diciendo R es la suma de A y B = , caso contrario, se hace el
producto y se imprime otro cartel que diga R . es el producto de A y B =
pseudocdigo del programa
nombre seleccin2program);
declaraciones (uses);
WinCrt;
variables (var);
A (valor que ingresa) : entero;
B (valor que ingresa) : entero;
funciones(function);
inicio (begin);
limpieza (limpia la pantalla) ;
ingreso (ingreso de datos);
alternativa (decisin A>B e imp.);
resultado ( para ver los resultados):
fin(end.)
Como se puede ver dentro de alternativa se coloc la impresin de resultados quedndonos
este algoritmo estructurado de la siguiente manera.
algoritmo alternativa
Pseudocdigo del alternativa
procedimiento alternativa
inicio (begin);
si A > B
entonces R A + B
Imprimir cartel suma y resultados
sino R Prod (A, B)
Imprimir cartel producto y resultados
fin(end;)
if A > B then
begin {* comienzo del then *}
- 18 -
R := A + B;
writeln ( 'R es la suma de A y B = ', R);
end {* fin del then *}
else
begin {* comienzo del else *}
writeln ( 'R es el producto de A y B = ', R);
end; {* fin del else *}
Program Seleccion_2; {* Este es el primer programa con estructuras de seleccin y funciones *}
uses
Wincrt; {* declaraciones *}
{const} {* no hay c onstantes *}
var
A, B : integer; {* valores que ingresan *}
R: integer; {* salida de la operacin *}
function Prod ( C, D: integer ): integer; {* obtiene el producto entre dos valores enteros *}
Prod := C * D;
begin
ClrScr;
begin
write ('Ingrese A '); {* ingreso de variable A *}
readln (A);
writeln ('Ingrese B '); {* ingreso de variable B *}
read (B);
procedure alternativa; {* compara A con B y hace los clculos e imprime resultados *}
if A > B then
begin {* comienzo del then *}
R := A + B;
writeln ( 'R es la suma de A y B = ', R); {* imprime resultados *}
end {* fin del then *}
else
begin {* comienzo del else *}
writeln ( 'R es el producto de A y B = ', R); {* imprime resultados *}
end; {* fin del else *}
procedure resultado; {* comienzo la muestra de los resultados *}
Var H :char;
- 19 -
begin
readln (H); {* esta instruccin y la anterior son para dar tiempo para ver resultados *}
end; {* fin de la muestra de los resultados *}
begin
limpieza;
{* llamado al procedimiento limpieza *}
ingreso;
{* llamado al procedimiento ingreso *}
alternativa;
{* llamado al procedimiento alternativa *}
resultado;
{* llamado al procedimiento resultado *}
end.
Hay varias cosas para tomar en cuenta cuando en alguna de las opciones tiene ms de una
instruccin dicha opcin deber llevar un begin con su correspondiente end. Debe notarse que
el end del then no tiene puntuacin en cambio el del else si lleva punto y coma (;) esto se debe
que este end es el ltimo del if.
Tambin debe notarse que las variables del llamado de la funcin son distintas a las de la
funcin en si.
R := Prod (A,B);
function Prod ( C, D: integer ): integer;
Tanto en funciones como en procedimientos esto es posible ya que el lenguaje vincula automticamente la primera variable del llamado con la primera de la declaracin, la segunda con
la segunda y as sucesivamente. Esto nos permite llamar a una funcin (o procedimiento), con
distintos juegos de variables. Sin que tengamos que atenernos a nombres especficos. Solo
debemos tener en cuenta que las variables sean del mismo tipo.
Mltiples salidas :
Si se tiene ms de dos posibles salidas, aqu aparecen dos soluciones
similares al problema.
IF anidado : en esta solucin se utiliza un if dentro de otro. Siempre se anida por la salida
Else (sino).
Ejemplo :
Se pide un programa donde ingresa un nmero entre 1 y 5 incluidos ambos y se
imprime en pantalla su expresin de caracteres ( ingresa 2 imprime Dos).
En este caso tenemos cinco salidas probables (uno, dos, tres, cuatro o cinco), esto indica
que deberemos tener 4 if anidados.
Si a = 1
Entonces impre = Uno
Sino Si a = 2
Entonces impre = Dos
Sino Si a = 3
Entonces impre = Tres
Sino Si a = 4
Entonces impre = Cuatro
Sino impre = Cinco
fin_si {* fin_si no tiene equivalente en Pascal *}
fin_si
fin_si
fin_si
- 20 -
procedure alternativa;
{* determina el valor de A y lo expresa en letras *}
if A = 1 then
{* pregunta por uno *}
writeln ( 'U n o ')
{* salida por uno *}
else if A = 2 then
{* pregunta por dos *}
writeln ( 'D o s ')
{* salida por dos *}
else if A = 3 then
{* pregunta por tres *}
writeln ( 'T r e s ') {* salida por tres *}
else if A = 4 then
{* pregunta por cuatro *}
writeln ( 'C u a t r o ') {* salida por cuatro *}
else writeln ( 'C i n c o '); {* salida por cinco *}
Program Seleccion_3;
{* If anidados *}
uses
Wincrt; {declaraciones}
{const}
var
A : integer;
{* valor que ingresa *}

begin
ClrScr;

begin
write ('Ingrese un numero de 1 a 5 : '); {* ingreso de variable A *}
readln (A);
procedure alternativa;
{* determina el valor de A y lo expresa en letras *}
if A = 1 then
{* pregunta por uno *}
writeln ( 'U n o ')
else if A = 2 then
{* pregunta por dos *}
writeln ( 'D o s ')
- 21 -
else if A = 3 then
{* pregunta por tres *}
writeln ( 'T r e s ') {* salida por tres *}
else if A = 4 then
{* pregunta por cuatro *}
writeln ( 'C u a t r o ') {* salida por cuatro *}
procedure resultado; {* se utiliza para dejar en pantallas los resultados *}
Var H :char;
begin
readln (H); {* esta instruccin y la anterior son para dar tiempo para *}
{* ver resultados *}
end; {* fin de resultado *}
begin
limpieza;
ingreso;
alternativa;
resultado;
end.
Opcin : esta solucin se utiliza en reemplazo del if anidado. Es ms prctica y eficiente.
su pseudocdigo genrico es:
opcin E de
E1: sentencia 1
E2: sentencia 2
E3: sentencia 3
.........................
.........................
En: sentencia n
[sino sentencia x ]
fin...opcin
Case <variable> of
Opcin1
Opcin2
Opcin n
........
else
Para el problema anterior su pseudocdigo ser:
opcin A de
1: Imprimir U n o
2: Imprimir D o s
3: Imprimir T r e s
4: Imprimir C u a t r o
sino Imprimir C i n c o
- 22 -
fin...opcin
procedure seleccion;
{* determina el valor de A y hace su valor a letras *}
case A of
{* comienza seleccion *}
1 : writeln ( 'U n o ');
2 : writeln ( 'D o s ');
3 : writeln ( 'T r e s ');
{* salida por tres *}
4 : writeln ( 'C u a t r o '); {* salida por cuatro *}
end;
{* fin del case *}
Program Seleccion_4;
{* Uso de selectores *}
uses
{const}
var
A : integer;
{* valor que ingresa *}

begin
ClrScr;
begin
write ('Ingrese un numero de 1 a 5 : '); {* ingreso de variable A *}
readln (A);
procedure seleccion;
{* determina el valor de A y hace su valor a letras *}
case A of
{* comienza seleccion *}
1 : writeln ( 'U n o ');
2 : writeln ( 'D o s ');
3 : writeln ( 'T r e s ');
{* salida por tres *}
4 : writeln ( 'C u a t r o '); {* salida por cuatro *}
end;
{* fin del case *}
procedure resultado; {* se utiliza para dejar en pantallas los resultados *}
Var H :char;
- 23 -
begin
end; {* fin de resultado *}
begin
limpieza;
ingreso;
seleccion;
resultado;
end.
Resumen:
Existen tres tipos de estructuras selectivas
a) If
b) If anidado
c) case
Cada uno tiene su aplicacin especfica y se debe tener cuidado si se tiene por salida una o
ms sentencias. (Si hay ms de una sentencia por salida colocar Begin End ).
Hasta ahora hemos visto dos tipos de estructuras de control
secuenciales
selectivas
En esta practica veremos el tipo de estructura que nos queda.

Repetitivas: Las estructuras repetitivas (llamadas tambin bucles, lazo o ciclo) se utilizan
para realizar varias veces el mismo conjunto de operaciones. Dentro de ellas encontramos
aquellas donde la cantidad repeticiones se manejan por un nmero, las que se realizan hasta
que se cumple cierta condicin.
Son tres la sentencia for y la sentencia while y la sentencia repeat
For esta sentencia, es un bucle controlado por un contador, denominado variable de control o ndice.
Cdigo se programa
para variable (v) ? vi hasta vf hacer
for variable (v):= vi to vf do

begin
< accin S1>

<accin S2 >
< accin S1>
.......................
< accin S2>
fin para
......................
end
Ejemplos:
a) Hacer un programa que imprima los nmeros de 5 hasta 28.
- 24 -
nombre repeticin1(program);
WinCrt;
constantes(const)
A = 5;
B = 28;
variables (var)
funciones(function)(NO hay);
inicio (begin);
ciclo (hace ciclo e imprime);
salida
fin(end.)
Como se puede ver tenemos varios procedimientos ya vistos. Por lo tanto solo se desarrollara el pseudocdigo y el estructurado de ciclo, y todo lo que de l dependa.
algoritmo ciclo
Pseudocdigo del ciclo
procedimiento ciclo
inicio (begin);
para R ? A hasta B hacer
imprimo R
fin(end;)
procedure ciclo; {* comienzo el ciclo *}
begin
for R := A to B do {* se define el ciclo A *}
writeln ('Numero ',R ); {* imprime salida *}
end; {* fin del ciclo *}
Program Repeticion_1;
{* Este es el primer programa con estructuras de repeticin *}
uses
const {* constantes *}
A = 5;
B = 28;
var
R: integer; {* controla el ciclo *}
- 25 -
begin
ClrScr;
begin
writeln ('Numero ',R ); {* imprime salida *}
procedure salida; {* comienzo del procedimiento salida *}
{*solo sirve para ver los resultados *}
Var H :char;
begin
end; {* fin del procedimiento salida *}
begin
limpieza;
ciclo;
salida;
end.
b) Hacer un programa que calcule e imprima el factorial de los nmeros 1 a 7
nombre repeticin2(program);
WinCrt, Dos;
constantes(const)
A = 1;
B = 7;
variables (var)
R, Fac (resultado de la oper.): entero
inicio (begin);
ciclo2 (hace ciclo e imprime);
salida
fin(end.)
algoritmo ciclo
procedimiento ciclo
inicio (begin);
para R= A hasta B hacer
Fac Fac * R
imprimo Fac
- 26 -
fin
fin(end;)
Como se puede ver dentro del ciclo se hace dos procesos, el clculo del factorial y la impresin del resultados quedndonos este algoritmo estructurado.
begin
Fac := 1;
begin
Fac := Fac * R; {* Calcula factorial *}
writeln ('Numero : ',R, ' Factorial : ',Fac );
{* imprime salida numero y factorial *}
end
Como se puede observar se necesit colocar un begin y un end para definir comienzo y fin
del ciclo, ya que el mismo tiene ms de una instruccin. Fac se define igual a uno, porque sino
el producto nos dara siempre 0 (cero).
{* Este es el segundo ejemplo de For *}
uses
winCrt ; {declaraciones}
A = 1;
B = 7;
var
R, Fac : integer; {* controla el ciclo *}
begin
ClrScr;
Procedure ciclo; {* c omienzo el ciclo *}
begin
Fac := 1;
begin
Fac := Fac * R; {* Calcula factorial *}
writeln ('Numero : ',R, ' Factorial : ',Fac );
{* imprime salida numero y factorial *}
end
- 27 -
{* solo sirve para ver resultados *}
Var H :char;
begin
begin
limpieza;
ciclo;
salida;
end.
Hay que tomar en cuenta que los ciclos cumplen con las mismas reglas que las opciones: si
tiene ms de una instruccin, el ciclo deber llevar un begin con su correspondiente end..
Por otro lado, A > B el for podra ser
for K: = A downto B do
Bucles controlados por una bandera (While - Repeat)
Estos bucles no se repiten una cantidad definida de veces, sino se realizan hasta que se cumple una cierta condicin. La diferencia entre ambos bucles (While y Repeat) es cuando se realiza la pregunta de la condicin.
While : en este ciclo la pregunta de condicin se hace cada vez antes de comenzar el ciclo.
Ejemplo :
Se pide un programa donde ingresan una serie de nmeros, el ltimo es un valor negativo. Se pide calcular el promedio de los valores positivos (no incluir el ltimo valor),
e imprimir los valores y su promedio.
En este caso tenemos que pautar si el ltimo valor lo imprimimos o no. (si optamos por imprimirlo), esto implicar el siguiente pseudocdigo.
procedimiento ciclo
inicio (begin);
N 0
S 0
leo A
imprimo A
mientras A >= 0 hacer
comenzar
SS+A
N N+1
leo A
imprimo A
terminar
fin(end;)
- 28 -
Como se puede ver dentro del ciclo se hace dos procesos, el clculo del factorial y la impresin
del resultados quedndonos este algoritmo estructurado.
procedure ciclo; {* comienzo de ciclo *}
begin
S := 0;
N := 0;
write ( 'Ingrese un valor ');
read (A); {* esta instruccin y la anterior son el ingreso de datos *}
writeln ( 'El valor es : ',A ); {* esta instruccin imprime el valor *}
WHILE A >= 0 DO {* se define el ciclo *}
begin {* comienzo de While *}
S := S + A; {* Calcula la suma de valores *}
N := N + 1; {* Calcula la cantidad de valores *}
writeln ; {* Salta una lnea *}
end {* fin de While *}
end; {* fin de ciclo *}
{* Este es el ejemplo de While *}
uses
{const} {* constantes no hay*}
var
A, N, S : integer; {* controla el ciclo *}
Prom :real;
begin
ClrScr;
procedure ciclo; {* comienzo de ciclo *}
begin
S := 0;
N := 0;
WHILE A >= 0 DO {* se define el ciclo *}
begin {* comienzo de While *}
- 29 -
end {* fin de While *}
end; {* fin de ciclo *}
procedure promedia; {* comienzo de promedia *}
begin
Prom := S / N; {* Calcula el promedio *}
writeln ( 'Promedio es = ', Prom:5:2 ); {* Imprime el promedio *}
end; {* fin de promedia *}
Var H :char;
begin
begin
limpieza;
ciclo;
promedia;
salida;
end.
En el procedimiento promedia en la escritura del promedio, aparece
donde Prom:5:2 significa que la variable Prom ser escrita en un formato de 5 caracteres, de
los cuales 2 corresponden a los decimales, se necesita un carcter para el punto decimal.
Repeat : esta solucin se utiliza cuando el ciclo debe incluir el ltimo valor ingresado. Ya
que la pregunta se hace al final del ciclo.
Ejemplo :
Se ingresan una serie de nmeros distintos, el ltimo es el valor 12. Se pide un
programa que calcule el promedio de los valores (incluir el ltimo valor), e imprimir los valores y su promedio.
procedimiento ciclo
inicio (begin);
N 0
S0
repetir
leo A
imprimo A
SS+A
N N+1
hasta_que A = 12
fin(end;)
- 30 -
begin
S := 0;
N := 0;
repeat
{* comienza ciclo *}
read (A); {* esta instruccin y la anterior son el ingreso
de datos *}
writeln ( 'El valor es : ',A ); {* esta instruccin imprime el
valor *}
until A = 12; {* definicin al final del ciclo *}
{* Este es el ejemplo de Repeat - Until *}
uses
WinCrt; {declaraciones}
{const}
{* constantes no hay*}
var
A, N, S : integer; {* controla el ciclo *}
Prom :real;
begin
ClrScr;
begin
S := 0;
N := 0;
repeat
{* comienza ciclo *}
until A = 12; {* definicin al final del ciclo *}
procedure promedia; {* comienzo de promedia *}
begin
Prom := S / N; {* Calcula el promedio *}
- 31 -
end; {* fin de promedia *}
Var H :char;
begin
begin
limpieza;
ciclo;
promedia;
salida;
end.
Como se puede observar esta estructura (repeat-until) carece de begin y end, ya que los
dos extremos estn definidos por el propio ciclo.
Anidacin
Se pueden colocar un ciclo dentro de otro (anidar), esto quiere decir que una estructura contiene en su interior a otra. Las estructuras pueden ser de igual o de distinto tipo.
Siempre que se cumpla con las condiciones que aparecen en la siguientes figuras.
anidado
anidado
incorrecto
Resumen:
Existen tres tipos de estructuras repetitivas
a) For
b) While
c) Repeat - until
Cada uno tiene su aplicacin especfica y se debe tener cuidado cuando se anidan.
Estructura de datos
- 32 -
Hasta aqu se han visto distintos tipos de estructuras de control. A partir de este punto se
ver la aplicacin de las mismas a distintos tipos de problemas.
Estructura de datos:
Una estructura de datos es una coleccin de datos que pueden ser caracterizados por su
organizacin y las operaciones que se definen en ella.
Dentro de ellas encontramos distintos tipos, los tipos de datos ms frecuentes en los diferentes lenguajes son:
Tipos de datos
entero (integer)
real (real)
carcter (char)
lgico (boolean)
Estndar
simples
Definidos por el programador
(no estndar)
subrango (subrange)
enumerativo (enumerated)
simples o estticos
arrays (vectores/matrices)
registros
ficheros
conjuntos
cadenas (string)
estructurados
compuestos o dinmicos
listas (pilas/colas)
listas enlazadas
rboles
grafos
Las estructuras estticas son aquellas en las que el tamao de memoria ocupado se
define antes de que el programa se ejecute y no puede modificarse durante la ejecucin
Las estructuras dinmicas son aquellas en las que no se debe definir previamente el
tamao de memoria
Los datos simples tienen en comn que cada variable representa un elemento, en los
estructurados un identificador puede representar mltiples datos individuales, pudiendo cada
uno de estos ser referenciados independientemente.
Tratamiento de Cadenas de Caracteres
Una cadena de caracteres (string), es una serie de caracteres cuya longitud puede variar entre 1 y 255 caracteres. A este tipo se lo define tipo string, para declarar este tipo de variable se puede hacer de cualquiera de las siguientes formas:
Ejemplo
type
cadena50 = string [50];
var
nombre : cadena50;
var
mensaje : string [80];
Longitud de una cadena:

La longitud de una cadena es igual al nmero de caracteres (contando como tales tambin los espacios en blanco), pero ocupara en memoria un byte ms. Por ejemplo:
- 33 -
Nombre : string [10];
Si en nombre utilizo Murcielago, ocupar en memoria 11 bytes, 1 por letra y uno ms
por la longitud.
Nmero de byte
0
10
1
M
2
u
3
r
4
c
5
i
6
e
7
l
8
a
9
g
10
o
En Turbo Pascal existen para una cadena dos longitudes:

Longitud fsica:
Es la cantidad de memoria que se le reserva a la cadena al comienzo del programa, 10
bytes en el caso de Nombre del ejemplo anterior.
Longitud lgica:
Es la cantidad el nmero de caracteres que se tienen almacenados en esa variable en un
cierto momento.
Por ejemplo: si durante el programa hago
Nombre := Ada; La longitud lgica ser igual a 3.
Se puede acceder a cualquier elemento de una cadena: para ello hay que indicar el nmero del carcter al cual se quiere acceder.
Ejemplo
Var
Carac : char;
Nombre : string[10];
begin
Nombre := Murcielago
Carac := Nombre [6];
A partir de aqu la variable Carac toma el valor e
OPERACIONES CON CADENAS
Dos cadenas pueden sumarse.
Pap de + Pepe Pap de Pepe
Dos cadenas pueden compararse.
Pap < Pepe porque a < e
Lo que compara es el ASCII que le corresponde a los caracteres. Comienza comparando
el primero con el primero, si son iguales lo hace con el segundo y as sucesivamente hasta encontrar la desigualdad.
Procedimientos y funciones con cadenas
Funcin Concat:
Es equivalente a la suma de string, si la cantidad de caracteres supera los 255 corta el
excedente del string.
- 34 -
Concat(S1, S2, S3) S1 + S2 + S3

Funcin Length(s):
Devuelve un entero que es la longitud lgica del string s

Length(nombre) 10
Procedimiento Delete :
Delete(s, posicin, nmero)
Delete(nombre,3,4) Mulago
Elimina a partir del tercer carcter, 4 caracteres (rcie).
Procedimiento Insert:
Insert(s ,cad1, posicin)
Insert( 'ju', nombre, 4) Murjucielago
Inserta el string s o en nuestro caso los caracteres entre apstrofos en cad1, a partir
del carcter posicin.
Funcin Pos:
Pos(S1, S2) devuelve la posicin donde S1 = S2
Pos('ci', nombre, ) 4
Devuelve la posicin de un string dentro de la cadena.
Funcin Copy:
Copia parte de un string y lo almacena en otro.
S2 := Copy(S1, posicin, nmero)
S2 := Copy(Nombre, 5, 4) "iela"
Procedimiento Str:
Str(valor,cad1)
Convierte un nmero en un string.
Str(1573, S1) "1" "5" "7" "3"
Procedimiento Val:
Val(S1,nmero, cdigo)
Ingresa un string S1 y devuelve un valor, si lo puede convertir el cdigo ser 0, caso
contrario indica la posicin del carcter que no pudo convertir.
Val(S1, V1, C1) si S1 = "1" "5" "." "7" "3" V1 =15.73 y C1 = 0
Val(S1, V1, C1) si S1 = "1" "5" "a" "7" "3" V1 = 0 y C1 = 3
Funcin Upcase:
Convierte minsculas a maysculas.
Upcase (char)
- 35 -
Upcase (a) A
Upcase (A) A
Upcase (4) 4
FUNCIONES PARA MANEJO DE PANTALLA y TECLADO
La unidad WinCrt posee una serie de rutinas de salida a pantalla y otras sin salida a pantalla como Delay, Sound, NoSound,
ClrEol
Borra todos los caracteres desde la posicin actual del cursor hasta el final de la lnea sin
mover el cursor.
ClrScr
Borra todos los caracteres de la pantalla y coloca el cursor en la esquina superior izquierda. Si se esta trabajando en una ventana, borrar los caracteres de la ventana y coloca el cursor en la esquina superior izquierda de la ventana.
DelLine
Borra la lnea donde se halla el cursor. Las lneas que se hallan por debajo son desplazadas hacia arriba.
GotoXY
Coloca el cursor en la coordenada x y. X le indica la columna 1 a 80, e Y el nmero de lnea de 1 a 25. El ngulo superior izquierdo tiene coordenadas (1,1). Si se opera en una ventana, las coordenadas son relativas a la ventana.
GotoXY(x, y) x e y son de algn tipo entero.
InsLine
Inserta una lnea vaca donde se halla el cursor. Desplazando las dems una hacia abajo.
HighVideo
Selecciona caracteres de alta intensidad.
LowVideo
Selecciona caracteres de baja intensidad.
NormalVideo
Fija el atributo del texto al valor que tena inmediatamente antes que el programa fuera
ejecutado.
TextBackground (Color :Byte)
Define el color de fondo. Color toma valores de 0 a 7.
TextColor (Color : Byte)
Define el color del texto 0 a 15, y 128 (parpadeo).
- 36 -
WhereX : byte
Devuelve la columna donde se halla el cursor.
WhereY : byte
Devuelve la lnea donde se halla el cursor.
Window : (x1, y 1, x2, y2 :byte)
Define una ventana de texto, dando las coordenadas del vrtice superior izquierdo y del
vrtice inferior derecho.
Sound (Frec : word)
Emite un sonido de una frecuencia (Frec en herzios)
NoSound
Interrumpe la emisin de sonido.
Delay (ms : word)
Detiene la ejecucin del programa durante ms milisegundos.
ReadKey char
Lee un carcter del teclado. El carcter no se visualiza en pantalla.
Key Pressed : boolean.
Devuelve el valor verdadero si se pulsa una tecla, y falso en caso contrario.
Vectores y Matrices
ARRAY UNIDIMENSIONALES: VECTORES
ARRAY (ARREGLO): Es un conjunto finito y ordenado de elementos homogneos.
Ordenado : cada elemento del arreglo puede ser identificado
Homogneo : son del mismo tipo de dato
El tipo ms simple de arreglo es el unidimensional o vector (matriz de una dimensin).
Por ejemplo podra ser un vector denominado NOTAS
NOTAS[1]
5
NOTAS[2]
8
..........
NOTAS[k]
7
......
NOTAS[n]
3
Los subndices 1, 2, k, n, indican la posicin del elemento, en Pascal van entre corchetes.
El primer elemento es el 5, el segundo es el 8, el elemento k es 7 y el ensimo es 3.
Un array puede ser declarado de dos formas distintas que son:
Declaraciones Tipo Array
En las declaraciones del tipo array usaremos los siguientes pasos.:
1.
La estructura del arreglo se describe en Type.
2.
Se le asigna ese tipo a una o ms variables.
- 37 -
Type
XX = array [1..3000] of real;
Var:
Alfa : XX;
array y of son obligatorias
[1...3000] indica los valores que toman los ndices del vector, son del tipo subrango.
real identifica que tipo de elementos almacena el vector.
Variables Tipo Array
En las declaraciones de variable tipo array se har de la siguiente forma.:
1.
En la declaracin se describe la variable.

Var:
Alfa : array [1..3000] of real;
Los elementos cumplen la misma funcin que en el caso anterior.
Dentro de los distintos tipos que un array puede almacenar en sus posiciones, puede ser un tipo Array como el del siguiente tipo:
Type
Linea = array [1..40] of char;
Hoja = array [1..30] of Linea;
Libro = array [1..30] of Hoja;
Las operaciones que se pueden hacer con un vector son:
asignacin
lectura/escritura
recorrido (acceso secuencial)
actualizar (aadir, borrar, insertar)
ordenacin
bsqueda
Asignacin: Es darle un valor a un elemento de un vector

Pseudocdigo
A[3] 5
Cdigo se programa
A[3] := 5;
Para la asignacin como para otro procesos se debe recurrir a estructuras repetitivas (para, mientras o repetir).
Ejemplo:
A cada uno de los 55 elementos del vector CARGA se le debe asignar el valor 0
Algoritmo de asigna
Pseudocdigo
Cdigo se programa
Para I 1 hasta 55 hacer
for I := 1 to 55 do
CARGA[I] 0
CARGA[I] := 0;
Fin
- 38 -
nombre vector1(program);
WinCrt;
constantes(const)
A = 1;
B = 55;
tipo (type)
matriz = array [1..55] de enteros
variables (var)
I entero
CARGA matriz
funciones(function)(NO hay);
inicio (begin);
asigna (hace ciclo y asigna);
Salida
fin(end)
Como se puede ver tenemos la definicin del vector en tipo o type.
procedure asigna; {* comienzo de la asignacin *}
begin
for I := A to B do {* se define el ciclo de 1 a 55*}
CARGA[I] := 0; {* asigna los valores *}
Program Vector_1;
{* Este es el primer programa con vectores *}
uses
WinCrt; {declaraciones}
A = 1;
B = 55;
type
vector = array [1..55] of integer;
var
I: integer; {* controla el ciclo *}
CARGA: vector;
begin
ClrScr;
begin
for I := A to B do {* se define el ciclo de 1 a 55 *}
- 39 -
CARGA[I] := 0; {* asigna la valores *}
end; {* fin de la asignacin *}
Var
H :char;
begin
begin
limpieza;
asigna;
salida;
end.
Lectura/escritura:
Es una operacin de entrada salida sobre un vector. Manejado por estructuras repetitivas.
Ejemplo:
Ingresar por teclado cada uno de los 5 elementos de un vector de nombre vec. Y luego
leerlos y presentarlos por pantalla en orden inverso al que entraron (de 5 a 1)
Algoritmo de lectura
Cdigo se programa
para I = 1 hasta 5 hacer

comienzo
imprimo mensaje
leo y almaceno en vec[I]
for I := 1 to 5 do
begin
write (
);
read (vec[I] );
end;
fin

procedure lectura (var vec:vector; inic, final:integer);
var
i: integer;
{* almacena en el vector *}
begin
for i := inic to final do {* se define el ciclo de inic a final*}
begin
write ('Ingrese vec('i:1,') : ');
readln(vec[i]); {* almacena en el vector *}
end;
end; {* fin de lectura *}
Algoritmo que imprime
Cdigo se programa
- 40 -
para I = 1 hasta 5 hacer
escribo vec[I]
for I := 1 to 5 do
writeln (vec[I] );
fin
procedure impresion(vec:vector; inic, final:integer); {* imprime el vector *}
var
i:integer;
begin
for i := final downto inic do {* se define el ciclo de final a inic*}
writeln ('vec(',i:1,') = ',vec[i]:2);
{* imprime el contenido del vector por pantalla *}
end; {* fin de impresion *}
Nombre vector2(program);
Declaraciones (uses)
WinCrt;
tipo (type)
Vector = array [1..10] de enteros
variables (var)
primero, ultimo: entero
valores: Vector
Funciones(function)(NO hay);
Procedimientos (procedure);
inicio (begin);
limpieza{limpia la pantalla};
lectura (valores, primero, ultimo) {lee el vector)
impresin (valores, primero, ultimo) {imprime el vector por pantalla}
salida
fin(end.)
Program Vector_2
{* Este es el segundo programa con vectores *}
uses
type
var
valores: vector;
primero, ultimo:integer;
begin
ClrScr;
procedure lectura(var vec:vector; inic, final:integer); {* lee el vector *}
var
i: integer;
- 41 -
begin
for i := inic to final do {* se define el ciclo de inic a final *}
begin
write ('Ingrese vec(',i:1,') : ');
readln(vec[i]); {* lee las componentes del vector *}
end;
end; {* fin de lectura *}
procedure impresin(vec:vector; inic, final:integer) ; {imprime el vector por pantalla}
var
i:integer;
begin
for i:= final downto inic do {* se define el ciclo de final a inic *}
writeln ('vec(',i:1,') = ',vec[i]:2);
{*saca por pantalla *}
end; {* fin de impresin *}
Var
H :char;
begin
begin
limpieza;
lectura(valores, primero, ultimo);
impresin(valores;primero, ultimo);
salida;
end.
Recorrer: Esta operacin se realiza cuando uno lee el vector, y se aplica tanto cuando se
busca un elemento de un vector o cuando se desea listar el mismo, como lo vimos en el ejemplo anterior.
Actualizar
Aadir: Se denomina as a la operacin de agregar un nuevo, elemento al final del vector. la nica condicin necesaria para esta operacin consiste en la comprobacin de espacio
libre en memoria.
Ejemplo:
Dado el vector U de 7 elementos aadir un elemento ms al vector
Algoritmo de aade
I 0
repetir
Cdigo se programa
I := 0;
repeat
I I +1
I := I + 1;
until U[I] = 0 or i >k
hasta que U[I] = 0 o i > k

si i es menor o igual a k
entonces
if I <= k then
read (U[I] )
- 42 -
leo nuevo U[I]
else
sino
imprimo No ms lugar
writeln(No mas lugar)
fin_si
procedure agrega; {* agrega un elemento al vector *}
begin
I:=0;
repeat
I := I + 1;
until (U[I]=0) or (I> 7);
{* Se repite hasta que se encuentre una bandera o se termine el vector *}
if I<= 7 then
begin
writeln ('Ingrese un nuevo elemento al vector');
read ( U[I])
end
else
writeln ('No hay mas lugar en el vector');
end; {* fin de agrega *}
Borrar: Es eliminar un elemento de un vector se puede hacer de dos maneras una es
reemplazar el elemento por el utilizado como seal. Puede servir pero no es recomendado en
proyectos pequeos. Pero no as en grandes. El otro mtodo consiste en mover los elementos
que se encuentran debajo de l una posicin hacia arriba, colocando una bandera en la ltima
celda.
Ambos mtodos tienen el paso de bsqueda en comn utilizado en aadir, lo que varan
son los pasos posteriores al Si. (Solo representaremos estos pasos)
Ejemplo:
Dado el vector U de 7 elementos, eliminar un elemento al vector
Algoritmo que elimina Aux
leer Aux
Cdigo se programa
read(Aux)
I 0
I := 0;
repeat
repetir
I I +1
hasta que U[I] = Aux o I > k
si I es menor o igual a k
entonces
U[I] 0
sino
imprimo No existe el elemento
fin_si
Algoritmo de elimina (otro)
I := I + 1;
until U[I] = Aux or I > k
if I <= k then
U[I] := 0;
else
writeln(No existe el elemento)
Cdigo se programa
I 0
I := 0;
Lee Aux
- 43 -
repetir
I I +1
hasta que U[i] = Aux o I > k
Readln(Aux);
si i es menor o igual a k
entonces
repetir
U[I] U[I + 1]
I I +1
hasta que U[i] = 0 o I > k
sino
imprimo No existe el elemento
fin_si
repeat
I := I + 1;
until U[i] = Aux or I >k
if I <= k then
repeat
U[I] := U[I+1];
I := I + 1;
until U[I] = 0 or I >k ;
else
writeln(No existe el elemento)
Insertar:
Se debe trabajar sobre un vector ordenado. Consiste en introducir un nuevo elemento al
vector sin que este pierda el orden. Para ello se debe comprobar que haya lugar libre en el vector, luego de lo cual se deber desplazar hacia bajo los elementos necesarios como para generar un espacio libre en la posicin adecuada sin que se pierda el orden.
Algoritmo de inserta (Ordenado creciente)
Cdigo se programa
I 0
I := 0;
Lee Aux
Read(Aux);
repetir
I I +1
hasta que U[i] = 0 o I > B
repeat
I := I + 1;
until U[i] = 0 or I >B
si i es menor o igual a B
entonces
I I -1
mientras U[i] > Aux
U[I+1] U[I]
I I -1
fin mientras
U[I+1] Aux
sino
imprimo No hay lugar
fin_si
if I <= B then
begin
I := I - 1;
while U[I] > Aux
begin
U[I+1] := U[I];
I := I - 1;
end;
U[I+1] = Aux;
end
else
writeln(No hay lugar)
Ordenacin:
La ordenacin o clasificacin es, el proceso de clasificar datos en algn orden o secuencia especfica como creciente o decreciente. Existen varios mtodos de ellos elegiremos el de
intercambio (decantacin).
Algoritmo de ordena (Ordenado creciente)
I 0
Cdigo se programa
I := 0;
repetir
I I +1
hasta que U[i] = 0 o I > B
repeat
I := I + 1;
until U[i] = 0 or I > B
- 44 -
P I -1
P := I - 1;
para I 1 hasta P -1 hacer

para J 1 hasta P - I hacer
si U[J] > U[J +1]
entonces (intercambiar)
Aux U[J]
U[J] U[J +1]
U[J +1] Aux
fin si
fin
fin
for I := 1 to P-1 do
for J := 1 to P- I do
if U[J] > U[J +1] then
begin
Aux := U[J];
U[J] := U[J +1];
U[J +1] := Aux ;
end;
Bsqueda:
La bsqueda de un dato dentro de un array consiste en determinar si un elemento N pertenece o no al conjunto de datos y posicin que el ocupa en el conjunto.
Los distintos tipos de bsqueda se pueden clasificar en:
bsqueda secuencial
bsqueda binaria
bsqueda por transformacin de claves (hash)
Bsqueda Secuencial:
Compara cada elemento del vector con el valor deseado. Si se encuentra
es el mtodo que ofrece menor eficiencia pero el ms sencillo.
Esto se puede ver en el ejemplo anterior.
Ejemplo general
Hacer un programa que permita operar con un vector de siete posiciones, que opere con
nmeros naturales. Pudiendo agregar, eliminar o insertar un valor, tambin se podr listar todos los valores que tiene el vector.
Usaremos como centinela el nmero 0 (cero) por lo cual lo primero que deber hacer el
programa deber asignarle a todos los elementos del vector dicho valor .
El programa cuenta con tres llamados.
begin
limpieza; {* limpia la pantalla *}
asigna; {* asigna los 0 al vector *}
menu; {* llama al mdulo men *}
end.
Los mdulos limpieza y asigna ya se han detallado. En cuanto a menu es un selector.
Algoritmo de menu
Cdigo se programa
repeat
repeat
limpieza;
writeln ('
M E N U ');
writeln ( '
1. Ingresar un valor al vector ');
writeln;
write ( '
Elija una opcin ');
repetir
repetir
llama a Limpieza
escribir Titulos
escribir Opciones
leer valor elegido (H)
hasta que H > 0 y H < 7
- 45 -
opcion H de
1: llama a Agrega
2: llama a Lista
3: llama a Borra
4: llama a Ordena
5: Inserta
sino limpia pantalla
fin opcion de
hasta que H = 6
readln (H); {* lee la opcin *}

until (H > 0) and (H < 7);
case H of
1 : Agrega;
2 : Lista;
3 : Borra;
4 : Ordena;
5 : Inserta;
else clrscr;
end;
until H = 6;
En el procedimiento borra, lo que realiza el algoritmo es desplazar cada uno de los elementos posteriores al que queremos eliminar a una posicin anterior a la que tenamos. Este
procedimiento cuenta con dos partes.
a) encuentra el elemento a borrar
b) desplaza los elementos posteriores a una posicin anterior; la marca nos sirve
para optimizar el proceso.
program vectores; {* Programa de subrutinas de vectores *}
uses
wincrt; {*declaraciones*}
NL = #13#10; {* Nueva Lnea Carrige Return, Line Feed*}
A = 1;
B = 7;
type
var
I: integer; {* controla el ciclo *}
U: vector;
begin
ClrScr;
Var
H :char;
begin
procedure Lugar; {* determina cuantos lugares estn ocupados del vector *}
begin
I:=0;
repeat
I := I + 1;
until (U[I]=0) or (I> 7);
{* Se repite hasta que se encuentre una bandera o se termine el vector *}
end; {* fin de lugar *}
- 46 -
begin
for I := 1 to 7 do {* se define el ciclo de 1 a 7 *}
U[I] := 0; {* asigna *}
end; {* fin de la asignacin *}
procedure Ordena; {* ordena el vector *}
var
J, P, Aux : integer;
begin
I := 0;
repeat
I := I + 1;
until (U[I]=0) or ( I>B ); {* Determina cuantos valores validos hay en el vector *}
P := I - 1;
for I := 1 to P - 1 do {* se define el ciclo hasta el anteltimo valor cargado
*}
for J := 1 to P - I do
if U[J] > U[J+1] then
begin
{* Intercambia *}
Aux := U[J];
U[J] := U[J+1];
U[J+1] := Aux;
end
end; {* fin del ordenamiento *}
procedure lista; {* lee y lista el vector *}
begin
I := 1;
while (U[I] <> 0) and (I<= B ) do {* se lee hasta encontrar *}
begin {* un centinela o el final del vector *}
writeln ('U(',I:1,') = ',U[I]:3);
{* lee el vector y lo saca por pantalla *}
I := I + 1;
end;
Salida;
end; {* fin de lectura y listado *}
- 47 -
procedure Borra; {* borra un elemento del vector *}
var
J : integer;
H : char;
begin
I := 1;
write ('Ingrese el valor a borrar : ');
read (J);
while (U[I] <> 0) and (I<= B ) and (U[I] <> J) do {* se hace la bsqueda *}
I := I + 1;
if U[I] <> J then
begin
{* No se encontr el valor *}
write (' Elemento no encontrado ');
readln(H);
end
else
begin
while U[I] <> 0 do {* Se borra el valor *}
begin
U[I] := U[I+1];
I := I + 1;
end;
write (' Elemento borrado ');
readln(H);
end;
end; {* fin de borrado *}
procedure agrega; {* agrega un elemento al vector *}
var
H:char;
begin
Lugar;
if I <= 7 then
repeat
write ('Ingrese un nuevo valor al vector : ');
readln ( U[I]);
I := I + 1;
until (U[I-1] = 0) or (I > B)
else
begin
write ('No hay mas lugar en el vector');
Read (H);
end
procedure inserta; {* inserta un elemento al vector ordenado *}
var
H:char;
K, Aux : integer;
begin
Lugar;
if I <= B then
begin
K := I;
write ('Ordeno el vector ? (S/N) ');
- 48 -
Read (H);
if (H = 'S') or (H = 's') then Ordena;
write ('Ingrese el valor a insertar : ');
Read (Aux);
I := K - 1;
while U[I] > Aux do
begin
U[I+1] := U[I];
I := I - 1;
end;
U[I+1] := Aux;
end
else
begin
write ('No hay mas lugar en el vector');
Read (H);
end
procedure menu; {* comienzo del procedimiento menu *}
{* genera y maneja un menu de opciones *}
Var
H :integer;
begin
repeat
repeat
limpieza;
writeln ('
M E N U ');
writeln ('
-----------', NL, NL, NL);
writeln ( '
1. Ingresar un valor al vector ', NL);
writeln ( '
2. Listar el vector ', NL);
writeln ( '
3. Borrar un valor ', NL);
writeln ( '
4. Ordenar el vector ', NL);
writeln ( '
5. Insertar un valor ', NL);
writeln ( '
6. Salir del programa ', NL, NL);
write ( '
Elija una opcin ');
readln (H); {* lee la opcin *}
until (H > 0) and (H < 7);
case H of
1 : Agrega; {* Llamada al procedimiento de agregar *}
2 : Lista; {* Llamada al procedimiento de listar *}
3 : Borra; {* Llamada al procedimiento de borrar *}
4 : Ordena; {* Llamada al procedimiento de ordenar *}
5 : Inserta; {* Llamada al procedimiento de insertar *}
else clrscr; {* Llamada a la salida del programa *}
end;
until H = 6;
end; {* fin del procedimiento menu *}
begin {* Comienzo del programa *}
limpieza; {* limpia la pantalla *}
asigna; {* asigna los 0 al vector *}
menu; {* llama al mdulo men *}
end. {* Fin del programa *}
- 49 -
Copia de un array:
Un array puede ser asignado a otro array, si y solo si, ambos tienen el mismo tipo y el
mismo tamao. Lo que implica que ambos fueron declarados por el mismo identificador o por
identificadores equivalentes.
Ejemplo:
Type
XX = array [1..30] of byte;
YY = array [1..30] of byte;
Var:
Alfa, Gama: XX;
Beta: YY;
Alfa := Gama; {nica expresin vlida}.
Beta := Alfa;
Pasaje de elementos individuales:
En lugar de pasar todos los elementos del array, se pueden pasar de a uno por vez. Por
ejemplo, si quisiramos chequear la identidad entre elementos correspondientes de dos vectores:
function Identidad (A, B : real) : boolean;
begin
{aqu ira el cuerpo de identidad}
end;
R := Identidad(M[3], N[3]);
Array bidimensionales (Tablas)
Un array bidimensional (tabla o matriz) es un array con dos ndices, al igual que los vectores que deben ser ordinales o tipo subrango. Para localizar o almacenar un valor en el array se
deben especificar dos posiciones (dos subndices), uno para la fila y otro para la columna. Los
elementos se referencian con el formato:
T [3,4] elemento de la fila 3 y columna 4 Los diferentes tipos de ndices no necesitan ser
subrango del mismo tipo.
Declaracin de los arrays bidimensionales
Al igual que en los arrays de una dimensin (los vectores), los arrays multidimensionales
(tablas) se crean con declaraciones type y var cuando un programa se codifica en Pascal.
type
Tabla = array [1..10,4..25] of real;
type
Tabla = array [1..10] of array [4..25] of real;
var
M, : array [1..10,4..25] of real;
- 50 -
Manejo de tablas
Para el manejo de tablas, no debemos olvidarnos que las celdas de las mismas se identifican por dos subndices. Por lo tanto cualquier proceso que queramos realizar sobre la misma,
involucrar a ambos subndices.
Por ejemplo cuando se desea leer un array se podr hacer por filas, segn se puede ver.
var
M, : array [1..10,4..25] of real;
For Fila := 1 to 10
For Columna := 4 to 25
Readln(A[Fila, Columna]);
Por columnas.
For Columna := 4 to 25
For Fila := 1 to 10
Readln(A[Fila, Columna]);
Array multidimensionales
Pascal no tiene lmite para el nmero de dimensiones. Pero al usuario corriente no se le
recomienda superar las 3 dimensiones, ya que se vuelve complejo su manejo.
Declaracin de los arrays multidimensionales
Al igual que en los arrays de bidimensionales (las tablas), los arrays multidimensionales
se crean con declaraciones type y var cuando un programa se codifica en Pascal.
type
Matriz = array [1..10,4..25, A..Z] of byte;
type
Vector = array [1..10] of byte;
Matriz = array [4..25,A..Z] of Vector;
type
Vector = array [1..10] of byte;
Tabla = array [4..25] of Vector;
Matriz = array [A..Z] of Tabla;
var
M, : array [1..10] of array [4..25,] of array [ A..Z] of byte;
CONSTANTES DE TIPO ARRAY (TIPEADAS)
Turbo Pascal permite que las constantes con tipo (tipeadas) puedan ser de casi cualquier
tipo. Las constantes con tipo, no son constantes en el estricto sentido, sino variables inicializadas, es decir, variables que tienen un valor inicial especfico en la cabecera del programa.
Ejemplos
const
A : array [1..5] of integer = (10,20,30,40,50);
const ( vectores )
Dias Por Mes : array [l..l2] of integer = (31,28,31,30,31,30,31,31,30,31,30,31);
- 51 -
REGISTROS
TIPO DE DATOS REGISTRO

Un registro (record) es un tipo de datos estructurado, que formado por un conjunto de
datos que pueden ser del mismo tipo o de distintos tipos. A estos com ponentes se los denominan campos. Cada campo posee un nombre, que se declara en el tipo registro.
Formato
type t_ reg = record
campo_1a, campo_1b : tipo 1;
campo_2 : tipo 2;
campo_n : tipo n
end;
t_reg nombre de la estructura o dato registro campo_1 a campo_n, lista de los nombres
de campos separados por comas, tipo puede ser cualquier tipo de dato estndar o definido por
el usuario
Un registro se suele representar grficamente en funcin de sus campos.
Registro
Campo_1
Campo_2
Campo_3
Campo_n
Ejemplos
type
Empleado = record
Edad : integer;
Domicilio : string [40];
Salario : real
end;
Fecha =
record
Mes : (Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio
Agosto, Septiembre, Octubre, Noviembre, Diciembre);
Dia : 1..31;
Anio : 1900..2100 {*ao*}
end ;
Estas declaraciones han creado un tipo de datos llamado Empleado -con cuatro campos:
Nombre, Edad, Domicilio y Salario y otro denominado Fecha con tres campos: Mes, Dia
(da) y Anio. (ao)
Como cualquier otro tipo se puede asignar variable a l. Esto se obtiene con la declaracin var.
Ejemplo
- 52 -
var
Nacimiento : Fecha;
Trabajador : Empleado;
Las variables Nacimiento y Trabajador tienen la estructura especificada en la declaracin
del tipo de registro Empleado y Fecha
Otra forma de declarar el registro es en directamente en la variable:
Ejemplo
var
Nacimiento : record
Mes : (Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio,
Dia : 1..31;
Anio : 1900..2100 {*ao*}
end ;
Acceso a los campos de un registro
Se puede acceder a cada campo de un registro directamente utilizando un selector de
campo de la forma
nombreReg. nombreCampo
La asignacin de datos para un registro de tipo Empleado seria:
Empleado.Nombre := "Julio Gustavo Garona";
Empleado.Edad := 43;
Empleado.Domicilio := "Bernardo de Irigoyen 1250";
Empleado.Salario := 6532;
Una vez que los datos estn almacenados en un registro, se pueden manipular de igual
forma que otros datos en memoria.
Write (Empleado.Nombre)
se visualizar Julio Gustavo Garona
Operaciones sobre registros

Tanto para la lectura o escritura de un registro, como ya hemos visto, se debe indicar el
nombre de la variable y el campo sobre el cual leeremos o escribiremos. Cada campo se lee (o
escribe), en forma individual).
Se puede asignar el contenido de un registro a otro si ambos son del mismo tipo.
Ejemplo:
var
Ingreso, Egreso, Actual : Fecha;
La sentencia de asignacin de registros
- 53 -
Egreso := Actual;
equivale a
Egreso.mes := Actual.mes;
Egreso.dia := Actual.dia;
Egreso.anio := Actual.anio;
La sentencia WITH
Cuando los registros poseen varios campos la probabilidad de cometer un error en el
nombre alguno de los campos o las variables aumenta. Para disminuir esta probabilidad se
puede evitar escribir el nombre de la variable. La sentencia with permite referenciar el nombre
del registro en su cabecera, y posteriormente para llamar a algn (o todos) campo, slo nombrando el campo indicado. Por ejemplo, dia en lugar de Egreso.dia. La sentencia with slo
permite un medio fcil de manejar los diferentes campos de una variable de tipo registro. Para
el ejemplo anterior tendramos:
with Egreso do
begin
mes := Actual.mes;
dia := Actual.dia;
anio := Actual.anio
end;
Como se puede ver with esta asociado a la variable Egreso, por lo tanto no la nombramos
en los pasos posteriores y solo nombramos los sus campos. Pero no esta asociada a la variable Actual lo que implica que debo nombrarla en cada caso. Cada With puede asignarse a
una nica variable. (Se recomienda notar la cierta semejanza entre la estructura With y For)
La estructura With se representa de la siguiente forma
Pseudocdigo
Con Egreso hacer
mes Actual.mes
dia Actual.dia
Anio Actual.anio
Fin Con
Registros que contienen estructuras complejas
En los ejemplos anteriores todos los campos de los registros eran tipos de datos simples,
cadenas. Ahora veremos casos de registros que contienen estructuras ms complejas como
matrices, o conjuntos.
Ejemplos
type
Mes = (Enero, Febrero, Marzo, Abril,
Mayo, Junio, Julio, Agosto, Septiembre,
Octubre, Noviembre, Diciembre);
- 54 -
R_Empleado = record
Edad : integer;
Dia =1..31;
Anio = Array [Mes,Dia] of character;
Concurrencia = Set of Mes;

Salario : real;
Calendario : Anio;
Asistencia : Concurrencia
End;
En nuestro caso el registro R_Empleado se ha ampliado y dentro de l encontramos, un

campo (Calendario) que es una tabla de 12(filas) X 31 (columnas), y otro (concurrencia que es
un conjunto)
Si deseramos escribir un cdigo para dejar un registro en blanco el mismo debera se el
siguiente.
Var
Empleado, A_Empleado, S_Empleado : R_Empleado;
Meses : Mes;
Dias : Dia;
Begin
With S_Empleado do
Begin
Nombre := '';
Edad := 0;
Domicilio := '';
Salario := 0;
For Meses := Enero to Diciembre do
For Dias := 1 to 31 do
Calendario[Meses, Dias] :='';
Asistencia :=[]
end;
Otra operacin vlida con estos registros (fuera de la estructura With), sera la siguiente.
Empleado.Asistencia := A_Empleado.Asistencia * S_Empleado.Asistencia;
Debemos recordar que el campo Asistencia es tipo conjunto y la operacin interseccin
(*) entre conjuntos es una operacin vlida.
REGISTROS JERRQUICOS (ANIDADOS)
Hasta aqu vimos campos de los registros de tipos de datos simples, cadenas o matrices
o conjuntos. Ahora veremos registros donde uno o ms de sus campos que son otros registros.
Un registro con uno o ms campos, los cuales son tipo registro, se denomina: registro
jerrquico o registro anidado.
Un ejemplo de esto sera sien el registro del empleado quisiramos agregar campos que
almacenen fechas, tales como la de nacimiento, ingreso y egreso de la empresa, etc. Habra
que modificar nuestro registro bsico de la siguiente forma.
- 55 -
type
Fecha
record
Mes : (Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio
Dia : 1..31;
Anio : 1900..2100 {*ao*}
end ;
R_Empleado = record
Edad : integer;
Salario : real;
F_Ingreso : Fecha;
F_Egreso : Fecha;
end;
Otra forma de definir los mismos campos sera:
R_Empleado = record
Edad : integer;
Salario : real;
F_Ingreso : record
Mes : (Enero, Febrero, Marzo, Abril, Mayo,
Junio, Julio, Agosto, Septiembre,
Dia : 1..31;
Anio : 1900..2100 {*ao*}
end ;
F_Egreso : record
Mes : (Enero, Febrero, Marzo, Abril, Mayo,
Junio, Julio, Agosto, Septiembre,
Dia : 1..31;
Anio : 1900..2100 {*ao*}
end ;
end;
Esta ltima forma resulta de lectura ms dificultosa que la primera, debido a los mltiples
sangrados por lo cual no se recomienda su uso.
Acceso a los campos de un registro anidado
Para refenciar un campo de un registro anidado, se debe indicar el camino desde el nombre del registro hasta el campo especfico.
Por ejemplo:
Si se desea almacenar la fecha de ingreso de un empleado en la variable Empleado de
tipo R_Empleado se deber asignar as:
- 56 -
Empleado.F_Ingreso.Mes := Enero;
Empleado.F_Ingreso.Dia := 25;
Empleado.F_Ingreso.Anio := 1998;
Sentencias WITH anidadas
Cuando los registros estn anidados se puede utilizar sentencias With anidadas, para
hacer el cdigo ms simple.
Por ejemplo:
With Empleado do
begin
WriteLn ('Introduzca el nombre');
ReadLn (Nombre);
WriteLn ('Introduzca la edad');
ReadLn (Edad);
WriteLn ('Introduzca el domicilio');
ReadLn (Domicilio);
WriteLn ('Introduzca la salario');
ReadLn (Salario);
With F_Ingreso do
begin
WriteLn ('Introduzca el da');
ReadLn (Dia);
WriteLn ('Introduzca el anio');
ReadLn (Anio);
end;
end;
Como se puede observar nos ahorra cdigo. Tambin se puede ver que no se ha cargado el mes, no es un olvido sino que mes es del tipo Enumerado y habra que agregar mucho
cdigo que lo nico que implicara hacer ms complejo e ilegible el ejemplo.
Los registros como parmetros
Los registros pueden ser utilizados como parmetros en funciones y en procedimientos.
Una funcin no puede devolver un registro.
En el caso de los procedimientos los registros pueden pasar por valor y por variable.
Array de registros
Los registros pueden ser agrupados en matrices de registros. Aunque los ms comunes
toman la forma de una lista Pascal permite el uso de matrices de registros de n dimensiones.
Se maneja como cualquier matriz, pero con el cuidado que cada dato es un registro completo.
type
R_Empleado = record
Edad : integer;
Salario : real
end;
- 57 -
V_Empleados = Array [1..365] of R_Empleado;
Var
Empleado : R_Empleado;
Empleados : V_Empleados ;
Begin
For N := 1 to 10 do
Begin
Write ('Ingrese el nombre :');
Readln (Empleados[N].Nombre);
Write ('Ingrese la edad :');
Readln (Empleados[N].Edad);
Write ('Ingrese la domicilio :');
Readln (Empleados[N].Domicilio);
Write ('Ingrese la salario :');
Readln (Empleados[N].Salario);
End
El cdigo que est en el ejemplo corresponde a una carga de datos en el vector de registros.
Cuando se opera con vectores o matrices de registro los mismos pueden ser ordenados
con los mismos algoritmos Pero se debe considerar dos cosas
a) La comparacin se realiza utilizando un campo del registro
b) Las variables que se usan en el intercambio, an la auxiliar es tipo registro.
REGISTROS VARIANTES
Los registro usados hasta este punto se denominan registros invariantes o registros fijos.
Esto se debe a que una vez que el tipo registro ha sido definido, cualquier registro de ese tipo
debe incluir todos los campos incluidos en la definicin del tipo.
Ahora veremos los registros variantes, que son aquellos tipos de registros que tienen algunos campos que son iguales para todas las variables de ese tipo (parte fija) y otros campos
que pueden ser diferentes (parte variante).
Por ejemplo, supongamos registros que contengan las referencias de los alumnos y de
los profesores. Tanto alumnos como profesores tienen nombre, direccin y materia. Pero mientras los profesores tienen legajos, y salario, los alumnos poseen padrn, nota, condicin. Ambos datos pueden almacenarse en registros variantes con una parte fija (nombre, direccin y
materia) y una parte variante (legajos, salario, padrn, nota, condicin). Los registros variantes
se declaran de modo similar a los registros fijos excepto que hay un campo de indicador especial (tag) con una o ms opciones (variantes) del registro. Una sentencia case se utiliza para
declarar los campos diferentes variantes. El indicador especial puede constar de una variable
indicadora (con un tipo asignado) o slo un tipo.
type
Nivel = (Alumno, Docente);
- 58 -
R_Facultad =
record
Materia : string [20];
Case Flag : Nivel of
Docente : (
Legajo : Integer;
Salario : real );
Alumno : (
Padron : Integer;
Nota : Byte;
Condicin : Char)
end;
El tamao de un registro variante es constante, no importando cual de las opciones de la

parte variante se elija. Siempre su tamao ser igual al necesario para almacenar la opcin que
ocupe mayor espacio.
Se pueden crear registros que posean campos para un nico caso. Por ejemplo si del
alumno lo nico que nos interesara fueran sus datos generales (no el padrn, ni la nota, ni la
condicin), para ese ejemplo el registro sera:
type
R_Facultad = record
Case Flag : Nivel of
Docente : (Legajo : Integer ;
Salario : real );
Alumno : ( )
end;
Registros variantes anidados
Podemos tener el caso que un registro variante este dentro de otro registro variante. Esto
es debido a la existencias de condiciones mltiples. Por ejemplo nuestro docente puede tener
dedicacin parcial, semiexclusiva o exclusiva. Y en funcin de esto se determina distintos parmetros de trabajo. El registro posible sera:
type
Dedicacion = (Parcial, Semiexclusiva, Exclusiva);
R_Facultad = record
Case Flag1: Nivel of
Docente : (
Legajo : Integer;
Salario : real;
H_Clase : byte);
Case Flag2 : Dedicacion of
- 59 -
Exclusiva
: ( H_Aten_Alumnos : byte;
H_Investigacin : byte);
Semiexclusiva : ( H_Aten_Alumnos : byte);
Parcial
: ( );
Alumno : ( Padron : Integer;
Nota : Byte;
Condicin : Char)
end;
Ahora vamos a dar un ejemplo de un procedimiento que almacena datos en este registro.
Procedure Carga ( Var Registro : R_Facultad);
Var
Alfa, Beta : char;
Begin
With Registro do
begin
WriteLn ('Ingrese el nombre');
ReadLn (Nombre);
WriteLn (' Ingrese el domicilio');
ReadLn (Domicilio);
WriteLn (' Ingrese la materia');
ReadLn (Materia);
WriteLn (' Ingrese "A" si es alumno y "D" si es docente ');
ReadLn (Alfa);
If Alfa = "D" Then
Flag1 := Docente
Else
Flag1 := Alumno;
Case Flag1 of
Docente : begin
WriteLn (' Ingrese el salario');
ReadLn (Salario);
WriteLn (' Ingrese la cantidad de horas de clase');
ReadLn (H_Clase);
WriteLn (' Ingrese tipo de dedicacin Parcial "P",
Semiexclusiva "S" o Exclusiva "E");
ReadLn (Beta);
Case Beta of
"P" : Flag2 := Parcial;
"S" : Flag2 := Semiexclusiva;
"E" : Flag2 := Exclusiva;
end; {* Case Beta * }
Case Flag2 of
Exclusiva : begin
WriteLn ('Ingrese horas de atencin
alumnos');
ReadLn (H_Aten_Alumnos);
WriteLn ('Ingrese horas de investigacin');
ReadLn (H_Investigacin);
end;
Semiexclusiva : begin
WriteLn ('Ingrese horas de atencin alumnos');
ReadLn (H_Aten_Alumnos)
- 60 -
end;
end; {* Case Flag2 * }
end; {* Docente * }
Alumno : begin
WriteLn (' Ingrese el padrn');
ReadLn (Padron);
WriteLn (' Ingrese la nota');
ReadLn (Nota);
WriteLn (' Ingrese la condicin "R" regular y "L" libre');
ReadLn (Condicion);
end; {* Alumno * }
end; {* Flag1 * }
end; {* Procedimiento carga * }
Como se puede el cdigo de este procedimiento es largo, aunque el mismo carece de
control de entradas. Lo correcto sera particionarlo en varios procedimientos y funciones pequeas que puedan manejar tambin el control de ingresos.
- 61 -

Introduccion Al Pascal

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduccion Al Pascal

Uploaded by

Copyright:

Available Formats

ALGORTMICA Y PROGRAMACIN

Tipos carcter (Char)

{lee un valor real}

En Pascal estndar, la declaracin de constantes se sita inmediatamente despus de la

EXPRESIONES Y OPERACIONES ARITMETICAS

escribir (listas de variables salida)

En Pascal todas las operaciones de entrada/salida se realizan ejecutando unidades de

Lo anteriormente expresado es vlido para el proceso WRITE

limpieza o borrado de la pantalla

movimiento del cursor

El borrado (limpieza) de la pantalla: Clrscr

(el valor de B-C se asigna a A)

cuyo significado es evidente.

Poner un espacio en cada lado de un operador

Otras reglas de escritura

Poner cada sentencia en una lnea distinta.

PUESTA A PUNTO DE PROGRAMAS

Anlisis del programa (entrada, salida, datos auxiliares y proceso).

Errores tpicos de programacin

La planificacin de un programa comienza con el anlisis del problema [especificaciones

(* definicin de las variables *)

begin (* Comienzo del programa *)

(* declaraciones de las constantes *)

(* definicin de las variables *)

begin (* Comienzo del programa *)

(* Fin del programa *)

Las estructuras de tipo secuencial se han visto en el prctico anterior.

entonces < accin S1>

then < accin S1>

sino <accin S2 >

else < accin S2>

{* llamado al procedimiento limpieza *}

b) Se leen dos valores enteros A, B. Si A es mayor que B se realiza la suma de

{* valor que ingresa *}

procedure limpieza; {* comienzo de limpieza de la pantalla *}

procedure ingreso; {* comienzo del ingreso de datos *}

{* valor que ingresa *}

procedure limpieza; {* comienzo de limpieza de la pantalla *}

Hasta ahora hemos visto dos tipos de estructuras de control

En esta practica veremos el tipo de estructura que nos queda.

para variable (v) ? vi hasta vf hacer

for variable (v):= vi to vf do

< accin S1>

< accin S1>

< accin S2>

Longitud de una cadena:

En Turbo Pascal existen para una cadena dos longitudes:

Concat(S1, S2, S3) S1 + S2 + S3

Devuelve un entero que es la longitud lgica del string s

La estructura del arreglo se describe en Type.

Se le asigna ese tipo a una o ms variables.

En la declaracin se describe la variable.

Asignacin: Es darle un valor a un elemento de un vector

Para I 1 hasta 55 hacer

para I = 1 hasta 5 hacer

El cdigo del procedimiento es:

hasta que U[I] = 0 o i > k

writeln(No mas lugar)

para I 1 hasta P -1 hacer

readln (H); {* lee la opcin *}

TIPO DE DATOS REGISTRO

se visualizar Julio Gustavo Garona

Operaciones sobre registros

Domicilio : string [40];