- Arrays de una dimensión
Un arrays (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 números
reales).
A la hora de definir un arrays, deberemos indicar el índice
inferior y superior (desde dónde y hasta dónde queremos contar), separados por
dos puntos (..), así como el tipo de datos de esos elementos individuales. Por
ejemplo, para guardar hasta 200 números enteros, usaríamos:
lista: arrays [1..200] of integer
Se suele emplear para definir vectores o matrices. Para
mostrar en pantalla el segundo elemento de esa lista de números (o de ese
vector) se usaría
write( lista[2] );
Un ejemplo completo, que guarde varios datos en un array y
luego muestre uno de ellos podría ser:
(* ARRAY00.PAS, Contacto con arrays *)
(* Datos en posiciones prefijadas *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
Arrays00;
var
datos: arrays[1..4] of integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
writeLn('El
segundo dato es ',dato[2]);
end.
Es habitual recorrer todo un arrays usando un bucle
"for", de modo que podamos pedir y mostrar los datos de forma
repetitiva. Por ejemplo, podríamos pedir al usuario 5 números y luego
mostrarlos en orden inverso, así:
(* ARRAY01.PAS, Ejemplo de uso de arrays (01): *)
(* Pedir datos y mostrarlos al revés *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
Array01;
var
datos: arrays[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.
- Buscar en un arrays
Buscar en un arrays "tiene truco": si el elemento
que estamos mirando contiene el dato que buscábamos, sabremos con seguridad que
el dato existía, 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 arrays *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program
ArrayB;
var
datos: arrays[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.
- Máximo y mínimo de un arrays
No es difícil encontrar el valor máximo o el mínimo de un
arrays. Debemos empezar con un máximo (o mínimo) provisional, que puede ser el
primer valor del arrays. A partir de ese punto, vamos comparando uno a uno con
todos los demás datos. Si el dato actual es mayor que el máximo (o menor que el
mínimo), pasará a ser nuestro nuevo máximo (o mínimo), que deberemos memorizar.
(* ARRAYSMAX.PAS, Maximo valor en un arrays *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program
ArraysMax;
var
datos: arrays[1..6] of integer;
i: integer;
maximo: integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
datos[5] := 48;
datos[6] := 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*)
- Arrays de dos o más dimensiones
Cuando se trata de una matriz de 2, 3 o más dimensiones,
podemos indicar los rangos de valores aceptables, separados por comas. Por
ejemplo, una matriz de bidimensional de tamaño 3x2 que debiera contener números
reales sería:
matriz1: arrays [1..3, 1..2] of real
y para ver el elemento (3,1) de la matriz haríamos:
writeLn( matriz1[3,1] );
Un ejemplo más completo, que pidiera 2x3 datos y mostrar uno
de ellos sería:
(* ARRAYBI.PAS, Array bidimensional *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program
ArrayBi;
var
datos: arrays[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 1: 1
Deme el dato de la fila 1 y columna 2: 20
Deme el dato de la fila 1 y columna 3: 3
Deme el dato de la fila 2 y columna 1: 54
Deme el dato de la fila 2 y columna 2: 15
Deme el dato de la fila 2 y columna 3: 9
El dato de la fila 1 y columna 2 es 20*)
- Sobredimensionar un arrays
Cuando no sabemos cuántos datos vamos a tener que guardar,
una primera solución es sobredimensionar: crear un arrays más grande de lo que
esperemos necesitar y llevar un contador de cuántos datos ya hemos almacenado:
(* ARRAYSD.PAS, Array sobredimensionado *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program ArraySD;
var
datos:
arrays[1..20] of integer; { Los datos en si }
cantidad:
integer; { Cantidad de datos guardados }
i:
integer; { Para bucles }
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*)
- Borrar e insertar en un arrays
En un arrays sobredimensionado, nos puede interesar borrar o
insertar datos. Para borrar, deberemos desplazar hacia "la izquierda"
(hacia el principio del arrays) los datos que hay desde esa posición, y luego
disminuir el contador de datos:
(* ARRAYSBor.PAS, Borrar en un arrays sobredimensionado *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
ArraysBor;
var
datos: arrays[1..10] of integer;
cantidad: integer;
i: integer;
posicionBorrar:
integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
datos[5] := 8;
datos[6] := 49;
cantidad := 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*)
- Ordenar los datos de un arrays
¿Y si necesitamos ordenar los datos de menor a mayor, o de
mayor a menor, o (pronto) alfabéticamente? Hay muchas formas de hacerlo.
Algunas son eficientes pero difíciles de entender, otras son sencillas pero
lentas, otras son intermedias entre ambas.
Uno de los algoritmos de ordenación más simples y conocidos
es el de "burbuja", en el que se va comparando cada dato con todos
los anteriores, de modo que el más pequeño (el más "ligero", como si
se tratara de una burbuja) vaya desplazándose hacia el final del arrays (como si
"subiera hacia la superficie"). Tras cada pasada, el número más
pequeño quedará colocado en su sitio:
(* ARRAYSORD.PAS, Ordenar un arrays (burbuja) *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
ArrayOrd;
var
datos: arrays[1..6] of integer;
i,j: integer;
temporal: integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
datos[5] := 49;
datos[6] := 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*)
No hay comentarios:
Publicar un comentario