Lo prometido es deuda, así que llegamos con una nueva edición de esta guía en la que Como Lo Hago intenta ayudarlos a adentrarse al mundo de la programación de la mejor manera posible.

En esta edición, cubriremos las últimas temáticas relativas a programación en pseudo-código para ya a partir de las próximas entrar de lleno en los lenguajes reales.

Todo el detalle, como siempre, después del salto.

Cómo aprender a programar y no morir en el intento – Parte 5

Como es habitual, veamos lo que cubriremos en esta ocasión:

Contenidos

1.- Introducción a los arrays

2.- Vectores

3.- Matrices

Así que con todo especificado, vamos, a seguir aprendiendo:

Introducción a los arrays

Hasta ahora, todos los datos con los que hemos trabajado los hemos almacenado en variables, las cuales entre sus características podemos indicar que son capaces de almacenar un valor “simple”, o sea un número (de uno o más dígitos) o un carácter (o cadena de ellos) o un valor booleano. De cualquier forma siempre almacenan solamente un y nada más que un valor a la vez.

Pero, ¿qué pasa si es que necesitamos almacenar más de un valor?. Podríamos usar más variables, sin embargo, cuando los valores necesarios de almacenar son 10 o más, disponer de tantas variables, y más importante aún, recordar sus nombres y manipularlas, puede ser bastante engorroso.

Para esto es que en la programación disponemos de los arrays o arreglos, los cuales son variables que nos permiten almacenar más de un valor del mismo tipo y manipularlos, todo dentro de la misma variable.

Comunmente en los lenguajes de programación, los arreglos solo pueden contener múltiples valores del mismo tipo y hasta una longitud finita indicada al momento de su declaración. Sin embargo, en algunos lenguajes especificos, existen tipos de arrays que no se apegan a estas reglas (ya sea almacenando valores de distinto tipo o siendo dinámicos, o sea, creciendo a medida que decidimos almacenar un nuevo valor en ellos).

Los arreglos pueden ser unidimensionales o bidimensionales. Los primeros en la programación son conocidos como vectores, y los segundos como matrices.

Independiente de su dimensionalidad, los arrays deben cumplir con ciertas características, algunas similares a las variables que hemos visto hasta ahora y otras no tanto.

1.- Nombre: Todo array debe tener un nombre, el cual debe cumplir con las mismas características de los nombres de variable, o sea, debe ser único, no debe ser una palabra reservada del lenguaje, ni empezar con números, guiones o underscores (pueden llevar alguno de los 3 últimos entremedio).

2.- Tipo: Todo array debe tener un tipo, que corresponde al tipo de valores que se podrán almacenar en el. Pueden ser los mismos tipos que para las variables vistas hasta ahora.

3.- Posición: Aquí entra la diferencia. Para facilitar la visualización, imaginémonos que una variable común y corriente es una cajón en el que guardamos algo. Ahora, cuando pensamos en un array, pensemos que es una cajonera, con un número de cajones, dentro de los cuales se pueden almacenar varias cosas. Cada uno de estos cajones corresponde a una “posición del array”. Cada posición es como si fuera una variable dentro del array y almacena un valor. Después cuando queramos rescatar ese valor, se accede a la posición necesaria.

Veremos algunos esquemas ahora que especificaremos los tipos de arrays.

Vectores

Los vectores en la programación, son arrays unidimensionales en los cuales se pueden almacenar múltiples valores (finitos) y que cuentan con las características anteriormente definidas.

Para declarar un vector, en pseudocódigo, lo hacemos de la siguiente forma:

Numero vector[5];
Tipo nombre[largo];

El largo indicara cuantas posiciones tendrá el vector, y por ende, cuantos datos se podrán almacenar.

Antes de seguir, debemos hacer una salvedad. En el mundo de la computación, siempre se empieza a contar desde el cero y no el uno. Eso debemos tener en cuenta cuando queramos acceder a una posición, ya que estaremos accediendo al número correspondiente a si empezáramos a contar desde el cero. Por ejemplo, con ese vector que recién declaramos, tendríamos algo como esto:

0           1              2           3          4

Si nos fijamos, a pesar de ser un vector de largo 5, sus posiciones van desde el 0 a la 4, siendo estas a las que debemos acceder si queremos recuperar la información almacenada ahí.

Para almacenar valores en un vector los asignamos de la misma forma que a una variable común y corriente, a diferencia de que ahora debemos indicar el indice correspondiente a la posición donde almacenaremos el valor, por ejemplo, si queremos almacenar el valor 2 en la tercera posición de un vector de 5 posiciones:

Vector[2] = 2;

Y si queremos leer el valor de un vector, lo hacemos de la misma forma. Por ejemplo, si queremos comprobar un valor en un Si:

Si(vector[2]==2)

Tanto para ingresar datos, como para leerlos, una operación común es recorrerlos mediante ciclos, ya sea con un ciclo de tipo Mientras o uno de tipo Para. Al hacer esto, declaramos una variable para utilizar como indice, la cual se irá moviendo a lo largo del vector. Por ejemplo, si quisieramos llenar un vector con números iguales a su indice, haríamos algo como esto, asumiendo que el vector es de largo 5:

i = 0;

mientras(i<5)
{
    vector[i]=i;
    i++;
}

Si en vez de ingresar datos, quisiéramos leerlos, lo hacemos de la misma forma.

Para resumir, veamos un ejemplo. En este caso lo que haremos será declarar un vector, decirle al usuario que llene los valores para sus posiciones y luego las mostraremos por pantalla.

Inicio
/*Damos inicio al programa */

Numero vector[5];
Numero i = 0;
Declaramos el vector y la variable que utilizaremos como índice para recorrerlo.

principal()
    mientras(i<5)
    {
        /*Mediante un ciclo mientras, le mostramos un mensaje al usuario para que ingrese el valor correspondiente a la posición del      vector y luego leemos el dato.

        mostrar("Ingrese el valor %numero del vector", i);
        leer(vector[i], &numero);
        i++;
        i = 0;
    }
    mostrar(“Los valores ingresados fueron: “);
    /* Mostramos el mensaje avisando que desplegaremos los valores.*/

    mientras(i<5)
    {
    /*Dentro de un ciclo mientras, mostramos todos los valores almacenados en el vector.

        mostrar(“%numero”, vector[i]);
        i++;
    }
    Fin

Trabajar con vectores lleva un poco de costumbre, pero con práctica nos veremos utilizándolos más y más a menudo y viendo como nos facilitan todo.

Matrices

Al igual que los vectores, las matrices son arrays. Sin embargo, a diferencia de ellos, son bidimensionales, o sea operan en 2 dimensiones, a las cuales nos referiremos como filas y columnas, como si fueran una especie de tabla.

Algo así:

Para declarar una matriz se hace igual que un vector, pero ahora en vez de indicar el largo, debemos indicar el número de filas y el número de columnas. Como ejemplo:

Numero matriz[4][4];

Esa es una matriz cuadrada, de 4 filas y 4 columnas. No es necesario que siempre tengan el mismo número de filas y de columnas. Al igual que en el álgebra, pueden variar.

Para el proceso de ingreso de datos en una posición de la matriz, debemos indicar su posición relativa con respecto a filas y columnas. Por ejemplo, si quisieramos almacenar el valor 8 en la segunda fila y primera columna, diríamos algo como esto:

matriz[1][0] = 8;

Al igual que en los vectores, cuando queremos ingresar o leer múltiples datos, hacemos uso de ciclos. La diferencia ahora es que para las matrices debemos utilizar 2 ciclos, uno que recorra las filas y otro las columnas. Sería ejemplificado algo así, con una matriz de 4 x 4 y llenando todas sus posiciones con un 8:

i = 0;
j = 0;

mientras(i<4)
{

    mientras (j<4)
    {

        Matriz[i][j]=8;
        j++:
    }
    i++;
}

Para recorrer sería el mismo proceso, pero en vez de ingresar datos, los leemos.

Veamos ahora un ejemplo, donde primero declararemos una matriz, luego le diremos a un usuario que ingrese valores y finalmente los mostraremos:

Inicio
/* Damos inicio al programa. */

Numero matriz[4][4];
Numero i=0;
Numero j=0;

/ *Declaramos la matriz y las variables que utilizaremos para recorrerlas. */

Principal()

mientras(i<4)
{
    mientras(j<4)
    {
        /* Dentro de los 2 ciclos necesarios para recorrer filas y columnas en la matriz, mostramos un mensaje para que ingresen un valor a esa posición y luego lo leemos. */

        mostrar(“Ingrese el valor correspondiente a la fila %numero y la columna %numero”,i,j);
        leer(%numero, &matriz[i][j]);
        j++;
    }
    i++;
}

i = 0;
j = 0;

mostrar("Los valores ingresados son: ");

/* Avisaremos que mostraremos los valores */

mientras(i<4)
{
    mientras(j<4)
    {
        /* Mostramos los valores recorriendo la matriz con los 2 ciclos necesarios. */

        mostrar(“%numero”,matriz[i][j]);
        j++;
    }
    i++;
}

Fin

Como podemos apreciar, es un proceso bastante sencillo. La mayor complejidad se presente en poder entender el tema de los índices, pero una vez que lo logramos, todo se vuelve muy simple.

Con este ultimo tema estamos llegando al final de esta edición, en la cual hemos cubierto el tema de los arrays por completo, desde sus declaraciones hasta usos variados.

En la próxima edición:

1.- Funciones

2.- Ultimas consideraciones de Pseudo-codigo

3.- Entrando a un lenguaje real.

4.- Mas sobre los paradigmas de programación.

Y recuerden que como siempre, este tutorial ha sido desarrollado, probado y documentado por el equipo de Como Lo Hago, por lo que cuenta con nuestro Sello de Garantía.

Cualquier duda pueden consultarnos en el área habilitada a continuación.

Esperamos que este tutorial haya sido de utilidad para Uds.

Muchas gracias por leer y será hasta una próxima oportunidad.

Staff CLH