Programación: Seudocódigos

Arreglos
A diferencia de los elementos estudiados hasta ahora, los arreglos pertenecen al dominio de los tipos de datos
y no al de las instrucciones de Pascal. A grandes rasgos, son conjuntos de variables que comparten un mismo
nombre, pudiendo ser referenciadas de manera individual las variables del conjunto con ayuda de uno o más
índices. Los arreglos guardan estrecha similitud con elementos de datos de la vida cotidiana, como los
vectores y las tablas, y en cierto modo trazan una línea que separa la programación básica de la avanzada.
Como la sintaxis formal de los arreglos es muy general, se comenzará definiendo los arreglos
unidimensionales o vectores.
Arreglos unidimensionales: vectores
Supóngase que se tienen cinco variables: a, b, c, d y e. Si se desea hacer referencia a las cinco, deben usarse
sus nombres, y eso implicaría, a nivel de programación, poner sus nombres en cada sentencia que se requiera
(ReadLn, fórmulas, etc.) y repetir las mismas cinco veces. Un enfoque más general es poner a las variables un
mismo nombre, y distinguirlas por un número, parecido a como hacen los libros de matemáticas para referirse
de manera general a las componentes de los vectores o de las tuplas. Entonces, se hablaría de a(1), a(2), a(3),
a(4) y a(5), en vez de las letras usadas anteriormente; como ya se sabe cómo generar los índices (los números
entre paréntesis que permiten distinguir las variables), se puede usar un ciclo para manipular las variables y
usar menos código.
La sintaxis para declarar un arreglo de una sola dimensión es:
Var
<nomb> : Array [<li>..<ls>] Of <tipo>;
donde <nomb> es el nombre del arreglo, <li> es el valor inferior que puede tomar el índice y <ls> es el valor
superior del índice. Un ejemplo real de declaración de arreglos se muestra a continuación:
Var
a : Array[1..5] Of Integer;
que produce un arreglo llamado a de cinco variables enteras. La primera es a[1], la segunda es a[2], y así
sucesivamente.
¿Cuál es la utilidad de este esquema? Si se tienen que leer cinco variables declaradas por separado, con
nombres distintos, se usaría algo como esto:
ReadLn(a);
ReadLn(b);
ReadLn(c);
ReadLn(d);
ReadLn(e);
mientras que con arreglos, basta escribir:
For i := 1 To 5 Do
ReadLn(a[i]);
que es evidentemente más cómodo.
1
A lo largo del curso se han visto programas que suman una cantidad de números usando dos variables, una
para leer cada número y otra para acumular la suma. Este enfoque tiene la desventaja de que se pierden los
valores de los sumandos. El uso de arreglos permite calcular la suma de los números con una cantidad mínima
de código y a la vez conservar cada valor, como muestra el siguiente programa completo:
Program SumaN;
Uses WinCrt;
Const
n = 5; {Cant. de #s}
Var
nums: Array[1..n] Of Integer;
s, i: Integer;
Begin
For i:=1 To n Do Begin
Write('Número: ');
ReadLn(nums[i]);
s := s + nums[i];
End;
WriteLn('Suma: ', s);
End.
Nótese el uso de una constante para marcar el tamaño del arreglo; dicha constante, naturalmente, también
sirve para controlar el For. De este modo, sólo se hace necesario cambiar un número para adecuar el programa
a la escala apropiada.
Arreglos bidimensionales: tablas
Siguiendo la misma línea, se pueden relacionar grupos de vectores para formar tablas. Por ejemplo, supóngase
que se quieren almacenar nombres de personas y sus respectivos números de teléfonos; se puede tener un
vector de nombres y uno de números, de modo que el i−ésimo número de teléfono (en un vector) sea de la
i−ésima persona (en el otro vector). Pues bien: existe un modo de fundir ambos vectores en un solo tipo de
variable, una tabla de dos columnas y varias filas (o viceversa) en la que la posición [1, i] indique el nombre
de una persona y la posición [2, i] indique el número de teléfono de esa persona. Para declarar esta estructura,
se escribe:
Var
Tabla: Array[1..2, 1..n] Of String;.
y de manera general, se puede declarar un arreglo bidimensional así:
Var
<nomb>: Array[<li1>..<ls1>, <li2>..<ls2>] Of <tipo>;
De hecho, aunque no están contemplados en el programa del Laboratorio de Elementos de Computación, se
pueden definir más dimensiones; no hay un límite definido a la cantidad de dimensiones de un arreglo.
Volviendo al ejemplo de la lista de personas y números de teléfono, se puede escribir un programa completo
que use una tabla para leer y guardar esta información:
Program Telefonos;
Uses WinCrt;
Const
2
n = 5;
Var
Tabla: Array[1..2, 1..n] Of String;
i: Integer;
Begin
For i:=1 To n Do Begin
ReadLn(Tabla[1, i]);
Write('Teléfono: ');
ReadLn(Tabla[2,i]);
WriteLn('Persona: ', i);
Write('Nombre: ');
End;
End.
En este momento, los datos están en la memoria, y el esfuerzo que se requirió para leerlos fue menor que
usando 10 variables independientes (cinco para los nombres y cinco para los números). Además, con sólo
cambiar un valor, el de n, el programa almacena más pares de nombre y teléfono. Y aunque no se verá aquí,
manipular esos datos una vez leídos es igual de fácil.
Unas consideraciones importantes sobre los arreglos: son racimos o conjuntos de variables, pero no pueden
manejarse como tales. Siempre deberá hacerse referencia a una posición específica del arreglo; si se desea
acceder a una parte del mismo o a su totalidad, deberá hacerse de manera iterativa, visitando los elementos
que lo componen uno a uno.
3