Hola, bienvenidos.
Vamos a ver a continuación un ejemplo para recorrer los elementos de una matriz.
Están listos?
Vamos.
Bien, ya tenemos definida nuestra matriz, que es de dos renglones por tres columnas, con los valores
que ya hemos venido trabajando, los valores de 100 a 600, tal como lo tenemos también en nuestra animación.
Ahora vamos a quitar este código y vamos a obtener los elementos de nuestra matriz, así que vamos.
La matriz, pero ya sabemos que tenemos que utilizar dos ciclos for anidados.
El ciclo más externo nos va a permitir iterar los renglones y de manera interna vamos a utilizar otro
ciclo for para recorrer cada una de las columnas de cada renglón que estamos iterando en cierto momento.
Así que vamos a mandar a imprimir.
En primer lugar, imprimimos un título.
Y te damos la matriz.
Y al final agregamos también un salto de línea.
Simplemente es un pequeño título para que sepamos que a partir de ese momento vamos a empezar a imprimir
cada uno de los elementos de nuestra matriz.
Posteriormente abrimos un primer ciclo más externo y de manera interna abrimos otro ciclo for para controlar
las columnas.
Así que este ciclo más externo.
Es el ciclo for para controlar los renglones y el ciclo más interno.
Aquí agregamos también un comentario a fin del ciclo FOR para acceder a cada una de las columnas del
renglón que estamos iterando en cierto momento.
Bien, entonces este ciclo for más externo vamos a definir nuestra variable llamada red, que bien puede
llamarse renglón.
De momento solamente lo vamos a llamar Ren para que sea un poco más compacto el nombre, y entonces
esta variable de Ren lo vamos a iterar según la cantidad de renglones que tengamos.
Para ello especificamos la constante de renglones, así que vamos a iterar esta variable de ren según
la cantidad de renglones que tengamos en nuestra matriz y por cada vez que queramos incrementamos esta
variable de ren.
En el caso de arreglos, recordemos que utilizamos la variable y para el índice.
Sin embargo, recordemos que en una matriz tenemos que especificar tanto el renglón como la columna.
Por ello es que esta variable se llama ren en el ciclo for más externo.
Ahora, en el ciclo más interno vamos a utilizar algo similar, pero para poder recorrer cada una de
las columnas.
Así que definimos nuestra variable de rol para poder acceder a cada columna y entonces esta variable
la vamos a recorrer según la cantidad de columnas que tengamos en nuestra matriz y entonces al final
vamos a incrementar nuestra variable de col por cada columna que tengamos en cada renglón que estemos
recorriendo en cierto momento.
Entonces esto es un ciclo for anidado, es un ciclo for dentro de otro y ya una vez que estamos dentro
de este ciclo for anidado, entonces simplemente mandamos a imprimir el valor que queremos acceder.
En este caso es un valor de tipo entero y vamos a mandar a imprimir el elemento que estamos iterando
en este momento.
Así que para ello la variable de red tiene un cierto valor en este momento y la variable de columna
también tiene un valor en este momento, según el valor que estemos iterando con nuestros ciclos.
For.
Bien, prácticamente con esto ya tenemos todo nuestro código.
Aún así, en el siguiente vídeo vamos a ver la ejecución paso a paso para que todo esto quede completamente
claro.
Pero de momento, si ejecutamos nuestro código, podemos ver que se imprime en cada uno de los valores
de 100, 200, 300 400 500 y 600.
Vamos a separarlos por un espacio para que se vean más claro estos valores y entonces podemos cebar.
Si tenemos la matriz, podemos ver cada uno de los valores según estamos accediendo a los valores de
100, 200, 300 400 500 y 600.
Pero además, vamos a agregar un poco más de información.
Por ejemplo, en este caso, si cada vez que mandamos a imprimir el ciclo más externo mandamos a imprimir
el valor del renglón, entonces podemos observar.
Qué tenemos?
Un renglón pivote.
En cierto momento, ya que este valor del renglón que estamos iterando no se mueve hasta que terminemos
de iterar todas las columnas que tenemos asignadas a cierto renglón.
Así que en este caso vamos a mandar a imprimir la variable de renglón, ya que es el renglón pivote
que estamos iterando en este momento.
Sin embargo, aquí al final voy a dar un salto de línea también para que no se junte toda la información.
Y entonces podemos observar lo siguiente para nuestro ciclo más externo que estamos iterando cada uno
de los renglones.
Entonces la primera vez que estamos iterando el renglón, tenemos el renglón cero y entonces para el
renglón cero se queda en fijo y empezamos a acceder cada una de las columnas de este renglón.
Así que para el renglón cero sería este el renglón cero, ya que podemos observar que aquí el renglón
en todo momento vale cero.
Y entonces ahora simplemente vamos a acceder a cada una de las columnas.
Así que en este caso esta sería el renglón cero, columna cero.
Estamos recuperando este valor.
Posteriormente este sigue haciendo el renglón cero.
Por lo tanto esta en fijo.
Este valor es el pivote y posteriormente la columna sería la columna uno.
Así que tenemos el renglón cero columna uno y estamos recuperando este valor de 200 y posteriormente
el valor de 300 también es el renglón cero, pero la columna dos.
Así que observamos que este ciclo for más interno es el que está incrementando cada una de las columnas
del renglón que ya está en fijo.
Así que por ello estamos recorriendo por completo todas las columnas del primer renglón que estamos
recorriendo en este momento.
Y posteriormente, una vez que termina de iterar cada una de las columnas de este ciclo más interno,
termina de ejecutarse este ciclo for.
Y entonces continuamos con la siguiente iteración del ciclo más externo.
Así que ahora se incrementa el renglón y por lo tanto ahora el pivote cambia.
Ya tenemos el renglón uno y podemos observar que para el renglón uno accedemos a la columna cero, la
columna uno y la columna dos, pero todo del renglón uno.
Así que por ello esos son los valores del renglón uno y estamos moviendo simplemente cada una de las
columnas para este renglón de la columna cero, uno y dos, respectivamente.
Así que con esto ya tenemos más información de lo que estamos accediendo.
Y por último, para cada uno de los elementos de nuestra matriz, simplemente voy a poner un formato
para que todo esto quede un poco más claro.
Voy a especificar tanto el valor del renglón y también el valor de la columna que estamos accediendo.
Así que agregando este pequeño formato, en primer lugar proporciono el renglón posteriormente de la
columna que estamos accediendo y finalmente el valor que estamos recuperando de nuestra matriz.
Vamos a comprobar y también voy a dar un salto de línea por cada elemento que estamos accediendo.
Así que al inicio de esta impresión agrego un salto de línea para que se imprima cada uno de los elementos
en una línea distinta.
Aquí, para la impresión del pivote, ya no es necesario agregar este salto.
Voy a quitar este salto de línea.
Volvemos a ejecutar.
Y entonces ahora, si tenemos que estamos iterando nuestra matriz para el renglón con pivotes cero,
accedemos a cada uno de los elementos.
Aquí podemos observar que el renglón siempre vale cero, por lo tanto es el valor pivote del renglón
y recorremos cada una de las columnas de nuestro renglón con el ciclo for más interno.
Así que accedemos a los valores de 100, 200 y 300 respectivamente.
Y una vez que termina el ciclo for más interno, entonces continuamos con la siguiente iteración del
ciclo for más externo.
Por lo tanto.
El pivote se mueve.
Ahora el renglón vale uno.
Y podemos ver que en este caso el renglón está en fijo.
Es el valor del pivote con valor de uno.
Así que el renglón vale uno y recorremos cada una de las columnas con los valores de cero, uno y dos
respectivamente.
Así que recuperamos los valores de 400, 500 y 600.
Ahora, si queremos agregar un salto de línea, cada vez que terminamos la ejecución de un renglón,
simplemente agregamos un salto de línea.
Pero al terminar la iteración de cada una de las columnas, también este salto de línea al final de
la impresión del título lo voy a quitar.
Así que ya tenemos solamente la iteración de la matriz.
Posteriormente la impresión del pivote, imprimimos los valores que estamos iterando y antes de iterar
el siguiente renglón, mandamos a imprimir un salto de línea.
Así que con esto ya tenemos todo nuestro código.
Y ahora si ya podemos observar un poco más claro.
Este es el primer renglón que estamos iterando.
Ya sabemos que es un valor en fijo y recorremos cada columna con el ciclo for más interno y obtenemos
cada uno de los valores según podemos observar en nuestra animación.
Y para el segundo renglón se mueve el valor del renglón pivote.
Está en fijo el valor de uno y recorremos cada una de las columnas obteniendo los valores de 400, 500
y 600 respectivamente.
Bien.
Así que esta es la forma de utilizar un ciclo for anidado para poder recorrer cada uno de los elementos
de nuestra matriz.
Pongan en práctica lo que hemos visto y continuamos en la siguiente lección.
Saludos.