Conenzando a programar: 11b- Subrangos y Arreglos lineales.

[Kyshuo]

Tenemos un Subrango de enteros que va de 33 a 90. Luego tenemos arr1 que es un arreglo de 256 celdas (cantidad total de caracteres) cuyos índices según la Tabla Ascii van del ‘ ’ a ‘ ’ (del primer elemento de la tabla hasta el último) donde cada cela puede contener cualquier entero. arr2 que es un arreglo de 57 celdas numeradas del 33 al 90 donde cada una puede contener cualquier real. Luego tenemos arr3 que pretendería ser un arreglo de unas 65536 celdas numeradas desde el -32768 hasta el 32767 donde cada una podría contener caracteres. Este es un arreglo exorbitantemente grande, ocuparía muchísima memoria y provocaría muchos problemas. Además no es para nada ético crear este tipo de estructuras.
Finalmente tenemos arr4 que tiene 57 celdas numeradas del 33 al 90 donde cada una es un booleano que puede valer TRUE o FALSE.


Utilización de arreglos:

Hasta ahora solo hemos visto como se declara un arreglo y lo que significan las distintas declaraciones, sin embargo hace falta trabajar con ellos, y su sintaxis es un poco distinta a lo que venimos acostumbrados. Veremos un primer ejemplo donde crearemos un arreglo de enteros de 10 celdas cuyos índices van del 1 al 10 y a cada celda le daremos el mismo valor que su índice, o sea, a la primera le daremos el valor 1, a la segunda el 2 y así sucesivamente:

Código Pascal:

PROGRAM arreglos;
 
Type
     arr= array[1..10] of integer;
 
Var
     arreglo1: arr;
 
BEGIN
 arreglo1[1]:= 1;
 arreglo1[2]:= 2;
 arreglo1[3]:= 3;
 arreglo1[4]:= 4;
 arreglo1[5]:= 5;
 arreglo1[6]:= 6;
 arreglo1[7]:= 7;
 arreglo1[8]:= 8;
 arreglo1[9]:= 9;
 arreglo1[10]:= 10;
END.
 

En la línea 3 indicamos que comenzará la declaración de tipos para, luego, en la línea 4 declarar el tipo arr que será un arreglo de 10 celdas numeradas del 1 al 10 del tipo entero. Como arr es un tipo su propósito es declarar variables de ese tipo, por lo tanto en la línea 7 declaramos la variable arreglo1 del tipo arr. Podemos, al igual que con los tipos primitivos, declarar tantas variables como queramos de cualquier tipo que nosotros mismos definamos; en este caso tenemos solo una, pero podría tener más y cada una sería independiente.

Bien, en la línea 9 comienza nuestro programa, el cual consta de diez líneas de asignación donde en cada una le damos un valor a cada celda del arreglo. Veamos esto con detalle, es bien sencillo. Cada celda del arreglo funciona como una variable independiente, por tanto, en ese arreglo tenemos diez variables del tipo integer. Para referirnos a una celda debemos dar el nombre de nuestro arreglo (no el nombre del tipo sino el de la variable de ese tipo) seguido por el índice entre paréntesis rectos de la celda a la que queremos ir. De este modo, en la línea 10, al escribir

arreglo1[1]:= 1

estamos diciendo que vaya a la primera celda de arreglo1 y le asigne el valor 1. La sintaxis genérica sería

Variable_del_tipo_arreglo[indice_de_la_celda]

con lo cual nos referiríamos a cualquier celda. Recordar que cada una es una variable independiente, por tanto esa declaración es como si fuera el nombre de la variable y funciona igual que cualquier otra variable, valga la redundancia.

Todo lo que sigue del programa es asignar a las celdas restantes el valor que queremos y termina nuestro programa. Sin embargo no es muy útil tener que escribir instrucción por instrucción para dar un valor a cada celda. Imaginen un arreglo de 1000 celdas, tendríamos un programa de 1000 líneas solo en asignaciones. Veamos el mismo programa pero asignando los mismos valores a cada celda de una forma más inteligente:

Código Pascal:

PROGRAM arreglos;
 
Type
     arr= array[1..10] of integer;
 
Var
     arreglo1: arr;
     i: integer;
 
BEGIN
 For i:=1 to 10 do
    arreglo1[i]:= i;
END.
 

Hemos sustituido las 10 líneas de asignación por una instrucción FOR que va de 1 a 10. Fíjense que hemos colocado la variable de control i dentro los paréntesis rectos que indican el índice de nuestras celdas. De este modo, cuando i valga 1 estaremos hablando de la primera celda, cuando i pase a valer 2 estaremos hablando de la segunda celda, y así sucesivamente hasta 10. En este caso hemos asignado a cada celda el mismo valor de su índice, pero esto podría no ser así. Este arreglo dibujado sería:



Ahora veamos lo mismo pero asignando el doble del índice a cada celda:

Código Pascal:

PROGRAM arreglos;
 
Type
     arr= array[1..10] of integer;
 
Var
     arreglo1: arr;
     i: integer;
 
BEGIN
 For i:=1 to 10 do
    arreglo1[i]:= i*2;
END.
 

De este modo arreglo1 ahora quedaría así:



Dentro de los paréntesis rectos que indican el índice del arreglo es posible, como hemos visto ya, colocar el valor del índice, una variable del tipo correcto o, como no hemos visto aún, una expresión que dé cómo resultado un valor del tipo correcto y que esté dentro del rango de índices posibles.

Es muy importante que lo que esté dentro de los paréntesis rectos nunca exceda el rango en que está numerado el arreglo. Si en este ejemplo nosotros escribiéramos

Código:

For i:=1 to 11 do
arreglo1[i]:= i*2;

se produciría un error cuando i alcanzara el valor 11 y el programa se cerraría abruptamente ya que la celda 11 no existe. Si han activado Range checking lo más probable es que el compilador les avise antes, pero esto no es siempre seguro ya que no siempre es detectable que podemos estar saliéndonos del arreglo.

Veamos un nuevo ejemplo del mismo programa, solo que ahora los índices serán caracteres y a cada celda le
asignamos el valor del ordinal de su índice. No olviden que el arreglo es de enteros.

Código Pascal:

PROGRAM arreglos;
 
Type
     arr= array[‘a’..’j’] of integer;
 
Var
     arreglo1: arr;
     i: char;
 
BEGIN
 For i:=’a’ to ‘j’ do
    arreglo1[i]:= ord(i);
END.
 

De este modo nuestro arreglo quedaría así:




Hacer WRITE y READ de un arreglo:

Si quisiéramos desplegar un arreglo en la pantalla, o sea, que se nos muestren todos sus valores, debemos escribir celda por celda. En el ejemplo anterior teníamos el arreglo llamado arreglo1. Como primer impulso para escribirlo en pantalla uno tendería a hacer algo como esto

Código:

write(arreglo1);

y sin embargo eso no es posible. De hacerlo tendrán un error en tiempo de compilación en el cual el compilador se les quejará por no poder escribir o leer variables de ese tipo. Esto es porque un arreglo es una estructura de datos y no un valor específico. Por este motivo es que debemos escribir celda por celda. No se olviden que cada celda es como una variable más y funciona del mismo modo. Veamos entonces como mostrar el arreglo de nuestro ejemplo anterior:

Código Pascal:

PROGRAM arreglos;
 
Type
     arr= array[‘a’..’j’] of integer;
 
Var
     arreglo1: arr;
     i: char;
 
BEGIN
 For i:=’a’ to ‘j’ do
    arreglo1[i]:= ord(i);
 
 For i:=’a’ to ‘j’ do
    Write(arreglo1[i],’ ‘);
END.
 

La única diferencia entre este programa y el anterior es que agregamos un FOR que en cada iteración escribe el valor de una de las celdas. Verifiquen esto ustedes mismos.

Ejercicio: Modifiquen este programa para que con un solo FOR asigne los valores al arreglo y lo muestre en pantalla.

Del mismo modo, si quisiéramos hacer read de un arreglo para que el usuario ingrese los valores de cada celda debemos hacerlo para cada una por separado.

Ejercicio: Realicen un programa en el cual exista un arreglo de enteros de cinco celdas de modo que el usuario sea quién ingrese los valores para cada celda. Deben utilizar una instrucción FOR para ello.


Declaración anónima de un arreglo:

Los arreglos que hemos visto hasta ahora los hemos declarado como tipos de modo que podemos declarar muchas variables de ese tipo. Sin embargo, a veces sucede que sabemos que vamos a usar un único arreglo en nuestro programa y nada más. Dado este caso no es necesario declarar el arreglo como tipo sino hacerlo de forma anónima, directamente como variable. Veamos esto con el programa anterior ya que tenemos un único arreglo en este:

Código Pascal:

PROGRAM arreglos;
 
Var
     arreglo1: array[‘a’..’j’] of integer;
     i: char;
 
BEGIN
  For i:=’a’ to ‘j’ do
     arreglo1[i]:= ord(i);
 
 For i:=’a’ to ‘j’ do
      Write(arreglo1[i],’ ‘);
END.
 

Como ven este programa es igual al anterior solo que hemos quitado la declaración de tipos y hemos declarado el arreglo directamente como variable. De este modo solo se usará como arreglo1 y no como tipo por lo cual no podremos declarar variables como en los casos anteriores.

No está mal si declaran siempre los arreglos como tipo, pero tengan en cuenta que un arreglo como tipo ocupa más memoria que uno declarado anónimamente. Si han declarado un tipo array el programa guardará memoria para “recordar” que existe un tipo definido por ustedes y qué datos puede contener y luego también guardará memoria para cada variable que declaren de ese tipo. Si lo hacen de forma anónima solo guardará memoria para esa variable y punto.

Un programa que utiliza mucha memoria es menos eficiente, al igual que uno que realiza demasiadas instrucciones o tareas. Siempre es importante tratar de que el programa haga el menor trabajo posible para que sea más veloz y requiera menos recursos de la computadora para trabajar.

En algunos casos nombraré la mejor forma de realizar una tarea eficientemente.

Continua en la parte c.