1
00:00:00,870 --> 00:00:01,750
Hola y bienvenidos.

2
00:00:01,830 --> 00:00:06,060
Vamos a ver a continuación como iterar los elementos de una matriz están listados.

3
00:00:06,150 --> 00:00:06,630
Vamos.

4
00:00:08,780 --> 00:00:11,960
Bien, Vamos a ver entonces cómo iterar los elementos de una matriz.

5
00:00:12,230 --> 00:00:15,530
En primer lugar, vamos a ver la matriz que ya hemos venido trabajando.

6
00:00:15,920 --> 00:00:20,540
En este caso, podemos observar que nuestra matriz, utilizando la sintaxis simplificada, bien podríamos

7
00:00:20,540 --> 00:00:22,010
definirla en la misma línea.

8
00:00:22,370 --> 00:00:27,680
Así que estamos declarando una matriz de dos renglones por tres columnas y podemos ver que abrimos nuestras

9
00:00:27,680 --> 00:00:33,590
llaves, cerramos nuestro primer juego de llaves y de manera interna, por cada renglón abrimos otro

10
00:00:33,590 --> 00:00:39,980
juego de llaves, especificando cada uno de los valores que necesitamos, separados por coma y posteriormente

11
00:00:40,100 --> 00:00:41,480
para separar cada renglón.

12
00:00:41,660 --> 00:00:46,910
También utilizamos una coma y de esta forma podemos agregar tantos renglones como necesitemos.

13
00:00:47,090 --> 00:00:52,190
Ya el último elemento no es necesario agregar una coma ya que es el último renglón, así que con eso

14
00:00:52,190 --> 00:00:54,230
estamos comprobando que la sintaxis es simplificada.

15
00:00:54,470 --> 00:01:00,140
Bien podríamos utilizarla en una línea y entonces, en memoria tenemos lo siguiente Tenemos los elementos

16
00:01:00,140 --> 00:01:03,950
desde 100 hasta el valor de 600, tal como lo hemos venido trabajando.

17
00:01:04,280 --> 00:01:07,100
Pero ahora lo que vamos a ver es cómo iterar una matriz.

18
00:01:07,340 --> 00:01:12,860
A diferencia de los arreglos en el cual simplemente utilizando un ciclo for, era suficiente para poder

19
00:01:12,860 --> 00:01:15,380
iterar cada uno de los elementos de una matriz.

20
00:01:15,590 --> 00:01:20,780
En este caso, ya no va a ser suficiente con un ciclo for, así que vamos a necesitar dos ciclos for

21
00:01:20,960 --> 00:01:23,740
y sobre todo aplicar el concepto de form anidados.

22
00:01:23,780 --> 00:01:24,980
Vamos a ver cómo es esto.

23
00:01:25,280 --> 00:01:30,590
En primer lugar, vamos a iterar nuestra matriz utilizando en primer lugar un ciclo for más externo.

24
00:01:30,890 --> 00:01:35,600
Este ciclo for más externo se va a encargar de iterar los renglones de nuestra matriz.

25
00:01:35,990 --> 00:01:41,510
Así que en este caso, este primer for controla el acceso a cada uno de los renglones de nuestra matriz.

26
00:01:41,870 --> 00:01:47,360
Entonces este formas externo nos va a permitir iterar en primer lugar este renglón y posteriormente

27
00:01:47,360 --> 00:01:48,440
este segundo renglón.

28
00:01:48,830 --> 00:01:53,660
Ahora, de manera interna, necesitamos recorrer cada uno de los elementos de nuestra matriz.

29
00:01:53,840 --> 00:01:55,790
Para ello vamos a necesitar otro ciclo for.

30
00:01:55,910 --> 00:01:57,920
Pero este ciclo for va a ser interno.

31
00:01:58,190 --> 00:02:03,470
Así que por cada renglón que estemos recorriendo, vamos a necesitar recorrer a su vez cada una de las

32
00:02:03,470 --> 00:02:07,160
columnas de manera interna por cada renglón que tengamos.

33
00:02:07,460 --> 00:02:13,370
Así que por ello, para el primer renglón vamos a tener la columna cero, la columna uno y la columna

34
00:02:13,370 --> 00:02:13,700
dos.

35
00:02:13,970 --> 00:02:18,740
Recordemos que este es el primer renglón o renglón cero, y una vez que terminemos de iterar este primer

36
00:02:18,740 --> 00:02:24,140
renglón, entonces termina a ejecutarse la primera iteración del ciclo for más externo y entonces continuamos

37
00:02:24,140 --> 00:02:25,370
con la siguiente iteración.

38
00:02:25,520 --> 00:02:31,370
Por lo tanto, ahora vamos a acceder a la columna cero, pero ya del segundo renglón, el renglón con

39
00:02:31,370 --> 00:02:32,240
índice uno.

40
00:02:32,660 --> 00:02:38,020
Y entonces continuamos con las demás columnas, la columna uno y finalmente la columna dos.

41
00:02:38,030 --> 00:02:39,350
Pero del segundo renglón.

42
00:02:40,190 --> 00:02:45,470
Esto quiere decir que de manera externa tenemos un ciclo for que controla cada uno de los renglones

43
00:02:45,470 --> 00:02:50,870
y de manera interna vamos a tener un ciclo for que controla cada una de las columnas, pero podemos

44
00:02:50,870 --> 00:02:52,040
observar que se queda en fijo.

45
00:02:52,040 --> 00:02:56,090
En primer lugar el renglón cero y vamos accediendo a cada una de las columnas.

46
00:02:56,270 --> 00:02:59,780
Y una vez que terminamos con este primer renglón, accedemos al segundo renglón.

47
00:02:59,960 --> 00:03:04,250
Ahora se queda en fijo este segundo renglón y accedemos a cada columna.

48
00:03:04,520 --> 00:03:09,230
Por ello a esto se le va a conocer como renglón pivote, ya que estamos dejando en fijo un renglón para

49
00:03:09,230 --> 00:03:11,150
poder recorrer todas sus columnas.

50
00:03:11,180 --> 00:03:16,310
Por lo tanto, este va a ser el renglón pivote, para este caso el renglón cero para poder acceder a

51
00:03:16,310 --> 00:03:18,440
todas las columnas de este primer renglón.

52
00:03:18,740 --> 00:03:23,030
Y posteriormente, una vez que terminamos de recorrer este renglón, pasamos al segundo renglón.

53
00:03:23,060 --> 00:03:24,470
Así que ahora el pivote cambia.

54
00:03:24,710 --> 00:03:29,960
Por lo tanto el renglón uno ahora se va a quedar en fijo y vamos a ir accediendo tanto a la columna

55
00:03:29,960 --> 00:03:36,350
cero, uno y dos hasta que termine de recorrerse todas las columnas de este segundo renglón y así podemos

56
00:03:36,350 --> 00:03:40,850
continuar iterando más renglones, si es que esta matriz tuviera más renglones, pero de momento ya

57
00:03:40,850 --> 00:03:42,680
es toda la información que tiene esta matriz.

58
00:03:42,950 --> 00:03:48,200
Entonces, en resumen, para poder iterar también las columnas del renglón que estamos pisoteando o

59
00:03:48,200 --> 00:03:49,430
que se está quedando en fijo.

60
00:03:49,700 --> 00:03:54,500
Entonces, de manera interna, dentro del ciclo for que ya hemos definido para trabajar los renglones,

61
00:03:54,770 --> 00:04:00,470
ahora vamos a definir otro ciclo for para iterar cada una de las columnas del renglón que estamos iterando

62
00:04:00,470 --> 00:04:01,430
en este momento.

63
00:04:01,850 --> 00:04:06,530
Entonces podemos observar que de manera interna tenemos otro ciclo FOR, Así que es exactamente igual

64
00:04:06,530 --> 00:04:07,790
como lo tenemos en la figura.

65
00:04:08,000 --> 00:04:14,450
Es el ciclo for más externo y ese sería el ciclo for más interno el que nos ayuda a acceder a cada columna

66
00:04:14,630 --> 00:04:16,100
del renglón que estamos iterando.

67
00:04:16,370 --> 00:04:21,470
Así que de igual manera, este es el ciclo más externo que nos está ayudando a acceder a cada uno de

68
00:04:21,470 --> 00:04:27,710
los renglones y posteriormente el ciclo for más interno nos ayuda a acceder al renglón respectivo que

69
00:04:27,710 --> 00:04:32,240
está en pivote, y entonces accedemos a cada columna de renglón que está en fijo.

70
00:04:32,480 --> 00:04:37,130
Posteriormente, una vez que terminamos de recorrer cada uno de los elementos del renglón respectivo,

71
00:04:37,340 --> 00:04:42,560
entonces continuamos con el siguiente renglón y cada una de las columnas con ayuda del ciclo más interno.

72
00:04:43,550 --> 00:04:49,220
Entonces aquí tenemos el fin del ciclo que controla las columnas y también el fin del ciclo que controla

73
00:04:49,220 --> 00:04:49,970
los renglones.

74
00:04:50,210 --> 00:04:54,440
Y ya simplemente para poder visualizar la información en consola de manera interna.

75
00:04:54,470 --> 00:04:59,990
Dentro de los dos ciclo FOR mandamos a imprimir el elemento que estamos recorriendo en este momento,

76
00:05:00,410 --> 00:05:03,890
así que estamos trabajando con dos contadores en el ciclo más externo.

77
00:05:03,890 --> 00:05:09,110
Controla los renglones y el ciclo más interno, las columnas y de manera interna dentro de estos dos

78
00:05:09,110 --> 00:05:09,680
ciclos for.

79
00:05:09,890 --> 00:05:13,580
Entonces primero especificamos el renglón y posteriormente la columna.

80
00:05:14,820 --> 00:05:19,470
Y entonces esto finalmente va a ir imprimiendo cada uno de los valores que vamos a ir accediendo.

81
00:05:19,650 --> 00:05:24,660
Por ejemplo, en este caso, la primera iteración imprime el valor de 100, tal como estamos obteniendo

82
00:05:24,660 --> 00:05:26,550
el renglón cero columna cero.

83
00:05:26,910 --> 00:05:28,800
Posteriormente se avanza la columna.

84
00:05:29,040 --> 00:05:34,170
Así que se mantiene el renglón fijo y entonces accedemos al valor de 200.

85
00:05:34,380 --> 00:05:38,250
El renglón sería renglón cero, pero la columna ya sería la columna uno.

86
00:05:38,490 --> 00:05:40,410
Así que obtendríamos el valor de 200.

87
00:05:40,440 --> 00:05:44,130
Posteriormente, el siguiente elemento sería de nueva cuenta el renglón uno.

88
00:05:44,130 --> 00:05:44,520
En fijo.

89
00:05:44,520 --> 00:05:45,120
Todavía.

90
00:05:45,270 --> 00:05:46,590
Pero la columna dos.

91
00:05:46,800 --> 00:05:49,080
Y obtendríamos el valor de 300.

92
00:05:49,440 --> 00:05:53,160
Así que con esto ya estaremos recorriendo el primer renglón por completo.

93
00:05:53,600 --> 00:05:54,000
Bien.

94
00:05:54,030 --> 00:05:54,930
Posteriormente.

95
00:05:54,930 --> 00:06:00,630
Una vez que ya termina de iterar este ciclo for por completo, vamos a la siguiente iteración del ciclo

96
00:06:00,630 --> 00:06:01,680
for más externo.

97
00:06:02,010 --> 00:06:04,020
Y entonces ahora el renglón se incrementa.

98
00:06:04,320 --> 00:06:09,060
Tenemos el renglón uno, pero la columna se vuelve a reiniciar la columna cero.

99
00:06:09,300 --> 00:06:14,350
Esto quiere decir que vamos a mandar a imprimir el valor de 400 y así continuamos con los demás elementos.

100
00:06:14,430 --> 00:06:21,750
El renglón uno, columna uno, se imprime el valor de 500 y finalmente el renglón uno, columna dos

101
00:06:21,750 --> 00:06:24,240
se tendrá que imprimir el valor de 600.

102
00:06:24,510 --> 00:06:28,650
Y ya terminaríamos de iterar cada una de las columnas para el segundo renglón.

103
00:06:28,890 --> 00:06:31,590
Y eso ya sería la última iteración, ya sería el último renglón.

104
00:06:31,800 --> 00:06:37,200
Por lo tanto, también termina el ciclo for más externo y termina también la ejecución de nuestro programa.

105
00:06:37,780 --> 00:06:40,800
Bien, esta es la teoría para iterar cada uno de los elementos de nuestra matriz.

106
00:06:40,950 --> 00:06:45,090
Sin embargo, vamos a poner esto en práctica y también lo vamos a ejecutar paso a paso para que todo

107
00:06:45,090 --> 00:06:45,870
esto quede claro.

108
00:06:46,530 --> 00:06:48,450
Así que continuamos en el siguiente vídeo.

109
00:06:48,480 --> 00:06:49,080
Saludos.
