Idioma :

Sección 4 - Arreglos con variables alfanuméricas

https://www.atariware.cl/archivos/compu-util1/arreglos.png

¿Como crear los arreglos?


¿Que es un arreglo?


Un arreglo es una colección de elementos que, por tener algún tipo de relación entre sí, interesará al programador almacenarlos, bajo un mismo nombre de variable y, para diferenciar un elemento de otro, le pondrá un "apellido" (subíndice) a cada uno.


Veámoslo con un ejemplo.


Supongamos que administras un hotel de un piso, con 10 habitaciones.


La variable H(1) – se lee hache sub-uno – representará a la primera pieza y H(2), H(3) ... hasta H(10) las restantes.


Este tipo de arreglos con un subíndice se llama arreglo unidimensional.


Los arreglos representan una ventaja enorme para la programación, ya que evitan tener que disponer de un nombre diferente de variable para uno de los elementos, lo que seria muy confuso para colecciones numerosas. Otra ventaja, es la facilidad con que se hacen los ciclos FOR/NEXT, utilizando subíndices.


Si, por ejemplo, cada habitación cuesta $3.000 diarios, deberás asignar ese valor a las variables correspondientes. Si colocases nombres diferentes a cada variable, tendrías que hacer las asignaciones una por una. Es decir:

10 HABIT1 = 3000 
20 HABIT2 = 3000

hasta completar los 10 elementos del ejemplo.


Utilizando arreglos (variables indexadas), lo harás simplemente así:

10 FOR K = 1 to 10:A(K)=3000:NEXT K

Los arreglos permiten no sólo asignar valores sino también letras y signos (que conformarán palabras y mensajes) a las variables indexadas.


En todo caso, previo a usar subíndices, deberás declarar la DIMensión de tu arreglo, usando la sentencia DIM. En Atari Basic esta declaración funciona diferente si la aplicas a variables numéricas o a variables alfanuméricas.


En el caso de variables numéricas, la declaración de DIMensionamiento especificará la cantidad máxima de elementos que podrá contener tu arreglo.


Así: DIM A(500) significa que el arreglo (numérico) no podrá contener más de 500 elementos.


En el caso de los strings, la declaración DIM (en Atari Basic) representará la longitud máxima (cantidad de caracteres) que tendrá el string. Es obligatorio, en esta versión de Basic, declarar las dimensiones de todas las variables de string.


Por ejemplo:


DIM A$(100), significa que la variable alfanumérica A$ podrá tener hasta 500 caracteres de longitud.


Pero no sólo se puede hacer arreglos unidimensionales. En realidad, los arreglos pueden tener las dimensiones que el usuario necesite.


¡Sigamos con el ejemplo del hotel!


Ahora administras un hotel de 15 pisos, con 10 habitaciones por piso.


Tu arreglo ahora deberá tener dos subíndices: el primero que indicará el piso en que está la habitación y el segundo representará el número de la habitación.


Así: A(1,8) será la habitación N°8 del primer piso y A(12,7) será la habitación N°7 del duodécimo piso.


Pero podrías necesitar otro subíndice más.


Por tu excelente desempeño, te hemos ascendido a Gerente Comercial de una cadena de hoteles.


Necesitas, ahora, 3 subíndices:


  1. para indicar a cual hotel pertenece la pieza.
  2. para indicar en cual piso de ese hotel está ubicada.
  3. para indicar el numero de la habitación.

Entonces: A(2,20,35) es la habitación N°35, del vigésimo piso, del segundo hotel a tu cargo.


¿Verdad que es mucho más sencillo expresarlo con subíndices que con palabras?


Manejo de strings en Atari Basic


Una de las características que diferencia al Atari Basic de otros Basic (como el Microsoft, por ejemplo), es que en Atari las variables de strings (alfanuméricas) no pueden ser indexadas. Esto, de ninguna manera, constituye una desventaja. Veremos ahora una forma de hacer arreglos con strings en Atari Basic, haciendo uso de una gran cualidad de esta versión: los strings no están limitados a 255 caracteres cano en otros Basic. Su única limitación en el largo es la que impondrá la capacidad de memoria del computador. Así, si lo necesitas, puedes tener 20.000 o más caracteres en una sola variable.


Para hacer el arreglo alfanuméricas, dividiremos varios sub-strings, todos longitud y utilizaremos con variables el string en de la misma una variable "auxiliar" para que, actuando como puntero externo, nos permita tomar selectivamente cualquier porción del string principal.


Quisiéramos hacerte algunos alcances previos respecto del Atari Basic, antes de entrar en materia:


1. Todos los strings deben tener una declaración de DIMensionamiento, la que representará la cantidad máxima de caracteres que hemos estimado contendrá la variable alfanumérica en cuestión.


2. La expresión A$(20,30) significará que nos estamos refiriendo a la porción (o sub-string) de la variable A$ comprendida entre sus caracteres vigésimo y trigésimo.


Si D$="AMERICA" y escribimos :
PRINT D$(2,4)

El computador imprimirá MER (caracteres 2°, 3° y 4°).
Esto es una ventaja considerable, ya que en otras versiones de Basic tendríamos que usar la función MID$, LEFT$ o RIGHT$, según correspondiera.

3. Para concatenar (sumar) variables alfanuméricas en Atari Basic, hacemos uso de una extensión de lo expuesto en el punto 2. Cuando queremos tomar completa la última porción de un string (su parte extrema derecha), no es necesario explicitar la posición terminal. Siguiendo el ejemplo anterior con D$ = "AMERICA". D$(5) será igual a ICA y es equivalente a decir D$(5,7), en este caso.


Creando el arreglo alfanumérico


Lo que vamos a hacer en realidad, es crear un string suficientemente largo para contener todos los elementos del arreglo. Para que este string no tenga contenidos ajenos, procederemos a "limpiarlo" antes de usarlo.


Hay dos maneras de hacerlo. El programa que te mostramos a continuación, sencillamente DIMensiona en 1000 al string y luego lo llena con asteriscos, usando un ciclo FOR/NEXT. Finalmente, imprime el string.

100 DIM B$(1000)
110 FOR A=1 TO 1000 
120 B$(A,A)="*"
130 NEXT A 
140 PRINT B$

El siguiente programa hace exactamente lo mismo, de una manera un poco diferente, pero mucho más eficiente.

100 DIM B$(1000)
110 B$ ="*":B$(1000)="*":B$(2)=B$
120 PRINT B$

Bastante más rápido. ¿Verdad?


Puedes usar este método toda vez que necesites llenar un largo string con el mismo carácter.


Es exactamente lo que haremos para crear nuestro arreglo, sólo que esta vez necesitamos llenar el string con espacios en blanco.


Ingresa y ejecuta el programa que te mostramos a continuación. Cuando te pida nombres, puedes ingresar los de 10 amigos tuyos, presionando RETURN después de escribir cada uno. Tal coto esta escrito, el programa te permite nombres de hasta 10 letras.

100 DIM ARR$(100),ELEM$(10):PRINT CHR$(125)
110 ARR$=" ":ARR$(100)=" ":ARR$(2)=ARR$
120 FOR A=1 TO 10
130 PRINT "NOMBRE PARA ARR$(";A;") POR FAVOR";:INPUT ELEM$
140 ARR$(A*10-9,A*10)=ELEM$
150 ELEM$=" ":NEXT A
160 PRINT
170 FOR A=1 TO 10
180 PRINT "ARR$(";A;") ES ";ARR$(A*10-9,A*10)
185 NEXT A
190 TRAP 230
200 PRINT: PRINT "DAME EL NUMERO (DE 1 A 10)"
210 PRINT "DEL ELEMENTO QUE DESEAS VER ";:INPUT A
220 PRINT ARR$(A*10-9,A*10):GOTO 200
230 PRINT CHR$(253):GOTO 190

Fíjate que el programa ha creado un arreglo con 10 elementos y te permite elegir cualquiera de ellos.


Examinemos con más detención como está hecho.


La línea 100 DIMensiona el arreglo y limpia la pantalla.


La linea 110 llena el arreglo con espacios en blanco.


La línea 120 inicia un ciclo FOR/NEXT y le dice al computador que lo repita 10 veces.


La línea 130 te pide ingresar -uno a uno- los 10 nombres de los elementos que usarás.


La línea 140 es la clave para la creación del arreglo. Dentro del paréntesis le estamos indicando, al computador, en que parte del arreglo debe colocar tu ingreso más reci ente (ELEM$).


La primera vez, cuando A=1:


ARR$(A*10-9,A*10), equivale a ARR$(I*10-9,I*10), es decir ARR$(1,10)


En otras palabras, el nombre que acabas de ingresar (y que está provisoriamente almacenado en la variable ELEM$), será colocado en las 10 primeras posiciones del arreglo.


Cuando A = 2, ARR$(A*10-9,A*10), equivale a ARR$(11,20) y el segundo nombre será almacenado entre las posiciones 11 y 20 del arreglo.


El proceso continuará de la misma manera, hasta que el string esté completo, es decir A=10 y ARR$(91,100).


La línea 180 hace lo mismo, pero en el sentido inverso: lee desde ARR$ la porción apropiada y la imprime en la pantalla.


La línea 220 también ejecuta la misma acción, sólo que lo hace selectivamente, actuando sobre la parte del string que hayas determinado.


Intenta hacer algunos experimentos.


Por ejemplo, corre el programa e ingresa los 10 nombres pedidos. Entonces presiona la tecla BREAK y escribe PRINT ARR$ (sin número de línea, para que sea un comando de ejecución inmediata), presiona RETURN y observa que sucede.


Ahora corre el programa de nuevo, pero simplemente presiona RETURN (sin escribir nada) cuando se te pida los 10 nombres. Aparentemente, ARR$ no contiene información. En realidad eso es falso: ARR$ esta lleno con espacios en blanco. Nuevamente escribe: PRINT ARR$ y observa que sucede.


Seguramente te estarás preguntando para qué sirven las lineas 190 y 230. Ellas previenen que el el programa no se "caiga" cuando se haga un ingreso incorrecto.


TRAP 230 envía el programa a la linea 230, en lugar de escribir ERROR 8 LINE 210, si ingresas una letra o carácter que no sea un número entre 1 y 10, como lo requiere el programa.


PRINT CHR$(253) tocará un sonido de alerta (BUZZ) para avisarte el error en el ingreso.


Armado con estas herramientas, podrás usar arreglos de strings en tus propios programas.