Algoritmos: arreglos de una y dos dimensiones.

Cortesía de youtube

Cuando hablamos de variables podemos imaginarlas como una caja para guardar cosas, una caja que tiene una etiqueta en la que podemos indicar que esta guardado dentro.

etiqueta = valor

Dependiendo del lenguaje que estemos usando, en esa caja solo podremos guardar un tipo específico de informacion números enteros, números flotantes, cadenas de caracteres, un solo carácter. O sera una caja multipropósito que nos permitirá guardar cualquier tipo de informacion en ella.

¿Pero qué ocurre cuando necesitamos guardar más de un dato de la misma índole?

Imaginemos que estamos haciendo un algoritmo para generar el listado de los asistentes a nuestra fiesta de cumpleaños. El algoritmo solicitará el nombre de las personas y luego al finalizar imprimirá el listado. Supongamos que sólo deseamos invitar a 5 amigos.

Inicio
  invitado1 = ""
  invitado2 = ""
  invitado3 = ""
  invitado4 = ""
  invitado5 = ""
  
  imprimir "Como se llama el invitado 1? "
  leer invitado1
  imprimir "Como se llama el invitado 2? "
  leer invitado2
  imprimir "Como se llama el invitado 3? "
  leer invitado3
  imprimir "Como se llama el invitado 4? "
  leer invitado4
  imprimir "Como se llama el invitado 5? "
  leer invitado5
  imprimir "Los invitados a tu fiesta son:"
  imprimir invitado1
  imprimir invitado2
  imprimir invitado3
  imprimir invitado4
  imprimir invitado5
Fin

Como en una variable es posible guardar un solo dato, esto nos obliga a tener una variable por cada invitado que queremos que venga a nuestra fiesta.

¿Pero qué ocurre si queremos invitar a más personas?

Tendremos que agregar mas variables y agregar las lineas correspondientes para leer el valor del nuevo invitado y luego imprimir su nombre.

Quien use nuestro algoritmo no percibirá diferencia alguna, pero para nosotros que debemos darle mantenimiento empezará a ser una pesadilla a medida que se necesite agregar más personas.

Arreglos de una dimensión

Para estos casos contamos con una estructura de datos llamada arreglo o vector, que nos permite agrupar bajo una misma etiqueta un conjunto de datos. Podemos imaginarlos como una caja grande dividida en compartimientos iguales. Al crearla debemos suministrar la cantidad de compartimientos que deseamos que tenga nuestra caja.

etiqueta_arreglo[cantidad] 

Cuando queremos guardar algo en nuestro arreglo debemos guardarlo en alguna de las cajas.

invitados[5]
invitados[0] = "Cosme Fulanito"

En la primera línea crea nuestro conjunto de cajas, la segunda guarda dentro de la primera caja la informacion del nombre. El numero que esta encerrado entre corchetes al crear la variable es la cantidad de cajas que deseamos que tenga. Luego al interactuar con el arreglo el número entre los corchetes representa la caja dentro del arreglo a la que estamos haciendo referencia. Este valor es llamado índice.

Ahora, reescrito nuestro algoritmo queda de la siguiente forma:

Inicio
  invitados[5] = ""
  i = 0
  para i = 0 hasta 4 hacer
     imprimir "Como se llama el invitado " i+1 "? "
     leer invitados[i]
  fin
  imprimir "Los invitados a tu fiesta son:"
  para i = 0 hasta 4 hacer
     imprimir invitados[i]
  fin
Fin

Ahora no importa cuántos invitados nos pidan, con hacer unos cambios menores podremos satisfacer el requerimiento.

La primera línea luego del inicio es la “creación” del arreglo. Su igualación a la cadena vacía es una forma de indicar que estamos iniciando todos los valores del arreglo a una cadena vacía. Las sintaxis para hacer esto varían de lenguaje en lenguaje, así que para estos artículos yo escogí esta forma de hacerlo.

El ciclo nos permite llenar el arreglo de forma ordenada es decir, la primera caja, luego la segunda, la tercera y asi sucesivamente hasta completar todas.

Nótese que la instrucción leer contiene el nombre del arreglo y como como índice la variable contador del ciclo, lo que permite guardar en cada vuelta el nuevo dato en cajas contiguas.

Luego para mostrar los datos volvemos a hacer uso de un ciclo e imprimimos el valor de la caja correspondiente al valor que posea el contador en ese momento.

¿Cómo hacemos para guardar datos de distinto tipo para un grupo grande de informacion?

Imaginemos por ejemplo que queremos hacer un listado de nuestros amigos y su teléfono y dirección, pero tenemos la limitante de poder guardar solo un tipo de dato en un arreglo.

¡Podemos usar varios arreglos y usarlos en paralelo!

Veamos:

Inicio
  nombres[5] = ""
  telefon[5] = ""
  direcci[5] = ""
  i = 0
  para i = 0 hasta 4 hacer
    imprimir "Nombre del amigo " i + 1 " "
    leer nombres[i]
    imprimir "Teléfono del amigo " i + 1 " "
    leer telefon[i]
    imprimir "Dirección del amigo " i + 1 " "
    leer direcci[i]
  fin 
  imprimir "Listado de teléfonos y direcciones de amigos"
  para i = 0 hasta 4 hacer
    imprimir nombres[i] "  " telefon[i] "  " direcci[i]
  fin
Fin

Como puede observarse en el apartado de la carga de datos, guardamos todos los datos de una persona con el mismo índice en los tres arreglos. Así el nombre, el teléfono y la dirección de índice 3 le pertenecen a la misma persona.

Arreglos de dos dimensiones

Pero ahora. ¿Que pasa si queremos guardar más de un teléfono o mas de una dirección? Volvemos al mismo dilema anterior, el crear arreglos de tipo telefono1, telefono2 o direccion1, direccion2 escala hasta cierto nivel.

Bueno, para esto también tenemos opción, se llaman arreglos de dos dimensiones o matrices.

Tomemos nuevamente nuestro ejemplo anterior y decidamos que guardaremos 2 teléfonos por persona y 2 direcciones.

Inicio
  nombres[5] = ""
  telefon[5][2] = ""
  direcci[5][2] = ""
  i = 0
  j = 0
  para i = 0 hasta 4 hacer
    imprimir "Nombre del amigo " i + 1 " "
    leer nombres[i] 
    para j = 0 hasta 1 hacer
      imprimir "Teléfono " j + 1 " del amigo " i + 1 " "
      leer telefon[i][j] 
    fin 
    para j = 0 hasta 1 hacer 
      imprimir "Dirección " j + 1 " del amigo " i + 1 " "
      leer direcci[i][j]
    fin
  fin 
  imprimir "Listado de teléfonos y direcciones de amigos"
  para i = 0 hasta 4 hacer
    imprimir "Nombre: " nombres[i] 
    para j = 0 hasta 1 hacer 
      imprimir "Teléfono " j + 1 " " telefon[i][j]
    fin 
    para j = 0 hasta 1 hacer 
      imprimir "Dirección " j + 1 " " direcci[i][j]
    fin
  fin
Fin

Obsérvese que ahora además del ciclo que nos permite avanzar en las personas que vamos a guardar, tenemos un ciclo adicional para el telefono y asi poder guardar los dos telefonos que queremos por persona, y repetimos la estrategia para guardar las direcciones. Asi para cada persona nos preguntara, dos telefonos y dos direcciones.

Luego para mostrar la informacion volvemos a hacer uso de la misma estrategia, un ciclo para movernos en las personas y dos pequeños ciclos, uno para imprimir los teléfonos y otro para imprimir las direcciones.

La nomenclatura tambien cambia ahora en lugar de tener

variable[indice] = valor

Tenemos

variable[indice1][indice2] = valor

En el caso de nuestro ejemplo especifico seria:

telefon[persona][orden_telefono]

El primer índice corresponde a la posición de la persona en el listado y el segundo al orden de los teléfonos, primer teléfono introducido o segundo teléfono introducido.

Pero con los arreglos de dos dimensiones podemos hacer mucho mas, por ejemplo podemos guardar los datos ventas de x cantidad de vendedores durante los 12 meses del año para ello creariamos una matriz como la siguiente:

ventas[vendedor][meses]

Ahora para hacerlo un ejemplo tenemos:

Inicio
  vendedores[10] = ""
  ventas[10][12] = 0
  i = 0
  j = 0
  sumatoria = 0
  para i = 0 hasta 9 hacer
     imprimir "Introduzca el nombre del vendedor " i + 1 
     leer vendedores[i]
     para j = 0 hasta 11 hacer
       imprimir "Cuánto vendió " vendedores[i] " el mes " j + 1 
       leer ventas[i][j]
     fin
  fin 
  imprimir "Total y promedio de ventas por vendedor"
  para i = 0 hasta 10 hacer
    imprimir "Vendedor: " vendedores[i]
    sumatoria = 0
    para j = 9 hasta 11 hacer
       sumatoria = sumatoria + ventas[i][j]
    fin
    imprimir "Total de ventas: " sumatoria
    imprimir "Promedio de ventas: " sumatoria / 12
  fin
  imprimir "Total y promedio de ventas por mes"
  para i = 0 hasta 11 hacer 
     imprimir "Promedio del mes " i + 1
     sumatoria = 0
     para j = 0 hasta 9 hacer
       sumatoria = sumatoria + ventas[j][i]
     fin
     imprimir "Total de ventas del mes " i + 1 " es " sumatoria
     imprimir "Promedio de ventas del mes " i + 1 " es " sumatoria/10
  fin
Fin

En este ejemplo recorrimos la matriz de dos formas distintas, la primera fila a fila, es decir para cada vendedor, sumando las ventas de cada mes y dar el total y poder calcular también el promedio dividiendo todo lo vendido durante el año por un vendedor entre los meses del año.

La segunda forma fue columna a columna, sumando todo lo vendido por cada vendedor en un mes específico y calculando el total y el promedio de ventas de los vendedores en ese mes.

Nótese como los ciclos permanecen igual, i el más externo, j el más interno pero en la variable de la matriz se usan distinto, obviamente los límites también cambian.