1
00:00:01,230 --> 00:00:02,120
Hola y bienvenidos.

2
00:00:02,190 --> 00:00:07,230
Vamos a ver brevemente a la ejecución paso a paso, para iterar nuestra matriz en el lenguaje C, Así

3
00:00:07,230 --> 00:00:11,430
que vamos a poner un punto de ruptura, por ejemplo, en este caso en la definición de nuestra matriz

4
00:00:11,670 --> 00:00:17,700
en la línea ocho, vamos a dar un clic y entonces vamos a presionar este botón, el botón de debug para

5
00:00:17,700 --> 00:00:20,610
ejecutar paso a paso la ejecución de nuestra matriz.

6
00:00:21,860 --> 00:00:22,040
Bien.

7
00:00:22,040 --> 00:00:23,780
Así que de esta manera vamos a ver cómo se itera.

8
00:00:23,810 --> 00:00:26,090
Paso a paso la ejecución de nuestra matriz.

9
00:00:26,660 --> 00:00:30,950
Así que vamos a presionar este hover, este botón para que se quede en nuestra matriz.

10
00:00:31,340 --> 00:00:35,600
Posteriormente se manda a imprimir a consola el mensaje y tenemos nuestra matriz.

11
00:00:35,840 --> 00:00:40,640
Y entonces, en este momento se crea nuestra variable de renglón con el valor de cero y se revisa la

12
00:00:40,640 --> 00:00:46,670
condición si cero es menor que el valor de dos, ya que recordemos que renglones tiene el valor de dos

13
00:00:46,850 --> 00:00:49,430
y debido a que cero es menor que dos es verdadero.

14
00:00:49,640 --> 00:00:55,940
Entonces entramos por primera vez a nuestro ciclo for más externo, y debido a que la condición es verdadera,

15
00:00:55,940 --> 00:00:57,200
cero es menor que dos.

16
00:00:57,380 --> 00:01:00,650
Entonces entramos a nuestro ciclo for que controla los renglones.

17
00:01:01,160 --> 00:01:03,200
Así que presionamos el botón de este hover.

18
00:01:03,740 --> 00:01:08,750
Podemos observar que ya estamos en la línea 16 y ahora se va a mandar a imprimir el valor de la variable

19
00:01:08,750 --> 00:01:10,700
de red que en este momento vale cero.

20
00:01:11,030 --> 00:01:16,100
Presionamos este hover y podemos ver que ya estamos posicionados donde el renglón vale cero.

21
00:01:16,340 --> 00:01:17,450
Ese es el valor pivote.

22
00:01:17,630 --> 00:01:21,650
Se va a quedar fijo hasta que terminemos de ejecutar cada una de las columnas.

23
00:01:22,040 --> 00:01:28,040
Bien, entonces ya estamos en la línea 17 y ahora vamos a empezar a iterar cada una de las columnas

24
00:01:28,070 --> 00:01:29,630
del renglón que está en fijo.

25
00:01:30,080 --> 00:01:35,270
Así que presionamos de nueva cuenta este hover y podemos ver que entonces se creó la variable de col

26
00:01:35,300 --> 00:01:36,260
con el valor de cero.

27
00:01:36,500 --> 00:01:38,360
Posteriormente se revisa la condición.

28
00:01:38,600 --> 00:01:40,310
Si cero es menor que tres.

29
00:01:40,730 --> 00:01:46,610
Y entonces debido a que cero es menor que tres, se ejecuta nuestro ciclo for más interno y por lo tanto

30
00:01:46,610 --> 00:01:50,420
si presionamos este hover se manda a imprimir el primer valor.

31
00:01:50,600 --> 00:01:55,130
Recordemos que en este caso el renglón vale cero y la columna también vale cero.

32
00:01:55,340 --> 00:02:00,620
Por lo tanto accedemos al elemento Según podemos observar en nuestra animación estamos accediendo al

33
00:02:00,620 --> 00:02:01,940
renglón cero, columna cero.

34
00:02:02,150 --> 00:02:06,950
Por lo tanto, este es el valor que se imprime y esto quiere decir que tenemos que terminar de ejecutar

35
00:02:06,950 --> 00:02:08,330
este ciclo for más interno.

36
00:02:08,660 --> 00:02:11,930
Este va a ser la primera ejecución, pero faltan dos columnas más.

37
00:02:12,140 --> 00:02:17,720
Así que termina de ejecutarse y podemos ver que estamos regresando a la línea 17 para revisar de nueva

38
00:02:17,720 --> 00:02:19,040
cuenta esta condición.

39
00:02:19,370 --> 00:02:24,170
Ahora la variable de columna se incrementa al valor de uno y se vuelve a revisar la condición.

40
00:02:24,350 --> 00:02:25,810
Uno es menor que tres.

41
00:02:25,820 --> 00:02:27,110
En este caso es verdadero.

42
00:02:27,350 --> 00:02:29,360
Por lo tanto, se vuelve a ejecutar la línea 18.

43
00:02:29,780 --> 00:02:35,380
En este caso el renglón sigue valiendo cero, ya que es el valor pivote y la columna ya vale uno.

44
00:02:35,390 --> 00:02:36,670
Por lo tanto se ejecutamos.

45
00:02:36,680 --> 00:02:41,930
Entonces se manda a imprimir a consola el valor donde el renglón es cero, la columna es uno.

46
00:02:42,110 --> 00:02:44,570
Por lo tanto se van a imprimir el valor de 200.

47
00:02:44,990 --> 00:02:49,280
Todavía no termina de recorrer todas las columnas, por lo tanto regresamos a la línea 17.

48
00:02:49,280 --> 00:02:50,390
Como podemos observar.

49
00:02:50,600 --> 00:02:53,220
Entonces se incrementa nuestra variable de columnas.

50
00:02:53,360 --> 00:02:56,330
Ahora esta variable vale dos y se revisa la condición.

51
00:02:56,330 --> 00:03:01,700
Si dos es menor que tres, entonces todavía es verdadero y vamos a realizar la última ejecución de este

52
00:03:01,700 --> 00:03:03,080
ciclo for más interno.

53
00:03:03,410 --> 00:03:05,870
Así que presionamos de nueva cuenta este over.

54
00:03:06,320 --> 00:03:11,690
Entramos a la línea 18 y si revisamos la variable de renglón todavía vale cero.

55
00:03:11,720 --> 00:03:17,210
Esta en pivote es el valor pivote, el valor fijo hasta el momento y la columna ya vale dos.

56
00:03:17,450 --> 00:03:23,030
Por lo tanto, vamos a acceder a este elemento donde el renglón es cero y la columna vale dos.

57
00:03:23,090 --> 00:03:26,240
Por lo tanto, tendríamos que mandar a imprimir el valor de 300.

58
00:03:26,690 --> 00:03:32,540
Vamos a ejecutar y podemos llevar a hacer memoria que se van a imprimir el valor de 300, donde el renglón

59
00:03:32,570 --> 00:03:34,400
es cero y la columna es dos.

60
00:03:34,670 --> 00:03:39,430
Ahora hasta aquí regresamos a la línea 17, pero ahora, debido a que vamos a incrementar de nueva cuenta

61
00:03:39,440 --> 00:03:40,460
la variable de columnas.

62
00:03:40,700 --> 00:03:43,190
Ahora la variable de columnas ya va a valer tres.

63
00:03:43,340 --> 00:03:48,710
Por lo tanto se revisa la condición si tres es menor que tres y debido a que tres no es menor que tres,

64
00:03:48,710 --> 00:03:51,920
sino igual, entonces esta condición ya no se cumple.

65
00:03:52,130 --> 00:03:54,770
Regresa falso y entonces nos vamos a la siguiente línea.

66
00:03:55,040 --> 00:03:59,840
Una vez terminado este ciclo más interno y lo que va a suceder simplemente es que se van a imprimir

67
00:03:59,840 --> 00:04:04,940
un salto de línea para que los valores que imprimimos en la siguiente iteración del ciclo for más externo,

68
00:04:05,240 --> 00:04:08,360
entonces se impriman estos valores en una línea por separado.

69
00:04:09,240 --> 00:04:09,570
Bien.

70
00:04:09,570 --> 00:04:10,850
Así que vamos a ejecutar.

71
00:04:10,860 --> 00:04:15,150
Si presionamos este over, podemos ver que nos vamos directamente a la línea 20.

72
00:04:15,420 --> 00:04:20,880
Entonces se va a imprimir un salto de línea para separar los elementos que vamos a trabajar con el siguiente

73
00:04:20,880 --> 00:04:21,300
renglón.

74
00:04:21,600 --> 00:04:27,150
Y entonces ahora lo que sucede es que vamos a ir a la siguiente iteración del ciclo for más externo.

75
00:04:27,420 --> 00:04:32,040
Así que nuestro renglón pivote ya va a cambiar, ya que en este momento se va a incrementar.

76
00:04:32,190 --> 00:04:35,130
Recordemos que de momento el valor de renglón pivote valía cero.

77
00:04:35,340 --> 00:04:39,760
Y ahora, debido a que se va a incrementar, ya va a valer uno y se revisa la condición.

78
00:04:39,810 --> 00:04:42,900
Si uno es menor que dos, entonces todavía es verdadero.

79
00:04:42,960 --> 00:04:45,570
Por lo tanto, vamos a entrar a este ciclo for.

80
00:04:46,440 --> 00:04:47,340
Vamos a comprobarlo.

81
00:04:47,340 --> 00:04:50,520
Presionamos este hover, se ejecuta la línea 16.

82
00:04:50,520 --> 00:04:56,400
Ya estamos dentro y si ejecutamos esta línea se van a imprimir ahora renglón pivote con el valor de

83
00:04:56,400 --> 00:04:56,700
uno.

84
00:04:56,910 --> 00:04:59,190
Esto quiere decir que ya se incrementó la variable de red.

85
00:04:59,400 --> 00:05:02,280
Ya estamos en la siguiente iteración del ciclo más externo.

86
00:05:02,730 --> 00:05:07,020
Y ahora vamos a recorrer cada una de las columnas, pero para el renglón con valor de uno.

87
00:05:07,290 --> 00:05:10,740
Así que entramos a la primera iteración de este ciclo más interno.

88
00:05:11,070 --> 00:05:12,570
Si presionamos este hover.

89
00:05:13,750 --> 00:05:17,760
Se crea nuestra variable alcohol Nuevamente para controlar cada una de las columnas.

90
00:05:17,770 --> 00:05:19,480
Iniciamos con la columna en cero.

91
00:05:19,750 --> 00:05:24,790
Se revisa la condición Si cero es menor que tres, entonces esta condición es verdadera.

92
00:05:24,940 --> 00:05:27,190
Por lo tanto, entramos a la ejecución de este ciclo for.

93
00:05:27,850 --> 00:05:31,550
Y entonces en este momento vamos a acceder al valor de renglón uno.

94
00:05:31,570 --> 00:05:34,270
Podemos observar que ya se modificó este valor de pivote.

95
00:05:34,630 --> 00:05:38,540
Ahora se va a quedar en fijo con el valor de uno y el valor de la columna.

96
00:05:38,620 --> 00:05:39,730
Ahora es el valor de cero.

97
00:05:39,880 --> 00:05:44,650
Se reinició ya este valor para poder recorrer cada una de las columnas del siguiente renglón.

98
00:05:45,370 --> 00:05:49,290
Esto quiere decir entonces que vamos a acceder ahora al renglón uno columna cero.

99
00:05:49,330 --> 00:05:51,790
Por lo tanto, se va a acceder al valor de 400.

100
00:05:52,060 --> 00:05:54,340
Vamos a comprobarlo y presionamos este hover.

101
00:05:54,790 --> 00:06:00,730
Observamos que se van a imprimir el valor de 400, el cual está asignado al renglón uno, columna cero.

102
00:06:01,600 --> 00:06:03,890
Bien, y ahora se va a incrementar la variable de columna.

103
00:06:04,000 --> 00:06:10,320
Si presionamos este hover, entonces la variable de columna ya vale uno y se revisa la condición.

104
00:06:10,330 --> 00:06:14,250
Si uno es menor que tres, entonces todavía es verdadero.

105
00:06:14,350 --> 00:06:16,600
Por lo tanto, volvemos a ejecutar nuestro ciclo for.

106
00:06:16,840 --> 00:06:18,240
Se ejecuta la línea 18.

107
00:06:18,250 --> 00:06:20,710
En este caso la variable de renglón vale uno.

108
00:06:20,950 --> 00:06:25,510
Es el valor en pivote que tenemos ahora y la columna día también vale uno.

109
00:06:25,840 --> 00:06:30,880
Esto quiere decir que vamos a acceder ahora a este elemento donde el renglón vale uno y la columna también

110
00:06:30,880 --> 00:06:34,060
vale uno y se va a mandar a imprimir el valor de 500.

111
00:06:35,120 --> 00:06:35,960
Vamos a comprobarlo.

112
00:06:35,960 --> 00:06:37,370
Si presionamos este hover.

113
00:06:37,880 --> 00:06:40,940
Podemos observar en la salida que se imprime el valor de 500.

114
00:06:41,120 --> 00:06:43,190
Para el renglón uno, columna uno.

115
00:06:44,410 --> 00:06:48,520
Y por último, vamos a volver a ejecutar nuestro ciclo for más interno.

116
00:06:49,120 --> 00:06:54,160
Así que ahora la variable de columna se va a incrementar al valor de dos y se revisa la condición.

117
00:06:54,160 --> 00:06:57,330
Si dos es menor que tres, entonces todavía es verdadero.

118
00:06:57,340 --> 00:07:02,260
Por lo tanto, vamos a volver a ejecutar nuestro ciclo for más interno y ya va a ser la última vez que

119
00:07:02,260 --> 00:07:05,980
vamos a ejecutar este ciclo for más interno, por lo menos para este renglón.

120
00:07:06,370 --> 00:07:12,520
Esto quiere decir que ahora el renglón sigue valiendo uno es el valor pivote y la columna ya vale dos.

121
00:07:12,790 --> 00:07:18,730
Por lo tanto, vamos a mandar a imprimir este valor renglón uno, columna dos y se debería de mandar

122
00:07:18,730 --> 00:07:20,350
a imprimir el valor de 600.

123
00:07:20,530 --> 00:07:21,400
Vamos a comprobarlo.

124
00:07:21,410 --> 00:07:25,540
Si presionamos este hover podemos observar que se imprime el valor de 600.

125
00:07:25,870 --> 00:07:28,540
Ahora se va a incrementar el valor de la variable de columna.

126
00:07:28,720 --> 00:07:33,580
Por lo tanto, la variable de columna ahora ya va a valer tres y si revisamos la condición tres no es

127
00:07:33,580 --> 00:07:35,200
menor que tres, sino igual.

128
00:07:35,230 --> 00:07:36,940
Por lo tanto, esta condición es falsa.

129
00:07:37,300 --> 00:07:42,350
Termina ya de ejecutarse este ciclo for más interno y nos vamos a la siguiente línea.

130
00:07:42,370 --> 00:07:43,840
Después de este ciclo for.

131
00:07:44,140 --> 00:07:49,120
Esto quiere decir que ya simplemente se va a mandar a imprimir un salto de línea y terminada a ejecutarse

132
00:07:49,120 --> 00:07:49,660
este ciclo.

133
00:07:49,660 --> 00:07:51,010
For también más externo.

134
00:07:51,280 --> 00:07:55,540
Esto quiere decir que vamos a regresar otra vez a revisar el ciclo for más externo.

135
00:07:56,050 --> 00:07:57,640
Vamos a presionar este hover.

136
00:07:58,030 --> 00:08:00,430
Ya estamos en la línea 20, según lo habíamos comentado.

137
00:08:00,610 --> 00:08:03,280
Termina de ejecutarse este ciclo for más interno.

138
00:08:03,610 --> 00:08:08,380
Ahora, si presionamos este hover, entonces regresamos a revisar este ciclo más externo.

139
00:08:08,560 --> 00:08:14,860
Pero en este caso la variable de red se va a incrementar a dos y se revisa si dos es menor que dos.

140
00:08:14,860 --> 00:08:16,360
Esta condición ya es falsa.

141
00:08:16,570 --> 00:08:19,360
Por lo tanto, termina de revisarse este ciclo for más externo.

142
00:08:19,660 --> 00:08:23,080
Termina entonces este ciclo más externo y nos vamos a la siguiente línea.

143
00:08:23,350 --> 00:08:27,250
Después de ese ciclo for más externo ya es la última línea de código.

144
00:08:27,250 --> 00:08:29,470
Por lo tanto, termina la ejecución de nuestro programa.

145
00:08:29,830 --> 00:08:30,700
Vamos a comprobarlo.

146
00:08:30,700 --> 00:08:36,340
Presionamos este hover y entonces ya termina la ejecución de las iteraciones de nuestro ciclo for.

147
00:08:36,700 --> 00:08:41,950
En este caso, la ejecución del ciclo for más externo, ya que el ciclo más interno ya había terminado

148
00:08:41,950 --> 00:08:42,880
desde hace un momento.

149
00:08:43,240 --> 00:08:48,070
Bien, ya estamos en la línea 25 y con ello ya termina entonces la ejecución de nuestro programa.

150
00:08:49,740 --> 00:08:49,910
Bien.

151
00:08:49,950 --> 00:08:53,070
Así que esta es la forma en que trabaja la ejecución paso a paso.

152
00:08:53,070 --> 00:08:57,990
Cuando estamos iterando una matriz, sobre todo cuando estamos trabajando con ciclos for anidados.

153
00:08:58,200 --> 00:09:02,520
Pongan en práctica lo que hemos visto, ya que también esto va a ser muy importante para empezar a entender

154
00:09:02,520 --> 00:09:07,890
cómo resolver ejercicios más complejos, pero esta es la base para poder iterar cada uno de los elementos

155
00:09:07,890 --> 00:09:08,730
de una matriz.

156
00:09:09,040 --> 00:09:11,970
Bien, eso es todo por este vídeo y nos vemos en la siguiente lección.

157
00:09:11,970 --> 00:09:12,540
Saludos.
