1
00:00:03,569 --> 00:00:23,289
Vale, pues a ver esto. Bueno, pues entonces, el ejemplo que estaba proyectado antes, era un ejemplo en el cual después de denunciado, hemos identificado que hay algo que se tiene que hacer exactamente 10 veces.

2
00:00:23,289 --> 00:00:26,449
no hasta que el usuario

3
00:00:26,449 --> 00:00:27,429
introduzca un cero

4
00:00:27,429 --> 00:00:30,030
o no hasta que ocurra

5
00:00:30,030 --> 00:00:31,730
que la suma me dé positivo

6
00:00:31,730 --> 00:00:34,350
no hasta una condición cualquiera

7
00:00:34,350 --> 00:00:36,250
que hace que el número de veces

8
00:00:36,250 --> 00:00:37,750
que se realice sea indeterminado

9
00:00:37,750 --> 00:00:38,950
no hasta una condición

10
00:00:38,950 --> 00:00:40,929
sino un número exacto de veces

11
00:00:40,929 --> 00:00:43,530
vale, pues esa situación

12
00:00:43,530 --> 00:00:45,070
un número exacto de veces

13
00:00:45,070 --> 00:00:46,670
también

14
00:00:46,670 --> 00:00:48,990
como es un bucle

15
00:00:48,990 --> 00:00:52,579
la resolveríamos con un while

16
00:00:52,579 --> 00:00:54,679
¿verdad? algo que se haga un número exacto de veces

17
00:00:54,679 --> 00:00:55,920
pues podríamos hacer esto

18
00:00:55,920 --> 00:00:58,140
si yo quiero que algo se haga

19
00:00:58,140 --> 00:00:59,939
un número exacto de veces

20
00:00:59,939 --> 00:01:03,100
pues cojo una variable

21
00:01:03,100 --> 00:01:04,620
que me va a servir de contadora

22
00:01:04,620 --> 00:01:07,280
para contar cuantas veces ejecuta eso

23
00:01:07,280 --> 00:01:10,439
me pongo aquí esta condición

24
00:01:10,439 --> 00:01:12,780
aquí hago lo que haya que hacer

25
00:01:12,780 --> 00:01:13,620
lo que sea

26
00:01:13,620 --> 00:01:15,780
y ahora ya incremento

27
00:01:15,780 --> 00:01:18,519
¿vale? entonces repito

28
00:01:18,519 --> 00:01:19,700
si yo quisiera

29
00:01:19,700 --> 00:01:25,510
si yo quisiera un programa

30
00:01:25,510 --> 00:01:27,489
en el que algo, lo que sea

31
00:01:27,489 --> 00:01:29,790
se me haga un número

32
00:01:29,790 --> 00:01:31,209
exacto de veces

33
00:01:31,209 --> 00:01:32,670
n, por ejemplo

34
00:01:32,670 --> 00:01:34,569
pues tendríamos que hacer esto

35
00:01:34,569 --> 00:01:37,170
¿verdad? este bucle

36
00:01:37,170 --> 00:01:39,310
se ejecuta mientras

37
00:01:39,310 --> 00:01:41,310
i sea menor, perdón, menor

38
00:01:41,310 --> 00:01:43,069
exactamente que n, no menor o igual

39
00:01:43,069 --> 00:01:44,090
¿vale?

40
00:01:47,760 --> 00:01:49,420
y empieza valiendo 0

41
00:01:49,420 --> 00:01:51,980
y mientras i sea menor que n

42
00:01:51,980 --> 00:01:54,019
hago lo que tenga que hacer y dejo

43
00:01:54,019 --> 00:01:54,760
incrementada i

44
00:01:54,760 --> 00:01:57,500
entonces esta variable i que yo he puesto ahí

45
00:01:57,500 --> 00:02:00,079
como se puede llamar i, j, h, o la

46
00:02:00,079 --> 00:02:03,180
esa variable me está sirviendo solo

47
00:02:03,180 --> 00:02:06,519
para contar las veces que se ejecuta el bucle

48
00:02:06,519 --> 00:02:07,439
¿vale?

49
00:02:08,360 --> 00:02:09,500
entonces lo que hace el bucle

50
00:02:09,500 --> 00:02:11,319
pues no lo sé, dependerá de mi problema

51
00:02:11,319 --> 00:02:12,099
lo que haga

52
00:02:12,099 --> 00:02:14,620
pero sí que sé que esa estructura de aquí

53
00:02:14,620 --> 00:02:17,099
es una estructura en la cual

54
00:02:17,099 --> 00:02:19,460
esto, sea lo que sea

55
00:02:19,460 --> 00:02:22,500
se hace exactamente n veces

56
00:02:22,500 --> 00:02:23,259
¿vale?

57
00:02:23,259 --> 00:02:26,159
entonces es una situación que se nos puede dar

58
00:02:26,159 --> 00:02:28,840
el tener que hacer un programa

59
00:02:28,840 --> 00:02:30,479
en el que algo se haga

60
00:02:30,479 --> 00:02:32,759
un número de veces que ya conocemos

61
00:02:32,759 --> 00:02:34,759
tal cual, como ese ejemplo

62
00:02:34,759 --> 00:02:36,460
de antes, programa que lee

63
00:02:36,460 --> 00:02:38,979
10 números, pues 10 veces se va a ejecutar

64
00:02:38,979 --> 00:02:40,939
pues lee 20 nombres

65
00:02:40,939 --> 00:02:42,439
pues ese bucle se va a ejecutar

66
00:02:42,439 --> 00:02:44,780
20 veces, entonces cuando tenemos

67
00:02:44,780 --> 00:02:46,539
un programa en el cual algo

68
00:02:46,539 --> 00:02:48,000
ya sabemos de partida

69
00:02:48,000 --> 00:02:50,039
cuantas veces se va a ejecutar

70
00:02:50,039 --> 00:02:52,419
pues con el while podríamos hacer algo así

71
00:02:52,419 --> 00:02:53,240
y listo, ¿vale?

72
00:02:54,599 --> 00:02:55,740
Entonces, recordad que esto

73
00:02:55,740 --> 00:02:57,939
es una situación distinta a

74
00:02:57,939 --> 00:02:59,759
un bucle

75
00:02:59,759 --> 00:03:02,259
que se va a ejecutar

76
00:03:02,259 --> 00:03:04,039
mientras

77
00:03:04,039 --> 00:03:06,039
una condición sea falsa, pero

78
00:03:06,039 --> 00:03:07,460
no sé cuántas veces

79
00:03:07,460 --> 00:03:10,000
va a tardar el bucle en conseguir

80
00:03:10,000 --> 00:03:11,340
que la condición sea falsa.

81
00:03:11,939 --> 00:03:14,020
Es otra situación, ¿no? Como cuando hacemos un programa.

82
00:03:14,599 --> 00:03:15,860
Programa que está todo el rato

83
00:03:15,860 --> 00:03:18,020
introduciendo números hasta que

84
00:03:18,020 --> 00:03:19,319
introduzca uno positivo.

85
00:03:20,039 --> 00:03:22,000
¿No? Un programa de validar que tú estás

86
00:03:22,000 --> 00:03:24,039
metiendo un número todo el rato, mientras el usuario

87
00:03:24,039 --> 00:03:25,979
meta negativo, no te interesa. Hasta

88
00:03:25,979 --> 00:03:27,719
que no meta positivo, no sales del bucle.

89
00:03:28,439 --> 00:03:30,159
Ese bucle, no sabemos cuántas

90
00:03:30,159 --> 00:03:31,960
veces se va a ejecutar. En alguna

91
00:03:31,960 --> 00:03:33,919
ejecución, igual que se ejecuta 5, porque

92
00:03:33,919 --> 00:03:35,659
ha tardado 5 veces en meter el positivo.

93
00:03:36,639 --> 00:03:37,860
Pero en otra ejecución

94
00:03:37,860 --> 00:03:39,759
que hagamos después, a lo mejor se ejecuta

95
00:03:39,759 --> 00:03:41,699
10 veces, porque ha tardado

96
00:03:41,699 --> 00:03:43,419
10 veces en meter el positivo.

97
00:03:44,340 --> 00:03:45,180
Esa sería

98
00:03:45,180 --> 00:03:46,759
otra situación.

99
00:03:47,659 --> 00:03:49,479
Pero una situación muy concreta,

100
00:03:49,680 --> 00:03:51,900
repito, es aquella en la cual

101
00:03:51,900 --> 00:03:54,379
sabemos a priori las veces

102
00:03:54,379 --> 00:03:56,020
que queremos que se ejecute el bucle

103
00:03:56,020 --> 00:03:57,879
lo sabemos a priori, quiero que se ejecute

104
00:03:57,879 --> 00:04:00,259
20, porque es mi problema

105
00:04:00,259 --> 00:04:02,099
y necesita eso

106
00:04:02,099 --> 00:04:03,939
bueno, pues en ese caso

107
00:04:03,939 --> 00:04:05,180
haríamos algo así

108
00:04:05,180 --> 00:04:08,259
pero hay otra sintaxis

109
00:04:08,259 --> 00:04:10,439
para el bucle, hay otra sintaxis

110
00:04:10,439 --> 00:04:12,659
que lo único que aporta

111
00:04:12,659 --> 00:04:14,780
es escribir esto de forma más bonita

112
00:04:14,780 --> 00:04:15,639
nada más

113
00:04:15,639 --> 00:04:17,579
y esa sintaxis

114
00:04:17,579 --> 00:04:20,040
es la sintaxis del bucle for

115
00:04:20,040 --> 00:04:22,879
que la usamos

116
00:04:22,879 --> 00:04:24,819
porque queda más bonito

117
00:04:24,819 --> 00:04:25,639
solo por eso

118
00:04:25,639 --> 00:04:28,519
en situaciones en las cuales yo quiero

119
00:04:28,519 --> 00:04:30,339
que lo que hay dentro del bucle se ejecute

120
00:04:30,339 --> 00:04:32,300
exactamente un número

121
00:04:32,300 --> 00:04:33,620
concreto de veces

122
00:04:33,620 --> 00:04:35,600
¿vale?

123
00:04:37,079 --> 00:04:38,980
¿que es obligatorio usar el for?

124
00:04:39,180 --> 00:04:40,879
pues no, este bucle está muy bien

125
00:04:40,879 --> 00:04:42,339
este bucle

126
00:04:42,339 --> 00:04:44,819
es un bucle que se ejecuta exactamente

127
00:04:44,819 --> 00:04:45,759
n veces

128
00:04:45,759 --> 00:04:46,860
esto está bien

129
00:04:46,860 --> 00:04:50,779
lo que pasa es que, bueno, que he tenido que hacer esta variable aquí fuera,

130
00:04:51,680 --> 00:04:54,839
ahora tengo que incrementarla aquí, que ni siquiera tengo que incrementarla aquí,

131
00:04:54,959 --> 00:04:56,319
podría poner el más más ahí, ¿verdad?

132
00:04:57,160 --> 00:05:03,180
Podría poner ahí el más más, y aquí esto ya no me haría falta, ¿vale?

133
00:05:04,060 --> 00:05:07,660
Que, por tanto, el for no lo necesitamos en realidad.

134
00:05:08,000 --> 00:05:13,379
Es otra herramienta de sintaxis más para que mis códigos queden más bonitos, nada más.

135
00:05:14,600 --> 00:05:17,720
Bueno, pues vamos a ver entonces cuál es esa sintaxis del bucle for,

136
00:05:18,180 --> 00:05:30,779
que nos va a facilitar la escritura del código en algunos casos, simplemente nos va a facilitar la escritura porque es más ágil, pero no aporta nada que no haga un while, ¿vale?

137
00:05:31,379 --> 00:05:48,120
Bueno, pues ¿cuál es la sintaxis del bucle for? Vale, pues la sintaxis es, primero escribimos for, como no podía ser de otra manera, escribimos for.

138
00:05:48,120 --> 00:06:13,800
Y ahora, entre paréntesis, se pone lo que vamos a ver ahora. Y ahora ya aquí lo que se repite, ¿vale? Entre llaves. Que puede ser una sentencia o muchas, como siempre. Si es solo una, de nuevo, las llaves no son obligatorias. Si lo que se repite es solo una sentencia, las llaves no son obligatorias, ¿vale?

139
00:06:13,800 --> 00:06:15,279
vale

140
00:06:15,279 --> 00:06:17,959
ahora, ¿qué se pone

141
00:06:17,959 --> 00:06:19,759
aquí en estos paréntesis? pues tres

142
00:06:19,759 --> 00:06:22,019
cositas, aquí hay espacio

143
00:06:22,019 --> 00:06:23,160
para tres cosas

144
00:06:23,160 --> 00:06:27,470
y cada una de ellas está separada

145
00:06:27,470 --> 00:06:29,329
por el punto y coma, entonces en el

146
00:06:29,329 --> 00:06:31,550
bucle for van tres cosas separadas

147
00:06:31,550 --> 00:06:33,569
por punto y coma, ¿vale?

148
00:06:35,129 --> 00:06:37,230
¿es obligatorio que aparezcan las tres?

149
00:06:37,389 --> 00:06:39,529
no, puede que en alguna yo no quiera poner nada

150
00:06:39,529 --> 00:06:40,910
ahora cuando veamos lo que significa

151
00:06:40,910 --> 00:06:43,250
puede que lleguemos a la conclusión, no

152
00:06:43,250 --> 00:06:45,709
aquí no me interesa poner nada, pues se queda en blanco

153
00:06:45,709 --> 00:06:46,810
da igual, se queda en blanco

154
00:06:46,810 --> 00:06:49,209
pero el espacio tiene que estar

155
00:06:49,209 --> 00:06:50,829
no me refiero al espacio físico

156
00:06:50,829 --> 00:06:53,649
sino que los puntos y comas

157
00:06:53,649 --> 00:06:55,649
separando los campos tienen que estar

158
00:06:55,649 --> 00:06:57,250
aunque uno no tenga nada dentro

159
00:06:57,250 --> 00:06:59,149
vale, pues vamos a ver

160
00:06:59,149 --> 00:07:00,949
que se pone en estas posiciones

161
00:07:00,949 --> 00:07:02,689
en la 1

162
00:07:02,689 --> 00:07:04,949
en la 2 y en la 3

163
00:07:04,949 --> 00:07:08,529
en la posición 1

164
00:07:08,529 --> 00:07:11,350
yo ahí pongo

165
00:07:11,350 --> 00:07:14,629
una sentencia o varias

166
00:07:14,629 --> 00:07:26,519
¿vale? voy a

167
00:07:26,519 --> 00:07:28,740
poner lo que se puede poner ahí

168
00:07:28,740 --> 00:07:31,139
luego otra cosa es el uso habitual que se le dé

169
00:07:31,139 --> 00:07:32,759
una sentencia o varias

170
00:07:32,759 --> 00:07:34,680
y las que yo ponga ahí

171
00:07:34,680 --> 00:07:37,180
sé que se van a ejecutar

172
00:07:37,180 --> 00:07:38,860
en el momento en el que el for

173
00:07:38,860 --> 00:07:39,399
arranca

174
00:07:39,399 --> 00:07:42,680
y solo esa vez, ya nunca más se volverán

175
00:07:42,680 --> 00:07:44,180
a ejecutar, luego

176
00:07:44,180 --> 00:07:46,160
se ejecutan

177
00:07:46,160 --> 00:07:51,000
al comienzo del bucle

178
00:07:51,000 --> 00:07:53,500
pero solo una primera

179
00:07:53,500 --> 00:08:04,560
a ver, es decir, es como unas sentencias que se ejecutan cuando el bucle arranca, ¿vale?

180
00:08:04,620 --> 00:08:22,660
Y solo se ejecutan esa vez. ¿Qué se pone en la posición 2? Ahí hay que poner una

181
00:08:23,180 --> 00:08:33,059
condición, eso es lo que se pone ahí, una condición, muller. Esta condición sería

182
00:08:33,700 --> 00:08:38,779
como la condición del while, tiene el mismo significado, es una condición que si se cumple

183
00:08:38,779 --> 00:08:45,000
entramos y el bucle for vuelve arriba otra vez y vuelve a evaluar condición. Si se cumple

184
00:08:45,000 --> 00:09:03,620
volvemos a entrar y vuelve a evaluar condición. Si se cumple volvemos a entrar. Luego, este

185
00:09:03,620 --> 00:09:18,629
bucle, por ejemplo, este bucle con una condición aquí y este bucle for con esto y esto serían

186
00:09:18,629 --> 00:09:19,769
lo mismo, por ejemplo

187
00:09:19,769 --> 00:09:22,649
yo este campo no lo uso, este campo

188
00:09:22,649 --> 00:09:24,490
que todavía sabemos lo que es, no lo uso, uso solo

189
00:09:24,490 --> 00:09:26,230
la condición, luego

190
00:09:26,230 --> 00:09:28,649
esto y

191
00:09:28,649 --> 00:09:29,129
esto

192
00:09:29,129 --> 00:09:32,570
serían exactamente igual, me da igual

193
00:09:32,570 --> 00:09:34,669
poner una cosa que otra, lo que pasa

194
00:09:34,669 --> 00:09:36,549
es que esta queda muy fea, cuando usamos el

195
00:09:36,549 --> 00:09:38,370
for es porque queremos usar

196
00:09:38,370 --> 00:09:40,610
esta posibilidad y esta

197
00:09:40,610 --> 00:09:42,450
posibilidad, si no quiero

198
00:09:42,450 --> 00:09:44,429
usarlas, para eso pongo un while

199
00:09:44,429 --> 00:09:46,649
que se ve mucho más claro, mientras se cumple

200
00:09:46,649 --> 00:09:48,610
la condición y tera, mientras se cumple y tera

201
00:09:48,610 --> 00:09:51,549
entonces poner esto y poner esto

202
00:09:51,549 --> 00:09:52,590
significa lo mismo

203
00:09:52,590 --> 00:09:55,230
a efectos de lo que va a ejecutar el programa es lo mismo

204
00:09:55,230 --> 00:09:57,470
pero en este caso

205
00:09:57,470 --> 00:09:59,149
esta queda más fea

206
00:09:59,149 --> 00:10:01,350
para qué poner yo ahí unos espacios que no uso

207
00:10:01,350 --> 00:10:02,929
vacíos, pongo lo de arriba y ya está

208
00:10:02,929 --> 00:10:05,149
el for lo usamos

209
00:10:05,149 --> 00:10:06,409
cuando esto nos interesa

210
00:10:06,409 --> 00:10:09,429
vale, pues ya sabemos lo que significa

211
00:10:09,429 --> 00:10:10,370
este segundo campo

212
00:10:10,370 --> 00:10:13,649
y qué significa el tercer campo

213
00:10:13,649 --> 00:10:15,490
qué puedo poner yo ahí si quiero

214
00:10:15,490 --> 00:10:16,850
no es obligatorio poner algo

215
00:10:16,850 --> 00:10:19,350
ahí ponemos de nuevo

216
00:10:19,350 --> 00:10:21,070
una sentencia o varias

217
00:10:21,070 --> 00:10:32,679
una sentencia o varias

218
00:10:32,679 --> 00:10:33,860
¿y cuándo se ejecutan esas?

219
00:10:34,559 --> 00:10:36,080
pues se ejecutan

220
00:10:36,080 --> 00:10:38,480
en cada iteración

221
00:10:38,480 --> 00:10:41,259
y una vez que ha terminado lo que hay dentro

222
00:10:41,259 --> 00:10:43,019
¿vale? o sea el bucle for

223
00:10:43,019 --> 00:10:44,860
tendrá sentencias que son las que se repiten

224
00:10:44,860 --> 00:10:47,179
pues en cada vuelta

225
00:10:47,179 --> 00:10:49,460
se hará lo que hay dentro

226
00:10:49,460 --> 00:10:51,159
y después de hacerse

227
00:10:51,159 --> 00:10:52,639
se hace lo que hay aquí

228
00:10:52,639 --> 00:10:54,840
y volvemos arriba a evaluar condición

229
00:10:54,840 --> 00:10:57,600
si es cierta, se hace lo que hay dentro

230
00:10:57,600 --> 00:10:59,080
y se hace lo que hay aquí

231
00:10:59,080 --> 00:11:00,960
otra vez, luego

232
00:11:00,960 --> 00:11:03,200
esto se hace una vez en cada

233
00:11:03,200 --> 00:11:03,860
iteración

234
00:11:03,860 --> 00:11:07,519
y siempre después de haber terminado

235
00:11:07,519 --> 00:11:08,840
lo que hay escrito dentro

236
00:11:08,840 --> 00:11:23,720
no, solo se hace

237
00:11:23,720 --> 00:11:25,399
al principio cuando arranca el bucle

238
00:11:25,399 --> 00:11:27,620
y ya está

239
00:11:27,620 --> 00:11:28,340
solo esa vez

240
00:11:28,340 --> 00:11:39,820
vale, pues esta es la sintaxis, ahora el tema es

241
00:11:39,820 --> 00:11:42,580
¿en qué me puede

242
00:11:42,580 --> 00:11:44,500
ayudar a mí esto a escribir código?

243
00:11:44,860 --> 00:11:46,240
¿en qué puede ser útil?

244
00:11:46,379 --> 00:11:48,259
¿en qué puede ser práctico? ¿cómo me puede ayudar

245
00:11:48,259 --> 00:11:49,700
a escribir códigos un poquito

246
00:11:49,700 --> 00:11:51,279
más claros?

247
00:11:53,019 --> 00:11:54,419
¿vale? pues si ya entendemos

248
00:11:54,419 --> 00:11:56,379
lo que significa cada cosa, esto se

249
00:11:56,379 --> 00:11:58,159
adapta exactamente

250
00:11:58,159 --> 00:12:00,639
a la situación que hemos escrito antes

251
00:12:00,639 --> 00:12:02,419
para hacer un bucle

252
00:12:02,419 --> 00:12:04,320
que se ejecuta exactamente n veces

253
00:12:04,320 --> 00:12:08,220
¿por qué? vamos a

254
00:12:08,220 --> 00:12:14,399
esto, ah no

255
00:12:14,399 --> 00:12:21,659
¿cómo era lo de, a ver

256
00:12:21,659 --> 00:12:22,720
¿le puedo hacer?

257
00:12:28,360 --> 00:12:30,080
no, no sé cómo se hace pequeño

258
00:12:30,080 --> 00:12:32,700
cómo se hacía pequeño esto, por probar

259
00:12:32,700 --> 00:12:33,399
¿eh?

260
00:12:34,399 --> 00:12:35,899
¿es así? ¿por qué no lo

261
00:12:35,899 --> 00:12:38,960
pero y por qué no me

262
00:12:38,960 --> 00:12:42,279
ah, vale, así sí, vale

263
00:12:42,279 --> 00:12:45,299
vale, pues a ver

264
00:12:45,299 --> 00:12:51,960
vale, pues en qué medida

265
00:12:51,960 --> 00:12:54,799
este for de aquí

266
00:12:54,799 --> 00:12:56,080
este for de aquí

267
00:12:56,080 --> 00:12:58,480
nos puede ser útil para escribir código

268
00:12:58,480 --> 00:13:00,139
ya digo, no es que nos aporte nada

269
00:13:00,139 --> 00:13:01,899
todo lo que hacemos aquí lo pensamos como un while

270
00:13:01,899 --> 00:13:03,919
¿en qué medida? pues por ejemplo

271
00:13:03,919 --> 00:13:05,860
antes hemos dicho, vamos a ver

272
00:13:05,860 --> 00:13:08,480
yo quiero hacer algo exactamente

273
00:13:08,480 --> 00:13:09,840
n mayúscula a veces

274
00:13:09,840 --> 00:13:12,019
pues hemos dicho

275
00:13:12,019 --> 00:13:12,779
pues bueno

276
00:13:12,779 --> 00:13:16,639
tendré yo que hacer una variable

277
00:13:16,639 --> 00:13:20,080
ahora un bucle while

278
00:13:20,080 --> 00:13:25,059
que mientras esa variable sea menor que ese número exactamente de veces

279
00:13:25,059 --> 00:13:27,740
se haga lo que se tiene que hacer

280
00:13:27,740 --> 00:13:31,919
y luego voy a incrementar esta variable en cada iteración

281
00:13:31,919 --> 00:13:38,159
para asegurarme de que se va a ejecutar exactamente n veces

282
00:13:38,159 --> 00:13:40,480
la primera vez que entra i vale 0

283
00:13:40,480 --> 00:13:42,860
y luego sale con i valiendo 1

284
00:13:42,860 --> 00:13:45,580
la siguiente vez i vale 1

285
00:13:45,580 --> 00:13:47,639
y luego sale con i valiendo 2

286
00:13:47,639 --> 00:14:00,100
Mientras sea menor que n sigo entrando, luego con esta estructura está claro que este bucle se ejecuta n veces, ¿vale?

287
00:14:00,220 --> 00:14:07,799
Pero para conseguir que este bucle se ejecute n veces, pues he tenido que hacerme esta sentencia que se ejecuta al principio

288
00:14:07,799 --> 00:14:15,200
y luego he tenido que hacerme esta otra aquí que se va a ejecutar en cada iteración y al finalizar.

289
00:14:15,200 --> 00:14:17,720
pues es que es justo

290
00:14:17,720 --> 00:14:19,879
para lo que sirven los campos

291
00:14:19,879 --> 00:14:21,820
del for, es justo para lo que sirven

292
00:14:21,820 --> 00:14:23,720
entonces el for

293
00:14:23,720 --> 00:14:25,259
aunque se puede usar

294
00:14:25,259 --> 00:14:27,379
poniendo uno aquí lo que le dé la gana

295
00:14:27,379 --> 00:14:28,919
sabiendo lo que hará

296
00:14:28,919 --> 00:14:31,820
la situación típica para la que

297
00:14:31,820 --> 00:14:32,639
encajes en esta

298
00:14:32,639 --> 00:14:35,419
si yo quiero programar esto con un for digo

299
00:14:35,419 --> 00:14:37,820
ah maravilloso, esta sentencia

300
00:14:37,820 --> 00:14:39,200
que quiero que se ejecute una vez

301
00:14:39,200 --> 00:14:41,820
al arrancar, esta sentencia

302
00:14:41,820 --> 00:14:43,620
la coloco aquí

303
00:14:43,620 --> 00:14:44,340
en el 1

304
00:14:44,340 --> 00:14:46,700
aquí pongo la condición

305
00:14:46,700 --> 00:14:48,559
porque es la condición que marca

306
00:14:48,559 --> 00:14:49,860
si yo

307
00:14:49,860 --> 00:14:51,899
sigo iterando o no

308
00:14:51,899 --> 00:14:54,840
y esta otra la pongo

309
00:14:54,840 --> 00:14:56,259
aquí, que está

310
00:14:56,259 --> 00:14:59,039
este campo de aquí tiene la sentencia

311
00:14:59,039 --> 00:15:01,220
que se hace una vez

312
00:15:01,220 --> 00:15:02,519
por iteración

313
00:15:02,519 --> 00:15:03,700
y siempre al acabar

314
00:15:03,700 --> 00:15:07,159
pues justo, en lugar de escribirlo así con el while

315
00:15:07,159 --> 00:15:08,100
que queda más feo

316
00:15:08,100 --> 00:15:11,039
pues lo puedo escribir esto a mismo

317
00:15:11,039 --> 00:15:13,679
con un for

318
00:15:13,679 --> 00:15:18,649
y si lo escribo con un for

319
00:15:18,649 --> 00:15:19,950
pues esto será

320
00:15:19,950 --> 00:15:28,190
en el primer campo esa primera sentencia

321
00:15:28,190 --> 00:15:30,389
luego la condición

322
00:15:30,389 --> 00:15:36,720
y luego esta otra

323
00:15:36,720 --> 00:15:40,860
y ahora aquí ya

324
00:15:40,860 --> 00:15:41,919
lo que sea

325
00:15:41,919 --> 00:15:48,059
luego el código de la izquierda

326
00:15:48,059 --> 00:15:49,779
y el código de la derecha

327
00:15:49,779 --> 00:15:51,820
hacen exactamente lo mismo

328
00:15:51,820 --> 00:15:52,759
hacen lo mismo

329
00:15:52,759 --> 00:15:56,320
pero aquí está como más compacto

330
00:15:56,320 --> 00:15:57,720
está más bonito

331
00:15:57,720 --> 00:16:02,779
y este es el uso habitual

332
00:16:02,779 --> 00:16:03,600
de un bucle for

333
00:16:03,600 --> 00:16:05,000
el uso habitual

334
00:16:05,000 --> 00:16:06,659
el

335
00:16:06,659 --> 00:16:10,679
escribir un bucle

336
00:16:10,679 --> 00:16:12,299
que sabemos que se va a ejecutar

337
00:16:12,299 --> 00:16:14,539
exactamente lo que yo ponga aquí

338
00:16:14,539 --> 00:16:16,580
que yo quiero un bucle que se ejecute

339
00:16:16,580 --> 00:16:17,679
exactamente 10 veces

340
00:16:17,679 --> 00:16:20,139
pongo esto, con n igual a 10

341
00:16:20,139 --> 00:16:23,139
si quiero un bucle que se ejecute exactamente 15 veces

342
00:16:23,139 --> 00:16:25,279
pongo esto, con n igual a 15

343
00:16:25,279 --> 00:16:27,820
¿el que?

344
00:16:27,820 --> 00:16:28,440
la llave

345
00:16:28,440 --> 00:16:31,580
Bueno, sí, quería ponerla que se abriera

346
00:16:31,580 --> 00:16:32,360
¿Vale?

347
00:16:33,080 --> 00:16:33,379
Dime

348
00:16:33,379 --> 00:16:37,299
No, no es tercera condición, es sentencia

349
00:16:37,299 --> 00:16:39,279
Sí, y más más

350
00:16:39,279 --> 00:16:40,440
Que es esta misma que va aquí

351
00:16:40,440 --> 00:16:41,759
¿Vale?

352
00:16:48,200 --> 00:16:49,600
Pues es el uso habitual

353
00:16:49,600 --> 00:16:52,919
Que programa que lee

354
00:16:52,919 --> 00:16:53,779
30 números

355
00:16:53,779 --> 00:16:57,000
Pues lo metemos en un for desde i igual a 0

356
00:16:57,000 --> 00:16:59,200
Mientras i sea menor que 30, incrementando i

357
00:16:59,200 --> 00:17:01,360
Leo número y hago lo que sea con él

358
00:17:01,360 --> 00:17:02,600
¿Vale?

359
00:17:02,600 --> 00:17:03,799
En lugar de hacer esto

360
00:17:03,799 --> 00:17:06,640
primero hago la sentencia, aquí la voy incrementando

361
00:17:06,640 --> 00:17:08,619
pues escribimos esto y ya está

362
00:17:08,619 --> 00:17:10,440
que es más

363
00:17:10,440 --> 00:17:11,500
cómodo

364
00:17:11,500 --> 00:17:14,640
pero eso sí, el uso que se le

365
00:17:14,640 --> 00:17:16,039
puede hacer de estos campos

366
00:17:16,039 --> 00:17:18,279
es el que a uno le dé la gana

367
00:17:18,279 --> 00:17:19,920
pero claro

368
00:17:19,920 --> 00:17:22,480
la idea es simplificar, o sea no meter aquí

369
00:17:22,480 --> 00:17:24,299
un montón de código que se hacía al principio

370
00:17:24,299 --> 00:17:26,339
lo pongo antes y ya está

371
00:17:26,339 --> 00:17:28,519
o no poner aquí un montón de sentencias

372
00:17:28,519 --> 00:17:30,599
porque eso se me estira y queda un montón de lío

373
00:17:30,599 --> 00:17:32,599
para eso las pongo aquí y se ve más

374
00:17:32,599 --> 00:17:34,359
claro, la idea es no hacer

375
00:17:34,359 --> 00:17:35,420
aquí un lío

376
00:17:35,420 --> 00:17:37,819
este es su uso habitual

377
00:17:37,819 --> 00:17:40,779
pero aquí se puede meter cualquier condición

378
00:17:40,779 --> 00:17:41,680
aquí cualquier

379
00:17:41,680 --> 00:17:43,900
sentencia, aquí también

380
00:17:43,900 --> 00:17:46,980
vale

381
00:17:46,980 --> 00:17:49,279
escribirlo así

382
00:17:49,279 --> 00:17:51,099
en lugar de así

383
00:17:51,099 --> 00:17:53,319
tiene una ventaja añadida

384
00:17:53,319 --> 00:17:56,359
primero lo claro que parece que se ve

385
00:17:56,359 --> 00:17:56,500
¿no?

386
00:17:57,500 --> 00:17:59,799
la ventaja añadida es que mirad

387
00:17:59,799 --> 00:18:02,000
esta declaración

388
00:18:02,000 --> 00:18:04,160
es decir, todo esto

389
00:18:04,160 --> 00:18:06,339
es una declaración

390
00:18:06,339 --> 00:18:07,539
a la vez que una asignación

391
00:18:07,539 --> 00:18:10,660
vale, pero la declaración

392
00:18:10,660 --> 00:18:12,900
está hecha en los paréntesis

393
00:18:12,900 --> 00:18:15,079
¿eso qué significa?

394
00:18:15,359 --> 00:18:16,819
que esta variable i

395
00:18:16,819 --> 00:18:18,480
dura solo

396
00:18:18,480 --> 00:18:20,200
solamente está viva, solo existe

397
00:18:20,200 --> 00:18:22,500
el tiempo que se ejecute este for

398
00:18:22,500 --> 00:18:24,759
sin embargo aquí

399
00:18:24,759 --> 00:18:26,559
esta variable i va a estar

400
00:18:26,559 --> 00:18:28,920
ya viva todo el programa

401
00:18:28,920 --> 00:18:30,579
con lo cual hay un nombre

402
00:18:30,579 --> 00:18:31,380
de variable i

403
00:18:31,380 --> 00:18:33,960
que ya está ahí

404
00:18:33,960 --> 00:18:35,740
molestando para siempre.

405
00:18:38,599 --> 00:18:39,160
¿Vale? Repito.

406
00:18:39,980 --> 00:18:42,180
Un segundo. Cuando declaramos una variable,

407
00:18:42,980 --> 00:18:44,400
por ejemplo, haciendo esto, ya sabemos

408
00:18:44,400 --> 00:18:45,019
lo que pasa.

409
00:18:46,019 --> 00:18:48,700
¿Qué hacemos? Que de repente aparece un espacio en memoria.

410
00:18:48,839 --> 00:18:50,740
¡Pum! Aparece. Del tamaño que toque.

411
00:18:50,740 --> 00:18:52,220
En este caso, 32 bits.

412
00:18:52,819 --> 00:18:54,900
A ese espacio en memoria se le da un nombrecito.

413
00:18:55,160 --> 00:18:56,000
El que yo ya he puesto aquí.

414
00:18:56,759 --> 00:18:58,359
Y luego, además, si hay una asignación,

415
00:18:58,500 --> 00:18:59,920
si además la hay, pues se asigna.

416
00:19:00,299 --> 00:19:01,240
Todo esto pasa.

417
00:19:01,240 --> 00:19:30,160
Vale, pues en esta versión del código, cuando hemos hecho esta declaración, pum, este espacio ha aparecido bajo el nombre i y ese espacio se queda para siempre, ya está, todo el programa ahí se queda, con lo cual este nombrecito i va a estar accesible en cualquier punto del programa, incluso 200 líneas más abajo, donde ya ni nos acordábamos de que había una variable i porque solo servía para esto, que es una cosa muy puntual.

418
00:19:30,160 --> 00:19:32,180
entonces no deja de ser una molestia

419
00:19:32,180 --> 00:19:33,700
el tener esa caja ahí

420
00:19:33,700 --> 00:19:35,480
que yo solamente la quería

421
00:19:35,480 --> 00:19:37,400
como contador de este bucle

422
00:19:37,400 --> 00:19:38,819
no deja de ser una molestia

423
00:19:38,819 --> 00:19:41,680
vale, pues al meterla aquí

424
00:19:41,680 --> 00:19:43,200
en estos paréntesis

425
00:19:43,200 --> 00:19:46,000
esta caja pum

426
00:19:46,000 --> 00:19:48,259
que de repente ha aparecido y se ha abierto

427
00:19:48,259 --> 00:19:49,519
cuando

428
00:19:49,519 --> 00:19:51,319
se ha hecho aquí la declaración

429
00:19:51,319 --> 00:19:53,700
cuando el bucle termina

430
00:19:53,700 --> 00:19:56,359
esta caja desaparece

431
00:19:56,359 --> 00:19:58,180
vale, solo está viva

432
00:19:58,180 --> 00:19:59,880
solo vive y solo está accesible

433
00:19:59,880 --> 00:20:02,619
Dentro del bucle, solo dentro

434
00:20:02,619 --> 00:20:04,779
Solo dentro, fuera ya no

435
00:20:04,779 --> 00:20:06,539
Fuera ya no hay variable ing

436
00:20:06,539 --> 00:20:06,920
Y nada

437
00:20:06,920 --> 00:20:09,940
Porque está declarada aquí dentro

438
00:20:09,940 --> 00:20:10,619
¿Vale?

439
00:20:10,619 --> 00:20:11,240
¿En el while?

440
00:20:12,339 --> 00:20:15,549
¿En el dentro del?

441
00:20:19,990 --> 00:20:22,369
¿Puede declarar dentro del while una variable?

442
00:20:22,650 --> 00:20:23,029
¿Aquí?

443
00:20:23,849 --> 00:20:25,029
No, ¿vale?

444
00:20:27,730 --> 00:20:29,869
No, no, no, eso es

445
00:20:29,869 --> 00:20:31,670
Lo siguiente con lo que a raíz de esto

446
00:20:31,670 --> 00:20:33,769
Me quería meter, el ámbito de variables

447
00:20:33,769 --> 00:20:35,650
Lo que pasa es que en este caso en concreto

448
00:20:35,650 --> 00:20:37,710
no la podrías declarar dentro del este

449
00:20:37,710 --> 00:20:39,549
porque si no la condición no la vería

450
00:20:39,549 --> 00:20:41,650
para esta situación en concreto es que no la podrías

451
00:20:41,650 --> 00:20:42,329
declarar dentro

452
00:20:42,329 --> 00:20:44,950
entonces ahora

453
00:20:44,950 --> 00:20:46,390
vamos por partes

454
00:20:46,390 --> 00:20:49,589
entendéis la diferencia

455
00:20:49,589 --> 00:20:50,390
de situaciones

456
00:20:50,390 --> 00:20:53,410
entonces esto nos lleva

457
00:20:53,410 --> 00:20:55,589
precisamente a lo que apuntas tú

458
00:20:55,589 --> 00:20:56,809
que las variables

459
00:20:56,809 --> 00:20:59,130
nosotros hemos asumido hasta ahora

460
00:20:59,130 --> 00:21:01,490
que desde el momento en que las declaras

461
00:21:01,490 --> 00:21:03,069
aparecen

462
00:21:03,069 --> 00:21:05,029
y ya están ahí

463
00:21:05,029 --> 00:21:06,990
vivas en memoria RAM

464
00:21:06,990 --> 00:21:08,990
para siempre con su nombre, todo el

465
00:21:08,990 --> 00:21:10,710
programa. Eso

466
00:21:10,710 --> 00:21:13,049
podría llegar a ser una molestia porque

467
00:21:13,049 --> 00:21:14,970
las variables a lo mejor yo las uso solo

468
00:21:14,970 --> 00:21:16,150
en un trocito de código

469
00:21:16,150 --> 00:21:18,910
y no quiero esa caja ahí abierta con ese

470
00:21:18,910 --> 00:21:20,829
nombre el resto del programa. Puede ser

471
00:21:20,829 --> 00:21:22,849
una molestia primero de ocupación

472
00:21:22,849 --> 00:21:24,089
de RAM innecesaria

473
00:21:24,089 --> 00:21:26,829
y luego que al final pues hay un montón de nombres

474
00:21:26,829 --> 00:21:28,869
que yo los puedo usar

475
00:21:28,869 --> 00:21:30,970
por error y se refiere a una variable

476
00:21:30,970 --> 00:21:32,710
que he declarado docente a líneas más arriba.

477
00:21:33,309 --> 00:21:34,890
Entonces nos gustaría alguna

478
00:21:34,890 --> 00:21:36,789
manera de acortar

479
00:21:36,789 --> 00:21:38,690
la vida de las variables y que sólo

480
00:21:38,690 --> 00:21:40,829
existan durante el tiempo

481
00:21:40,829 --> 00:21:42,569
el trozo de código en el que me interesa

482
00:21:42,569 --> 00:21:44,710
usarlas. ¿Se puede hacer

483
00:21:44,710 --> 00:21:46,890
eso? Sí. ¿Gracias a qué?

484
00:21:47,369 --> 00:21:48,930
Gracias a la existencia

485
00:21:48,930 --> 00:21:49,809
de lo que

486
00:21:49,809 --> 00:21:52,670
hemos mencionado que se llama

487
00:21:52,670 --> 00:21:54,750
bloques de código, que son

488
00:21:54,750 --> 00:21:56,190
trozos de código entre llaves.

489
00:21:57,390 --> 00:21:58,670
Entonces, esto que voy a

490
00:21:58,670 --> 00:22:00,269
mencionar ahora a raíz de lo del FOR

491
00:22:00,269 --> 00:22:02,869
es lo que llamamos

492
00:22:02,869 --> 00:22:03,930
ámbito

493
00:22:03,930 --> 00:22:05,789
de las variables

494
00:22:05,789 --> 00:22:08,990
el ámbito de las variables

495
00:22:08,990 --> 00:22:10,269
es

496
00:22:10,269 --> 00:22:12,049
el trozo de código

497
00:22:12,049 --> 00:22:14,329
en el que están vivas y son accesibles

498
00:22:14,329 --> 00:22:20,440
el ámbito de las variables

499
00:22:20,440 --> 00:22:20,940
es

500
00:22:20,940 --> 00:22:23,339
la porción de código

501
00:22:23,339 --> 00:22:32,740
en el que existen y son accesibles

502
00:22:32,740 --> 00:22:34,240
claro, por su nombre

503
00:22:34,240 --> 00:22:42,019
en el que existen y digamos

504
00:22:42,019 --> 00:22:43,119
que y por tanto

505
00:22:43,119 --> 00:22:45,859
son accesibles, claro

506
00:22:45,859 --> 00:22:47,680
por su nombre

507
00:22:47,680 --> 00:22:50,880
si no existen lógicamente no pueden ser accesibles

508
00:22:50,880 --> 00:22:55,950
bueno pues como controlamos

509
00:22:55,950 --> 00:22:57,390
esto del ámbito de las variables

510
00:22:57,390 --> 00:22:59,890
que ámbito tiene una variable

511
00:22:59,890 --> 00:23:01,970
como sé yo

512
00:23:01,970 --> 00:23:03,609
en que porción de código está viva

513
00:23:03,609 --> 00:23:05,650
y en que porción de código no está viva y por tanto

514
00:23:05,650 --> 00:23:07,289
no es accesible o no existe

515
00:23:07,289 --> 00:23:10,150
bueno pues esto está estrechamente

516
00:23:10,150 --> 00:23:12,009
relacionado con lo que

517
00:23:12,009 --> 00:23:13,470
hemos llamado bloques de código

518
00:23:13,470 --> 00:23:15,150
que son troces de código entre llaves

519
00:23:15,150 --> 00:23:17,710
entonces nosotros ya al hacer

520
00:23:17,710 --> 00:23:19,190
if for while

521
00:23:19,190 --> 00:23:21,170
ya hemos hecho programas

522
00:23:21,170 --> 00:23:23,089
que habrían muchos bloques de código

523
00:23:23,089 --> 00:23:25,470
por ejemplo

524
00:23:25,470 --> 00:23:26,390
nuestro programa

525
00:23:26,390 --> 00:23:28,529
siempre está dentro de un main

526
00:23:28,529 --> 00:23:30,750
eso sí o sí

527
00:23:30,750 --> 00:23:32,650
eso ya lo sabemos

528
00:23:32,650 --> 00:23:33,630
está dentro de un main

529
00:23:33,630 --> 00:23:36,549
pues siempre, obligatoriamente

530
00:23:36,549 --> 00:23:39,049
siempre hay un primer bloque de código gordote

531
00:23:39,049 --> 00:23:40,569
que es

532
00:23:40,569 --> 00:23:42,210
el que engloba todo

533
00:23:42,210 --> 00:23:44,809
este es el primer bloque de código

534
00:23:44,809 --> 00:23:46,410
el más gordo, el que lo engloba todo

535
00:23:46,410 --> 00:23:48,329
¿vale? que es mi programa en sí

536
00:23:48,329 --> 00:23:50,529
mi programa es todo un bloque de código muy grande

537
00:23:50,529 --> 00:23:52,670
que está comprendido

538
00:23:52,670 --> 00:23:54,089
entre las llaves del main, ¿vale?

539
00:23:54,109 --> 00:23:55,210
esto es un bloque de código

540
00:23:55,210 --> 00:23:58,509
por ejemplo, llamémosle bloque 1

541
00:23:58,509 --> 00:23:59,750
es un bloque de código, ¿vale?

542
00:24:01,569 --> 00:24:02,569
ahora, yo aquí

543
00:24:02,569 --> 00:24:04,410
dentro de este bloque, puedo declarar

544
00:24:04,410 --> 00:24:04,849
variables

545
00:24:04,849 --> 00:24:08,549
por ejemplo, int

546
00:24:08,549 --> 00:24:10,150
any, ¿vale?

547
00:24:10,849 --> 00:24:12,130
pues esta variable

548
00:24:12,130 --> 00:24:14,289
por estar declarada

549
00:24:14,289 --> 00:24:16,269
dentro de este bloque de código

550
00:24:16,269 --> 00:24:19,829
va a ser visible, accesible,

551
00:24:20,210 --> 00:24:23,109
va a existir todo el bloque entero.

552
00:24:24,009 --> 00:24:26,390
Es decir, una variable existe

553
00:24:26,390 --> 00:24:28,910
en todo el código,

554
00:24:29,829 --> 00:24:31,109
en todo el bloque, perdón,

555
00:24:31,309 --> 00:24:33,170
en todo el bloque en el cual se ha declarado.

556
00:24:33,890 --> 00:24:36,849
Entonces, como int n se ha declarado en el main,

557
00:24:37,569 --> 00:24:39,509
existe en todo el main.

558
00:24:39,910 --> 00:24:41,789
Si yo hago 10.000 líneas

559
00:24:41,789 --> 00:24:44,630
y ahora en la última de todos hago n igual a 100,

560
00:24:44,630 --> 00:24:47,789
ningún problema porque n sigue existiendo ahí

561
00:24:47,789 --> 00:24:49,890
n existe en todo el bloque

562
00:24:49,890 --> 00:24:50,990
por muy largo que sea

563
00:24:50,990 --> 00:24:53,910
vale, pero ocurre

564
00:24:53,910 --> 00:24:55,910
que dentro de un bloque puede abrirse

565
00:24:55,910 --> 00:24:56,210
otro

566
00:24:56,210 --> 00:24:59,710
por ejemplo, mi programa puede

567
00:24:59,710 --> 00:25:01,309
tener aquí a lo mejor una condición

568
00:25:01,309 --> 00:25:04,210
y aquí en esta condición

569
00:25:04,210 --> 00:25:05,849
se me abre otro bloque

570
00:25:05,849 --> 00:25:11,660
vale, en esta

571
00:25:11,660 --> 00:25:13,119
condición, como

572
00:25:13,119 --> 00:25:15,920
tiene un if con varias sentencias

573
00:25:15,920 --> 00:25:17,400
o solo con una

574
00:25:17,400 --> 00:25:18,819
pero yo le puedo poner llaves

575
00:25:18,819 --> 00:25:20,940
pues aquí

576
00:25:20,940 --> 00:25:22,500
se ha abierto otro bloque

577
00:25:22,500 --> 00:25:25,039
llamémosle a este

578
00:25:25,039 --> 00:25:26,680
bloque 2

579
00:25:26,680 --> 00:25:29,359
entonces los bloques son jerárquicos

580
00:25:29,359 --> 00:25:31,079
unos están contenidos dentro de otros

581
00:25:31,079 --> 00:25:33,779
igual que dentro del if

582
00:25:33,779 --> 00:25:35,339
podría haber otro if

583
00:25:35,339 --> 00:25:37,940
podría haber otro if con otra condición

584
00:25:37,940 --> 00:25:40,000
que abriera otro bloque dentro

585
00:25:40,000 --> 00:25:41,619
podría perfectamente

586
00:25:41,619 --> 00:25:43,619
entonces este programa tendría

587
00:25:43,619 --> 00:25:46,039
tres bloques, el bloque 3

588
00:25:46,039 --> 00:25:48,220
que es el código entre estas llaves

589
00:25:48,220 --> 00:25:50,180
del if, que estaría a su vez

590
00:25:50,180 --> 00:25:52,160
contenido dentro del bloque 2

591
00:25:52,160 --> 00:25:54,079
y el bloque 2 a su vez estaría

592
00:25:54,079 --> 00:25:56,099
contenido en el bloque 1 que es el

593
00:25:56,099 --> 00:25:56,619
grandote

594
00:25:56,619 --> 00:25:59,420
bueno pues

595
00:25:59,420 --> 00:26:02,279
dentro de cada bloque yo puedo

596
00:26:02,279 --> 00:26:04,160
declarar variables, las puedo declarar donde me

597
00:26:04,160 --> 00:26:05,220
dé la gana por supuesto

598
00:26:05,220 --> 00:26:08,319
bueno pues a lo mejor dentro de este bloque yo he declarado

599
00:26:08,319 --> 00:26:09,119
una variable m

600
00:26:09,119 --> 00:26:13,470
bueno pues esta variable m como está

601
00:26:13,470 --> 00:26:15,789
declarada en este bloque con estas

602
00:26:15,789 --> 00:26:18,049
llaves, solo existe

603
00:26:18,049 --> 00:26:19,789
en el trozo

604
00:26:19,789 --> 00:26:21,769
de código correspondiente a este bloque

605
00:26:21,769 --> 00:26:22,750
solo existe ahí

606
00:26:22,750 --> 00:26:25,769
cuando este código

607
00:26:25,769 --> 00:26:27,869
ya ha terminado, porque ya se ha ejecutado

608
00:26:27,869 --> 00:26:29,769
la rama del ir, aquí

609
00:26:29,769 --> 00:26:31,710
ya m no existe, y si yo intentara

610
00:26:31,710 --> 00:26:33,670
después de este bloque, hacer m

611
00:26:33,670 --> 00:26:35,450
igual a 100, me diría

612
00:26:35,450 --> 00:26:37,589
el compilador en particular

613
00:26:37,589 --> 00:26:39,750
me dice m is not visible, me diría

614
00:26:39,750 --> 00:26:41,710
eso, ¿qué significa? m no

615
00:26:41,710 --> 00:26:43,609
existe, ¿quién es m? claro que

616
00:26:43,609 --> 00:26:45,210
no existe, porque m

617
00:26:45,210 --> 00:26:51,970
Al estar declarada, recordad que es tener el tipo puesto delante, que es el momento en el que aparece la variable.

618
00:26:52,769 --> 00:26:59,049
Pues al estar declarada en este bloque, durante todo el bloque yo la puedo usar para hacer cosas.

619
00:26:59,470 --> 00:27:02,529
Pero cuando el bloque ha terminado, esa ha desaparecido.

620
00:27:06,950 --> 00:27:12,059
Entonces, ¿esto qué nomenclatura tiene?

621
00:27:12,559 --> 00:27:16,279
Pues bueno, se dice que esta variable M es local a este bucle.

622
00:27:16,279 --> 00:27:19,700
una variable se dice que es

623
00:27:19,700 --> 00:27:21,460
local a un bloque

624
00:27:21,460 --> 00:27:23,640
es local a un bloque porque

625
00:27:23,640 --> 00:27:26,079
solamente funciona

626
00:27:26,079 --> 00:27:27,500
dentro de ese bloque

627
00:27:27,500 --> 00:27:29,839
es una variable local de ese bloque

628
00:27:29,839 --> 00:27:31,960
está localizada en ese bloque

629
00:27:31,960 --> 00:27:33,440
es una variable local de ese bloque

630
00:27:33,440 --> 00:27:38,579
entonces yo puedo

631
00:27:38,579 --> 00:27:41,339
jugar con donde declaro las variables

632
00:27:41,339 --> 00:27:43,039
podría hacer un código

633
00:27:43,039 --> 00:27:45,259
en el cual todas las declaro aquí arriba

634
00:27:45,259 --> 00:27:47,079
todas, muy bien, no pasa nada

635
00:27:47,079 --> 00:27:49,000
están todas aquí arriba, pero hombre

636
00:27:49,000 --> 00:27:51,079
tengo durante todo el programa

637
00:27:51,079 --> 00:27:53,039
tengo un montón de variables que no estoy

638
00:27:53,039 --> 00:27:55,019
utilizando, entonces lo

639
00:27:55,019 --> 00:27:56,980
ideal es declarar

640
00:27:56,980 --> 00:27:58,740
las variables en el bloque

641
00:27:58,740 --> 00:28:00,000
más pequeño posible

642
00:28:00,000 --> 00:28:02,440
si yo esta variable m

643
00:28:02,440 --> 00:28:05,200
solo la utilizo aquí porque es una variable

644
00:28:05,200 --> 00:28:07,140
para hacer cositas que solo se hace aquí

645
00:28:07,140 --> 00:28:08,660
pues la declaro aquí

646
00:28:08,660 --> 00:28:10,559
¿para qué la voy a declarar aquí arriba?

647
00:28:11,119 --> 00:28:11,900
esta variable

648
00:28:11,900 --> 00:28:14,460
¿para qué la voy a declarar aquí?

649
00:28:14,960 --> 00:28:16,700
si solo la uso en este bloque de list

650
00:28:16,700 --> 00:28:18,980
para que esté ya la m viva

651
00:28:18,980 --> 00:28:21,099
todo el rato ahí ocupando

652
00:28:21,099 --> 00:28:23,140
memoria, pues no, la declaro

653
00:28:23,140 --> 00:28:24,059
aquí dentro y ya está

654
00:28:24,059 --> 00:28:29,910
¿vale? bueno pues

655
00:28:29,910 --> 00:28:32,230
tenemos por tanto

656
00:28:32,230 --> 00:28:33,490
que saber dos cosas, una

657
00:28:33,490 --> 00:28:35,470
principio básico de programación

658
00:28:35,470 --> 00:28:37,930
cuanto más locales

659
00:28:37,930 --> 00:28:40,349
sean las variables mejor, porque van a existir

660
00:28:40,349 --> 00:28:41,829
solo el tiempo que es necesario

661
00:28:41,829 --> 00:28:44,230
¿vale? entonces yo selecciono

662
00:28:44,230 --> 00:28:46,150
el código más pequeño en el que es obligatorio

663
00:28:46,150 --> 00:28:46,890
que estén, claro

664
00:28:46,890 --> 00:28:49,150
eso por un lado, y luego

665
00:28:49,150 --> 00:28:52,069
quedémonos con ese error

666
00:28:52,069 --> 00:28:53,950
cuando el compilador me dice

667
00:28:53,950 --> 00:28:55,650
oye, esta variable no es visible

668
00:28:55,650 --> 00:28:58,329
cuando me diga que esta variable no es visible

669
00:28:58,329 --> 00:29:00,170
rápidamente conectamos

670
00:29:00,170 --> 00:29:02,130
a esto, ah, es que la he declarado

671
00:29:02,130 --> 00:29:04,309
en un bloque pequeño

672
00:29:04,309 --> 00:29:06,109
y la tengo que sacar y declarar al bloque

673
00:29:06,109 --> 00:29:08,349
de arriba, porque la estoy usando

674
00:29:08,349 --> 00:29:10,069
aquí, entonces cuidado

675
00:29:10,069 --> 00:29:12,049
que la he declarado en un bloque demasiado pequeño

676
00:29:12,049 --> 00:29:14,049
saquemosla y declarémosla fuera

677
00:29:14,049 --> 00:29:15,910
para poder acceder yo aquí

678
00:29:15,910 --> 00:29:19,480
esas son las dos cosas esencialmente

679
00:29:19,480 --> 00:29:22,359
con las que tenemos que quedarnos por ahora

680
00:29:22,359 --> 00:29:26,660
en relación con el ámbito de las variables, ¿vale?

681
00:29:29,329 --> 00:29:34,890
Vamos a verlo con ejemplos.

682
00:29:57,650 --> 00:30:02,880
Vale, pues, a ver.

683
00:30:04,440 --> 00:30:06,700
En el proyecto de ejemplo de bucles,

684
00:30:07,039 --> 00:30:08,160
que volveré a subir,

685
00:30:08,960 --> 00:30:10,819
pues vamos a poner ejemplo de for.

686
00:30:29,130 --> 00:30:30,410
Vale, pues, por ejemplo,

687
00:30:31,210 --> 00:30:38,390
Vamos a leer 10 números decimales

688
00:30:38,390 --> 00:30:39,309
Por ejemplo

689
00:30:39,309 --> 00:30:42,190
Podrían decirme leer 10 números decimales

690
00:30:42,190 --> 00:30:43,170
Para hacer lo que sea

691
00:30:43,170 --> 00:31:05,900
Vale, entonces yo tengo que hacer 10 veces

692
00:31:05,900 --> 00:31:07,759
Esto de leer el numerito, ¿verdad?

693
00:31:08,359 --> 00:31:10,119
Tengo que hacer 10 veces esto

694
00:31:10,119 --> 00:31:12,000
Vale, pues entonces

695
00:31:12,000 --> 00:31:13,700
Desde el momento en que sé exactamente

696
00:31:13,700 --> 00:31:15,119
Las veces que tengo que hacer algo

697
00:31:15,119 --> 00:31:19,019
Pues ya me puedo hacer un bucle for directamente

698
00:31:19,019 --> 00:31:20,799
con esta sintaxis

699
00:31:20,799 --> 00:31:35,480
por ejemplo, este podría ser

700
00:31:35,480 --> 00:31:36,660
nuestro numerito

701
00:31:36,660 --> 00:31:53,130
vale, pues ya está

702
00:31:53,130 --> 00:31:55,710
esta es la sintaxis

703
00:31:55,710 --> 00:31:57,769
del for

704
00:31:57,769 --> 00:31:59,589
¿verdad? entonces lo vamos a leer

705
00:31:59,589 --> 00:32:21,880
vale, y esto se ejecutará

706
00:32:21,880 --> 00:32:23,759
a ver, voy a ponerle 3 para no tener que meter

707
00:32:23,759 --> 00:32:24,559
10 números

708
00:32:24,559 --> 00:32:27,200
le pongo 3

709
00:32:27,200 --> 00:32:29,000
y este bucle

710
00:32:29,000 --> 00:32:32,039
se va a ejecutar exactamente 3 veces

711
00:32:32,039 --> 00:32:33,779
esto ya es que

712
00:32:33,779 --> 00:32:35,200
la lectura ya no es muy natural

713
00:32:35,200 --> 00:32:40,309
porque esto significará, arrancando con i igual a 0

714
00:32:40,309 --> 00:32:42,990
y mientras i sea menor que 3

715
00:32:42,990 --> 00:32:45,890
e incrementando i en una unidad cada vez

716
00:32:45,890 --> 00:32:48,569
pues hace esto, eso que significa

717
00:32:48,569 --> 00:32:51,250
ejecútate 3 veces, si empiezas en 0

718
00:32:51,250 --> 00:32:55,630
te incrementas en una unidad cada vez y mientras i sea menor que 3

719
00:32:55,630 --> 00:32:58,490
pues se ejecutará

720
00:32:58,490 --> 00:33:00,390
para i igual a 0, 1 y 2

721
00:33:00,390 --> 00:33:03,779
¿vale? entonces

722
00:33:03,779 --> 00:33:09,359
aquí dentro

723
00:33:09,359 --> 00:33:11,460
podemos mostrar

724
00:33:11,460 --> 00:33:15,559
la variable i tranquilamente si queremos

725
00:33:15,559 --> 00:33:17,440
porque la variable i

726
00:33:17,440 --> 00:33:20,140
la hemos declarado aquí dentro

727
00:33:20,140 --> 00:33:23,519
y es una variable que existe y es accesible

728
00:33:23,519 --> 00:33:25,839
dentro de este código sin ningún problema

729
00:33:25,839 --> 00:33:29,579
¿no? por ejemplo este for me va a decir

730
00:33:29,579 --> 00:33:31,380
número 0

731
00:33:31,380 --> 00:33:33,519
y luego me pide el número

732
00:33:33,519 --> 00:33:35,039
número 1, número 2

733
00:33:35,039 --> 00:33:37,039
porque irá valiendo primero 0

734
00:33:37,039 --> 00:33:38,700
luego 1 y luego 2

735
00:33:38,700 --> 00:33:40,859
¿verdad? mi variable i

736
00:33:40,859 --> 00:33:43,039
la primera vez vale 0, la siguiente vale 1

737
00:33:43,039 --> 00:33:43,900
la siguiente vale 2

738
00:33:43,900 --> 00:33:47,079
y mi variable i yo la podría

739
00:33:47,079 --> 00:33:48,500
tocar aquí dentro y hacer con ellas

740
00:33:48,500 --> 00:33:51,000
mil cosas, bueno primero vamos a

741
00:33:51,000 --> 00:33:53,099
probar esto por si

742
00:33:53,099 --> 00:33:54,000
hemos escrito algo mal

743
00:33:54,000 --> 00:34:00,339
el número 0, pues este

744
00:34:00,339 --> 00:34:02,480
el número 1, este

745
00:34:02,480 --> 00:34:04,779
el número 2, este y ya está

746
00:34:04,779 --> 00:34:08,400
tres veces y acabó

747
00:34:08,400 --> 00:34:09,760
tres veces y acabó

748
00:34:09,760 --> 00:34:10,840
vale

749
00:34:10,840 --> 00:34:13,320
la variable i

750
00:34:13,320 --> 00:34:15,320
yo aquí puedo hacer con ella lo que me dé la gana

751
00:34:15,320 --> 00:34:17,280
es una variable más que está declarada

752
00:34:17,280 --> 00:34:17,980
en este bloque

753
00:34:17,980 --> 00:34:20,440
es una variable más

754
00:34:20,440 --> 00:34:23,300
por ejemplo

755
00:34:23,300 --> 00:34:26,579
¿qué podríamos hacer aquí para convertir a este

756
00:34:26,579 --> 00:34:28,579
bucle en un bucle infinito que no acabará nunca?

757
00:34:29,360 --> 00:34:30,480
¿qué sentencia puedo poner ahí?

758
00:34:34,019 --> 00:34:35,000
no, aquí mismo

759
00:34:35,000 --> 00:34:36,719
en donde yo estoy situada en este

760
00:34:36,719 --> 00:34:39,500
¿qué sentencia me sugerís

761
00:34:39,500 --> 00:34:41,280
para convertir este bucle en infinito?

762
00:34:41,900 --> 00:34:43,659
aquí, como última línea de código

763
00:34:43,659 --> 00:34:44,780
aquí

764
00:34:44,780 --> 00:34:48,849
¿qué podría escribir?

765
00:34:50,090 --> 00:34:52,170
claro, si la vuelvo a bajar otra vez

766
00:34:52,170 --> 00:34:53,190
entonces no avanzo

767
00:34:53,190 --> 00:34:56,269
porque i se va incrementando

768
00:34:56,269 --> 00:34:58,150
en cada iteración, pero yo aquí la vuelvo

769
00:34:58,150 --> 00:35:00,070
a bajar, con lo cual i no avanza

770
00:35:00,070 --> 00:35:01,269
jamás va a llegar a 3

771
00:35:01,269 --> 00:35:02,849
entonces este bucle

772
00:35:02,849 --> 00:35:05,829
se convertiría en un bucle

773
00:35:05,829 --> 00:35:08,190
ah bueno, es que le he metido

774
00:35:08,190 --> 00:35:10,130
una letra en vez de un número

775
00:35:10,130 --> 00:35:14,480
ahí se me queda hasta el infinito

776
00:35:14,480 --> 00:35:17,099
¿vale?

777
00:35:17,500 --> 00:35:20,139
entonces lo paro

778
00:35:20,139 --> 00:35:38,980
Cuando tenéis un programa que no para, acordaos que el proceso lo podéis detener aquí, ¿vale? Porque hay veces que habéis lanzado un programa un montón de veces porque no le funciona y lo volvéis a lanzar, no lo volvéis a lanzar y tenéis un montón de procesos ejecutándose.

779
00:35:38,980 --> 00:35:40,400
habéis lanzado un programa un montón de veces

780
00:35:40,400 --> 00:35:41,719
y que el programa no termina

781
00:35:41,719 --> 00:35:43,039
entonces

782
00:35:43,039 --> 00:35:45,559
cuidado

783
00:35:45,559 --> 00:35:47,860
para ver uno

784
00:35:47,860 --> 00:35:50,519
los programas que tiene lanzados

785
00:35:50,519 --> 00:35:53,440
si le dais aquí

786
00:35:53,440 --> 00:35:55,139
por ejemplo

787
00:35:55,139 --> 00:35:56,320
voy a lanzar

788
00:35:56,320 --> 00:35:58,079
este no ha terminado porque es imposible

789
00:35:58,079 --> 00:36:01,199
y sé que no ha terminado porque me aparece

790
00:36:01,199 --> 00:36:01,820
esto en rojo

791
00:36:01,820 --> 00:36:04,000
y podría lanzar otra vez

792
00:36:04,000 --> 00:36:04,219
este

793
00:36:04,219 --> 00:36:08,360
ala, otro lanjao que tengo aquí

794
00:36:08,360 --> 00:36:12,679
Y digo, uy, he cambiado una cosa

795
00:36:12,679 --> 00:36:14,400
He cambiado una cosa

796
00:36:14,400 --> 00:36:15,320
Voy a poner dos puntos

797
00:36:15,320 --> 00:36:17,019
Voy a volver a probarlo

798
00:36:17,019 --> 00:36:18,500
Y lo lanzo otra vez

799
00:36:18,500 --> 00:36:23,389
Otro, un tercer proceso que se está ejecutando

800
00:36:23,389 --> 00:36:26,530
Hombre, evitemos esto

801
00:36:26,530 --> 00:36:30,230
Vale, ahora mismo tengo tres procesos lanzados

802
00:36:30,230 --> 00:36:33,190
¿Cómo podemos pararlos?

803
00:36:33,449 --> 00:36:34,630
Este lo puedo parar así

804
00:36:34,630 --> 00:36:37,889
Pero, si le vais dando aquí

805
00:36:37,889 --> 00:36:39,090
A estas dos X de aquí

806
00:36:39,090 --> 00:36:42,570
te van resucitando los otros que tenías ahí parados

807
00:36:42,570 --> 00:36:44,010
o sea, que tenías ahí lanzados

808
00:36:44,010 --> 00:36:45,369
ahora voy a parar este

809
00:36:45,369 --> 00:36:47,849
¿tengo algún otro? uy, sí, tengo otro

810
00:36:47,849 --> 00:36:49,130
ahora lo voy a parar

811
00:36:49,130 --> 00:36:51,429
¿tengo algún otro? no, ya no tengo nada

812
00:36:51,429 --> 00:36:54,130
¿vale? cuidado con cuando lanzáis

813
00:36:54,130 --> 00:36:56,070
programas que tienen bucles infinitos

814
00:36:56,070 --> 00:36:57,050
o lecturas a menú

815
00:36:57,050 --> 00:36:58,690
y siguen ahí esperando

816
00:36:58,690 --> 00:37:02,030
no tengáis mil ejecuciones lanzadas a la vez

817
00:37:02,030 --> 00:37:04,570
porque llega un momento en que no sabéis en qué ejecución estáis

818
00:37:04,570 --> 00:37:06,369
y creéis que estáis ejecutando

819
00:37:06,369 --> 00:37:07,730
un código y estáis ejecutando otro

820
00:37:07,730 --> 00:37:10,980
¿vale?

821
00:37:11,300 --> 00:37:59,269
Entonces, dime, ¿puede haber cualquier cosa que sea una condición? Por ejemplo, imaginaos que el programa se modifica y me dicen ahora, introduce 10 números decimales, pero cuidado, si el número es 0, para.

822
00:37:59,269 --> 00:38:02,750
No hagas más, o sea, 10 siempre y cuando sean diferentes de 0

823
00:38:02,750 --> 00:38:04,650
¿Vale? Vamos a ponerlo aquí

824
00:38:04,650 --> 00:38:20,090
Versión en la que introduzco 3 números

825
00:38:20,090 --> 00:38:29,800
3 números decimales, pero si se introduce 0 se para

826
00:38:29,800 --> 00:38:39,400
¿Vale? Entonces aquí van a ser 10, pero si es 0 para

827
00:38:39,400 --> 00:38:41,880
Entonces podemos meter esto en esta condición

828
00:38:41,880 --> 00:38:47,869
Entonces, por ejemplo, esta versión

829
00:38:47,869 --> 00:38:50,250
Pues la podríamos hacer

830
00:38:50,250 --> 00:38:54,989
con esto leemos los tres números

831
00:38:54,989 --> 00:38:56,809
está claro, pero espérate

832
00:38:56,809 --> 00:38:57,889
si el número

833
00:38:57,889 --> 00:39:00,710
es cero

834
00:39:00,710 --> 00:39:02,670
quiero parar, entonces la condición

835
00:39:02,670 --> 00:39:04,710
para seguir, ahora la puedo

836
00:39:04,710 --> 00:39:06,110
modificar para que sea

837
00:39:06,110 --> 00:39:08,570
no solo si es menor que tres, sino que

838
00:39:08,570 --> 00:39:09,869
tiene que ser menor que tres

839
00:39:09,869 --> 00:39:11,349
y además

840
00:39:11,349 --> 00:39:13,849
el número leído

841
00:39:13,849 --> 00:39:17,929
que sea diferente de

842
00:39:17,929 --> 00:39:18,849
cero

843
00:39:18,849 --> 00:39:20,530
vale

844
00:39:20,530 --> 00:39:24,989
entonces

845
00:39:24,989 --> 00:39:28,349
aquí esta condición es más compleja

846
00:39:28,349 --> 00:39:30,369
este bucle

847
00:39:30,369 --> 00:39:31,489
se va a ejecutar

848
00:39:31,489 --> 00:39:34,110
una vez, otra vez, otra vez

849
00:39:34,110 --> 00:39:36,690
y así, mientras si sea menor que 3

850
00:39:36,690 --> 00:39:38,329
pero también es obligatorio

851
00:39:38,329 --> 00:39:39,630
que num sea diferente de 0

852
00:39:39,630 --> 00:39:42,210
si en algún momento yo meto el número 0 ya se para

853
00:39:42,210 --> 00:39:43,969
vale

854
00:39:43,969 --> 00:39:46,230
aquí claro me sale el error

855
00:39:46,230 --> 00:39:48,329
de compilación que me dice, oye num podría no tener

856
00:39:48,329 --> 00:39:50,050
nada, no pasa nada

857
00:39:50,050 --> 00:39:52,630
Lo vamos a inicializar a un valor cualquiera

858
00:39:52,630 --> 00:39:56,210
Para forzarle a entrar en el bucle

859
00:39:56,210 --> 00:39:59,329
Lo inicializamos a un valor cualquiera

860
00:39:59,329 --> 00:40:01,070
Y así entra en el bucle

861
00:40:01,070 --> 00:40:02,309
Entra la primera vez

862
00:40:02,309 --> 00:40:07,550
Si no hemos terminado todavía

863
00:40:07,550 --> 00:40:09,250
Y además num no es cero

864
00:40:09,250 --> 00:40:10,389
Entra la segunda

865
00:40:10,389 --> 00:40:14,010
Si todavía no hemos terminado

866
00:40:14,010 --> 00:40:16,269
Y num sigue sin ser cero

867
00:40:16,269 --> 00:40:17,230
Entra la tercera

868
00:40:17,230 --> 00:40:25,260
Luego efectivamente en estos campos de aquí

869
00:40:25,260 --> 00:40:29,460
Uno puede poner cualquier cosa que le interese

870
00:40:29,460 --> 00:40:31,000
Para hacer lo que tiene que hacer

871
00:40:31,000 --> 00:40:46,500
Por ejemplo, muchos de los enunciados que hemos hecho

872
00:40:46,500 --> 00:40:50,260
Pues habrían sido a lo mejor más legibles

873
00:40:50,260 --> 00:40:52,519
Más claros de hacer con un for

874
00:40:52,519 --> 00:40:56,699
Pero en lugar de volver a hacer esos

875
00:40:56,699 --> 00:41:00,480
Vamos a buscar alguno para hacerlo con un for

876
00:41:00,480 --> 00:41:09,840
vale, por ejemplo

877
00:41:09,840 --> 00:41:12,260
el 10

878
00:41:12,260 --> 00:41:14,920
esto, el 9 y el 10

879
00:41:14,920 --> 00:41:15,980
tenían ya que ver

880
00:41:15,980 --> 00:41:18,400
con el concepto de acumulador, ¿verdad?

881
00:41:19,659 --> 00:41:20,320
estos dos

882
00:41:20,320 --> 00:41:21,800
estos tres primeros

883
00:41:21,800 --> 00:41:24,760
eran una suma acumulativa

884
00:41:24,760 --> 00:41:26,380
y este será

885
00:41:26,380 --> 00:41:28,599
un producto acumulativo, que es lo que

886
00:41:28,599 --> 00:41:30,639
dijimos ayer, que fuerais haciendo

887
00:41:30,639 --> 00:41:32,400
vale, pues este primero

888
00:41:32,400 --> 00:41:36,139
esto se tiene que hacer exactamente

889
00:41:36,139 --> 00:41:38,639
10 veces, ¿el qué? el ir multiplicando

890
00:41:38,639 --> 00:41:39,519
por un acumulador

891
00:41:39,519 --> 00:41:42,639
pues venga, tratad de pensar el 10

892
00:41:42,639 --> 00:41:44,400
de hacer el 10 con un

893
00:41:44,400 --> 00:41:46,559
con un for, en lugar de, no sé si

894
00:41:46,559 --> 00:41:48,559
lo habéis hecho o no, pero si

895
00:41:48,559 --> 00:41:50,000
no lo habéis hecho, hacedlo

896
00:41:50,000 --> 00:41:52,239
y en lugar de con un while, con un for

897
00:41:52,239 --> 00:41:54,659
¿vale? idealmente

898
00:41:54,659 --> 00:41:56,719
tanto el 9 como el 10, el que no lo haya hecho

899
00:41:56,719 --> 00:41:58,579
que lo trate de hacer

900
00:41:58,579 --> 00:42:00,219
pero en lugar de con un while, con un for

901
00:42:00,219 --> 00:42:02,260
¿vale? el 9 y el 10, y ahora

902
00:42:02,260 --> 00:42:04,360
antes de irnos lo...