PASCAL CON FREE PASCAL

Una arreglo es un conjunto de espacios o bloques de memoria reservados, que se declaran con un sólo tipo de dato, todos estos espacios o bloques de memoria son continuos. A estos espacios o bloques de memoria se les suele llamar elementos del arreglo. El tipo de dato de los elementos de un arreglo, pueden ser tipos de datos simples o compuestos. El tamaño en bytes de una variable de tipo arreglo, se puede obtener por el tamaño en bytes del tipo de dato, que se usa al crear la variable de tipo arreglo, con la cantidad de elementos del arreglo. Es decir si creamos un arreglo de 15 elementos todos de tipo integer, entonces la variable ocupará en memoria 15*2=30 bytes.

Los espacios o bloques de memoria, o dicho de otro modo los elementos de un arreglo, se enumeran indicando un valor inicial y un valor final, estos valores pueden ser números enteros positivos o negativos, valores de un tipo de dato enumerado, o caracteres sólo del tipo char. Para acceder a uno de los elementos de un arreglo, lo hacemos directamente a través del identificador de la variable y encerrando entre corchetes la posición del elemento. Para crear una variable de tipo arreglo, hacemos uso de las palabras reservadas array y of, del siguiente modo:

Var
   Frecuencias : array [1..10] of single;

Como se puede observar la variable Frecuencias, es un arreglo de 10 números de tipo single. Los corchetes especifican la enumeración de los elementos o bloques de memoria del arreglo. Para asignar el valor 18.5 en la posición 5 de la variable Frecuencias, usamos su identificador Frecuencias y seguido entre corchetes colocamos el 5, para luego asignar el valor 18.5, del siguiente modo:

Frecuencias[5]:=18.5;

Si queremos usar un arreglo para guardar las medidas de conductividad de un metal, con un rango de temperaturas desde -100 hasta +100 grados centígrados, se puede declarar una variable de tipo arreglo del siguiente modo:

Conductividad = array [-100 .. 100] of real;

En este caso el tamaño del arreglo sería de 201*8=1608 bytes, pero existe una función que nos permite obtener el tamaño en bytes de cualquier variable. La función es SizeOf y se usa del siguiente modo:

Tamanio:=SizeOf(Conductividad);

En donde Tamanio, debe ser de tipo entero. A continuación un programa de ejemplo, que nos permite obtener la frecuencia acumulada(Ni) de las frecuencias absolutas(ni) ingresadas por el teclado:

{$codepage UTF8}

VAR  ni:array [1..100] of real;
     NNi:array[1..100] of real;
     i,n:byte;

BEGIN
  Write('Ingrese numero de datos : ');readln(n);
  for i:= 1 to  n do
   Begin
     Write('ni[',i,'] '); readln(ni[i])
   End;
  NNi[1]:=ni[1];
  for i:=2 to n do  NNi[i]:=NNi[i-1]+ni[i];
  Writeln('Frecuencias       Frecuencias');
  Writeln('Absolutas(ni)     Acumuladas(Ni)');
  for i:= 1 to n do Writeln(ni[i]:8:3,'   ',NNi[i]:16:3)
END.

El programa usa 3 estructuras de repetición, la primera para la lectura del arreglo frecuencias, la segunda para calcular las frecuencias absolutas, y el tercer bucle para mostrar las frecuencias relativas y acumuladas. También se pudo usar las estructuras repeat-until y while-do. Si deseamos calcular el tamaño de la muestra, lo haríamos del siguiente modo:

Tam:= 0;
for i:= 1 to n do Tam:= Tam + ni[i];

A continuación el programa completo:

{$codepage UTF8}

VAR  ni:array [1..100] of real;
     NNi:array[1..100] of real;
     i,n:byte;
     Tam : real;

BEGIN
  Write('Ingrese numero de datos : ');readln(n);
  for i:= 1 to  n do
    Begin
      Write('ni[',i,'] '); readln(ni[i])
    End;
  NNi[1]:=ni[1];
  for i:=2 to n do  Nni[i]:=NNi[i-1]+ni[i];
  Tam:=0;
  for i:=1 to n do Tam:=Tam+ni[i];
  Writeln('Frecuencias       Frecuencias');
  Writeln('Relativas(ni)     Acumuladas(Ni)');
  for i:= 1 to n do Writeln(ni[i]:8:3,'   ',Nni[i]:16:3);
  Writeln('Tamanio de la muestra = ', Tam:16:3)
END.

Un proceso muy común con arreglos que se usan para representar listas, es el ordenamiento. Este proceso consiste en acomodar los elementos de la lista en un nuevo orden, de acuerdo a algún criterio. Existen muchos algoritmos de ordenamiento, uno de ellos, es el denominado método de inserción que se explica mediante el siguiente enunciado:

“Para cada elemento de la lista después del primero, comparar los elementos con los anteriores desplazando una posición a la derecha a todos los elementos anteriores que cumplan con la comparación y luego colocar el elemento en la posición del último elemento anterior desplazado.”

A continuación el ejemplo con una lista de números enteros, ingresados por teclado:

{$codepage UTF8}

VAR
  lista : array [1..100] of  integer;
  aux : integer; 
  i,j,n:integer;

BEGIN
  Write(' Ingrese la cantidad de elementos de la lista :');readln(n);
  For i:=1 to n do 
    Begin
      Write('Lista[',i,']: ');readln(lista[i]);
    End;

  //Ordenando la lista                                                
  For i:=2 to n do  //despues del primero
    Begin
      aux:=lista[i];
      j:=i-1;
      While ( (j>=1) and (lista[j]>aux) ) do 
        //mientras no se termina la lista y la comparación (mayor  que ) del elemento con
        //el anterior sea verdadera
      Begin 
        lista[j+1] := lista[j];  //desplazar el anterior una  posición a la derecha
        j := j - 1;
      End;
      lista[j+1]:=aux;    //colocar el elemento en la posición del  último elemento desplazado.
    End;
  //Mostrando la lista
   Writeln('Lista ordenada ');
   for i:= 1 to n do Writeln('Lista[',i,']: ',Lista[i]);
END.

En el programa anterior, ordena la lista de modo ascendente, si quisiéremos lo contrario se tiene que cambiar la comparación siguiente: lista[j]>aux , por esta otra: lista[j]<aux.

El programa anterior también se puede usar para ordenar una lista de palabras acorde al alfabeto en latín (El alfabeto latín no tiene ñ), a continuación el programa:

{$codepage UTF8}

VAR
 lista : array [1..100] of  string;
 aux : string; 
 i,j,n:integer;

BEGIN
 Write(' Ingrese la cantidad de elementos de la lista :');readln(n);
 For i:=1 to n do 
  Begin
   Write('Lista[',i,']: ');readln(lista[i]);
  End;


//Ordenando la lista


 For i:=2 to n do  //después del primero
   Begin
    aux:=lista[i];
    j:=i-1;
    While ( (j>=1) and (lista[j]>aux) ) do 
      //mientras no se termina la lista y la comparación (mayor  que ) del elemento con
      //el anterior sea verdadera
      Begin
        lista[j+1] := lista[j];  //desplazar el anterior una  posición a la derecha
        j := j - 1; 
      End;
    lista[j+1]:=aux;    //colocar el elemento en la posición del  último elemento desplazado.
   End;

//Mostrando la lista

  Writeln('Lista ordenada ');
  for i:= 1 to n do Writeln('Lista[',i,']: ',Lista[i]);
END.

Hasta ahora sólo se han visto arreglos que se pueden usar para representar listas, vectores, frecuencias, etc., que se les conoce como arreglos de una dimensión. Sin embargo en algunas situaciones se hace necesario representar tablas que tengan diferentes columnas, como por ejemplo:

La tabla anterior como se puede observar, está compuesto por 3 filas y 4 columnas, a estos arreglos se les conocen como arreglos de dos dimensiones. En principio un arreglo puede tener cualquier número de dimensiones.

Para declarar el arreglo Ventas por Trimestre se declara del mismo modo que un arreglo de una dimensión colocando entre corchetes los valores inicial y final, primero las filas y separado por una coma las columnas, del siguiente modo:

Var VentasPorTrimestre: array [1..3,1..4] of real;

Para asignar el valor 1425 que corresponde al 3er. Semestre del Producto B, es decir el que se encuentra en la fila 2 y columna 3, usamos su identificador VentasPorTrimestre y seguido entre corchetes colocamos las coordenadas fila y columna, del siguiente modo: [B]VentasPorTrimestre[2,3]:=1425;

Lo anterior se puede hacer usando tipos de datos enumerados que nos permite usar coordenadas distintas a las numéricas, haciendo más legible la escritura del programa. A continuación el ejemplo:

{$codepage UTF8}

TYPE 
   Productos = (ProdA,ProdB,ProdC);
   Trimestres = (Trim1,Trim2,Trim3,Trim4); 

VAR
 VentasPorTrimestre: array [Productos,Trimestres] of real; 

BEGIN
 VentasPorTrimestre[ProdB,Trim3]:=1425;
 Writeln(VentasPorTrimestre[ProdB,Trim3]:10:3)
END.

Como se puede observar, se han creado los tipos de datos enumerados Productos y Trimestres, que luego se usan para crear la variable VentasPorTrimestre, y además se puede observar que al asignar el valor 1425, ya no indicamos la fila 2 y columna 3, si no que en su remplazo lo indicamos con la fila ProdB y columna Trim3. La variable VentasPorTrimestre, también se pudo haber creado del siguiente modo:

VentasPorTrimestre: array [ProdA..ProdC,Trim1..Trim4] of real;

El compilador nos permite usar indistintamente ambos métodos. Los arreglos también se pueden usar para representar matrices, el programa a continuación nos permite sumar dos matrices de las mismas dimensiones ingresadas por teclado:

{$codepage UTF8}

VAR
 MatrizA,MatrizB,MatrizC:array [1..100,1..100] of real;
 m,n:byte;
 i,j:byte;

BEGIN
 Writeln('Ingrese las dimensiones de las matrices a sumar (100 max) : ');
 Write('m :'); Readln(m);
 Write('n :'); Readln(n);
 Writeln('Ingrese los datos de la Matriz A :');
 for i:=1 to m do
   for j:=1 to n do
     Begin
       Write('MatrizA[',i,',',j,'] : ');
       read(MatrizA[i,j])
     End; 
 Writeln('Ingrese los datos de la Matriz B :');
 for i:=1 to m do
   for j:=1 to n do
     Begin
       Write('MatrizB[',i,':',j,'] : ');
       read(MatrizB[i,j])
     End;
//Sumando
 for i:=1 to m do
    for j:= 1 to n do
      MatrizC[i,j]:=MatrizA[i,j]+MatrizB[i,j];

 Writeln('La suma es : ');
 for i:=1 to m do
   Begin
     for j:=1 to n do Write(MatrizC[i,j]:10:2);
     Writeln 
   End; 
END.

Para la lectura de arreglos de dos dimensiones se usan siempre dos estructuras de repetición for-to-do encadenados, en el caso de tres dimensiones, se usarán tres estructuras de repetición for-to-do, etc. Al encadenarse las estructuras de repetición for-to-do se debe tener en cuenta en donde colocar los bloques de instrucciones, del ejemplo anterior, en el siguiente código:

for i:=1 to m do
   for j:=1 to n do
      Begin
         Write('MatrizB[',i,':',j,'] : ');
         read(MatrizB[i,j])
      End;

La única estructura de control que tiene un bloque de instrucciones es el for-to-do correspondiente a la variable j, pero el bucle for-to-do correspondiente a la variable i, sólo tiene al bucle for-to-do de la variable j que se considera por el compilador como una sola instrucción a ejecutarse repetidamente. Es por eso que no es necesario colocar las papabras reservadas begin y end, para el bucle for correspondiente a la variable i.

Los arreglos también se pueden usar para crear tipos de datos tal como se muestra en el siguiente programa:

{$codepage UTF8}

TYPE  Arreglo01=array[1..10] of byte;

VAR   A,B  :Arreglo01;
      i:byte;

BEGIN
   A[1]:=2; A[2]:=5;A[3]:=4;A[4]:=2;A[5]:=8;
   A[6]:=4; A[7]:=9;A[8]:=4;A[9]:=6;A[10]:=11;
   B:=A;
  for i:=1 to 10 do Writeln(B[i])
END.

Además de crear el tipo de dato Arreglo01, este programa nos muestra un ejemplo de asignación directa, en donde se asignan todos los elementos de la variable A en la variable B, esto es posible siempre y cuando las variables sean del mismo tipo de dato, en este ejemplo sería Arreglo01, y además las variables de tipo arreglo deben tener las mismas dimensiones. Los arreglos tienen un límite y sólo se pueden crear arreglos de hasta 2 GiB (2³¹)-1 aproximadamente, ya que esto depende mucho, de cómo el sistema operativo gestiona la memoria y de cuanta memoria se dispone en la computadora.