Este sitio web usa cookies de terceros para analizar el tráfico y personalizar los anuncios. Si no está de acuerdo, abandone el sitio y no siga navegando por él. ×


4. Arrays, cadenas, registros y conjuntos.

4.1. Arrays

4.1.1. Arrays de una dimensión

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 números reales).

A la hora de definir un array, 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: array [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 Array00;
 
var
    datos: array[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 array 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: 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 números enteros, que asigne a sus elementos los valores 3, 5 y 8, y que después 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 números 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 números 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 números 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) sería (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 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 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 números enteros, los guarde en un array y luego le pida un número más 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 números enteros, los guarde en un array y luego le vaya preguntando qué número quiere buscar de forma repetitiva, y diga si era parte de los 10 datos originales o no. Terminará cuando el número introducido sea 9999.
Ejercicio propuesto 4.1.2.3: Crea un programa que pida al usuario dos listas de 5 números enteros, usando dos arrays distintos, y luego muestre en pantalla los números que aparecen en ambas listas.

4.1.3. Máximo y mínimo de un array

No es difícil encontrar el valor máximo o el mínimo de un array. Debemos empezar con un máximo (o mínimo) provisional, que puede ser el primer valor del array. 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.

(* 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] := 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
*)
 

Ejercicio propuesto 4.1.3.1: Crea un programa que pida al usuario diez números reales, los guarde en un array y luego busque y muestre el menor de esos números.
Ejercicio propuesto 4.1.3.2: Crea una versión alternativa, que pida al usuario diez números 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 guardarán en dos arrays distintos. A continuación deberás mostrar el nombre de la persona más alta.

4.1.4. 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: array [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: 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 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
*)
 

Ejercicio propuesto 4.1.4.1: Crea un programa que pida al usuario dos bloques de 3 números 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 números enteros y luego diga la suma de ambos bloques.
Ejercicio propuesto 4.1.4.3: Crea un programa que sume dos matrices de tamaño 3x3.
Ejercicio propuesto 4.1.4.4: Si has estudiado álgebra matricial, crea un programa que multiplique dos matrices de tamaño 3x3.
Ejercicio propuesto 4.1.4.5: Si has estudiado álgebra matricial, crea un programa que calcule el determinante de una matriz de tamaño 3x3.
Ejercicio propuesto 4.1.4.6: Si has estudiado álgebra matricial, crea un programa que calcule el determinante de una matriz de tamaño 4x4.
Ejercicio propuesto 4.1.4.7: Si has estudiado álgebra matricial, crea un programa de resolución de sistemas de ecuaciones de 3 ecuaciones con 3 incógnitas usando el método de Gauss.

4.1.5. Sobredimensionar un array

Cuando no sabemos cuántos datos vamos a tener que guardar, una primera solución es sobredimensionar: crear un array 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: array[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 
*)
 

Ejercicio propuesto 4.1.5.1: Crea un programa que pida al usuario tantos números reales como desee, para después mostrar todos los datos con dos cifras decimales.
Ejercicio propuesto 4.1.5.2: Crea un programa que pida al usuario tantos números reales como desee, para después mostrar su media aritmética y los datos que están por encima de esa media.
Ejercicio propuesto 4.1.5.3: Crea un programa que pida al usuario tantos números reales como desee, para después mostrar su media aritmética, 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 posición, 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] := 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 
*)
 

De forma similar, podríamos insertar un dato en una cierta posición, si primero desplazamos hacia "la derecha" (hacia el final del array) los datos que hay a partir de esa posición 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 ocasión, deberá insertar el valor "10" en la tercera posición y mostrar el resultado.
Ejercicio propuesto 4.1.6.2: Crea un programa que permita al usuario guardar tantos números enteros como desee (hasta un máximo de 1000). Deberá permitir añadir datos al final, insertar en cualquier posición, borrar cualquier posición 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) 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 array (como si "subiera hacia la superficie"). Tras cada pasada, el número más pequeño 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] := 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 
*)
 

Ejercicio propuesto 4.1.7.1: Modifica el programa de ordenación mediante burbuja, para que muestre en pantalla el resultado de cada paso intermedio.
Ejercicio propuesto 4.1.7.2: Crea un programa que permita al usuario guardar tantos números enteros como desee (hasta un máximo de 1000) y luego los muestre ordenados.