1
00:00:01,300 --> 00:00:02,150
Hola, bienvenidos.

2
00:00:02,230 --> 00:00:06,070
Vamos a ver a continuación un ejemplo para recorrer los elementos de una matriz.

3
00:00:06,250 --> 00:00:07,040
Están listos?

4
00:00:07,090 --> 00:00:07,570
Vamos.

5
00:00:08,960 --> 00:00:13,490
Bien, ya tenemos definida nuestra matriz, que es de dos renglones por tres columnas, con los valores

6
00:00:13,490 --> 00:00:18,890
que ya hemos venido trabajando, los valores de 100 a 600, tal como lo tenemos también en nuestra animación.

7
00:00:19,310 --> 00:00:25,430
Ahora vamos a quitar este código y vamos a obtener los elementos de nuestra matriz, así que vamos.

8
00:00:26,650 --> 00:00:30,850
La matriz, pero ya sabemos que tenemos que utilizar dos ciclos for anidados.

9
00:00:31,000 --> 00:00:36,460
El ciclo más externo nos va a permitir iterar los renglones y de manera interna vamos a utilizar otro

10
00:00:36,460 --> 00:00:41,830
ciclo for para recorrer cada una de las columnas de cada renglón que estamos iterando en cierto momento.

11
00:00:42,640 --> 00:00:44,020
Así que vamos a mandar a imprimir.

12
00:00:44,920 --> 00:00:47,530
En primer lugar, imprimimos un título.

13
00:00:48,690 --> 00:00:51,090
Y te damos la matriz.

14
00:00:52,790 --> 00:00:54,800
Y al final agregamos también un salto de línea.

15
00:00:55,040 --> 00:00:59,870
Simplemente es un pequeño título para que sepamos que a partir de ese momento vamos a empezar a imprimir

16
00:00:59,870 --> 00:01:01,670
cada uno de los elementos de nuestra matriz.

17
00:01:01,820 --> 00:01:08,870
Posteriormente abrimos un primer ciclo más externo y de manera interna abrimos otro ciclo for para controlar

18
00:01:08,870 --> 00:01:09,560
las columnas.

19
00:01:09,830 --> 00:01:11,690
Así que este ciclo más externo.

20
00:01:13,790 --> 00:01:18,620
Es el ciclo for para controlar los renglones y el ciclo más interno.

21
00:01:19,760 --> 00:01:25,070
Aquí agregamos también un comentario a fin del ciclo FOR para acceder a cada una de las columnas del

22
00:01:25,070 --> 00:01:27,200
renglón que estamos iterando en cierto momento.

23
00:01:27,580 --> 00:01:32,960
Bien, entonces este ciclo for más externo vamos a definir nuestra variable llamada red, que bien puede

24
00:01:32,960 --> 00:01:33,740
llamarse renglón.

25
00:01:33,770 --> 00:01:39,020
De momento solamente lo vamos a llamar Ren para que sea un poco más compacto el nombre, y entonces

26
00:01:39,020 --> 00:01:43,430
esta variable de Ren lo vamos a iterar según la cantidad de renglones que tengamos.

27
00:01:43,610 --> 00:01:49,790
Para ello especificamos la constante de renglones, así que vamos a iterar esta variable de ren según

28
00:01:49,790 --> 00:01:54,740
la cantidad de renglones que tengamos en nuestra matriz y por cada vez que queramos incrementamos esta

29
00:01:54,740 --> 00:01:55,490
variable de ren.

30
00:01:56,090 --> 00:02:00,170
En el caso de arreglos, recordemos que utilizamos la variable y para el índice.

31
00:02:00,320 --> 00:02:04,700
Sin embargo, recordemos que en una matriz tenemos que especificar tanto el renglón como la columna.

32
00:02:04,850 --> 00:02:08,420
Por ello es que esta variable se llama ren en el ciclo for más externo.

33
00:02:08,720 --> 00:02:14,090
Ahora, en el ciclo más interno vamos a utilizar algo similar, pero para poder recorrer cada una de

34
00:02:14,090 --> 00:02:14,780
las columnas.

35
00:02:15,320 --> 00:02:20,330
Así que definimos nuestra variable de rol para poder acceder a cada columna y entonces esta variable

36
00:02:20,330 --> 00:02:27,500
la vamos a recorrer según la cantidad de columnas que tengamos en nuestra matriz y entonces al final

37
00:02:27,530 --> 00:02:33,050
vamos a incrementar nuestra variable de col por cada columna que tengamos en cada renglón que estemos

38
00:02:33,050 --> 00:02:34,640
recorriendo en cierto momento.

39
00:02:35,330 --> 00:02:41,270
Entonces esto es un ciclo for anidado, es un ciclo for dentro de otro y ya una vez que estamos dentro

40
00:02:41,270 --> 00:02:47,360
de este ciclo for anidado, entonces simplemente mandamos a imprimir el valor que queremos acceder.

41
00:02:47,600 --> 00:02:52,580
En este caso es un valor de tipo entero y vamos a mandar a imprimir el elemento que estamos iterando

42
00:02:52,580 --> 00:02:53,480
en este momento.

43
00:02:53,780 --> 00:02:58,970
Así que para ello la variable de red tiene un cierto valor en este momento y la variable de columna

44
00:02:58,970 --> 00:03:03,380
también tiene un valor en este momento, según el valor que estemos iterando con nuestros ciclos.

45
00:03:03,380 --> 00:03:03,650
For.

46
00:03:04,110 --> 00:03:06,560
Bien, prácticamente con esto ya tenemos todo nuestro código.

47
00:03:06,830 --> 00:03:11,660
Aún así, en el siguiente vídeo vamos a ver la ejecución paso a paso para que todo esto quede completamente

48
00:03:11,660 --> 00:03:12,050
claro.

49
00:03:12,200 --> 00:03:16,700
Pero de momento, si ejecutamos nuestro código, podemos ver que se imprime en cada uno de los valores

50
00:03:16,880 --> 00:03:20,330
de 100, 200, 300 400 500 y 600.

51
00:03:20,540 --> 00:03:25,940
Vamos a separarlos por un espacio para que se vean más claro estos valores y entonces podemos cebar.

52
00:03:25,940 --> 00:03:31,130
Si tenemos la matriz, podemos ver cada uno de los valores según estamos accediendo a los valores de

53
00:03:31,130 --> 00:03:34,940
100, 200, 300 400 500 y 600.

54
00:03:35,300 --> 00:03:37,520
Pero además, vamos a agregar un poco más de información.

55
00:03:37,790 --> 00:03:44,150
Por ejemplo, en este caso, si cada vez que mandamos a imprimir el ciclo más externo mandamos a imprimir

56
00:03:44,150 --> 00:03:46,970
el valor del renglón, entonces podemos observar.

57
00:03:49,730 --> 00:03:50,330
Qué tenemos?

58
00:03:50,330 --> 00:03:51,350
Un renglón pivote.

59
00:03:52,770 --> 00:03:59,400
En cierto momento, ya que este valor del renglón que estamos iterando no se mueve hasta que terminemos

60
00:03:59,550 --> 00:04:03,120
de iterar todas las columnas que tenemos asignadas a cierto renglón.

61
00:04:03,690 --> 00:04:09,150
Así que en este caso vamos a mandar a imprimir la variable de renglón, ya que es el renglón pivote

62
00:04:09,150 --> 00:04:10,950
que estamos iterando en este momento.

63
00:04:12,740 --> 00:04:17,330
Sin embargo, aquí al final voy a dar un salto de línea también para que no se junte toda la información.

64
00:04:18,310 --> 00:04:23,260
Y entonces podemos observar lo siguiente para nuestro ciclo más externo que estamos iterando cada uno

65
00:04:23,260 --> 00:04:24,100
de los renglones.

66
00:04:24,370 --> 00:04:29,680
Entonces la primera vez que estamos iterando el renglón, tenemos el renglón cero y entonces para el

67
00:04:29,680 --> 00:04:35,020
renglón cero se queda en fijo y empezamos a acceder cada una de las columnas de este renglón.

68
00:04:35,230 --> 00:04:40,210
Así que para el renglón cero sería este el renglón cero, ya que podemos observar que aquí el renglón

69
00:04:40,210 --> 00:04:41,680
en todo momento vale cero.

70
00:04:42,040 --> 00:04:45,850
Y entonces ahora simplemente vamos a acceder a cada una de las columnas.

71
00:04:46,060 --> 00:04:49,600
Así que en este caso esta sería el renglón cero, columna cero.

72
00:04:49,930 --> 00:04:51,580
Estamos recuperando este valor.

73
00:04:51,730 --> 00:04:54,070
Posteriormente este sigue haciendo el renglón cero.

74
00:04:54,220 --> 00:04:55,320
Por lo tanto esta en fijo.

75
00:04:55,330 --> 00:04:59,650
Este valor es el pivote y posteriormente la columna sería la columna uno.

76
00:04:59,950 --> 00:05:05,500
Así que tenemos el renglón cero columna uno y estamos recuperando este valor de 200 y posteriormente

77
00:05:05,500 --> 00:05:09,460
el valor de 300 también es el renglón cero, pero la columna dos.

78
00:05:09,880 --> 00:05:15,880
Así que observamos que este ciclo for más interno es el que está incrementando cada una de las columnas

79
00:05:16,120 --> 00:05:17,740
del renglón que ya está en fijo.

80
00:05:18,010 --> 00:05:22,570
Así que por ello estamos recorriendo por completo todas las columnas del primer renglón que estamos

81
00:05:22,570 --> 00:05:23,980
recorriendo en este momento.

82
00:05:24,400 --> 00:05:29,350
Y posteriormente, una vez que termina de iterar cada una de las columnas de este ciclo más interno,

83
00:05:29,560 --> 00:05:31,420
termina de ejecutarse este ciclo for.

84
00:05:31,660 --> 00:05:36,130
Y entonces continuamos con la siguiente iteración del ciclo más externo.

85
00:05:36,340 --> 00:05:40,670
Así que ahora se incrementa el renglón y por lo tanto ahora el pivote cambia.

86
00:05:40,690 --> 00:05:47,050
Ya tenemos el renglón uno y podemos observar que para el renglón uno accedemos a la columna cero, la

87
00:05:47,050 --> 00:05:50,680
columna uno y la columna dos, pero todo del renglón uno.

88
00:05:51,010 --> 00:05:55,480
Así que por ello esos son los valores del renglón uno y estamos moviendo simplemente cada una de las

89
00:05:55,480 --> 00:05:59,950
columnas para este renglón de la columna cero, uno y dos, respectivamente.

90
00:06:01,030 --> 00:06:04,620
Así que con esto ya tenemos más información de lo que estamos accediendo.

91
00:06:04,630 --> 00:06:09,610
Y por último, para cada uno de los elementos de nuestra matriz, simplemente voy a poner un formato

92
00:06:09,610 --> 00:06:11,440
para que todo esto quede un poco más claro.

93
00:06:11,800 --> 00:06:16,900
Voy a especificar tanto el valor del renglón y también el valor de la columna que estamos accediendo.

94
00:06:17,170 --> 00:06:22,000
Así que agregando este pequeño formato, en primer lugar proporciono el renglón posteriormente de la

95
00:06:22,000 --> 00:06:27,100
columna que estamos accediendo y finalmente el valor que estamos recuperando de nuestra matriz.

96
00:06:27,490 --> 00:06:32,080
Vamos a comprobar y también voy a dar un salto de línea por cada elemento que estamos accediendo.

97
00:06:32,380 --> 00:06:38,830
Así que al inicio de esta impresión agrego un salto de línea para que se imprima cada uno de los elementos

98
00:06:38,830 --> 00:06:40,090
en una línea distinta.

99
00:06:40,840 --> 00:06:44,410
Aquí, para la impresión del pivote, ya no es necesario agregar este salto.

100
00:06:44,710 --> 00:06:46,360
Voy a quitar este salto de línea.

101
00:06:46,810 --> 00:06:47,920
Volvemos a ejecutar.

102
00:06:49,440 --> 00:06:54,300
Y entonces ahora, si tenemos que estamos iterando nuestra matriz para el renglón con pivotes cero,

103
00:06:54,300 --> 00:06:56,520
accedemos a cada uno de los elementos.

104
00:06:56,760 --> 00:07:01,440
Aquí podemos observar que el renglón siempre vale cero, por lo tanto es el valor pivote del renglón

105
00:07:01,770 --> 00:07:06,180
y recorremos cada una de las columnas de nuestro renglón con el ciclo for más interno.

106
00:07:06,480 --> 00:07:10,110
Así que accedemos a los valores de 100, 200 y 300 respectivamente.

107
00:07:10,650 --> 00:07:16,140
Y una vez que termina el ciclo for más interno, entonces continuamos con la siguiente iteración del

108
00:07:16,140 --> 00:07:17,670
ciclo for más externo.

109
00:07:17,880 --> 00:07:18,450
Por lo tanto.

110
00:07:18,450 --> 00:07:19,380
El pivote se mueve.

111
00:07:19,710 --> 00:07:20,910
Ahora el renglón vale uno.

112
00:07:21,180 --> 00:07:23,640
Y podemos ver que en este caso el renglón está en fijo.

113
00:07:23,910 --> 00:07:26,070
Es el valor del pivote con valor de uno.

114
00:07:26,400 --> 00:07:31,260
Así que el renglón vale uno y recorremos cada una de las columnas con los valores de cero, uno y dos

115
00:07:31,260 --> 00:07:32,220
respectivamente.

116
00:07:32,430 --> 00:07:36,210
Así que recuperamos los valores de 400, 500 y 600.

117
00:07:36,630 --> 00:07:41,100
Ahora, si queremos agregar un salto de línea, cada vez que terminamos la ejecución de un renglón,

118
00:07:41,100 --> 00:07:43,020
simplemente agregamos un salto de línea.

119
00:07:44,270 --> 00:07:49,940
Pero al terminar la iteración de cada una de las columnas, también este salto de línea al final de

120
00:07:49,940 --> 00:07:51,770
la impresión del título lo voy a quitar.

121
00:07:52,220 --> 00:07:54,440
Así que ya tenemos solamente la iteración de la matriz.

122
00:07:55,010 --> 00:07:59,990
Posteriormente la impresión del pivote, imprimimos los valores que estamos iterando y antes de iterar

123
00:07:59,990 --> 00:08:02,810
el siguiente renglón, mandamos a imprimir un salto de línea.

124
00:08:03,440 --> 00:08:05,360
Así que con esto ya tenemos todo nuestro código.

125
00:08:05,930 --> 00:08:07,940
Y ahora si ya podemos observar un poco más claro.

126
00:08:08,240 --> 00:08:10,430
Este es el primer renglón que estamos iterando.

127
00:08:10,700 --> 00:08:17,030
Ya sabemos que es un valor en fijo y recorremos cada columna con el ciclo for más interno y obtenemos

128
00:08:17,030 --> 00:08:20,090
cada uno de los valores según podemos observar en nuestra animación.

129
00:08:20,360 --> 00:08:24,290
Y para el segundo renglón se mueve el valor del renglón pivote.

130
00:08:24,800 --> 00:08:30,800
Está en fijo el valor de uno y recorremos cada una de las columnas obteniendo los valores de 400, 500

131
00:08:30,800 --> 00:08:32,360
y 600 respectivamente.

132
00:08:33,530 --> 00:08:33,670
Bien.

133
00:08:33,770 --> 00:08:38,540
Así que esta es la forma de utilizar un ciclo for anidado para poder recorrer cada uno de los elementos

134
00:08:38,540 --> 00:08:39,380
de nuestra matriz.

135
00:08:39,560 --> 00:08:42,980
Pongan en práctica lo que hemos visto y continuamos en la siguiente lección.

136
00:08:43,040 --> 00:08:43,610
Saludos.
