4.

Arrays, cadenas, registros y

conjuntos.
4.1. Arrays
4.1.1. Arrays de una dimensin
Un array (que algunos autores traducen como "arreglo") es una estructura que
se utiliza para guardar una serie de elementos, todos los cuales son del mismo
tipo (por ejemplo, 20 nmeros reales).
A la hora de definir un array, deberemos indicar el ndice inferior y superior
(desde dnde y hasta dnde queremos contar), separados por dos puntos (..),
as como el tipo de datos de esos elementos individuales. Por ejemplo, para
guardar hasta 200 nmeros enteros, usaramos:

lista: array [1..200] of integer

Se suele emplear para definir vectores o matrices. Para mostrar en pantalla el
segundo elemento de esa lista de nmeros (o de ese vector) se usara

write( lista[2] );
Un ejemplo completo, que guarde varios datos en un array y luego muestre uno
de ellos podra ser:

(* ARRAY00.PAS, Contacto con arrays

(* Datos en posiciones prefijadas
(* Parte de CUPAS5, por Nacho Cabanes
Program Array00;
var
datos: array[1..4] of integer;

*)
*)
*)

begin
datos[1]
datos[2]
datos[3]
datos[4]

:=
:=
:=
:=

20;
12;
7;
35;

writeLn('El segundo dato es ',dato[2]);

end.

Es habitual recorrer todo un array usando un bucle "for", de modo que podamos
pedir y mostrar los datos de forma repetitiva. Por ejemplo, podramos pedir al
usuario 5 nmeros y luego mostrarlos en orden inverso, as:

(* ARRAY01.PAS, Ejemplo de uso de arrays (01): *)

(* Pedir datos y mostrarlos al revs
*)
(* Parte de CUPAS5, por Nacho Cabanes
*)
Program Array01;
var
datos: array[1..5] of integer;
i: integer;
begin
for i := 1 to 5 do
begin
write('Deme el dato ',i,': ');
readLn(datos[i]);
end;
write('Los datos al reves son: ');
for i := 5 downto 1 do
write(datos[i], ' ');

writeLn;
end.
Ejercicio propuesto 4.1.1.1: Crea un programa que reserve espacio para un
Array de 3 nmeros enteros, que asigne a sus elementos los valores 3, 5 y 8, y
que despus muestre en pantalla la suma de los valores de sus 3 elementos.
Ejercicio propuesto 4.1.1.2: Crea un programa que pida al usuario cinco
nmeros enteros, los guarde en un array y luego muestre el primero y el ltimo.
Ejercicio propuesto 4.1.1.3: Crea un programa que pida al usuario diez
nmeros enteros, los guarde en un array y luego muestre los que se
encuentran en posiciones impares (1, 3, 5, 7, 9).
Ejercicio propuesto 4.1.1.4: Crea un programa que pida al usuario diez
nmeros enteros, los guarde en un array y luego muestre los que son impares.
Ejercicio propuesto 4.1.1.5: Crea un programa que sume dos vectores, cuyos
componentes indicar el usuario. Por ejemplo, la suma de (1,2,3) y (7,11,-1)
sera (8,13,2).
Ejercicio propuesto 4.1.1.6: Crea un programa que halle el producto escalar
dos vectores, cuyos componentes indicar el usuario.

4.1.2. Buscar en un array

Buscar en un array "tiene truco": si el elemento que estamos mirando contiene
el dato que buscbamos, sabremos con seguridad que el dato exista, pero, por
el contrario, no podremos afirmar que un dato no existe hasta que no hayamos
comprobado todos los elementos. Por eso, lo habitual es usar un "boolean"
para memorizar si lo hemos encontrado o no:

(* ARRAYB.PAS, Buscar en un array

*)
(* Parte de CUPAS5, por Nacho Cabanes *)
program ArrayB;
var
datos: array[1..5] of integer;
i: integer;
encontrado: boolean;

begin
for i := 1 to 5 do
begin
write('Deme el dato ',i,': ');
readLn(datos[i]);
end;
encontrado := false;
write('Buscando un 10... ');
for i := 1 to 5 do
if datos[i] = 10 then encontrado := true;
if encontrado then
writeLn('Encontrado!');
else
writeLn('No encontrado.');
end.
Ejercicio propuesto 4.1.2.1: Crea un programa que pida al usuario diez
nmeros enteros, los guarde en un array y luego le pida un nmero ms y diga
si era parte de los 10 datos originales o no.
Ejercicio propuesto 4.1.2.2: Crea un programa que pida al usuario diez
nmeros enteros, los guarde en un array y luego le vaya preguntando qu
nmero quiere buscar de forma repetitiva, y diga si era parte de los 10 datos
originales o no. Terminar cuando el nmero introducido sea 9999.
Ejercicio propuesto 4.1.2.3: Crea un programa que pida al usuario dos listas
de 5 nmeros enteros, usando dos arrays distintos, y luego muestre en pantalla
los nmeros que aparecen en ambas listas.

4.1.3. Mximo y mnimo de un array

No es difcil encontrar el valor mximo o el mnimo de un array. Debemos
empezar con un mximo (o mnimo) provisional, que puede ser el primer valor
del array. A partir de ese punto, vamos comparando uno a uno con todos los
dems datos. Si el dato actual es mayor que el mximo (o menor que el
mnimo), pasar a ser nuestro nuevo mximo (o mnimo), que deberemos
memorizar.

(* ARRAYMAX.PAS, Maximo valor en un array *)

(* Parte de CUPAS5, por Nacho Cabanes
*)
program ArrayMax;
var
datos: array[1..6] of integer;
i: integer;
maximo: integer;
begin
datos[1]
datos[2]
datos[3]
datos[4]
datos[5]
datos[6]

:=
:=
:=
:=
:=
:=

20;
12;
7;
35;
48;
14;

maximo := datos[1];
for i := 2 to 6 do
if datos[i] > maximo then
maximo := datos[i];
writeLn('El maximo es: ', maximo);
end.
(* Resultado:
El maximo es: 48
*)
Ejercicio propuesto 4.1.3.1: Crea un programa que pida al usuario diez
nmeros reales, los guarde en un array y luego busque y muestre el menor de
esos nmeros.
Ejercicio propuesto 4.1.3.2: Crea una versin alternativa, que pida al usuario
diez nmeros reales y muestre el menor de todos ellos, sin usar arrays.
Ejercicio propuesto 4.1.3.3: Crea un programa que pida al usuario 10
nombres de personas y sus 10 estaturas. Estos datos se guardarn en dos

arrays distintos. A continuacin debers mostrar el nombre de la persona ms

alta.

4.1.4. Arrays de dos o ms dimensiones

Cuando se trata de una matriz de 2, 3 o ms dimensiones, podemos indicar los
rangos de valores aceptables, separados por comas. Por ejemplo, una matriz
de bidimensional de tamao 3x2 que debiera contener nmeros reales sera:

matriz1: array [1..3, 1..2] of real

y para ver el elemento (3,1) de la matriz haramos:

writeLn( matriz1[3,1] );
Un ejemplo ms completo, que pidiera 2x3 datos y mostrar uno de ellos sera:

(* ARRAYBI.PAS, Array bidimensional

*)
(* Parte de CUPAS5, por Nacho Cabanes *)
program ArrayBi;
var
datos: array[1..2, 1..3] of integer;
fila,columna: integer;
begin
for fila := 1 to 2 do
for columna := 1 to 3 do
begin
write('Deme el dato de la fila ',fila,
' y columna ', columna, ': ');
readLn(datos[fila, columna]);
end;

writeLn('El dato de la fila 1 y columna 2 es ',

datos[1,2]);
end.
(* Ejemplo de ejecucion:
Deme el dato de la fila 1 y columna
Deme el dato de la fila 1 y columna
Deme el dato de la fila 1 y columna
Deme el dato de la fila 2 y columna
Deme el dato de la fila 2 y columna
Deme el dato de la fila 2 y columna
El dato de la fila 1 y columna 2 es
*)

1:
2:
3:
1:
2:
3:
20

1
20
3
54
15
9

Ejercicio propuesto 4.1.4.1: Crea un programa que pida al usuario dos

bloques de 3 nmeros enteros y luego muestre en pantalla las dos filas de tres
datos cada una.
Ejercicio propuesto 4.1.4.2: Crea un programa que pida al usuario dos
bloques de 5 nmeros enteros y luego diga la suma de ambos bloques.
Ejercicio propuesto 4.1.4.3: Crea un programa que sume dos matrices de
tamao 3x3.
Ejercicio propuesto 4.1.4.4: Si has estudiado lgebra matricial, crea un
programa que multiplique dos matrices de tamao 3x3.
Ejercicio propuesto 4.1.4.5: Si has estudiado lgebra matricial, crea un
programa que calcule el determinante de una matriz de tamao 3x3.
Ejercicio propuesto 4.1.4.6: Si has estudiado lgebra matricial, crea un
programa que calcule el determinante de una matriz de tamao 4x4.
Ejercicio propuesto 4.1.4.7: Si has estudiado lgebra matricial, crea un
programa de resolucin de sistemas de ecuaciones de 3 ecuaciones con 3
incgnitas usando el mtodo de Gauss.

4.1.5. Sobredimensionar un array

Cuando no sabemos cuntos datos vamos a tener que guardar, una primera
solucin es sobredimensionar: crear un array ms grande de lo que esperemos
necesitar y llevar un contador de cuntos datos ya hemos almacenado:

(* ARRAYSD.PAS, Array sobredimensionado *)

(* Parte de CUPAS5, por Nacho Cabanes *)
program ArraySD;
var
datos: array[1..20] of integer; { Los datos en
si }
cantidad: integer;
datos guardados }
i: integer;
bucles }

Cantidad de

{ Para

begin
{ Pedimos 200 datos o hasta introducir el valor
999 }
cantidad := 0;
repeat
if cantidad >= 200 then
writeLn('No caben mas datos!')
else
begin
cantidad := cantidad+1;
write('Deme el dato ',cantidad,' (999 para
salir): ');
readLn(datos[cantidad]);
end;
until datos[cantidad]=999;
{ El ultimo dato no hay que guardarlo }
cantidad := cantidad-1;
{ Al final, muestro todos }
writeLn('Cantidad de datos: ', cantidad);
writeLn('Los datos al reves son: ');
for i := cantidad downto 1 do
write(datos[i], ' ');

writeLn;
end.
(* Ejemplo de ejecucion:
Deme el dato 1 (999 para salir): 23
Deme el dato 2 (999 para salir): 45
Deme el dato 3 (999 para salir): 7
Deme el dato 4 (999 para salir): 16
Deme el dato 5 (999 para salir): 999
Cantidad de datos: 4
Los datos al reves son: 16 7 45 23
*)
Ejercicio propuesto 4.1.5.1: Crea un programa que pida al usuario tantos
nmeros reales como desee, para despus mostrar todos los datos con dos
cifras decimales.
Ejercicio propuesto 4.1.5.2: Crea un programa que pida al usuario tantos
nmeros reales como desee, para despus mostrar su media aritmtica y los
datos que estn por encima de esa media.
Ejercicio propuesto 4.1.5.3: Crea un programa que pida al usuario tantos
nmeros reales como desee, para despus mostrar su media aritmtica, sin
utilizar arrays.

4.1.6. Borrar e insertar en un array

En un array sobredimensionado, nos puede interesar borrar o insertar datos.
Para borrar, deberemos desplazar hacia "la izquierda" (hacia el principio del
array) los datos que hay desde esa posicin, y luego disminuir el contador de
datos:

(* ARRAYBor.PAS, Borrar en un array sobredimensionado

*)
(* Parte de CUPAS5, por Nacho Cabanes
*)
Program ArrayBor;

var
datos: array[1..10] of integer;
cantidad: integer;
i: integer;
posicionBorrar: integer;
begin
datos[1]
datos[2]
datos[3]
datos[4]
datos[5]
datos[6]
cantidad

:=
:=
:=
:=
:=
:=
:=

20;
12;
7;
35;
8;
49;
6;

{ Primero mostramos los datos }

writeLn('Los datos iniciales son: ');
for i := 1 to cantidad do
write(datos[i], ' ');
writeLn;
{ Ahora borramos el tercero }
posicionBorrar := 3;
for i := posicionBorrar to cantidad-1 do
datos[i] := datos[i+1];
cantidad := cantidad-1;
{ Y mostramos el resultado }
writeLn('Los datos tras borrar el tercero son: ');
for i := 1 to cantidad do
write(datos[i], ' ');
writeLn;
end.
(* Resultado:
Los datos iniciales son:

20 12 7 35 8 49
Los datos tras borrar el tercero son:
20 12 35 8 49
*)

De forma similar, podramos insertar un dato en una cierta posicin, si primero

desplazamos hacia "la derecha" (hacia el final del array) los datos que hay a
partir de esa posicin e incrementamos el contador que almacena la cantidad
de datos.
Ejercicio propuesto 4.1.6.1: Crea una variante del programa que borra un
elemento de un array. En esta ocasin, deber insertar el valor "10" en la
tercera posicin y mostrar el resultado.
Ejercicio propuesto 4.1.6.2: Crea un programa que permita al usuario guardar
tantos nmeros enteros como desee (hasta un mximo de 1000). Deber
permitir aadir datos al final, insertar en cualquier posicin, borrar cualquier
posicin o mostrar los datos que hay almacenados.

4.1.7. Ordenar los datos de un array

Y si necesitamos ordenar los datos de menor a mayor, o de mayor a menor, o
(pronto) alfabticamente? Hay muchas formas de hacerlo. Algunas son
eficientes pero difciles de entender, otras son sencillas pero lentas, otras son
intermedias entre ambas.
Uno de los algoritmos de ordenacin ms simples y conocidos es el de
"burbuja", en el que se va comparando cada dato con todos los anteriores, de
modo que el ms pequeo (el ms "ligero", como si se tratara de una burbuja)
vaya desplazndose hacia el final del array (como si "subiera hacia la
superficie"). Tras cada pasada, el nmero ms pequeo quedar colocado en
su sitio:

(* ARRAYORD.PAS, Ordenar un array (burbuja) *)

(* Parte de CUPAS5, por Nacho Cabanes
*)
Program ArrayOrd;

var
datos: array[1..6] of integer;
i,j: integer;
temporal: integer;
begin
datos[1]
datos[2]
datos[3]
datos[4]
datos[5]
datos[6]

:=
:=
:=
:=
:=
:=

20;
12;
7;
35;
49;
8;

{ Primero mostramos los datos }

writeLn('Los datos iniciales son: ');
for i := 1 to 6 do
write(datos[i], ' ');
writeLn;
{ Ahora ordenamos mediante burbuja }
for i := 6 downto 2 do
for j := 0 to i - 1 do
if datos[j] > datos[j + 1] then
begin
temporal := datos[j];
datos[j] := datos[j + 1];
datos[j + 1] := temporal;
end;
{ Y mostramos el resultado }
writeLn('Los datos tras ordenar son: ');
for i := 1 to 6 do
write(datos[i], ' ');
writeLn;
end.
(* Resultado:

Los datos iniciales son:

20 12 7 35 49 8
Los datos tras ordenar son:
7 8 12 20 35 49
*)