1
00:00:01,260 --> 00:00:37,320
Vale, pues a ver, el ejercicio 9 dice, obtener a elevado a b, lo primero que hay que entender es que es a elevado a b, pero todos sabemos que a elevado a b es a por a por a b veces, entonces, todos sabemos que lo que tenemos que hacer es esto, que el resultado ya sabemos que va a ser igual a a por a y así, eso es lo que tenemos que hacer.

2
00:00:37,320 --> 00:00:41,939
Entonces, esto es lo mismo que hacer una suma de muchos sumandos,

3
00:00:42,240 --> 00:00:46,359
pero aquí es una multiplicación de muchos factores.

4
00:00:46,920 --> 00:00:48,219
Es la única diferencia.

5
00:00:48,799 --> 00:00:52,659
En lugar de ser una suma de muchos sumandos, es una multiplicación de muchos factores.

6
00:00:52,659 --> 00:01:03,039
Entonces, si quisiéramos hacer esto, a más a más a esto b veces,

7
00:01:04,260 --> 00:01:07,079
esto lo sabríamos hacer rápidamente.

8
00:01:07,319 --> 00:01:09,939
Porque es una suma de muchos humanos

9
00:01:09,939 --> 00:01:12,459
Entonces pediríamos primero los datos

10
00:01:12,459 --> 00:01:13,859
Pues venga

11
00:01:13,859 --> 00:01:14,819
Vamos a pedir

12
00:01:14,819 --> 00:01:18,920
Los datos

13
00:01:18,920 --> 00:01:23,980
Pediríamos primero los datos

14
00:01:23,980 --> 00:01:26,920
Bueno, ni pongo el mensajito

15
00:01:26,920 --> 00:01:29,099
A igual a

16
00:01:29,099 --> 00:01:36,439
Y B igual a

17
00:01:36,439 --> 00:01:37,239
Esto

18
00:01:37,239 --> 00:01:46,680
Vale, ya están los datos

19
00:01:46,680 --> 00:01:48,560
Entonces si el ejercicio fuera hacer esto

20
00:01:48,560 --> 00:01:49,840
A más A más A más A

21
00:01:49,840 --> 00:01:52,840
Ya sabríamos lo que tenemos que hacer

22
00:01:52,840 --> 00:01:53,579
Tenemos que

23
00:01:53,579 --> 00:01:56,439
Hacer una suma de muchos sumandos

24
00:01:56,439 --> 00:01:58,920
Pues una variable suma

25
00:01:58,920 --> 00:02:02,219
Para guardarlos todos

26
00:02:02,219 --> 00:02:03,780
Ahora

27
00:02:03,780 --> 00:02:09,280
Para poder hacer la suma de muchos sumandos

28
00:02:09,280 --> 00:02:10,159
Es que no hay otra

29
00:02:10,159 --> 00:02:11,400
Es esto

30
00:02:11,400 --> 00:02:15,810
Vale, ahora, los sumandos

31
00:02:15,810 --> 00:02:18,449
Los x, ¿cómo los generamos?

32
00:02:19,310 --> 00:02:21,270
Pues los sumandos son todo el rato

33
00:02:21,270 --> 00:02:23,469
A y A y A y A

34
00:02:23,469 --> 00:02:25,550
Pues entonces x lo inicializo valiendo A

35
00:02:25,550 --> 00:02:26,530
Y A no lo cambio

36
00:02:26,530 --> 00:02:27,870
A no lo cambio

37
00:02:27,870 --> 00:02:30,270
a no se cambia

38
00:02:30,270 --> 00:02:31,990
con lo cual este bucle está haciendo

39
00:02:31,990 --> 00:02:34,610
a más a más a más a más a

40
00:02:34,610 --> 00:02:36,090
así hasta el infinito

41
00:02:36,090 --> 00:02:38,669
claro, no queremos que sea hasta el infinito

42
00:02:38,669 --> 00:02:40,430
queremos que haga

43
00:02:40,430 --> 00:02:42,430
esta iteración

44
00:02:42,430 --> 00:02:44,270
b veces, que este bucle

45
00:02:44,270 --> 00:02:45,949
se ejecute solo b veces

46
00:02:45,949 --> 00:02:48,270
solamente b, entonces nos falta

47
00:02:48,270 --> 00:02:49,289
poner una condición

48
00:02:49,289 --> 00:02:52,129
para que forzara que este bucle

49
00:02:52,129 --> 00:02:53,930
se ejecute solo b veces

50
00:02:53,930 --> 00:02:56,110
vale, pues entonces

51
00:02:56,110 --> 00:02:59,129
Como ya sabemos contar

52
00:02:59,129 --> 00:03:01,930
Lo que tenemos es que contar aquí

53
00:03:01,930 --> 00:03:04,550
Para averiguar cuando hemos llegado

54
00:03:04,550 --> 00:03:06,569
A la iteración número B

55
00:03:06,569 --> 00:03:07,870
Ah, pero ya sabemos contar

56
00:03:07,870 --> 00:03:09,990
Pues, ¿y cómo contamos?

57
00:03:10,069 --> 00:03:11,229
Nos hacemos un contador

58
00:03:11,229 --> 00:03:14,860
¿Vale?

59
00:03:15,919 --> 00:03:17,300
¿Cómo funciona el contador?

60
00:03:17,439 --> 00:03:20,000
El contador lo incrementamos de uno en uno

61
00:03:20,000 --> 00:03:20,879
En cada iteración

62
00:03:20,879 --> 00:03:23,860
De forma que este contador lo va contando

63
00:03:23,860 --> 00:03:25,780
La primera suma que se hace, uno

64
00:03:25,780 --> 00:03:28,060
La siguiente suma que se hace, dos

65
00:03:28,060 --> 00:03:29,479
la siguiente suma 3

66
00:03:29,479 --> 00:03:32,479
es un contador de las sumas que voy haciendo

67
00:03:32,479 --> 00:03:34,419
pues entonces ahora ya sí

68
00:03:34,419 --> 00:03:35,099
podemos hacer

69
00:03:35,099 --> 00:03:37,419
mientras cont sea menor que b

70
00:03:37,419 --> 00:03:40,520
porque la primera iteración

71
00:03:40,520 --> 00:03:41,180
será la 0

72
00:03:41,180 --> 00:03:44,240
y se quedará valiendo 1

73
00:03:44,240 --> 00:03:46,020
la siguiente iteración será la 1

74
00:03:46,020 --> 00:03:47,180
y se quedará valiendo 2

75
00:03:47,180 --> 00:03:49,319
en la iteración b

76
00:03:49,319 --> 00:03:51,479
se quedará valiendo b más 1

77
00:03:51,479 --> 00:03:52,639
ahí ya quiero que salga

78
00:03:52,639 --> 00:03:57,370
pues si el ejercicio fuera

79
00:03:57,370 --> 00:03:58,969
a más a más a más a

80
00:03:58,969 --> 00:04:00,189
sería este

81
00:04:00,210 --> 00:04:26,410
Ya está. ¿Está claro? Vale. Pero resulta que no es a más a más a. Es casi lo mismo. Es a por a por a por a. Pues no pasa nada. Cambio la operación. La cambio de más a por y entonces se convierte en a por a por a por a por a por a.

82
00:04:26,410 --> 00:04:27,870
pero claro, ¿qué cambia?

83
00:04:28,350 --> 00:04:30,290
el valor inicial de suma

84
00:04:30,290 --> 00:04:32,129
porque cuando yo voy acumulando una suma

85
00:04:32,129 --> 00:04:34,990
el inicial sobre el que acumulo, la caja tiene que estar vacía

86
00:04:34,990 --> 00:04:36,649
cero, ahora sumo esto

87
00:04:36,649 --> 00:04:39,149
ahora sumo esto, pero cuando voy multiplicando

88
00:04:39,149 --> 00:04:40,889
claro, la primera

89
00:04:40,889 --> 00:04:42,829
multiplicación se tiene que hacer por uno

90
00:04:42,829 --> 00:04:44,730
que es el elemento neutro de la multiplicación

91
00:04:44,730 --> 00:04:45,829
para que no se afecte

92
00:04:45,829 --> 00:04:47,790
entonces lo único que cambia ahora sea esto

93
00:04:47,790 --> 00:04:50,290
hombre, y así cambio el nombre de la variable mejor

94
00:04:50,290 --> 00:04:55,689
porque llamarse suma es muy feo

95
00:04:55,689 --> 00:04:56,529
mult

96
00:04:56,529 --> 00:04:58,850
si la cambio ya, mucho mejor

97
00:04:58,850 --> 00:05:08,879
Vale, pues ya hemos conseguido el efecto de hacer b multiplicaciones

98
00:05:08,879 --> 00:05:10,620
Gracias a que hemos puesto un contador

99
00:05:10,620 --> 00:05:14,980
Que empieza valiendo 0, lo voy incrementando

100
00:05:14,980 --> 00:05:18,180
Y cuando ya ha rebasado el b, salgo

101
00:05:18,180 --> 00:05:21,000
¿Y qué voy haciendo estas multiplicaciones?

102
00:05:28,899 --> 00:05:30,259
Porque lo he empezado en 0

103
00:05:30,259 --> 00:05:32,339
Haz las cuentas y veas cómo salen

104
00:05:32,339 --> 00:05:36,879
Es decir, entra valiendo 0 para la multiplicación número 1

105
00:05:36,879 --> 00:05:39,660
con lo cual entrará valiendo

106
00:05:39,660 --> 00:05:41,480
b menos 1 para la multiplicación b

107
00:05:41,480 --> 00:05:42,480
que es la última

108
00:05:42,480 --> 00:05:45,079
entonces quieres entrar para b menos 1

109
00:05:45,079 --> 00:05:47,100
para b ya no quieres entrar

110
00:05:47,100 --> 00:05:50,120
porque si entrabas para b estaría haciendo una multiplicación de más

111
00:05:50,120 --> 00:05:52,459
a ver, si yo cambio contador

112
00:05:52,459 --> 00:05:53,720
empiezo mi cuenta en 1

113
00:05:53,720 --> 00:05:55,480
entonces aquí ya pongo menor o igual

114
00:05:55,480 --> 00:05:57,920
pero normalmente las cuentas

115
00:05:57,920 --> 00:05:59,500
se empiezan en 0

116
00:05:59,500 --> 00:06:02,100
entonces este bucle se va a hacer

117
00:06:02,100 --> 00:06:04,079
exactamente b veces

118
00:06:04,079 --> 00:06:06,100
empezando en 0

119
00:06:06,100 --> 00:06:08,000
con la condición estrictamente menor

120
00:06:08,000 --> 00:06:09,699
¿vale?

121
00:06:09,800 --> 00:06:11,360
con la condición estrictamente menor

122
00:06:11,360 --> 00:06:13,360
entonces es importante entender

123
00:06:13,360 --> 00:06:16,019
un segundinín, Adrián, que este bucle

124
00:06:16,019 --> 00:06:17,399
se va a

125
00:06:17,399 --> 00:06:19,339
ejecutar

126
00:06:19,339 --> 00:06:21,939
b veces, porque el contador

127
00:06:21,939 --> 00:06:22,920
ha empezado a cero

128
00:06:22,920 --> 00:06:25,879
y la condición es mientras sea menor que b

129
00:06:25,879 --> 00:06:27,779
se ejecutará para cero

130
00:06:27,779 --> 00:06:29,540
para uno, para dos, para tres

131
00:06:29,540 --> 00:06:31,379
y así hasta para b menos uno

132
00:06:31,379 --> 00:06:32,959
un total de b veces

133
00:06:32,959 --> 00:06:34,779
para la vez b no

134
00:06:34,779 --> 00:06:37,199
Adrián, ¿qué querías tú preguntar?

135
00:06:41,360 --> 00:06:44,220
Claro, esta es mi versión que yo he hecho

136
00:06:44,220 --> 00:06:46,060
la versión robótica, llamémosle así

137
00:06:46,060 --> 00:06:49,980
ahora ya podemos decir, bueno, pues efectivamente la variable x

138
00:06:49,980 --> 00:06:53,420
la estoy usando solamente para guardar el valor de a

139
00:06:53,420 --> 00:06:56,879
y la uso tal cual, luego no la modifico

140
00:06:56,879 --> 00:06:59,240
no hago nada con ella, pues efectivamente

141
00:06:59,240 --> 00:07:02,300
esta variable adicional x no me haría falta

142
00:07:02,300 --> 00:07:04,120
multiplico por ahí y se acabó

143
00:07:04,120 --> 00:07:12,660
vale, es decir, ahora podríamos simplificar y decir, hombre

144
00:07:12,660 --> 00:07:17,000
voy a simplificar y esto mismo de aquí

145
00:07:17,000 --> 00:07:20,959
pues sería, si yo multiplico directamente por A y quito esto

146
00:07:20,959 --> 00:07:27,360
verdad, sería lo mismo, quito esto y multiplico por A y ya está

147
00:07:27,360 --> 00:07:33,170
vale, si lo dejo aquí comentado, entonces

148
00:07:33,170 --> 00:07:36,870
en lugar de esta versión, pues esta me ahorra una variable

149
00:07:36,870 --> 00:07:38,449
mult

150
00:07:38,449 --> 00:07:43,050
igual a mult

151
00:07:43,050 --> 00:07:46,800
por a

152
00:07:46,800 --> 00:07:48,639
y ya está

153
00:07:48,639 --> 00:07:51,339
y ya me ahorro la variable x

154
00:07:51,339 --> 00:07:52,300
pero estoy haciendo lo mismo

155
00:07:52,300 --> 00:07:56,459
vale, de aquí lo interesante

156
00:07:56,459 --> 00:07:58,459
es que

157
00:07:58,459 --> 00:08:05,930
que nos va a permitir

158
00:08:05,930 --> 00:08:07,689
esta estructura introducir

159
00:08:07,689 --> 00:08:09,529
una sintaxis del bucle while

160
00:08:09,529 --> 00:08:11,889
de los bucles que va a ser más cómoda

161
00:08:11,889 --> 00:08:12,870
para situaciones como estas

162
00:08:12,870 --> 00:08:15,750
Lo que pasa es que voy a necesitar un rotulador

163
00:08:15,750 --> 00:08:20,120
El ejemplo que acabamos de hacer

164
00:08:20,120 --> 00:08:22,279
Era para hacer la multiplicación

165
00:08:22,279 --> 00:08:25,420
La potencia de A elevado a B

166
00:08:25,420 --> 00:08:26,540
Y para eso hemos hecho

167
00:08:26,540 --> 00:08:33,460
Nuestra variable multiplicadora

168
00:08:33,460 --> 00:08:36,279
Que empezaba valiendo 1

169
00:08:36,279 --> 00:08:40,309
Luego hemos hecho un contador

170
00:08:40,309 --> 00:08:42,690
Para contar la cantidad de veces

171
00:08:42,690 --> 00:08:43,870
Que se ejecuta el bucle

172
00:08:43,870 --> 00:08:45,929
Y ahora hemos hecho

173
00:08:45,929 --> 00:08:51,529
mientras ese contador sea menor que b

174
00:08:51,529 --> 00:09:02,419
hemos incorporado en multiplicación esta operación

175
00:09:02,419 --> 00:09:06,919
lo hemos multiplicado por a y el resultado lo hemos vuelto a guardar en multiplicación

176
00:09:06,919 --> 00:09:08,000
es la operación que hemos hecho

177
00:09:08,000 --> 00:09:10,340
y hemos incrementado contador

178
00:09:10,340 --> 00:09:15,740
hemos incrementado contador para contar una iteración más

179
00:09:16,700 --> 00:09:24,779
Entonces, esta variable contadora está solo, su único uso es contar la cantidad de veces que se ejecuta esto, nada más.

180
00:09:25,259 --> 00:09:28,320
Ni forma parte del resultado, ni hace nada.

181
00:09:28,639 --> 00:09:32,480
El resultado se va construyendo solamente con la a y la propia mult, claro.

182
00:09:33,120 --> 00:09:34,379
Esta está solo para contar.

183
00:09:35,440 --> 00:09:41,000
Vale, pues hay una situación que se nos puede dar muchas veces, que es exactamente esta,

184
00:09:41,000 --> 00:09:43,200
que es un bucle que yo sé

185
00:09:43,200 --> 00:09:44,940
de partida la cantidad

186
00:09:44,940 --> 00:09:46,500
de veces que quiero que se ejecute.

187
00:09:47,080 --> 00:09:48,940
Como es este caso, ¿no? En este caso

188
00:09:48,940 --> 00:09:50,379
nosotros sabíamos de partida

189
00:09:50,379 --> 00:10:00,960
que el bucle se tiene que ejecutar

190
00:10:00,960 --> 00:10:01,679
B veces.

191
00:10:16,129 --> 00:10:18,230
Vale, entonces, esto no ocurre siempre

192
00:10:18,230 --> 00:10:20,389
que nosotros sepamos de partida la cantidad

193
00:10:20,389 --> 00:10:21,649
de veces que se va a ejecutar un bucle.

194
00:10:22,029 --> 00:10:24,289
Por ejemplo, en el programa en el que

195
00:10:24,289 --> 00:10:26,370
hacíamos un bucle, en el que le estábamos

196
00:10:26,370 --> 00:10:28,210
pidiendo al usuario números

197
00:10:28,210 --> 00:10:30,309
todo el rato hasta que introduciera

198
00:10:30,309 --> 00:10:32,730
no positivo. Era imposible

199
00:10:32,730 --> 00:10:34,529
saber cuántas veces se iba a ejecutar.

200
00:10:35,350 --> 00:10:36,309
Las que tarden meten

201
00:10:36,309 --> 00:10:38,330
el positivo. Si tarda 20 veces, pues

202
00:10:38,330 --> 00:10:40,330
20 se va a ejecutar. Si mete el

203
00:10:40,330 --> 00:10:42,710
positivo a la primera, pues una se va a ejecutar.

204
00:10:43,210 --> 00:10:44,330
Entonces hay situaciones en las cuales

205
00:10:44,330 --> 00:10:46,269
de partida no se puede saber cuántas veces

206
00:10:46,269 --> 00:10:47,850
se va a ejecutar. Depende de la ejecución.

207
00:10:48,850 --> 00:10:50,190
Bueno, pero hay otras situaciones en las que

208
00:10:50,190 --> 00:10:52,110
si se sabe, era esta.

209
00:10:52,590 --> 00:10:53,830
Esta era uno de esos ejemplos.

210
00:10:54,409 --> 00:10:56,490
Nosotros sabemos que este bucle, sí o sí,

211
00:10:57,110 --> 00:10:58,169
se va a ejecutar

212
00:10:58,169 --> 00:10:59,269
estas veces.

213
00:11:00,309 --> 00:11:14,450
Y eso lo sabemos sí o sí, independientemente de la ejecución, se va a ejecutar B, ¿vale? Para eso hemos tenido que hacernos este mecanismo, un contador que se va incrementando y mientras sea menor que B se ejecuta.

214
00:11:15,129 --> 00:11:17,269
Vale, pues como eso es algo que ocurre a menudo,

215
00:11:18,129 --> 00:11:20,570
que uno identifique que tiene que hacer un bucle de sentencias,

216
00:11:20,750 --> 00:11:23,649
que sabe de partida cuántas veces va a ejecutar,

217
00:11:24,289 --> 00:11:26,389
pues hay una sintaxis para expresar eso

218
00:11:26,389 --> 00:11:29,450
que me simplifica las líneas de código, sin más,

219
00:11:29,549 --> 00:11:31,149
porque me incorpora dentro el contador.

220
00:11:31,610 --> 00:11:32,830
Y como me lo incorpora dentro,

221
00:11:33,570 --> 00:11:35,590
no tenemos que ponerlo fuera nosotros,

222
00:11:36,409 --> 00:11:38,470
que es la sintaxis for, ¿vale?

223
00:11:42,639 --> 00:11:46,320
Entonces, el bucle for es otra forma de expresar el way,

224
00:11:46,320 --> 00:11:47,179
es otra forma.

225
00:11:47,940 --> 00:11:57,279
¿Vale? Es otra manera, pero me facilita la escritura de código en bucles en los que yo sé de partida cuántas veces se va a ejecutar.

226
00:11:58,600 --> 00:12:00,879
¿Vale? Entonces, ¿cuál es la sintaxis del bucle for?

227
00:12:02,019 --> 00:12:17,000
Vale, pues la sintaxis del bucle for, vamos a ponerlo aquí más cerquita, la sintaxis del bucle for es esta.

228
00:12:17,000 --> 00:12:21,320
Empezamos con for

229
00:12:21,320 --> 00:12:24,779
Paréntesis que se abren y se cierran

230
00:12:24,779 --> 00:12:27,059
Y aquí tres campitos

231
00:12:27,059 --> 00:12:28,460
Que ahora vemos lo que significa

232
00:12:28,460 --> 00:12:29,659
Separados por punto y coma

233
00:12:29,659 --> 00:12:32,240
Sí

234
00:12:32,240 --> 00:12:35,460
Que uno se queda vacío

235
00:12:35,460 --> 00:12:36,720
Porque no tiene nada que poner

236
00:12:36,720 --> 00:12:37,960
Se queda vacío

237
00:12:37,960 --> 00:12:39,679
Pero los dos puntos y comas se quedan ahí

238
00:12:39,679 --> 00:12:41,440
Separando los tres campos

239
00:12:41,440 --> 00:12:44,340
Y aquí entre llaves

240
00:12:44,340 --> 00:12:45,659
Las sentencias que se repiten

241
00:12:45,659 --> 00:12:46,360
Igual que el while

242
00:12:46,360 --> 00:12:47,940
Aquí las mismas sentencias

243
00:12:47,940 --> 00:12:51,779
no, no se puede

244
00:12:51,779 --> 00:12:54,539
no se puede, tiene tres

245
00:12:54,539 --> 00:12:56,139
porque cada una tiene un uso concreto

246
00:12:56,139 --> 00:12:58,860
vale, pues que se ponen

247
00:12:58,860 --> 00:13:00,940
estas casillitas, si es que quieres poner algo

248
00:13:00,940 --> 00:13:02,500
vale

249
00:13:02,500 --> 00:13:04,720
la casilla del medio es la más

250
00:13:04,720 --> 00:13:05,700
fácil de entender

251
00:13:05,700 --> 00:13:08,980
en la casilla del medio se pone la condición

252
00:13:08,980 --> 00:13:11,019
que mientras se repita

253
00:13:11,019 --> 00:13:12,559
entras en el bucle

254
00:13:12,559 --> 00:13:14,480
es decir, la que en el while poníamos aquí

255
00:13:14,480 --> 00:13:15,720
vale

256
00:13:15,720 --> 00:13:18,019
entonces aquí se pone la condición

257
00:13:18,019 --> 00:13:22,440
luego un for

258
00:13:22,440 --> 00:13:24,460
con estas dos cosas vacías

259
00:13:24,460 --> 00:13:25,980
y ahí la condición

260
00:13:25,980 --> 00:13:28,059
es lo mismo que un while

261
00:13:28,059 --> 00:13:29,440
entonces si yo hago un bucle for

262
00:13:29,440 --> 00:13:30,899
hago este bucle for así

263
00:13:30,899 --> 00:13:34,120
vaya rotuz que me ha dado

264
00:13:34,120 --> 00:13:35,759
vale

265
00:13:35,759 --> 00:13:37,779
mi programa

266
00:13:37,779 --> 00:13:38,779
este

267
00:13:38,779 --> 00:13:43,850
int mult

268
00:13:43,850 --> 00:13:45,830
igual a 1

269
00:13:45,830 --> 00:13:48,649
int cont

270
00:13:48,649 --> 00:13:50,350
igual a 0

271
00:13:50,350 --> 00:13:52,009
y aquí

272
00:13:52,009 --> 00:13:58,279
mult for igual a

273
00:13:58,279 --> 00:14:00,639
y cont más más

274
00:14:00,639 --> 00:14:03,779
este código

275
00:14:03,779 --> 00:14:08,929
y el código de al lado son idénticos

276
00:14:08,929 --> 00:14:09,870
son idénticos

277
00:14:09,870 --> 00:14:13,029
porque esto es un bucle que se va a ejecutar

278
00:14:13,029 --> 00:14:14,809
mientras esta condición se acierta

279
00:14:14,809 --> 00:14:16,269
luego es igual

280
00:14:16,269 --> 00:14:18,570
¿qué ocurre? que el for me permite

281
00:14:18,570 --> 00:14:20,710
si yo quiero utilizar

282
00:14:20,710 --> 00:14:22,809
estos dos campos para meter dos cosas adicionales

283
00:14:23,690 --> 00:14:24,370
¿vale?

284
00:14:26,429 --> 00:14:29,789
A ver, lo que se mete aquí, ¿qué tiene que ser?

285
00:14:30,590 --> 00:14:33,889
Lo que se mete aquí es lo que a mí me dé la gana,

286
00:14:34,490 --> 00:14:36,870
pero tienen que ser sentencias de Java, válidas.

287
00:14:37,230 --> 00:14:37,889
Una o muchas.

288
00:14:39,149 --> 00:14:43,779
Yo ahí meto sentencias que se van a ejecutar

289
00:14:43,779 --> 00:14:48,220
solo una vez cuando el bucle arranca.

290
00:14:51,360 --> 00:14:53,639
Es decir, que se ejecutan al arrancar el bucle.

291
00:14:55,820 --> 00:14:58,039
Y solo una vez, solo la primera vez que entras,

292
00:14:58,120 --> 00:14:59,600
no las siguientes, las siguientes no.

293
00:14:59,600 --> 00:15:06,620
O sea, por ejemplo, una suma se ejecuta cada vez que pasa esto.

294
00:15:06,620 --> 00:15:08,539
No, que se ejecuta solo una vez.

295
00:15:08,639 --> 00:15:09,299
La primera vez que entra.

296
00:15:09,399 --> 00:15:10,480
Las siete instalaciones ya no.

297
00:15:11,399 --> 00:15:13,039
Como si fuera una inicialización.

298
00:15:13,960 --> 00:15:16,740
¿Lo primero es para que solo se hace una vez?

299
00:15:16,919 --> 00:15:17,899
¿Solo se hace una vez?

300
00:15:18,220 --> 00:15:19,240
O sea, tú vienes por aquí.

301
00:15:20,139 --> 00:15:20,779
Empieza el for.

302
00:15:21,039 --> 00:15:23,000
Lo primero que se hace es ejecutar lo que hay aquí.

303
00:15:23,759 --> 00:15:24,539
Una única vez.

304
00:15:25,200 --> 00:15:26,240
Ahora ya se mira condición.

305
00:15:26,320 --> 00:15:27,200
Que se cumple entras.

306
00:15:27,700 --> 00:15:29,700
El bucle vuelve arriba, pero eso ya no se ejecuta más.

307
00:15:30,279 --> 00:15:31,059
Es solo la primera vez.

308
00:15:31,600 --> 00:15:31,759
¿Vale?

309
00:15:32,240 --> 00:15:33,080
Solo la primera vez.

310
00:15:33,500 --> 00:15:33,720
¿Vale?

311
00:15:34,460 --> 00:15:35,980
¿Que aquí se quiere poner algo?

312
00:15:36,620 --> 00:15:37,559
Se puede poner algo.

313
00:15:38,000 --> 00:15:39,679
Y lo que se pone aquí, ¿qué tiene que ser?

314
00:15:40,039 --> 00:15:41,480
Lo mismo, sentencias,

315
00:15:41,820 --> 00:15:43,980
pero que éstas se ejecutan

316
00:15:43,980 --> 00:15:46,279
al final de cada iteración

317
00:15:46,279 --> 00:15:48,000
y en todas las iteraciones.

318
00:15:51,200 --> 00:15:51,679
Efectivamente.

319
00:15:52,940 --> 00:15:54,139
Entonces, por eso se adapta.

320
00:15:54,500 --> 00:15:55,539
La idea no es meter aquí

321
00:15:55,539 --> 00:15:56,799
millas de código y aquí mil,

322
00:15:57,200 --> 00:15:58,879
porque entonces te queda un for que no entiendes,

323
00:15:59,340 --> 00:16:01,620
sino que lo puedes usar, sobre todo,

324
00:16:01,779 --> 00:16:02,860
para situaciones como esa.

325
00:16:04,700 --> 00:16:05,840
Sentencias que se ejecutan

326
00:16:06,500 --> 00:16:09,679
al final

327
00:16:09,679 --> 00:16:13,539
de cada iteración.

328
00:16:16,769 --> 00:16:17,090
Luego,

329
00:16:18,350 --> 00:16:20,049
aquí que ponemos

330
00:16:20,049 --> 00:16:21,190
lo que nos interese

331
00:16:21,190 --> 00:16:22,409
para que nos quede un código

332
00:16:22,409 --> 00:16:23,470
claro y legible.

333
00:16:24,169 --> 00:16:25,610
Entonces, situación típica

334
00:16:25,610 --> 00:16:27,210
para la que se usa siempre el for

335
00:16:27,210 --> 00:16:28,769
y prácticamente para la única

336
00:16:28,769 --> 00:16:29,490
que se utiliza.

337
00:16:29,730 --> 00:16:30,649
Prácticamente para la única.

338
00:16:32,090 --> 00:16:33,909
Cuando tenemos que contar

339
00:16:33,909 --> 00:16:35,610
la cantidad de veces

340
00:16:35,610 --> 00:16:36,710
que se ejecuta un bucle.

341
00:16:37,250 --> 00:16:38,389
Porque para eso

342
00:16:38,389 --> 00:16:39,450
siempre hay que hacer

343
00:16:39,450 --> 00:16:40,409
esto al principio.

344
00:16:41,070 --> 00:16:41,710
Esto al principio.

345
00:16:41,710 --> 00:16:42,370
y solo una vez

346
00:16:42,370 --> 00:16:45,649
y luego al final de cada iteración está

347
00:16:45,649 --> 00:16:47,529
al final de cada iteración está

348
00:16:47,529 --> 00:16:48,870
pues justo clavado

349
00:16:48,870 --> 00:16:50,269
entonces pongo aquí

350
00:16:50,269 --> 00:16:53,049
int cont igual a cero

351
00:16:53,049 --> 00:16:55,870
con lo cual ya de aquí

352
00:16:55,870 --> 00:16:56,330
la quito

353
00:16:56,330 --> 00:16:59,570
y aquí pongo con más más

354
00:16:59,570 --> 00:17:02,889
lo voy a dejar ya

355
00:17:02,889 --> 00:17:04,170
puesto entero

356
00:17:04,170 --> 00:17:20,920
este es el uso habitual del for

357
00:17:20,920 --> 00:17:23,680
uno puede poner aquí lo que le dé la gana

358
00:17:23,680 --> 00:17:24,339
y le interese

359
00:17:24,339 --> 00:17:26,359
pero es el uso habitual

360
00:17:26,359 --> 00:17:38,519
Porque esto uno lo ve rápidamente y dice, ah, vale, esto es un bucle que se va a ejecutar desde un contador valiendo cero, incrementándose una vez en cada iteración y mientras el contador no haya llegado a ser B.

361
00:17:38,960 --> 00:17:42,980
Con lo cual uno ve esto y dice, ah, vale, esto es un bucle que se ejecuta B veces y ya está.

362
00:17:43,539 --> 00:17:48,319
Y se olvida de poner esta variable fuera porque no hace falta, ya está aquí.

363
00:17:48,859 --> 00:17:55,319
Con lo cual esto en cuanto entremos en el for es lo primero que se va a hacer, declarar el cont y inicializarlo a cero, lo primero.

364
00:17:55,319 --> 00:17:58,519
y después de caer, este ya no sobraría

365
00:17:58,519 --> 00:18:00,319
claro, este ya no sobraría

366
00:18:00,319 --> 00:18:02,640
entonces ahora

367
00:18:02,640 --> 00:18:04,079
este código

368
00:18:04,079 --> 00:18:05,660
y este son iguales

369
00:18:05,660 --> 00:18:07,980
pero este está como más compactado

370
00:18:07,980 --> 00:18:08,940
más claro y más bonito

371
00:18:08,940 --> 00:18:12,259
vale, venimos por aquí, esto es lo primero que se hace

372
00:18:12,259 --> 00:18:13,039
cae el contador

373
00:18:13,039 --> 00:18:16,119
se evalúa condiciones, se entran

374
00:18:16,119 --> 00:18:18,359
y esto se hace después de que hay iteración

375
00:18:18,359 --> 00:18:19,539
esto es como si estuviera aquí abajo

376
00:18:19,539 --> 00:18:22,099
yo podría dejar esto en blanco

377
00:18:22,099 --> 00:18:24,259
y poner esto aquí, sería el mismo

378
00:18:24,259 --> 00:18:26,279
efecto, pero para eso no uso un for, pues había un

379
00:18:26,279 --> 00:18:28,240
no hay, si uso un for es para en lugar

380
00:18:28,240 --> 00:18:29,940
de ponerlo aquí abajo

381
00:18:29,940 --> 00:18:32,640
ponerlo ahí, vale, pero acordémonos

382
00:18:32,640 --> 00:18:34,279
que se ejecuta al final, siempre

383
00:18:34,279 --> 00:18:35,839
al final de las sentencias

384
00:18:35,839 --> 00:18:38,460
entonces suele ser

385
00:18:38,460 --> 00:18:40,240
el uso habitual, yo tengo un bucle que quiero

386
00:18:40,240 --> 00:18:41,799
que se ejecute x veces

387
00:18:41,799 --> 00:18:44,200
pues me lo planto con un contador desde

388
00:18:44,200 --> 00:18:46,339
cero, incrementándose

389
00:18:46,339 --> 00:18:48,079
de uno en uno, mientras

390
00:18:48,079 --> 00:18:50,099
sea menor que el

391
00:18:50,099 --> 00:18:51,740
valor final de veces que tiene que hacer

392
00:18:51,740 --> 00:18:53,900
es el uso habitual

393
00:18:53,900 --> 00:18:56,660
de hecho la variable

394
00:18:56,660 --> 00:18:58,680
la ventaja que tiene es que

395
00:18:58,680 --> 00:18:59,980
aquí esta variable contadora

396
00:18:59,980 --> 00:19:02,519
como la hemos declarado fuera del bucle

397
00:19:02,519 --> 00:19:04,359
porque era necesario declararla fuera del bucle

398
00:19:04,359 --> 00:19:05,259
para evaluarla aquí

399
00:19:05,259 --> 00:19:08,619
esta variable contadora ya se va a quedar

400
00:19:08,619 --> 00:19:10,720
visible para el resto del programa toda la vida

401
00:19:10,720 --> 00:19:12,579
sin embargo esta

402
00:19:12,579 --> 00:19:14,279
al estar declarada aquí

403
00:19:14,279 --> 00:19:15,759
es local al bucle

404
00:19:15,759 --> 00:19:18,259
y cuando ya hemos terminado la variable

405
00:19:18,259 --> 00:19:19,900
cont ya no existe, entonces ya no molesta

406
00:19:19,900 --> 00:19:22,359
esa es la ventaja

407
00:19:22,359 --> 00:19:24,039
entre esta versión y esta

408
00:19:24,039 --> 00:19:26,240
que este contador ya es una variable

409
00:19:26,240 --> 00:19:28,259
que ya se va a quedar visible para toda la vida

410
00:19:28,259 --> 00:19:30,440
y ya no puede declarar nada más

411
00:19:30,440 --> 00:19:31,059
que se llame cont

412
00:19:31,059 --> 00:19:34,480
sin embargo en esta variante como int está declarada aquí dentro

413
00:19:34,480 --> 00:19:36,059
es local al for

414
00:19:36,059 --> 00:19:37,720
y aquí ya no existe

415
00:19:37,720 --> 00:19:38,740
podría volver a declararla

416
00:19:38,740 --> 00:19:43,599
como pauta general

417
00:19:43,599 --> 00:19:44,559
de programación

418
00:19:44,559 --> 00:19:47,779
a esta variable que cuenta

419
00:19:47,779 --> 00:19:50,019
que sirve para contar las veces que se va a ejecutar

420
00:19:50,019 --> 00:19:50,500
el for

421
00:19:50,500 --> 00:19:52,720
se la suele llamar i

422
00:19:52,720 --> 00:19:57,049
que así queda más bonito y más claro

423
00:19:57,049 --> 00:19:59,069
se la suele llamar i

424
00:19:59,069 --> 00:20:01,509
pero vamos

425
00:20:01,509 --> 00:20:02,789
como le dé la gana a 1

426
00:20:02,789 --> 00:20:05,430
y se le suele llamar

427
00:20:05,430 --> 00:20:06,950
la variable índice del bucle

428
00:20:06,950 --> 00:20:09,390
porque es la variable que te va

429
00:20:09,390 --> 00:20:10,690
marcando en qué iteración estás

430
00:20:10,690 --> 00:20:12,230
la primera vez estarás en i igual a 0

431
00:20:12,230 --> 00:20:15,390
la siguiente vez ya estarás en i igual a 1

432
00:20:15,390 --> 00:20:17,109
la siguiente en i igual a 2

433
00:20:17,109 --> 00:20:19,230
y cuando hayas llegado a i igual a b

434
00:20:19,230 --> 00:20:20,289
ya no entras más

435
00:20:20,289 --> 00:20:22,529
porque ya no te cambias

436
00:20:22,529 --> 00:20:28,650
¿vale? luego ese es el aspecto

437
00:20:28,650 --> 00:20:30,430
que nos encontramos siempre en el bucle for

438
00:20:30,430 --> 00:20:32,549
pero uno

439
00:20:32,549 --> 00:20:34,190
puede poner aquí lo que le dé la gana

440
00:20:34,190 --> 00:20:36,529
y aquí lo de que siempre que sean sentencias

441
00:20:36,529 --> 00:20:38,650
separadas por comas

442
00:20:38,650 --> 00:20:40,809
aquí cualquier condición

443
00:20:40,809 --> 00:20:42,930
y aquí sentencias separadas por comas

444
00:20:42,930 --> 00:20:43,750
todas las que quiera

445
00:20:43,750 --> 00:20:46,849
pero bueno, se trata de hacer códigos que sean claros

446
00:20:46,849 --> 00:20:48,769
no hay que meter ahí todo el programa

447
00:20:48,769 --> 00:20:49,390
aquí metido

448
00:20:49,390 --> 00:20:52,410
si yo me enchuco aquí un programa entero, pues lo va a hacer

449
00:20:52,410 --> 00:20:53,450
cuando acabe la interacción

450
00:20:53,450 --> 00:20:56,170
Pero vaya follón de código que dejo

451
00:20:56,170 --> 00:21:03,079
Vale, ya con esto uno puede jugar

452
00:21:03,079 --> 00:21:03,920
Y hacer lo que quiera

453
00:21:03,920 --> 00:21:07,680
Que queremos mostrar pues todos los números pares

454
00:21:07,680 --> 00:21:09,839
Pues podríamos hacerlo con este mismo bucle for

455
00:21:09,839 --> 00:21:11,680
Por ejemplo

456
00:21:11,680 --> 00:21:12,740
Si hacemos esto

457
00:21:12,740 --> 00:21:18,160
Por ejemplo

458
00:21:18,160 --> 00:21:24,779
¿Qué estaría haciendo con este for?

459
00:21:28,430 --> 00:21:30,230
Pues mostrar todos los pares

460
00:21:30,230 --> 00:21:31,109
Entre 0 y 100

461
00:21:31,109 --> 00:21:34,269
Porque aquí el salto que estoy dando es de 2 en 2

462
00:21:34,269 --> 00:21:34,930
Por ejemplo

463
00:21:34,930 --> 00:21:37,490
Lo que me refiero es que uno ya hace las modificaciones que quiere

464
00:21:37,490 --> 00:21:39,390
y le interesa, está viendo cómo funciona el pot

465
00:21:39,390 --> 00:21:41,670
este bucle

466
00:21:41,670 --> 00:21:43,329
partiría de cero

467
00:21:43,329 --> 00:21:45,470
en este caso, i se iría

468
00:21:45,470 --> 00:21:47,410
incrementando de dos en dos, porque me da

469
00:21:47,410 --> 00:21:48,549
a mí la gana ponerlo así

470
00:21:48,549 --> 00:21:50,990
y ahora

471
00:21:50,990 --> 00:21:53,410
mientras i sea menor que cien

472
00:21:53,410 --> 00:21:55,230
me va mostrando el valor de i, lo mostraría cero

473
00:21:55,230 --> 00:21:57,549
lo mostraría dos, luego cuatro

474
00:21:57,549 --> 00:21:59,569
luego seis, que cada uno lo usa

475
00:21:59,569 --> 00:22:00,089
como quiera

476
00:22:00,089 --> 00:22:03,589
claro, tú ya

477
00:22:03,589 --> 00:22:05,289
lo usas como quieras

478
00:22:05,289 --> 00:22:06,950
sabiendo que

479
00:22:06,950 --> 00:22:09,150
normalmente su uso es este

480
00:22:09,150 --> 00:22:11,190
poner una variable

481
00:22:11,190 --> 00:22:13,009
aquí inicializada

482
00:22:13,009 --> 00:22:14,990
tocar aquí esa variable

483
00:22:14,990 --> 00:22:17,829
y esa variable te suele servir como contadora

484
00:22:17,829 --> 00:22:19,250
de las veces que se está haciendo

485
00:22:19,250 --> 00:22:21,789
y aquí ya en función del

486
00:22:21,789 --> 00:22:24,089
límite final, pues sabes cuando terminas, cuando no

487
00:22:24,089 --> 00:22:27,380
¿y si lo que quieras poner en impares?

488
00:22:28,299 --> 00:22:29,519
bueno, pues podrías empezar

489
00:22:29,519 --> 00:22:30,759
desde 1, por ejemplo

490
00:22:30,759 --> 00:22:32,700
este mismo programa

491
00:22:32,700 --> 00:22:35,000
empiezas desde 1 y ya tienes los impares

492
00:22:35,000 --> 00:22:36,279
desde el 1, 3, 5

493
00:22:36,279 --> 00:22:42,519
pero vamos, el uso habitual del for es

494
00:22:42,519 --> 00:22:44,380
pues eso, cuando yo tengo un bucle que sé

495
00:22:44,380 --> 00:22:46,140
que se va a ejecutar exactamente un número

496
00:22:46,140 --> 00:22:48,319
de veces las que sea, pues igual

497
00:22:48,319 --> 00:22:50,140
hacer un contador, incrementarlo

498
00:22:50,140 --> 00:22:52,460
y poner la condición, pues lo pongo aquí

499
00:22:52,460 --> 00:22:54,140
pongo aquí el contador empezado a cero

500
00:22:54,140 --> 00:22:56,740
aquí marco que lo vaya incrementando

501
00:22:56,740 --> 00:22:58,460
y aquí la condición final y ya está

502
00:22:58,460 --> 00:23:00,640
y es más cómodo poner todo eso

503
00:23:00,640 --> 00:23:02,440
que hacerse todo igual con el conti

504
00:23:02,440 --> 00:23:04,519
¿vale? y a partir de ahí uno usa

505
00:23:04,519 --> 00:23:06,240
el for como quiera y como siempre y cuando

506
00:23:06,240 --> 00:23:08,359
le sea más cómodo, ¿vale?

507
00:23:09,839 --> 00:23:29,269
Entonces, en los ejercicios que vienen a partir de ahora

508
00:23:29,269 --> 00:23:32,009
Pues si uno ve que le pega más un for

509
00:23:32,009 --> 00:23:34,869
Pues puede hacer un for

510
00:23:34,869 --> 00:23:37,250
¿Vale? En este caso

511
00:23:37,250 --> 00:23:44,210
Pues con bucle for

512
00:23:44,210 --> 00:23:51,809
Vale

513
00:23:51,809 --> 00:23:54,329
Con bucle for, ¿cómo quedaría la cosa?

514
00:23:55,069 --> 00:23:56,430
Vamos a volver a poner

515
00:23:56,430 --> 00:23:59,349
la multiplicadora 1

516
00:23:59,349 --> 00:24:05,240
pues con bucle for

517
00:24:05,240 --> 00:24:06,140
quedaría así

518
00:24:06,140 --> 00:24:29,460
vale, pues entonces

519
00:24:29,460 --> 00:24:30,920
esto de a elevado a b

520
00:24:30,920 --> 00:24:32,559
Con el for se queda así

521
00:24:32,559 --> 00:24:33,420
Que queda más bonito

522
00:24:33,420 --> 00:24:35,220
¿Verdad?

523
00:24:35,319 --> 00:24:36,339
Mult empieza valiendo 1

524
00:24:36,339 --> 00:24:38,240
Y ahora voy sobre mult

525
00:24:38,240 --> 00:24:40,119
Multiplicando a por a por a por a

526
00:24:40,119 --> 00:24:40,640
B veces

527
00:24:40,640 --> 00:24:42,259
Desde igual a 0

528
00:24:42,259 --> 00:24:43,140
Incrementando i

529
00:24:43,140 --> 00:24:44,180
Mientras i sea menor que b

530
00:24:44,180 --> 00:24:46,799
¿Vale?

531
00:25:01,710 --> 00:25:03,049
Vale, pues ¿qué es el factorial?

532
00:25:03,109 --> 00:25:03,569
Es lo mismo

533
00:25:03,569 --> 00:25:05,430
Lo vais a hacer vosotros ahora antes de iros

534
00:25:05,430 --> 00:25:07,849
¿Qué es el factorial?

535
00:25:08,150 --> 00:25:09,309
A ver, ejercicio 11

536
00:25:09,309 --> 00:25:17,420
Eso era multiplicar el número de

537
00:25:17,420 --> 00:25:18,779
1, 2, 3

538
00:25:18,779 --> 00:25:20,140
Hasta que llegue al número que tenéis

539
00:25:20,140 --> 00:25:46,980
Eso, justo. Vale. Vale, el factorial de un número n, pues hay que multiplicar efectivamente 1 por 2 por 3, así hasta que llegas al propio n. Así.

540
00:25:46,980 --> 00:25:50,240
luego de nuevo es una multiplicación

541
00:25:50,240 --> 00:25:51,599
de muchos factores

542
00:25:51,599 --> 00:25:53,980
luego habrá que hacer muchas

543
00:25:53,980 --> 00:25:55,960
multiplicaciones, ya sabemos cómo

544
00:25:55,960 --> 00:25:58,119
una variable multiplicadora que empieza

545
00:25:58,119 --> 00:26:00,099
valiendo 1, ahora ya sí

546
00:26:00,099 --> 00:26:02,220
ahora ya la variable sí que cambia

547
00:26:02,220 --> 00:26:04,099
la variable por la que multiplico no es a

548
00:26:04,099 --> 00:26:06,019
todo el rato, será una

549
00:26:06,019 --> 00:26:07,980
variable x que la voy a ir

550
00:26:07,980 --> 00:26:10,119
cambiando, ahora ya no es por a todo el rato

551
00:26:10,119 --> 00:26:12,140
no es por a, por a, por a, es por la

552
00:26:12,140 --> 00:26:14,480
que toque, luego ahora ya sí que la tendré que generar

553
00:26:14,480 --> 00:26:17,079
vale, entonces

554
00:26:17,079 --> 00:26:20,829
vale

555
00:26:20,829 --> 00:26:24,809
me ha ocupado dos líneas

556
00:26:24,809 --> 00:26:27,210
claro, este programa

557
00:26:27,210 --> 00:26:29,250
se queda, tú lees n

558
00:26:29,250 --> 00:26:41,660
leemos n

559
00:26:56,309 --> 00:26:57,190
de nuevo

560
00:26:57,190 --> 00:26:58,670
hecho así en plan robótico

561
00:26:58,670 --> 00:27:01,009
pues sería, oye vamos a

562
00:27:01,009 --> 00:27:03,029
una variable

563
00:27:03,029 --> 00:27:05,710
factorial, que es la que va a tener el resultado

564
00:27:05,710 --> 00:27:07,710
inicializada 1

565
00:27:07,710 --> 00:27:09,549
porque sé que son muchas multiplicaciones

566
00:27:09,549 --> 00:27:13,819
pues venga, esto será

567
00:27:13,819 --> 00:27:15,680
fat por

568
00:27:15,680 --> 00:27:18,019
igual

569
00:27:18,019 --> 00:27:21,940
el factor que va multiplicando

570
00:27:21,940 --> 00:27:24,079
este factor que va multiplicando

571
00:27:24,079 --> 00:27:25,900
venga, inicialmente que sea el

572
00:27:25,900 --> 00:27:27,740
1, aunque bueno, podría empezar del 2

573
00:27:27,740 --> 00:27:28,519
porque

574
00:27:28,519 --> 00:27:31,799
me da igual, esta multiplicación no afecta

575
00:27:31,799 --> 00:27:34,200
Pero bueno, para que sea la definición matemática bonita.

576
00:27:35,700 --> 00:27:38,539
Y ahora ya, x más más.

577
00:27:41,059 --> 00:27:41,539
Claro.

578
00:27:42,720 --> 00:27:47,279
Mientras que, mientras x sea menor que n, ¿verdad?

579
00:27:49,960 --> 00:27:52,200
Menor o igual que n.

580
00:27:52,599 --> 00:27:55,220
Porque para n queremos entrar también, ya n más 1 no.

581
00:27:58,029 --> 00:27:58,450
Vale.

582
00:27:58,970 --> 00:28:00,089
Y ahora ya mostramos FAD.

583
00:28:00,170 --> 00:28:02,930
Esta sería la versión hecha, pues, de principio a fin.

584
00:28:02,930 --> 00:28:13,369
Pero efectivamente, pues nos sobra, hay variables que podemos, la x nos sobra, podemos sobre factorial ir acumulando la propia n a la que vamos decrementando.

585
00:28:16,890 --> 00:28:21,130
Claro, yo he hecho resultado igual a resultado por menos menos n.

586
00:28:22,789 --> 00:28:24,130
Claro, entonces.

587
00:28:24,130 --> 00:28:25,250
N es ya mayor que 1.

588
00:28:26,309 --> 00:28:34,910
Claro, entonces aquí hemos usado una variable adicional que nos podemos quitar, porque la propia n mayúscula la podemos a ella ir decrementando.

589
00:28:34,910 --> 00:28:36,970
E ir multiplicando primero por ella

590
00:28:36,970 --> 00:28:38,690
Luego por ella menos uno, luego por ella menos dos

591
00:28:38,690 --> 00:28:39,329
De que llegues a uno

592
00:28:39,329 --> 00:28:42,490
¿Vale? Entonces ya, nos vamos quitando variables

593
00:28:42,490 --> 00:28:43,630
Porque ya somos muy

594
00:28:43,630 --> 00:28:45,670
Apañados y

595
00:28:45,670 --> 00:28:48,470
¿Vale? Pues entonces

596
00:28:48,470 --> 00:28:50,970
¿Cómo se da uno cuenta de que esta variable le sobra?

597
00:28:52,029 --> 00:28:52,970
Se da uno cuenta

598
00:28:52,970 --> 00:28:54,910
De que esta variable le sobra cuando dice

599
00:28:54,910 --> 00:28:56,650
A ver, es que esta variable

600
00:28:56,650 --> 00:28:59,089
N mayúscula no la estoy usando para nada más

601
00:28:59,089 --> 00:29:00,710
Que para esto de aquí

602
00:29:00,710 --> 00:29:02,130
No la estoy usando para nada más

603
00:29:02,130 --> 00:29:04,829
¿Vale? Entonces otra versión

604
00:29:04,829 --> 00:29:06,509
que es la que habréis hecho vosotros, pues sería

605
00:29:06,509 --> 00:29:08,309
pues mira, más recogidita

606
00:29:08,309 --> 00:29:10,349
mientras n

607
00:29:10,349 --> 00:29:11,990
sea mayor

608
00:29:11,990 --> 00:29:14,950
o igual que 1

609
00:29:14,950 --> 00:29:18,109
pues

610
00:29:18,109 --> 00:29:19,569
fact por

611
00:29:19,569 --> 00:29:22,029
igual n

612
00:29:22,029 --> 00:29:23,849
y la dejas decrementada

613
00:29:23,849 --> 00:29:26,369
vale, la versión súper

614
00:29:26,369 --> 00:29:27,890
comprimida de lo de arriba

615
00:29:27,890 --> 00:29:29,609
no lo podemos comprimir ya más

616
00:29:29,609 --> 00:29:32,529
esta ya es

617
00:29:32,529 --> 00:29:33,970
para profesionales

618
00:29:33,970 --> 00:29:37,029
sobre factorial vamos multiplicando algo

619
00:29:37,029 --> 00:29:39,250
que lo dejamos decrementado

620
00:29:39,250 --> 00:29:39,990
para la próxima

621
00:29:39,990 --> 00:29:47,450
cuando se quede en 1

622
00:29:47,450 --> 00:29:49,230
me va a entrar, multiplica por 1

623
00:29:49,230 --> 00:29:51,849
luego cuando se me queda en 0

624
00:29:51,849 --> 00:29:53,690
como no es mayor

625
00:29:53,690 --> 00:29:54,490
no, está bien

626
00:29:54,490 --> 00:29:56,390
está bien, está bien

627
00:29:56,390 --> 00:29:58,390
está bien

628
00:29:58,390 --> 00:30:00,009
mayor o igual que 1

629
00:30:00,009 --> 00:30:02,910
está bien, o estrictamente mayor que 0

630
00:30:02,910 --> 00:30:04,829
da lo mismo, me da igual poder mayor o igual que 1

631
00:30:04,829 --> 00:30:05,549
o mayor que 0

632
00:30:05,549 --> 00:30:08,589
vale, bueno, esta versión es

633
00:30:08,589 --> 00:30:10,630
lo mismo, pero quitando la variable x

634
00:30:10,630 --> 00:30:12,450
porque no la necesitamos

635
00:30:12,450 --> 00:30:13,589
pero iría cada uno a su

636
00:30:13,589 --> 00:30:15,529
a su gusto

637
00:30:15,529 --> 00:30:20,480
vale, bueno

638
00:30:20,480 --> 00:30:23,349
este

639
00:30:23,349 --> 00:30:26,049
el que no lo haya hecho, que lo haga

640
00:30:26,049 --> 00:30:28,829
el 10, el que no lo haya hecho

641
00:30:28,829 --> 00:30:30,730
que lo haga, pensando pues en

642
00:30:30,730 --> 00:30:32,630
estas últimas, pensando en como muchas

643
00:30:32,630 --> 00:30:33,329
anteriores

644
00:30:33,329 --> 00:30:35,730
el 12

645
00:30:35,730 --> 00:30:39,569
la media, la media es una suma

646
00:30:39,569 --> 00:30:41,029
sumar sabemos

647
00:30:41,029 --> 00:30:43,190
claro

648
00:30:43,190 --> 00:30:45,049
lo que pasa es que la media es

649
00:30:45,049 --> 00:30:47,190
no solo la suma, sino dividida entre el total

650
00:30:47,190 --> 00:30:48,829
de los que hemos leído

651
00:30:48,829 --> 00:30:50,970
pues habrá que incorporar contadores

652
00:30:50,970 --> 00:30:53,190
para positivos, negativos y ceros

653
00:30:53,190 --> 00:30:55,049
vale

654
00:30:55,049 --> 00:30:57,750
bueno

655
00:30:57,750 --> 00:31:00,309
si, vamos a