TABLAS AULA MENTOR

Introducción

Podríamos hacer una primera clasificación de los tipos de datos que maneja un ordenador:
tipos de datos simples y tipos de datos compuestos.

*Simples: son aquellos que sirven para representar información de tipos elementales
como por ejemplo números enteros, reales o información de tipo carácter. Son los que hemos
estudiado hasta este momento.
*Compuestos: son conjuntos de datos simples relacionados entre sí de alguna forma.

Dentro de los tipos de datos compuestos, podremos hablar de estáticos y de dinámicos. En los
primeros el tamaño de los datos está prefijado al iniciar el programa. En los segundos el
tamaño de los datos puede variar durante la ejecución del programa.

Definición

En este apartado vamos a introducir una estructura compuesta: las tablas, y en concreto las de
carácter monodimensional (una dimensión). Más adelante estudiaremos las tablas
multidimensionales (más de una dimensión).
Definimos tabla como un conjunto finito y ordenado de elementos homogéneos. Las tablas
también reciben el nombre de matrices o arrays.

*Finito: está compuesta por un número limitado de elementos.

*Ordenado: los elementos se pueden referenciar según su posición (su orden en la tabla).
*Homogéneos: los componentes de una tabla han de ser del mismo tipo.

En las tablas monodimensionales los elementos están ordenados desde el primero hasta el
último, pudiendo acceder a los mismos mediante un índice que indica su posición.

Una tabla se identifica por un nombre. Si especificamos dicho nombre sin hacer referencia al
índice nos estaremos refiriendo a la tabla entera, no a alguno de sus elementos.

Para acceder al contenido de un elemento de una tabla se deberá especificar el nombre de la

tabla e indicar mediante un índice la posición del elemento en cuestión.

-1-
TABLAS AULA MENTOR

El índice de una tabla podrá variar desde el límite inferior hasta el superior, que se especifican
en la definición de la tabla. Estos límites deberán ser constantes, y por lo tanto el tamaño de la
tabla esta fijado en el momento de la compilación.

Las tablas se utilizan para facilitar el acceso a información que puede ser agrupada siguiendo
algún concepto lógico de agrupación, y que además sea información homogénea, por ejemplo:
-Las notas de un conjunto de alumnos: todas son del mismo tipo, reales, y podemos tener a los
alumnos ordenados alfabéticamente.
-Los precios de los productos de una tienda: son todos del mismo tipo, y pueden ser ordenados
por el número de referencia.
-Las medidas de un termómetro, o cualquier tipo de sensor o alarma, a lo largo del día: todas
las medidas serán del mismo tipo, y pueden ser ordenadas por la hora en que fueron tomadas.

Puede encontrar la representación gráfica de una tabla de la siguiente forma:

Pasemos a estudiar como se definen y usan las tablas en Pascal.

Definición

Para definir una tabla en Pascal se utiliza la palabra reservada array. Además necesitamos
conocer:

*El tamaño de la tabla, indicando su índice inicial y final.

*El tipo de los elementos de la tabla o tipo base.

Se pueden definir directamente variables de tipo tabla o utilizar la sección de tipos definidos
por el usuario:

Type
lecturas = array[1..24] of integer; (* tipo base: integer *)

-2-
TABLAS AULA MENTOR

Var
temperaturas : lecturas; (* Almacena temperaturas cada hora *)
humedad : lecturas; (* Almacena humedad cada hora *)
medias: array[1..31] of real;
i: integer;

Definimos en la sección Type un tipo definido por el usuario de nombre lecturas, que será una
tabla de 24 valores de tipo entero. Una vez definido este tipo lecturas, podremos usarlo en las
definiciones de variables como cualquier tipo básico. Es lo que encontramos a continuación:
la definición de dos variables, temperatura y humedad de ese tipo.

En la misma sección definimos otra tabla de nombre medias, que almacena 31 valores de tipo
real. Observe la notación para especificar el valor inicial y final de los índices, encerrados
entre corchetes y separados por dos puntos.

Utilización

Para acceder a un elemento de la tabla simplemente necesitamos el nombre de la tabla y el

índice de ese elemento. A partir de ese momento lo podremos usar en cualquier expresión tal
como usábamos las variables de tipos simples, variables de tipo entero o real:

temperaturas[7] := 25;
media := (temperaturas[7] + temperaturas[8]) / 2;

O en operaciones de lectura y escritura:

write('Introduzca la temperatura al mediodia');

readln( temperaturas[12] );
write( 'La temperatura a las 12:00 es de ', temperatura[12] );

Tablas y bucles

Lo que hace realmente útil y potente a las tablas es la posibilidad de usarlas en bucles, en los
que la variable de control se utiliza al mismo tiempo como índice de acceso a los elementos de
la tabla:

writeln('Introduzca los valores de las temperaturas(01:00 hasta 24:00')

for i:= 1 to 24 do
begin

write('Temp. a las ', i, ': ');

readln(temperatura[i]);

end;

-3-
TABLAS AULA MENTOR

En este bucle se solicita al usuario que vaya introduciendo las temperaturas medidas a lo largo
del día. Y para ello aprovecha la variable de control (o índice) para acceder a los distintos
elementos de la tabla temperatura.

Tablas y módulos

Los módulos (funciones y procedimientos) pueden recibir como parámetros tablas. Siguiendo
los ejemplos anteriores, observe esta función que recibe como parámetro una tabla (del tipo
lecturas) y devuelve como resultado de la función la media de las medidas realizadas.

Para calcular la media de un conjunto de valores se suman todos los valores, y la suma total se
divide por el número de valores. Para ello necesitamos una variable que acumule la suma, e
iniciarla antes del bucle a cero.

Function Media(medidas: lecturas): Real;

Var
i: integer;
suma: integer;
Begin
suma := 0;
for i:= 1 to 24 do
suma:= suma + medidas[i];
Media := suma/24.0
End;

No es posible en Pascal que una función devuelva como resultado de la función una tabla. Por
lo tanto la única manera de modificar una tabla dentro de una función o procedimiento es
pasarla por referencia. Puede repasar como se usan los parámetros por referencia o consultar
el tema de subprogramas.

Observe la siguinte función Lectura: se solicita al usuario que vaya tecleando los 24 valores de
temperatura y se van almacenando en los elementos de la tabla, que se ha pasado por
referencia. Y de nuevo utilizamos la variable de control del bucle como índice de los
elementos de la tabla.

Procedure Lectura(VAR medidas: lecturas);

Var
i: integer;
Begin
writeln('Introduzca los valores(01:00 hasta 24:00');
for i:= 1 to 24 do
begin
write('Medida a las ', i, ': ');

-4-
TABLAS AULA MENTOR

readln(medidas[i]);
end;
End;

Existe otra limitación: es necesario definir un tipo de datos definido por usuario (sección
Type) que se corresponda con la tabla antes de definir la función y usarla como parámetro. La
siguiente definición sería errónea:

(* *)
(* !!!!!!!!!!!! Este procedimiento no compila !!!!!!!!!!!!!!! *)
(* *)
Procedure Lectura(VAR medidas: array[1..24] of integer);
Var
i: integer;
Begin
writeln('Introduzca los valores(01:00 hasta 24:00');
for i:= 1 to 24 do
begin
write('Medida a las ', i, ': ');
readln(medidas[i]);
end;
End;

Será necesario definir primero un tipo de datos que se corresponda con esa tabla y usar el
identificador de ese tipo creado por el usuario en el procedimiento:

Type
lecturas = array[1..24] of integer;

Procedure Lectura(VAR medidas: lecturas);

Var
i: integer;
Begin
writeln('Introduzca los valores(01:00 hasta 24:00');
for i:= 1 to 24 do
begin
write('Medida a las ', i, ': ');
readln(medidas[i]);
end;
End;

Antes de continuar, estudiemos ejemplos de uso de tablas y funciones. Vamos a analizar una
función que calcula la media de todos los valores de una tabla.

Function Maximo(medidas: lecturas): Integer;

Var
i: integer;
max: integer;

-5-
TABLAS AULA MENTOR

Begin
(* Como no conocemos los valores de la tabla *)
(* suponemos que el primer valor es el max. *)
max := medidas[1];
(* Recorremos el resto de la tabla comprobando *)
for i:= 2 to 24 do (* si hay algún valor mayor en la tabla *)
if max < medidas[i] then
max := medidas[i]; (* si lo hay, es nuestro nuevo máximo *)

Maximo := max;
End;
*La tabla medidas se pasa por valor: no hay que modificarla, sólo consultarla.
*Se supone que el máximo es el primero elemento de la tabla.
*A continuación se recorre el resto de la tabla. En el caso que algún valor sea mayor que le
primero, será nuestro nuevo máximo.
*La última sentencia de la función es una sentencia de asignación. Recuerde: se le asigna al
nombre de la función el valor que deseamos que devuelva la función.

Repase todas estas funciones, y algunas más, en el programa tablas.pas. Observe que si
compila este ejemplo recibirá unos mensajes de aviso o atención, llamados warnings o avisos
que puede observar en la siguinte figura:

Nos avisa que hemos definido variables que luego no se utilizan en el código. Esto es debido a
que dentro de este programa hemos conservado la versión inicial para que compare como se
va mejorando y haciendo modular un programa.

A continuación estudiaremos un tipo muy particular de tablas: las tablas de caracteres.

Cadenas de caracteres: strings

-6-
TABLAS AULA MENTOR

Hemos introducido el concepto de tabla y definido las tablas monodimensionales y su uso.

Más tarde estudiaremos las tablas multidimensionales.

Antes vamos a detenernos en un tipo muy particular de tabla monodimensional: las tablas de
caracteres, llamadas cadenas de caracteres. Las cadenas de caracteres no son más que tablas
unidimensionales cuyo tipo base es char. Para facilitar su uso en Pascal se utiliza el tipo de
datos string.

Definición

Para definirlas es necesario utilizar la palabra reservada string en vez de array:

type

cadena40 = string[40]; (* No se declara el tipo base *)

cadena80 = string[80];
cadena = string; (* Si no se especifica el tamaño es 255 *)

var

nombre = cadena40;
direccion = cadena80;
descripcion = cadena;
apellidos = string[50];

Como podemos observar es posible definir un tipo de datos string en la sección Type. O
definir variables de este tipo usando la palabra string directamente en la definición de la
variable.

En este tipo no se define el valor inicial y final de la tabla: sólo se define el tamaño. El valor
inicial se supone siempre que es uno (1). Luego el tipo cadena40 significa que tenemos una
tabla de 40 caracteres, y el índice varía desde 1 hasta 40.

En este tipo es opcional definir el tamaño de la cadena: si no lo hacemos se supone que es

255. Hemos definido cadenas de distintos tamaños en función de las posibles necesidades.

Acceso

Se puede acceder a los elementos de una cadena de caracteres de forma individual como en las
tablas, o hacer asignaciones directas utilizando el nombre de la variable:

apellidos[5] := 'L'; (* Acceso caracter a caracter *)

readln(apellidos[4]);

nombre := 'Felipe Fernandez'; (* Asignacion directa utilizando el nombre *)

-7-
TABLAS AULA MENTOR

readln(descripcion);
writeln(nombre);

Tamaño físico y longitud

Se puede observar que no siempre utilizamos todas las posiciones de una cadena. Por lo tanto
existen dos tamaños a utilizar cuando trabajamos con cadenas de caracteres o strings:

*El tamaño máximo o físico de la cadena.

*El tamaño que realmente estamos utilizando en cada momento. Este último se suele
denominar longitud, o tamaño lógico de la cadena.

En el caso de la variable nombre, su tamaño máximo o físico es 40, y su longitud tras la

asignación nombre := 'Felipe Fernandez'; es de 16.

Realmente el tamaño físico de la tabla es superior al esperado. Hemos mencionado

previamente que el índice de la cadena puede oscilar desde 1 hasta el tamaño del string. El
valor de índice cero (0) almacena el tamaño lógico de la cadena de caracteres en cada
momento. No es conveniente modificar este valor en nuestro programa porque estaremos
truncando nuestra cadena, y forzando una longitud lógica que no es la real.

Limitaciones

En el tipo string existen limitaciones similares a las tablas: no es posible que una función
devuelva como resultado una cadena ni definir este tipo de datos en la cabecera de un módulo.

Tablas con índices no enteros

Por otra parte, los índices de las tablas pueden ser de cualquier tipo ordinal: enteros, carácter,
subrango, etc. Estudie el siguiente ejemplo, donde el índice de la tabla es de tipo carácter.

Se trata de solicitar al usuario una cadena de caracteres por pantalla y contar el número de
repeticiones de las distintas letras:

repeticiones: array['a'..'z'] of integer;

(* El índice indica la letra, y el valor que almacena el
número de repeticiones *)
...

for l:='a' to 'z' do

write(l,': ', repeticiones[l], ' ');

-8-
TABLAS AULA MENTOR

Observe la definición de la tabla y su uso posterior en un bucle. El algoritmo lo que hace es

recorrer la cadena de caracteres uno a uno, e ir incrementando el elemento de la tabla
repeticiones cuyo índice coincida con el valor de la cadena de caracteres (cadena[i]).

long := ord(cadena[0]);
(* La longitud lógica de una cadena se *)
(* almacena en el elemento 0 *)

for i:=1 to long do

repeticiones[cadena[i]] := repeticiones[cadena[i]] + 1;
Observe resaltados tanto el cálculo de la longitud de una cadena de caracteres (elemento cero)
como el acceso a los elementos de la tabla repeticiones para incrementarlos en una unidad. El
índice de la tabla repeticiones es el carácter i de la cadena (cadena[i]), que es una letra.

El código completo de este ejemplo lo puede encontrar en TablasLetras.pas.

Intente mejorar este programa, creando procedimientos que hagan el cálculo de ocurrencias y
la presentación por pantalla de los resultados.

(*

Tema 7: Tablas

Programa ejemplo del uso de Tablas con índices no enteros.

Este programa cuenta el número de repeticiones de las letras
en una cadena que se solicita por pantalla.

*)

Program TablasLetras;

Var
i: integer; (* Var. auxiliar para bucles *)
long: integer; (* Longitud lógica de la cadena *)
l: char; (* Var. auxiliar para bucles *)
cadena: string; (* Var. que lamacena la cadena *)

repeticiones: array['a'..'z'] of integer;

(* El índice indica la letra, y el valor que almacena el

número de repeticiones de esa letra *)

(* Modulo principal *)
begin
write('Introduzca una cadena de muestra: ');
readln(cadena);

long := ord(cadena[0]); (* La longitud lógica de

una cadena se *)

-9-
TABLAS AULA MENTOR

(* almacena en el elemento 0 *)

for l:='a' to 'z' do (* inicia la tabla repeticiones a

cero *)
repeticiones[l] := 0;

for i:=1 to long do

repeticiones[cadena[i]] := repeticiones[cadena[i]] + 1;

(* Presenta por pantalla las ocurrencias de cada letra *)

for l:='a' to 'z' do
write(l,': ', repeticiones[l], ' ');

end.

Pasemos a estudiar a continuación las tablas multidimensionales.

Tablas Multidimensionales

Las tablas multidimensionales se basan en el mismo concepto que las tablas

monodimensionales: un conjunto de elementos ordenado y homogéneo. Pero ahora el acceso a
los elementos se hace mediante más de un índice. De esta forma tendremos tablas
bidimensionales (dos índices), tridimensionales (tres índices), etc.
Definición

La definición de tipos o variables de este tipo es muy similar al de tablas unidimensionales. La

única diferencia es que tenemos varias dimensiones. Se define el rango de cada índice como
en tablas unidimensionales (inicio..fin), y cada rango se separa del siguiente por comas (i1..f1,
i2..f2, i3..f3):

type

nombre_tipo = array[vi_1..vf_1, v1_2..vf_2, ... vi_n..vf_n] of tipo_base;

var

nombre_var = array[vi_1..vf_1, v1_2..vf_2, ... vi_n..vf_n] of tipo_base;

Acceso a los elementos

- 10 -
TABLAS AULA MENTOR

El acceso a los elementos de una tabla mutidimensional se hace especificando un índice para
cada dimensión, separados estos por comas dentro de los corchetes:

nombre_var[ind_1, ind_2, ..... ind_n] := valor ;

readln(nombre_var[ind_1, ind_2, ..... ind_n]);

En el caso de una tabla bidimensional:

for i:=1 to 10 do
for j :=1 to 10 do
total := total + valor[i,j];
Es muy frecuente utilizar tablas de dos dimensiones para representar variables que son
funciones de dos parámetros distintos.

Estas tablas bidimensionales se corresponden con la información que representamos

habitualmente en filas y columnas. Podemos utilizar la primera dimensión para las filas y la
segunda para las columnas.

Esto es lo que se representa en la siguiente figura: tres filas por cinco columnas. En las
posiciones de las tablas hemos representado los índices necesarios para acceder a cada
elemento de al tabla.

Ejemplos de posible utilización de tablas bidimensionales son:

*Gastos mensuales clasificados por tipo de gastos: una dimensión puede representar los meses
y otra el tipo de gastos.

- 11 -
TABLAS AULA MENTOR

*Ventas de una empresa clasificadas por meses y por regiones.

Notas de una clase por alumnos y asignatura.

A continuación vamos a estudiar el uso de tablas multidimensionales. Al mismo tiempo

iremos repasando los conceptos de modularidad, funciones y procedimientos.

Ejemplo: ventas

Estudie el siguiente programa: intentamos que una tabla refleje las ventas por meses y por
zonas de varios agentes comerciales.

Necesitamos una tabla bidimensional: las filas representan los meses y las columnas las zonas.

Type
ventas = array[1..2, 1..4] of real;
(* Tabla para almacenar las ventas mensuales en cada región *)
(* Tenemos 12 meses (1..12) y 4 regiones (1..4) *)

Var
i: integer; (* Var. auxiliar para contadores *)

- 12 -
TABLAS AULA MENTOR

j: integer; (* Var. auxiliar para contadores *)

Cesar: ventas; (* Tabla que recoge las ventas de un
comercial 12 meses por 4 zonas *)

A continuación nuestro programa solicita al usuario los datos por meses y por zonas. Par ello
debe recorrer la tabla por filas y columnas. Es necesario un bucle que recorra las filas. Para
cada iteración de este bucle necesitamos un bucle interior que vaya recorriendo las columnas
de esa fila.

(* Observe: para "llenar" la tabla bidimensional necesitamos dos bucles for anidados. El
primero o exterior recorre las filas, y el segundo o interior recorre las columnas *)

for i:= 1 to 2 do (* recorre filas: desde Enero hasta Diciembre *)

begin

writeln('Ventas mes ', i);

for j:= 1 to 4 do (* recorre columnas: desde zona 1 hasta 4 *)
begin

write(' Zona ', j, ': ');

read(Cesar[i,j]);

end;

end;

Un bucle similar se utiliza para presentar los valores de la tabla por pantalla. El código
completo lo puede encontrar en tablasmulti_01.pas.

Edítelo, estudie el código y compile el programa. Ejecútelo para comprobar su

funcionamiento.

Pero esta es simplemente nuestra primera versión. Posiblemente tengamos varios vendedores,
y no sería muy elegante ni eficaz repetir los bucles de lectura y escritura anteriores para cada
uno ellos. Es necesario crear un procedimiento genérico para la lectura y otro para la escritura.
A estos habrá que pasarles como parámetro la tabla que queremos actualizar o presentar por
pantalla.

No olvide un detalle: ¿cómo se le debe pasar la tabla a la función de lectura? Posiblemente ya

lo haya descubierto: por referencia.

Además, a las funciones de lectura y escritura le vamos a pasar como parámetro una cadena de
caracteres para avisar al usuario del comercial del que se trata.

Procedure lee_ventas(VAR empleado: ventas; nombre: string);

Var

i,j: integer;

- 13 -
TABLAS AULA MENTOR

begin
(* Observe: para "llenar" la tabla bidimensional necesitamos dos bucles for
anidados. El primero o exterior recorre las filas, y el segundo o interior recorre
las columnas *)

for i:= Enero to Diciembre do (* recorre filas: Enero hasta Diciembre *)

begin

writeln('Ventas de ', nombre,' mes ', i);

for j:= 1 to 4 do (* recorre columnas: desde zona 1 hasta 4 *)
begin

write(' Zona ', j, ': ');

readln(empleado[i,j]);

end;

end;

end;

Observe que:
La tabla de ventas se pasa por valor o referencia.
Se le pasa también una cadena de caracteres para ayudar a la presentación por pantalla, y
almacenará el nombre del vendedor.
Se usa como límite del bucle más externo las constantes Enero y Diciembre, definidas como 1
y 12 en la zona de constantes.

El cuerpo del programa principal queda mucho más legible:

(* Lectura de las ventas anuales *)

writeln('Introduzca las ventas anuales de Cesar ');
writeln('**************************************');
lee_ventas(Cesar, 'Cesar');
write_ventas(Cesar, 'Cesar');

Pero además de la legibilidad hemos conseguido que leer y presentar las ventas de cualquier
otro vendedor sea inmediato:

writeln('Introduzca las ventas anuales de Jesus ');

writeln('**************************************');
lee_ventas(Jesus, 'Jesus');
write_ventas(Jesus, 'Jesus');

Como puede observar, la modularidad es un concepto muy importante a la hora de modificar o

mejorar las prestaciones de un programa.

- 14 -
TABLAS AULA MENTOR

Y ahora seguramente querrá hacer algo con los datos de ventas, como por ejemplo calcular el
máximo de ventas de cada vendedor. Vamos a implementar una función que reciba los datos
de ventas de un empleado y devuelva el máximo de dichas ventas.

(* Calcula el máximo de ventas (en todos los meses y en todas las zonas de un empleado que
se le pasa como parámetro por valor *)

Function max_ventas(empleado: ventas): Real;

Var

max: Real;
i,j: integer;

begin

max := -1.0;
for i:= Enero to Diciembre do (* recorre filas: Enero hasta Diciembre *)
begin

for j:= 1 to 4 do(* recorre columnas: desde zona 1 hasta 4 *)

if (empleado[i,j] > max) then

max := empleado[i,j];

end;

max_ventas := max;

end;

Y la llamada a esta función será simplemente:

writeln('Maximos de ventas');
writeln('Cesar: ', max_ventas(Cesar):0:1);
writeln('Jesus: ', max_ventas(Jesus):0:1);

Observe como la llamada a la función max_ventas se realiza dentro de la función writeln. El

código completo se encuentra en el fichero tablamulti_02.pas. Si compila este programa
obtendrá un nuevo warning: de nuevo dejamos variables definidas pero no utilizadas. Elimine
las definiciones de esas variables y vuelva a compilar para que desaparezcan los avisos.

- 15 -
TABLAS AULA MENTOR

A partir de aquí las posibilidades son infinitas. Por ejemplo el tipo base de las tablas no tiene
por que ser un tipo básico: puede ser un tipo definido por el usuario. De esta forma las
posibilidades se multiplican, sobre todo cuando estudiemos en el tema siguiente los registros.

Vamos a proponer un nuevo cambio: crear una tabla unidimensional, donde cada uno de los
elementos sea una tabla del tipo ventas.

Type
ventas = array[Enero..Diciembre, 1..NumZonas] of real;
(* Tabla para almacenar las ventas mensuales en cada región *)
(* Tenemos 12 meses (1..12) y 4 regiones (1..4) *)

vendedores = array[1..NumEmple] of ventas;

(* Tabla de vendedores: cada una de las posiciones almacena
las ventas de un comercial. El índice de la tabla será
el nombre del vendedor
*)

Var
plantilla: vendedores;

De esta forma no tendremos que modificar los procedimientos creados, sólo las llamadas o
invocaciones a estos procedimientos. Si a las funciones de los ejemplos anteriores se le pasaba
como parámetro una tabla del tipo ventas, ahora le pasaríamos como parámetro un elemento
de la tabla vendedores. Cada uno de estos elementos es del tipo ventas.

Las llamadas a las funciones de lectura y escritura del módulo principal quedarían de la
siguiente forma:

(* Lectura de las ventas de Angel *)

lee_ventas(plantilla[1], 'Angel');
write_ventas(plantilla[1], 'Angel');

(* Lectura de las ventas de Carmen *)

lee_ventas(plantilla[2], 'Carmen');
write_ventas(plantilla[2], 'Carmen');

Y podremos crear una función que a partir de lo anterior calcule el máximo de todos los
vendedores, aprovechando que ya tenemos una función que calcula el máximo de un
vendedor:

(* Calcula el máximo de ventas mensuales entre TODOS los empleados *)

Function max_todos(empleados: vendedores ): Real;
Var
max: Real;
i: integer;
begin

- 16 -
TABLAS AULA MENTOR

max := -1.0;
for i:= 1 to NumEmple do
if max_ventas(empleados[i]) > max then
max := max_ventas(empleados[i]);

max_todos := max;
end;

Y la llamada a esta función quedaría:

writeln('TODOS : ', max_todos(plantilla):0:1);

El código final lo puede estudiar en tablasmulti_03.pas

(*
Tema 7: Tablas

Tablasmulti_03, versión mejorada de tablasmulti_02

Se crea un tabla cuyos elementos son tablas del tipo ventas. Es similar a
una tabla de tres dimensiones.

Se añaden funciones para la lectura y escritura de las tablas.

Programa ejemplo del uso de Tablas Multidimensionales en Pascal.

Define una tabla bidimensional: las filas son los meses, y las columnas las
zonas de venta.

Nota: Para abreviar las pruebas se reduce el número de meses a dos o tres
*)

Program TablasMulti_03;
Const
Enero = 1;
Diciembre = 2;
NumEmple = 2;
NumZonas = 2;
Type
ventas = array[Enero..Diciembre, 1..NumZonas] of real;
(* Tabla para almacenar las ventas mensuales en cada región *)
(* Tenemos 12 meses (1..12) y 4 regiones (1..4) *)

vendedores = array[1..NumEmple] of ventas;

(* Tabla de vendedores: cada uan de las
posiciones almacena
las ventas de un comercial. El índice de
la tabla será
el nombre del vendedor
*)
Var

- 17 -
TABLAS AULA MENTOR

plantilla: vendedores;

(* Solicita por pantalla las ventas por meses y regiones de un vendedor *)

(* Observe que la variable empleado se pasa por VALOR. Al mismo tiempo *)
(* se pasa el nombre del empleado para facilitar la presentación *)
Procedure lee_ventas(VAR empleado: ventas; nombre: string);
Var
i,j: integer;
begin
(* Observe: para "llenar" la tabla bidimensional necesitamos dos bucles for
anidados. El primero o exterior recorre las filas, y el segundo o
interior recorre las columnas
*)

for i:= Enero to Diciembre do (* recorre filas: Enero hasta Diciembre *)

begin
writeln('Ventas de ', nombre,' mes ', i);
for j:= 1 to NumZonas do (* recorre columnas: desde zona 1 hasta 4 *)
begin
write(' Zona ', j, ': ');
readln(empleado[i,j]);
end;
end;
end;

(* Presenta los resultados de ventas por meses y zonas *)

Procedure write_ventas(empleado: ventas; nombre: string);
Var
i,j: integer;
begin
(* Para mostrar los valores de la tabla también necesitamos dos bucles for
anidados. El primero o exterior recorre las filas, y el segundo o
interior recorre las columnas
*)

for i:= Enero to Diciembre do (* recorre filas: Enero hasta Diciembre *)

begin
writeln('Ventas de ', nombre,' mes ', i);
for j:= 1 to NumZonas do (* recorre columnas: desde zona 1 hasta 4 *)
begin
write(' Zona ', j, ': ');
write(empleado[i,j]:0:0,' ');
end;
writeln();
end;
end;

(* Calcula el máximo de ventas (en todos los meses y en todas las zonas
de un empleado que se le pasa como parámetro por valor *)

- 18 -
TABLAS AULA MENTOR

Function max_ventas(empleado: ventas): Real;

Var
max: Real;
i,j: integer;
begin
max := -1.0;
for i:= Enero to Diciembre do (* recorre filas: Enero hasta Diciembre *)
begin
for j:= 1 to NumZonas do (* recorre columnas: desde zona 1 hasta 4 *)
if empleado[i,j] > max then
max := empleado[i,j];
end;
max_ventas := max;
end;

(* Calcula el máximo de ventas mensuales entre TODOS los empleados *)

Function max_todos(empleados: vendedores ): Real;
Var
max: Real;
i: integer;
begin
max := -1.0;
for i:= 1 to NumEmple do
if max_ventas(empleados[i]) > max then
max := max_ventas(empleados[i]);
max_todos := max;
end;

(* Modulo principal *)
begin

(* Lectura de las ventas de Angel *)

lee_ventas(plantilla[1], 'Angel');
write_ventas(plantilla[1], 'Angel');

(* Lectura de las ventas de Carmen *)

lee_ventas(plantilla[2], 'Carmen');
write_ventas(plantilla[2], 'Carmen');

writeln('Maximos de ventas');
writeln('Angel : ',max_ventas(plantilla[1]):0:1);
writeln('Carmen: ',max_ventas(plantilla[2]):0:1);
writeln('TODOS : ',max_todos(plantilla):0:1);

end.

- 19 -