1
00:00:00,500 --> 00:00:06,599
Voy a grabar esta clase, por lo tanto, si habláis o hacéis preguntas, me autorizáis a grabar vuestro.

2
00:00:06,879 --> 00:00:10,820
¿Vale? Os acordáis que estamos en estructura de control.

3
00:00:11,460 --> 00:00:14,199
Había tres tipos de estructura de control.

4
00:00:14,539 --> 00:00:17,839
Había los condicionales, las iterativas y las llamadas a métodos.

5
00:00:18,280 --> 00:00:29,000
Las sentencias de control o estructura de control lo que hacen es alterar el flujo normal de ejecución de un programa.

6
00:00:29,000 --> 00:00:38,000
normalmente el flujo de ejecución normal es secuencial antes de arriba abajo de izquierda

7
00:00:38,000 --> 00:00:46,140
a derecha vale estándar si yo utilizo una de estas estructuras pues lo que hago es cambiarlo

8
00:00:46,140 --> 00:00:54,799
un poco puede hacer que salte un trozo puede hacer que un trozo lo haga a condición que se

9
00:00:54,799 --> 00:01:00,740
cumpla la condición y si no se cumple hacer otra puede hacer varias veces el mismo bloque puedo

10
00:01:00,740 --> 00:01:05,900
hacer un bloque que está en otro lado y luego volver a donde estaba anteriormente se debe

11
00:01:05,900 --> 00:01:13,040
cambiar el orden con que se ejecutan las cosas nosotros movistos condicionales dos tipos de

12
00:01:13,040 --> 00:01:20,000
condicionar eso es grosso modo if the switch vale hemos dicho que son prácticamente equivalentes

13
00:01:20,000 --> 00:01:21,760
puedo hacer cambios y cosas

14
00:01:21,760 --> 00:01:23,519
para hacer lo que hago en uno, en otro

15
00:01:23,519 --> 00:01:24,719
y lo que hago en otro en uno

16
00:01:24,719 --> 00:01:27,980
hoy vamos a ver la segunda

17
00:01:27,980 --> 00:01:30,299
familia de

18
00:01:30,299 --> 00:01:32,920
estructuras de control

19
00:01:32,920 --> 00:01:33,239
cuidado

20
00:01:33,239 --> 00:01:36,180
porque con esta

21
00:01:36,180 --> 00:01:37,000
pequeña

22
00:01:37,000 --> 00:01:39,719
cosa que añadimos

23
00:01:39,719 --> 00:01:41,299
las cosas

24
00:01:41,299 --> 00:01:43,760
los programas se pueden complicar

25
00:01:43,760 --> 00:01:44,400
mucho

26
00:01:44,400 --> 00:01:47,239
¿os acordáis cuando hablamos de

27
00:01:47,239 --> 00:01:50,819
programación estructurada.

28
00:01:51,060 --> 00:01:52,739
Y decimos que tiene una serie de características

29
00:01:52,739 --> 00:01:54,859
que son, que tiene la secuencia,

30
00:01:55,099 --> 00:01:57,060
tiene el condicional, tiene el iterativo.

31
00:01:57,420 --> 00:01:59,040
Pues con esto completamos

32
00:01:59,040 --> 00:02:00,079
sustancialmente, porque

33
00:02:00,079 --> 00:02:02,480
la llamada al método es útil

34
00:02:02,480 --> 00:02:04,500
para estructurar, pero

35
00:02:04,500 --> 00:02:06,719
técnicamente podrías

36
00:02:06,719 --> 00:02:08,319
no utilizarlo, ¿vale?

37
00:02:08,319 --> 00:02:10,099
Y aún así hacer toda la

38
00:02:10,099 --> 00:02:12,180
complejidad que te da la gana. O sea que con

39
00:02:12,180 --> 00:02:13,520
estos tres elementos

40
00:02:13,520 --> 00:02:16,159
ya podemos hacer programas

41
00:02:16,159 --> 00:02:21,979
serios no los haremos porque es principio y porque hacerlo con solo estas tres cosas es un infierno

42
00:02:21,979 --> 00:02:28,819
vale necesitamos más piezas para que sea más cómodo hacer programas complejos y completos

43
00:02:28,819 --> 00:02:38,020
vale pero ya con esto se puede mejorar mucho todo lo que hacemos y también juntitos con los

44
00:02:38,020 --> 00:02:44,800
iterativos van nuestros personales enemigos, los arrays. Entonces dentro de

45
00:02:44,800 --> 00:02:52,240
poco entrarán también en juego los arrays y con eso ya cambia

46
00:02:52,240 --> 00:02:57,680
la forma de ver programación. Ahora he decidido

47
00:02:57,680 --> 00:03:04,139
que puede sufrir. Vale, entonces estructuras iterativas, ¿qué son? ¿Para qué sirven?

48
00:03:04,139 --> 00:03:09,740
Las estructuras iterativas permiten repetir un determinado bloque más de una vez, ¿vale?

49
00:03:10,740 --> 00:03:19,439
Si yo quiero que este bloque se repita y repita y repita mientras una condición sea verdadera,

50
00:03:19,439 --> 00:03:28,000
mientras se cumpla una condición, mientras que esto es verdadero, tengo que utilizar un BLIND.

51
00:03:28,000 --> 00:03:31,060
si quiero en vez

52
00:03:31,060 --> 00:03:33,560
sé cuantas veces voy a hacer

53
00:03:33,560 --> 00:03:35,860
esta interacción, la quiero hacer 6 veces

54
00:03:35,860 --> 00:03:37,659
la quiero hacer 10 veces, la quiero hacer

55
00:03:37,659 --> 00:03:39,860
el número de veces que me ha puesto

56
00:03:39,860 --> 00:03:41,379
el usuario por teclado

57
00:03:41,379 --> 00:03:43,900
y cosas por el estilo, pues eso

58
00:03:43,900 --> 00:03:45,139
es un FOR

59
00:03:45,139 --> 00:03:47,379
son dos estructuras

60
00:03:47,379 --> 00:03:49,560
parecidas que son

61
00:03:49,560 --> 00:03:51,539
hermanas como SWITCH e INFA

62
00:03:51,539 --> 00:03:53,620
es decir que todo lo que puede hacer con un WHILE

63
00:03:53,620 --> 00:03:54,699
lo puede hacer con el FOR

64
00:03:54,699 --> 00:03:57,280
todo lo que hago con el FOR lo puede hacer con el WHILE

65
00:03:57,280 --> 00:04:06,280
Pero en determinados casos un while te sale más sencillo y en determinados casos un for te sale más sencillo.

66
00:04:06,280 --> 00:04:12,280
Por lo tanto, hay que empezar a entender antes o después cuándo usar un while y cuándo usar un for.

67
00:04:12,280 --> 00:04:21,279
En general la regla es sencilla, si no sé cuántas veces voy a hacer una cosa es un while, si sé cuántas veces voy a hacer una cosa es un for.

68
00:04:21,279 --> 00:04:23,699
esto no quiere decir

69
00:04:23,699 --> 00:04:25,660
a tiempo de programación

70
00:04:25,660 --> 00:04:27,779
a tiempo de, mientras yo estoy

71
00:04:27,779 --> 00:04:29,600
haciendo el código, quiere decir que

72
00:04:29,600 --> 00:04:31,160
si cuando empiezo el while

73
00:04:31,160 --> 00:04:33,759
en ejecución, sé cuantas veces

74
00:04:33,759 --> 00:04:35,740
lo tengo que hacer, pues ese es un for

75
00:04:35,740 --> 00:04:37,800
¿sí? ¿qué quiere decir todo esto?

76
00:04:38,360 --> 00:04:39,819
que a lo mejor yo no sé si una cosa

77
00:04:39,819 --> 00:04:41,660
si un trozo lo voy a hacer

78
00:04:41,660 --> 00:04:43,540
seis o diez veces, porque

79
00:04:43,540 --> 00:04:45,519
soy el usuario que me lo escribe

80
00:04:45,519 --> 00:04:47,680
por teclado

81
00:04:47,680 --> 00:04:49,540
yo le digo, ¿cuantas veces

82
00:04:49,540 --> 00:04:51,259
quiero hacer esto? y me dice siete

83
00:04:51,259 --> 00:04:52,920
pues entonces lo hago 7 veces

84
00:04:52,920 --> 00:04:55,680
¿cuántas veces quiero hacer esto?

85
00:04:55,779 --> 00:04:57,120
100, pues lo hago 100 veces

86
00:04:57,120 --> 00:04:58,279
yo a tiempo de

87
00:04:58,279 --> 00:05:01,259
preparación del programa

88
00:05:01,259 --> 00:05:02,579
mientras estoy programando

89
00:05:02,579 --> 00:05:05,939
no sé si esto se va a hacer 5 o 10 veces

90
00:05:05,939 --> 00:05:07,620
pero luego

91
00:05:07,620 --> 00:05:09,379
lo sabré, sé que se va a hacer

92
00:05:09,379 --> 00:05:11,660
n veces, hay una variable que se llama n

93
00:05:11,660 --> 00:05:13,160
y ese número de veces

94
00:05:13,160 --> 00:05:14,279
pues eso es un for

95
00:05:14,279 --> 00:05:17,579
que en vez de yo te digo

96
00:05:17,579 --> 00:05:18,379
¡ay usuario!

97
00:05:18,379 --> 00:05:21,300
me ponga a hacer

98
00:05:21,300 --> 00:05:23,360
algo, ¿vale? Sumas.

99
00:05:24,160 --> 00:05:25,079
Y cuando tú

100
00:05:25,079 --> 00:05:27,240
quieres acabar, me pones

101
00:05:27,240 --> 00:05:29,000
un cero y ese cero

102
00:05:29,000 --> 00:05:30,800
quiere decir que ha acabado.

103
00:05:31,079 --> 00:05:32,639
Cuando yo empiezo este bucle,

104
00:05:33,240 --> 00:05:35,000
no lo sé si el usuario me pondrá uno,

105
00:05:35,120 --> 00:05:38,449
diez o veintisiete. ¿Me entiende?

106
00:05:39,709 --> 00:05:40,589
Entonces, en este

107
00:05:40,589 --> 00:05:41,310
caso sería un while.

108
00:05:45,980 --> 00:05:48,259
Es un while. El comando while se usa

109
00:05:48,259 --> 00:05:50,180
cuando quiero repetir un cierto bloque

110
00:05:50,180 --> 00:05:55,180
instrucciones mientras sea verdadera una determinada condición. Es decir, una cosa

111
00:05:55,180 --> 00:05:59,300
de este estilo. Entro por aquí, hay una condición. Si la condición es falsa, me

112
00:05:59,300 --> 00:06:03,519
salto todo y sigo adelante con la siguiente bloque de instrucción. Si la

113
00:06:03,519 --> 00:06:08,839
condición es verdadera, hago un bloque de instrucción y vuelvo justo antes del

114
00:06:08,839 --> 00:06:17,939
wine. Y vuelvo a comprobar otra vez si la condición es verdadera o falsa. Si es

115
00:06:17,939 --> 00:06:22,220
Si es verdadera, entro otra vez. Si es verdadera, entro otra vez. Si es verdadera, entro otra vez.

116
00:06:22,540 --> 00:06:28,279
Y así, así, así, hasta que algo en estas instrucciones me cambie la condición a falsa,

117
00:06:28,620 --> 00:06:30,839
y entonces saldré por aquí y seguiré grabando.

118
00:06:31,319 --> 00:06:35,660
Cuidado. Un while puede ser eterno.

119
00:06:37,759 --> 00:06:41,199
Si yo, dentro de estas instrucciones, dentro de este bloque de instrucciones,

120
00:06:41,199 --> 00:06:48,199
no cambio la condición nunca, pues este while es un while insignito.

121
00:06:49,379 --> 00:06:57,740
Entra dentro y como no puedo cambiar la instrucción, no puedo cambiar la condición, siempre será verdadera y por lo tanto me quedo atrapado ahí.

122
00:06:58,180 --> 00:07:04,360
¿Es un error? En un 99% de las veces sí, pero hay programas que no acaban nunca.

123
00:07:05,819 --> 00:07:10,740
Hay programas que yo cuando hago un programa, pues quiero volver al principio y pediros a ver de ahí ahora qué hago.

124
00:07:11,680 --> 00:07:14,579
En ese caso estará en un while que no acaba nunca.

125
00:07:14,579 --> 00:07:16,600
normalmente que acabe nunca, nunca, nunca

126
00:07:16,600 --> 00:07:18,579
no existe, habrá una

127
00:07:18,579 --> 00:07:20,540
condición especial de administrador

128
00:07:20,540 --> 00:07:22,680
porque el administrador puede bloquear

129
00:07:22,680 --> 00:07:24,579
habrá un código especial que si

130
00:07:24,579 --> 00:07:26,540
el administrador pone ese código

131
00:07:26,540 --> 00:07:28,860
pues el programa se arresta

132
00:07:28,860 --> 00:07:30,720
y yo puedo hacer mantenimiento para instalar

133
00:07:30,720 --> 00:07:32,620
una nueva versión y arrancarlo otra vez

134
00:07:32,620 --> 00:07:33,980
pensad a un

135
00:07:33,980 --> 00:07:36,620
cajero automático

136
00:07:36,620 --> 00:07:38,680
vas allí, dame

137
00:07:38,680 --> 00:07:40,680
la tarjeta, mete la tarjeta, dame

138
00:07:40,680 --> 00:07:42,540
el dinero, pones el dinero, te da

139
00:07:42,540 --> 00:07:44,800
y a ese punto no hay que decir

140
00:07:44,800 --> 00:07:46,319
he acabado y se apaga

141
00:07:46,319 --> 00:07:49,079
vuelve al principio y dice dame la tarjeta

142
00:07:49,079 --> 00:07:50,600
y tú puedes hacer otra operación

143
00:07:50,600 --> 00:07:53,019
sin embargo está el administrador

144
00:07:53,019 --> 00:07:55,259
que tendrá su forma de toquetear

145
00:07:55,259 --> 00:07:56,939
su código para poner para que él

146
00:07:56,939 --> 00:07:58,779
se arreste de verdad entre modalidad

147
00:07:58,779 --> 00:08:00,579
mantenimiento y yo pueda activar

148
00:08:00,579 --> 00:08:02,980
o actualizar lo que tenga que actualizar

149
00:08:02,980 --> 00:08:04,740
y luego arrancarlo otra vez

150
00:08:04,740 --> 00:08:08,959
cuando las condiciones se vuelven falsas

151
00:08:08,959 --> 00:08:10,899
el programa deja de repetir el bloque

152
00:08:10,899 --> 00:08:20,040
instrucciones y sigue adelante. Ejemplo del while, int i es igual a 0, wille i es menor

153
00:08:20,040 --> 00:08:28,480
o igual que 10, condición, mientras que i sea menor o igual a 10, entra dentro, escribe

154
00:08:28,480 --> 00:08:35,419
system.out.println i y luego dale i++. ¿Qué hace este programa?

155
00:08:35,419 --> 00:08:45,970
Lanzo este programa, que veo

156
00:08:45,970 --> 00:08:48,009
Si

157
00:08:48,009 --> 00:08:52,870
Lanzo este programa, que veo

158
00:08:52,870 --> 00:08:58,070
Lanzo este programa, que veo

159
00:08:58,070 --> 00:08:59,350
Que me sale

160
00:08:59,350 --> 00:09:01,529
Y diez veces

161
00:09:01,529 --> 00:09:05,909
Y diez veces

162
00:09:05,909 --> 00:09:10,830
1, 2, 3, 4, 5

163
00:09:10,830 --> 00:09:13,509
No, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

164
00:09:13,509 --> 00:09:14,850
Eso es lo que veo

165
00:09:14,850 --> 00:09:18,490
¿Sí? Vamos a ver

166
00:09:18,490 --> 00:09:19,470
Vamos a ver

167
00:09:19,470 --> 00:09:35,200
Package

168
00:09:35,200 --> 00:09:36,860
Ejemplos

169
00:09:36,860 --> 00:09:40,659
Plus

170
00:09:40,659 --> 00:09:42,820
Ejemplo

171
00:09:42,820 --> 00:09:43,980
Wille

172
00:09:43,980 --> 00:09:47,460
Entonces, tengo un main

173
00:09:47,460 --> 00:09:54,070
y aquí digo

174
00:09:54,070 --> 00:09:56,610
int i es igual a cero

175
00:09:56,610 --> 00:10:00,970
i es menor o igual a diez

176
00:10:00,970 --> 00:10:04,779
si hizo i

177
00:10:04,779 --> 00:10:08,139
i más más

178
00:10:08,139 --> 00:10:11,779
Si lo lanzo

179
00:10:11,779 --> 00:10:16,529
tengo los números de cero a diez

180
00:10:19,529 --> 00:10:21,149
No hace cero, no hace cero más cero

181
00:10:21,149 --> 00:10:22,909
Tú dices, ¿cuánto vale i?

182
00:10:23,490 --> 00:10:25,429
0. ¿Es menor que 10?

183
00:10:26,269 --> 00:10:27,750
Sí. Escríbeme i.

184
00:10:27,929 --> 00:10:29,529
¿Cuánto vale? 0.

185
00:10:29,649 --> 00:10:31,269
Me ha escrito 0. Lo pongo aquí abajo.

186
00:10:34,929 --> 00:10:36,049
Ha escrito un 0.

187
00:10:36,429 --> 00:10:37,990
Y ahora dice i más más.

188
00:10:38,070 --> 00:10:38,610
¿Qué hace esto?

189
00:10:40,029 --> 00:10:41,789
i es igual a i más 1.

190
00:10:42,070 --> 00:10:43,649
¿Vale? Entonces ahora i vale

191
00:10:43,649 --> 00:10:45,830
1. Vuelvo aquí.

192
00:10:47,049 --> 00:10:47,970
1 es menor

193
00:10:47,970 --> 00:10:48,710
igual a 10.

194
00:10:48,710 --> 00:10:51,710
Sí, por lo tanto entro, escribo

195
00:10:51,710 --> 00:10:52,389
Uno

196
00:10:52,389 --> 00:10:56,250
Hago uno más más

197
00:10:56,250 --> 00:10:57,210
Sería dos

198
00:10:57,210 --> 00:11:00,169
Vuelvo aquí, dos es menor que diez

199
00:11:00,169 --> 00:11:02,450
Sí, entro dentro, escribo dos

200
00:11:02,450 --> 00:11:04,009
Más más

201
00:11:04,009 --> 00:11:05,730
Y así, así, así, así

202
00:11:05,730 --> 00:11:07,190
Hasta llegar a

203
00:11:07,190 --> 00:11:09,549
Diez, ¿vale?

204
00:11:10,070 --> 00:11:11,029
Cuando llega a diez

205
00:11:11,029 --> 00:11:13,629
Cuando llega a diez

206
00:11:13,629 --> 00:11:15,990
Llego aquí, diez es menor o igual que diez

207
00:11:15,990 --> 00:11:19,179
Sí

208
00:11:19,179 --> 00:11:27,220
Entro dentro, escribo 10, voy aquí, 10 más más, 11. 11 es menor o igual que 10,

209
00:11:27,220 --> 00:11:46,610
falso. Entonces esto es lo que sale. De 0, porque la primera vez vale 0, a 10. ¿Qué hace esto?

210
00:11:46,610 --> 00:11:53,289
De 0 a 9

211
00:11:53,289 --> 00:11:54,730
0, 1, 2, 3, 4, 5, 6, 7, 8, 9

212
00:11:54,730 --> 00:11:55,690
¿Correcto?

213
00:11:56,409 --> 00:11:57,649
¿Qué hace esto?

214
00:12:17,730 --> 00:12:20,370
Porque siempre antes lo suma

215
00:12:20,370 --> 00:12:21,990
Y luego lo escribe

216
00:12:21,990 --> 00:12:24,470
Eso quiere decir que cuando entra aquí como 9

217
00:12:24,470 --> 00:12:25,590
Escribe 10

218
00:12:25,590 --> 00:12:27,929
Cuando entra como 0 escribe 1

219
00:12:27,929 --> 00:12:30,690
Cuando entra como 1 escribe 2

220
00:12:30,690 --> 00:12:32,090
Cuando entra como 2 escribe 3

221
00:12:32,090 --> 00:12:34,049
Cuando entra como 9, que es la última vez

222
00:12:34,049 --> 00:12:35,110
Escribe 10

223
00:12:35,110 --> 00:12:38,009
pasa 10, 10 no es menor que 10

224
00:12:38,009 --> 00:12:38,830
y por lo tanto sale

225
00:12:38,830 --> 00:12:49,779
¿sí? ¿qué hace esto?

226
00:12:51,299 --> 00:12:52,519
de 3 a 3

227
00:12:52,519 --> 00:12:53,519
de 4

228
00:12:53,519 --> 00:12:55,200
de 4 a 10

229
00:12:55,200 --> 00:12:56,320
¿vale?

230
00:13:00,320 --> 00:13:00,639
¿sí?

231
00:13:21,809 --> 00:13:23,389
pasa tantos segundos

232
00:13:23,389 --> 00:13:53,370
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30.

233
00:13:53,389 --> 00:13:56,950
La primera vez que entra como 3, suma 1 y escribe 4.

234
00:14:03,190 --> 00:14:04,049
Incluido el 10.

235
00:14:04,549 --> 00:14:06,350
Porque entrará como 9.

236
00:14:08,429 --> 00:14:14,490
Entra como 9, pone 10, escribe 10, pasa 11, llega aquí y sale 9.

237
00:14:16,269 --> 00:14:16,570
¿Sí?

238
00:14:17,210 --> 00:14:20,029
Y así podéis jugar cuanto queráis.

239
00:14:20,309 --> 00:14:20,549
¿Vale?

240
00:14:20,549 --> 00:14:28,549
Hacéis un while, escribís cosas al azar y luego pensáis en lo que tiene que salir y después le dais al play.

241
00:14:28,549 --> 00:14:31,549
¿Pero esto no sería con hold?

242
00:14:31,549 --> 00:14:37,549
No, no tiene que estar ahí. Pero entiéndeme, es el primer while que se lee, ¿vale?

243
00:14:37,549 --> 00:14:48,549
Depende, porque si yo hago esto de... Escribe un número y si es más o menos 10 a cabo, ¿tú sabes cuántas veces lo escribiré?

244
00:14:48,549 --> 00:14:55,730
Y es igual a scan.nexi.

245
00:14:55,730 --> 00:14:58,549
Con el scan no, pero poniéndolo como lo estamos poniendo.

246
00:15:00,309 --> 00:15:02,929
¿Tú sabes cuántas veces voy a entrar aquí?

247
00:15:07,210 --> 00:15:10,629
Así sí lo puedes contar, lo puedes saber más o menos.

248
00:15:10,950 --> 00:15:23,129
Pero si yo te pongo esto, ¿qué hace?

249
00:15:26,710 --> 00:15:27,990
Negativos infinitos.

250
00:15:28,470 --> 00:15:34,970
Desde el 3 al infinito, restando siempre 1.

251
00:15:41,110 --> 00:15:41,990
¿Hasta cuándo?

252
00:15:44,470 --> 00:15:47,090
¿Hasta cuándo?

253
00:15:49,090 --> 00:15:51,330
¿Hasta cuándo? ¿Dos?

254
00:15:51,330 --> 00:15:51,370
¿Dos?

255
00:15:58,970 --> 00:16:01,789
Menos 2.000 millones, grosso modo.

256
00:16:01,830 --> 00:16:03,830
porque luego explotan los ints.

257
00:16:03,830 --> 00:16:07,590
¿Sí?

258
00:16:07,590 --> 00:16:09,590
Fijaos.

259
00:16:09,590 --> 00:16:11,590
Cuando a vosotros

260
00:16:11,590 --> 00:16:13,590
os pasa esto,

261
00:16:13,590 --> 00:16:15,590
aquí tenéis un cuadradito rojo

262
00:16:15,590 --> 00:16:17,590
que os

263
00:16:17,590 --> 00:16:19,590
para la ejecución.

264
00:16:19,590 --> 00:16:21,590
Cuidado,

265
00:16:21,590 --> 00:16:23,590
porque vosotros hacéis esto.

266
00:16:23,590 --> 00:16:29,460
No funciona.

267
00:16:29,460 --> 00:16:31,460
Le doy otra vez.

268
00:16:31,460 --> 00:16:33,460
No funciona. Le doy otra vez.

269
00:16:33,460 --> 00:16:35,460
Y ahora yo tengo

270
00:16:35,460 --> 00:16:52,480
tengo mi CPU al 93% haciendo menos, menos, menos, menos tres veces, ¿vale? Y sigo aquí

271
00:16:52,480 --> 00:17:02,139
hasta que explote. Ahí está la damenzona desde antes, ¿vale? Entonces, tened en cuenta

272
00:17:02,139 --> 00:17:09,319
también que esto tarda relativamente poco en explotar, porque si solo hace esto, llegar

273
00:17:09,319 --> 00:17:11,880
a menos dos millones, no tarda nada.

274
00:17:20,119 --> 00:17:22,890
La tarda un rato.

275
00:17:27,589 --> 00:17:32,509
Entonces, cuidado con esto, porque vosotros no veis que está viendo nada, habéis hecho

276
00:17:32,509 --> 00:17:37,150
un error, no está funcionando, aquí no veo ganas de nada, pues le doy otra vez, y otra

277
00:17:37,150 --> 00:17:46,269
vez y otra vez y tenéis varios while que están haciendo un montón de cosas, sin nada. Cuidado,

278
00:17:46,269 --> 00:17:52,809
porque llega un momento en que él se lía y ya no funciona bien, porque está haciendo demasiadas

279
00:17:52,809 --> 00:18:00,109
cosas. Siempre cuando hacéis con el while y tenéis cuidado, que no sabéis bien si puede ser que sea

280
00:18:00,109 --> 00:18:06,029
un while infinito, siempre un ojo aquí. Si veis que este es rojo, es que os habéis metido en algún

281
00:18:06,029 --> 00:18:16,769
momento de while infinito y tenéis que pararlo de aquí, ¿vale?

282
00:18:16,769 --> 00:18:22,769
Si tú pones valores que son, por ejemplo, letras, ¿qué pasa? Explota.

283
00:18:22,769 --> 00:18:25,769
Aquí no se lee el teclado.

284
00:18:25,769 --> 00:18:27,769
Ya, pero en caso de...

285
00:18:27,769 --> 00:18:37,599
Como antes. No explota el while, explota el hecho que tú estás leyendo un chart cuando tienes que leer un int, explota.

286
00:18:37,599 --> 00:18:56,750
Eh, quería decir algo, pero no me acuerdo, no me acuerdo, va, entonces, cuidado con estas cosas de aquí, cuidado con los while, ah, sí, quería decir, ¿por qué? ¿Por qué este es infinito?

287
00:18:56,750 --> 00:19:01,349
¿Por qué?

288
00:19:05,769 --> 00:19:08,390
Porque por el algoritmo que yo he hecho

289
00:19:08,390 --> 00:19:10,849
La condición no cambia nunca

290
00:19:10,849 --> 00:19:12,369
¿Vale?

291
00:19:12,650 --> 00:19:15,049
Si la condición no cambia nunca

292
00:19:15,049 --> 00:19:16,589
Porque es siempre true

293
00:19:16,589 --> 00:19:17,349
¿Vale?

294
00:19:17,829 --> 00:19:19,109
Pues se queda ahí

295
00:19:19,109 --> 00:19:21,569
Cuidado que en realidad sí cambia

296
00:19:21,569 --> 00:19:24,130
Pero claro, está cambiando de una forma

297
00:19:24,130 --> 00:19:25,430
Que nunca será false

298
00:19:25,430 --> 00:19:26,029
¿Vale?

299
00:19:26,809 --> 00:19:27,990
Si yo hiciera esto

300
00:19:27,990 --> 00:19:47,619
acaba no va a acabar simplemente porque aquí dentro la condición no está cambiando he hecho

301
00:19:47,619 --> 00:19:53,759
un error porque en mi condición no va nunca a cambiar por lo tanto esto no podrá nunca ser

302
00:19:53,759 --> 00:20:04,140
force y por lo tanto seguirá aquí para siempre dudas o de cuidado hasta ahora por cuanto vosotros

303
00:20:04,140 --> 00:20:11,019
hicierais daño en la programación bueno pero ahora ya tenéis en mano algo un poquito más

304
00:20:11,019 --> 00:20:17,700
complejo vale que puede hacer daño o pero sí pero es más sencillo

305
00:20:17,700 --> 00:20:30,200
que no lo puedes hacer

306
00:20:30,200 --> 00:20:38,279
tenemos ahora algunos ejercicios a estos ejercicios que te decía lee cinco vocales

307
00:20:38,279 --> 00:20:43,740
o cinco números y suma los y cosas por el estilo tenía sólo él y pues tenía que usar

308
00:20:43,740 --> 00:20:45,740
de esas cosas. Pues ahora yo te podría decir

309
00:20:45,740 --> 00:20:47,339
lees el número

310
00:20:47,339 --> 00:20:49,819
porque va a venir el código del programa

311
00:20:49,819 --> 00:20:51,700
se va a entre bien el código. Dentro de un

312
00:20:51,700 --> 00:20:52,799
while siempre haces lo mismo.

313
00:20:53,819 --> 00:20:55,759
Ahora, veremos cómo se usa.

314
00:20:55,900 --> 00:20:57,900
Pues literalmente cambiarías el 10 por un 100

315
00:20:57,900 --> 00:20:59,759
y podrías uno más.

316
00:21:01,559 --> 00:21:02,039
Realmente,

317
00:21:02,279 --> 00:21:03,140
si yo quiero

318
00:21:03,140 --> 00:21:07,460
si yo quiero escribir

319
00:21:07,460 --> 00:21:09,920
los números de 1 a 100

320
00:21:09,920 --> 00:21:11,259
¿cómo lo haríais?

321
00:21:11,259 --> 00:21:20,210
Pones aquí un

322
00:21:20,210 --> 00:21:22,210
1 por ejemplo

323
00:21:22,210 --> 00:21:25,730
Y él está escrito de 1 a 100

324
00:21:25,730 --> 00:21:28,329
Y si quise hacerlo hasta 10.000

325
00:21:28,329 --> 00:21:35,410
O si lo queréis ver

326
00:21:35,410 --> 00:21:36,890
A lo mejor lo veis mejor así

327
00:21:36,890 --> 00:21:44,759
Y si quise hacerlo

328
00:21:44,759 --> 00:22:07,309
hacer 10.000.000? Si quisiera hacer hasta, no sé, la complejidad está aumentando. Y

329
00:22:07,309 --> 00:22:20,509
Si quisiera hacerlo, por ejemplo, a ver, 10.000 millones, es una duda y no tiene un máximo.

330
00:22:20,509 --> 00:22:21,710
Había hecho una pregunta.

331
00:22:21,710 --> 00:22:22,710
Es lo mismo.

332
00:22:22,710 --> 00:22:23,710
¿Sí?

333
00:22:23,710 --> 00:22:24,710
No, ahí está.

334
00:22:24,710 --> 00:22:25,710
Ahí está el límite.

335
00:22:25,710 --> 00:22:26,710
¿Veis que caí una cosa?

336
00:22:26,710 --> 00:22:27,710
Estos son 1.000 millones.

337
00:22:27,710 --> 00:22:28,710
¡Tax!

338
00:22:28,710 --> 00:22:29,710
Explota.

339
00:22:29,710 --> 00:22:30,710
El límite.

340
00:22:30,710 --> 00:23:00,630
millones. Tax. Explota. El límite. ¿Entonces qué hago? Estas cosas ya las hemos estudiado, eh. Sé que vosotros en los castings lo habéis visto solo una vez y os da igual, pero este número de aquí como entero no me vale porque sale del rango de enteros, pero si lo miro

341
00:23:00,630 --> 00:23:06,210
como double pues lo puede usar tranquilamente o si le pongo punto cero es un dado si le pongo

342
00:23:06,210 --> 00:23:13,009
una l para long cosas lo hemos visto en clase están grabados y la tenéis que saber porque

343
00:23:13,009 --> 00:23:25,009
antes o después os pillas los dedos dudas vale entonces eso es un guay fácil la sintaxis es

344
00:23:25,009 --> 00:23:30,910
súper fácil es como todo en programación la sintaxis la parte más sencilla es luego utilizarlo

345
00:23:30,910 --> 00:23:33,569
combinar lo que se vuelve complejo, ¿vale?

346
00:23:36,230 --> 00:23:40,029
Existe el hermano del while, que es el do while.

347
00:23:40,210 --> 00:23:44,410
Si os fijáis aquí, ¿cuántas veces se va a ejecutar

348
00:23:44,410 --> 00:23:49,869
este bloque? Vale.

349
00:23:49,990 --> 00:23:54,029
En general, sin saber cuál es la condición, ¿cuántas veces

350
00:23:54,029 --> 00:23:59,000
se ejecuta esto? El mínimo

351
00:23:59,000 --> 00:24:07,349
cero. Si la condición es falsa, si yo aquí pongo 100,

352
00:24:07,349 --> 00:24:09,109
¿Cuántas veces se ejecuta esto?

353
00:24:10,029 --> 00:24:10,670
Cero

354
00:24:10,670 --> 00:24:13,769
Entonces un while ejecuta ese bloque cero

355
00:24:13,769 --> 00:24:15,410
O muchas veces

356
00:24:15,410 --> 00:24:18,369
¿Y qué pasa si yo quiero

357
00:24:18,369 --> 00:24:21,670
Estar seguro que esto al menos una vez

358
00:24:21,670 --> 00:24:22,849
Se ejecute?

359
00:24:23,609 --> 00:24:25,130
Claro, a lo mejor no se vuelve a ejecutar

360
00:24:25,130 --> 00:24:27,130
Pero no cero o más

361
00:24:27,130 --> 00:24:28,890
Más uno o más

362
00:24:28,890 --> 00:24:31,750
Pues uso el do while

363
00:24:31,750 --> 00:24:33,549
El do while

364
00:24:33,549 --> 00:24:36,490
Es un procedimiento que empieza con do

365
00:24:36,490 --> 00:24:38,470
Hace un bloque de instrucciones

366
00:24:38,470 --> 00:24:40,710
Y después del bloque de instrucciones

367
00:24:40,710 --> 00:24:42,150
Hace una condición

368
00:24:42,150 --> 00:24:43,650
Que es una condición igual al while

369
00:24:43,650 --> 00:24:45,910
Y si es verdadera

370
00:24:45,910 --> 00:24:48,250
Vuelve aquí arriba y repite

371
00:24:48,250 --> 00:24:50,230
¿Vale? Ahora estamos como antes

372
00:24:50,230 --> 00:24:51,730
Si en vez de es falsa sale

373
00:24:51,730 --> 00:24:53,849
Pero una vez ha pasado por aquí

374
00:24:53,849 --> 00:24:54,410
Siempre

375
00:24:54,410 --> 00:24:57,259
¿Entendé?

376
00:24:59,440 --> 00:25:01,240
Y esto es la sintaxis

377
00:25:01,240 --> 00:25:02,140
Do

378
00:25:02,140 --> 00:25:04,859
Do es hacer

379
00:25:04,859 --> 00:25:05,859
Hace esto

380
00:25:05,859 --> 00:25:07,859
Mientras

381
00:25:07,859 --> 00:25:17,400
fijaos que tiene una cosa un poquito rara que mientras el while por sí mismo no tiene punto

382
00:25:17,400 --> 00:25:29,400
y coma al final del bloque while el do while sí entonces si usáis el do while al final del

383
00:25:29,400 --> 00:25:36,079
while aquí hay punto y coma porque aquí acaba este comando digamos en el while en vez ejecutaría

384
00:25:36,079 --> 00:25:40,220
sólo lo que viene después que sería este bloque y por lo tanto ya está

385
00:25:44,019 --> 00:25:49,259
cualquier cosa que se puede hacer con un guay se puede hacer con dubai cualquier cosa que se

386
00:25:49,259 --> 00:25:54,019
puede hacer cuando guay se puede hacer con guay es simplemente cambiar un poquito la condición

387
00:25:54,019 --> 00:25:59,980
y forzar que la primera sea verdadera y pues luego compruebe y si tienes cuba ilusión de un guay

388
00:26:06,079 --> 00:26:09,500
¿Por qué? Porque son dos estructuras distintas.

389
00:26:09,700 --> 00:26:13,839
En el while, tú podrías hacer que esto no lo ejecutes nunca.

390
00:26:14,460 --> 00:26:18,400
Porque tú llegas aquí, dices, condición falsa, sales.

391
00:26:18,960 --> 00:26:20,279
Nunca has hecho las instrucciones.

392
00:26:21,539 --> 00:26:26,380
Pero existe otra versión que tú puedes usar o olvidarte,

393
00:26:26,940 --> 00:26:31,480
que es esta de aquí, en que estas instrucciones la primera vez las haces.

394
00:26:32,019 --> 00:26:32,539
Siempre.

395
00:26:32,539 --> 00:26:35,279
y que si es verdadera la condición

396
00:26:35,279 --> 00:26:36,640
vuelves a regirla

397
00:26:36,640 --> 00:26:38,440
si es falsa sigues adelante

398
00:26:38,440 --> 00:26:41,380
pero aquí puede ser que sean

399
00:26:41,380 --> 00:26:42,900
cero o una

400
00:26:42,900 --> 00:26:44,779
o dos o tres

401
00:26:44,779 --> 00:26:45,980
o sea cero o más

402
00:26:45,980 --> 00:26:48,680
este bloque de instrucción

403
00:26:48,680 --> 00:26:51,500
mientras aquí es una vez seguro

404
00:26:51,500 --> 00:26:53,119
y luego puede otra vez

405
00:26:53,119 --> 00:26:54,220
puede otra vez o no

406
00:26:54,220 --> 00:26:55,900
entonces una o más

407
00:26:55,900 --> 00:27:00,970
la primera vez hace las instrucciones sin comprobar

408
00:27:00,970 --> 00:27:01,869
si es verdadero o falso

409
00:27:01,869 --> 00:27:10,109
Si tú fuerzas que la primera vez sea verdadero siempre la condición, con alguna razón, como tú puedas,

410
00:27:10,109 --> 00:27:13,549
pues entonces es equivalente a un while que a un dual.

411
00:27:13,549 --> 00:27:16,190
Pero al final es lo mismo, ¿no?

412
00:27:16,190 --> 00:27:23,910
Al final es lo mismo que esto. Son estructuras iterativas y ya he dicho que todo lo que puedes hacer con un while,

413
00:27:23,910 --> 00:27:27,269
lo puedes hacer con un dual, y todo lo que haces con un dual, lo puedes hacer con un while.

414
00:27:27,269 --> 00:27:33,650
Solo que a veces hay situaciones, hay cosas, que con un do while te sale mucho más elegante que con un while.

415
00:27:33,910 --> 00:27:36,990
Con un while tienes que hacer algunos cambios ahí que te dicen por qué hace eso.

416
00:27:37,250 --> 00:27:40,490
Y es para forzar que la condición sea verdadera y poder entrar.

417
00:27:40,849 --> 00:27:42,069
Entonces tú usas un do while.

418
00:27:44,230 --> 00:27:44,950
Para decir.

419
00:27:49,289 --> 00:27:52,069
Ejemplo de do while, esta cosa de aquí, ¿qué hace?

420
00:27:52,069 --> 00:28:08,640
vamos a ver

421
00:28:08,640 --> 00:28:14,339
do

422
00:28:14,339 --> 00:28:22,349
sistema

423
00:28:22,349 --> 00:28:25,349
punto

424
00:28:25,349 --> 00:28:28,190
auto.println

425
00:28:28,190 --> 00:28:28,630
i

426
00:28:28,630 --> 00:28:31,730
y más

427
00:28:31,730 --> 00:28:36,440
huile

428
00:28:36,440 --> 00:28:38,359
i

429
00:28:38,359 --> 00:28:41,480
menor o igual a 10

430
00:28:41,480 --> 00:28:43,140
punto y coma aquí

431
00:28:43,140 --> 00:28:48,339
vale

432
00:28:48,339 --> 00:28:51,420
aquí pongo i es igual a 1

433
00:28:51,420 --> 00:28:53,119
otra vez

434
00:28:53,119 --> 00:28:56,670
estos dos señores

435
00:28:56,670 --> 00:29:01,400
hacen lo mismo

436
00:29:01,400 --> 00:29:04,440
este escribe de 1 a 10

437
00:29:04,440 --> 00:29:06,460
y este escribe de 1 a 10

438
00:29:06,460 --> 00:29:08,099
son iguales

439
00:29:08,099 --> 00:29:10,259
¿Hace lo mismo?

440
00:29:14,759 --> 00:29:15,920
Imaginaos esto.

441
00:29:24,200 --> 00:29:26,519
Ah, apretad, que aquí también tengo por aquí.

442
00:29:27,819 --> 00:29:28,380
No es trampa.

443
00:29:35,549 --> 00:29:36,829
¿Por qué esto?

444
00:29:37,210 --> 00:29:39,410
Llega aquí y dice 15 menos el que 10.

445
00:29:40,450 --> 00:29:41,089
No.

446
00:29:41,410 --> 00:29:42,670
Entonces se lo salta y se acabó.

447
00:29:43,690 --> 00:29:46,569
Esto empieza de 15 y dice, escríbelo.

448
00:29:47,089 --> 00:29:53,289
Zumba 1, llegas a 16, y ahora dices, ¿16 es menor que 10?

449
00:29:53,990 --> 00:29:54,549
No.

450
00:29:54,890 --> 00:29:55,630
Entonces se acaba.

451
00:29:56,490 --> 00:30:01,109
Pero en esto no lo ha escrito, y en este sí ha escrito el primero.

452
00:30:01,930 --> 00:30:05,910
En este, aquí, ¿cuánto vale y aquí?

453
00:30:11,240 --> 00:30:12,740
En este punto, ¿cuánto vale y?

454
00:30:12,819 --> 00:30:13,180
15.

455
00:30:13,519 --> 00:30:13,859
15.

456
00:30:14,380 --> 00:30:15,920
En este punto, ¿cuánto vale y?

457
00:30:16,019 --> 00:30:16,420
16.

458
00:30:16,619 --> 00:30:17,180
16.

459
00:30:18,539 --> 00:30:19,099
¿Sí?

460
00:30:19,099 --> 00:30:22,539
son muy parecidos

461
00:30:22,539 --> 00:30:23,160
sí

462
00:30:23,160 --> 00:30:26,220
pero pueden tener un comportamiento distinto

463
00:30:26,220 --> 00:30:28,099
esto, este

464
00:30:28,099 --> 00:30:30,619
incremento lo hará siempre al menos

465
00:30:30,619 --> 00:30:32,380
una vez, este de aquí

466
00:30:32,380 --> 00:30:34,019
puede que no lo haga nunca

467
00:30:34,019 --> 00:30:37,500
¿dudas?

468
00:30:46,059 --> 00:30:46,339
vale

469
00:30:46,339 --> 00:30:54,079
si, veamos también el for

470
00:30:54,079 --> 00:30:55,440
tanto lo repasamos la próxima semana

471
00:30:55,440 --> 00:30:57,440
entonces, el otro

472
00:30:57,440 --> 00:31:00,039
while y do while son prácticamente lo mismo

473
00:31:00,039 --> 00:31:02,000
la otra sintaxis

474
00:31:02,000 --> 00:31:04,960
que tenemos, la otra estructura

475
00:31:04,960 --> 00:31:07,839
que podemos utilizar es el for. Se utiliza cuando

476
00:31:07,839 --> 00:31:10,160
se necesita ejecutar una serie de sentencias

477
00:31:10,160 --> 00:31:13,059
un número fijo y conocido de veces.

478
00:31:13,960 --> 00:31:16,740
Quiero hacer esto siete veces. Ejercicio.

479
00:31:17,160 --> 00:31:19,599
Dame diez números y los sumo.

480
00:31:19,940 --> 00:31:22,839
Sé que tengo que leer diez números. Pues es un for.

481
00:31:23,180 --> 00:31:30,099
¿Cómo funciona? Hay tres pasos.

482
00:31:30,660 --> 00:31:32,140
Hay una inicialización.

483
00:31:32,140 --> 00:31:36,819
Luego, como en el while se verifica una condición

484
00:31:36,819 --> 00:31:40,279
Si es verdadera, hace las instrucciones

485
00:31:40,279 --> 00:31:42,519
Y al final de las instrucciones

486
00:31:42,519 --> 00:31:46,619
Hace una actualización de las variables

487
00:31:46,619 --> 00:31:47,460
¿Vale?

488
00:31:47,900 --> 00:31:48,740
Inicializa

489
00:31:48,740 --> 00:31:50,559
Verifica

490
00:31:50,559 --> 00:31:51,880
Actualiza

491
00:31:51,880 --> 00:31:53,579
Y luego empieza aquí

492
00:31:53,579 --> 00:31:54,980
Actualiza y verifica

493
00:31:54,980 --> 00:31:55,940
Actualiza y verifica

494
00:31:55,940 --> 00:31:56,940
Actualiza y verifica

495
00:31:56,940 --> 00:31:58,500
Como sea es esto

496
00:31:58,500 --> 00:31:59,119
¿Vale?

497
00:31:59,779 --> 00:32:00,799
Entonces, for

498
00:32:00,799 --> 00:32:01,920
Para

499
00:32:01,920 --> 00:32:03,740
por, por, por

500
00:32:03,740 --> 00:32:06,400
int i que va

501
00:32:06,400 --> 00:32:07,640
desde cero

502
00:32:07,640 --> 00:32:10,680
mientras que sea menor que diez

503
00:32:10,680 --> 00:32:12,279
la actualización

504
00:32:12,279 --> 00:32:13,220
i más más

505
00:32:13,220 --> 00:32:15,279
lo repito

506
00:32:15,279 --> 00:32:18,480
inicialización, por donde empiezo

507
00:32:18,480 --> 00:32:20,539
tú crea una variable

508
00:32:20,539 --> 00:32:22,259
i que vale cero

509
00:32:22,259 --> 00:32:22,859
al principio

510
00:32:22,859 --> 00:32:25,940
¿cuál es la condición

511
00:32:25,940 --> 00:32:27,799
que voy a utilizar? esta

512
00:32:27,799 --> 00:32:30,240
está en el medio, que i sea menor

513
00:32:30,240 --> 00:32:38,900
que 10. Y cada vez que llego al final, antes de volver a comprobar esta condición, ¿cómo

514
00:32:38,900 --> 00:32:46,299
la actualizo? Pues con i++. Súmale un. Entonces, la primera vez que entro aquí, i valdrá

515
00:32:46,299 --> 00:33:11,170
la segunda a 1, la tercera a 2, la cuarta a 3, y me escribe los números de 0 a 9, porque el menor es tecto.

516
00:33:11,170 --> 00:33:17,170
Cuando entrará aquí, hará la actualización, llegará a 10 y va a mirar si 10 es menor que 10,

517
00:33:17,170 --> 00:33:18,549
aquel no, y sale.

518
00:33:21,579 --> 00:33:23,119
O sea, que esto es parecido

519
00:33:23,119 --> 00:33:24,660
a los otros dos que hemos hecho.

520
00:33:25,839 --> 00:33:27,200
Voy aquí.

521
00:33:35,000 --> 00:33:36,279
Entonces, esto lo vuelvo a 1,

522
00:33:36,440 --> 00:33:37,400
esto lo vuelvo a 1.

523
00:33:40,009 --> 00:33:41,509
Entonces, tengo

524
00:33:41,509 --> 00:33:42,950
mi variable i

525
00:33:42,950 --> 00:33:45,490
que empieza y hace, mientras que

526
00:33:45,490 --> 00:33:47,329
se me enriquece 0, hace esta de aquí,

527
00:33:47,509 --> 00:33:49,430
pues me escribe los números de 1

528
00:33:49,430 --> 00:33:50,890
a 10 incluido.

529
00:33:51,369 --> 00:33:53,410
Este de aquí me escribe los números de 1

530
00:33:53,410 --> 00:33:55,529
a 10 incluido. Es decir,

531
00:33:55,609 --> 00:33:57,190
que estos dos están haciendo lo mismo.

532
00:33:57,309 --> 00:33:58,910
de 1 a 10

533
00:33:58,910 --> 00:34:02,630
ahora si quisiera hacer lo mismo con el for

534
00:34:02,630 --> 00:34:03,529
diría

535
00:34:03,529 --> 00:34:04,730
for

536
00:34:04,730 --> 00:34:07,650
una variable

537
00:34:07,650 --> 00:34:10,590
int j

538
00:34:10,590 --> 00:34:12,190
es igual a 0

539
00:34:12,190 --> 00:34:15,010
podría hacer así

540
00:34:15,010 --> 00:34:18,400
estaría utilizando

541
00:34:18,400 --> 00:34:19,099
la variable id

542
00:34:19,099 --> 00:34:21,300
normalmente en un for

543
00:34:21,300 --> 00:34:24,059
se suele declarar

544
00:34:24,059 --> 00:34:25,840
una nueva variable aquí dentro

545
00:34:25,840 --> 00:34:28,159
y esta variable de aquí es como un índice

546
00:34:28,159 --> 00:34:30,539
es como un contador que te dice

547
00:34:30,539 --> 00:34:32,360
a qué punto del for estoy

548
00:34:32,360 --> 00:34:33,039
¿vale?

549
00:34:34,079 --> 00:34:36,380
punto y coma, o de uno

550
00:34:36,380 --> 00:34:38,059
hemos dicho, porque contamos de uno a diez

551
00:34:38,059 --> 00:34:40,739
mientras que j

552
00:34:40,739 --> 00:34:42,360
sea menor

553
00:34:42,360 --> 00:34:43,940
o igual que diez

554
00:34:43,940 --> 00:34:46,340
por cada ciclo

555
00:34:46,340 --> 00:34:48,000
j más más

556
00:34:48,000 --> 00:34:53,050
piso j

557
00:34:53,050 --> 00:34:55,230
esto

558
00:34:55,230 --> 00:34:56,849
hace lo mismo

559
00:34:56,849 --> 00:34:57,750
que los otros y

560
00:34:57,750 --> 00:35:06,199
de uno a diez

561
00:35:06,199 --> 00:35:17,730
Si os fijáis, alguien lo ha dicho al principio, si no me equivoco, sí, este de aquí, más

562
00:35:17,730 --> 00:35:24,030
o menos, en cuántas veces lo hago, es un Ford, y de hecho, el Ford, aquí me sale mucho

563
00:35:24,030 --> 00:35:30,730
más elegante que esta cosa, mucho más bonito, mucho más compacto, mucho más...

564
00:35:30,730 --> 00:35:36,769
Porque en un caso como esto, que das cuenta de 1 a 10, pues es mejor un Ford que un van,

565
00:35:36,769 --> 00:36:10,460
sé cuántas veces lo tengo que hacer. ¿Dudas? A ver si aquí hay algo más. Vale, este es el primer ejemplo, vale, fijaos que si yo declaro esta variable aquí dentro, en el for, la puedo usar aquí fuera.

566
00:36:10,460 --> 00:36:12,679
puede hacer yo si hizo

567
00:36:12,679 --> 00:36:14,659
de j aquí fuera

568
00:36:14,659 --> 00:36:16,500
no te lo va a detectar

569
00:36:16,500 --> 00:36:18,559
no existe

570
00:36:18,559 --> 00:36:21,519
porque las variables que declaro

571
00:36:21,519 --> 00:36:23,380
aquí solo existen

572
00:36:23,380 --> 00:36:25,320
en este block, solo existen

573
00:36:25,320 --> 00:36:26,159
dentro del for

574
00:36:26,159 --> 00:36:29,480
y como podría hacer para escribir

575
00:36:29,480 --> 00:36:29,960
j aquí

576
00:36:29,960 --> 00:36:32,699
poniéndolo fuera

577
00:36:32,699 --> 00:36:35,159
declaro antes

578
00:36:35,159 --> 00:36:37,420
int j es igual a 0

579
00:36:37,420 --> 00:36:39,199
aquí se enfada

580
00:36:39,199 --> 00:36:40,920
porque dice, oye, j ya existe

581
00:36:40,920 --> 00:36:42,980
entonces no la declaro

582
00:36:42,980 --> 00:36:44,980
simplemente la inicializo

583
00:36:44,980 --> 00:36:47,039
y ahora

584
00:36:47,039 --> 00:36:48,420
cuando ha acabado el for

585
00:36:48,420 --> 00:36:50,619
j sigue existiendo

586
00:36:50,619 --> 00:36:53,199
porque su ámbito

587
00:36:53,199 --> 00:36:54,500
su scope

588
00:36:54,500 --> 00:36:57,380
¿se acuerdan? es el ámbito de una variable, lo hemos visto

589
00:36:57,380 --> 00:36:59,280
pues es el bloque

590
00:36:59,280 --> 00:37:00,380
donde está creada

591
00:37:00,380 --> 00:37:02,980
y el bloque donde está creado no es esto

592
00:37:02,980 --> 00:37:04,099
ma es esto

593
00:37:04,099 --> 00:37:08,159
y entonces la puedo utilizar

594
00:37:08,159 --> 00:37:11,139
¿dudas?

595
00:37:11,139 --> 00:37:16,980
vale, esto es lo que os dice esta transparencia de aquí

596
00:37:16,980 --> 00:37:20,239
dice si yo declaro int fuera

597
00:37:20,239 --> 00:37:23,000
luego la inicializo, pongo

598
00:37:23,000 --> 00:37:26,679
en la condición, pongo la actualización

599
00:37:26,679 --> 00:37:29,500
hago lo que sea, luego la puedo utilizar

600
00:37:29,500 --> 00:37:31,579
fuera, vale

601
00:37:31,579 --> 00:37:35,380
y este de aquí me escribiría 0, 1 y 2

602
00:37:35,380 --> 00:37:38,360
empieza de 0, menor estricto de 3

603
00:37:38,360 --> 00:37:40,000
0, 1 y 2

604
00:37:40,000 --> 00:37:45,039
si lo hago así

605
00:37:45,039 --> 00:37:47,400
sería incorrecto porque la i

606
00:37:47,400 --> 00:37:49,079
la he declarado solo aquí

607
00:37:49,079 --> 00:37:50,679
y es local al bucle

608
00:37:50,679 --> 00:37:53,960
es una variable local dentro de este bloque

609
00:37:53,960 --> 00:37:55,380
por lo tanto fuera

610
00:37:55,380 --> 00:37:56,960
no la puedo utilizar

611
00:37:56,960 --> 00:37:59,639
¿está claro?

612
00:38:02,739 --> 00:38:05,039
puedo anidar un for dentro de un for

613
00:38:05,039 --> 00:38:06,800
y esto es un infierno

614
00:38:06,800 --> 00:38:09,250
¿ok?

615
00:38:10,690 --> 00:38:12,010
esta cosa de aquí

616
00:38:12,010 --> 00:38:14,230
escribe esta cosa de aquí

617
00:38:14,230 --> 00:38:16,869
¿vale? suerte con entender

618
00:38:16,869 --> 00:38:26,449
la vamos a intentar ver

619
00:38:26,449 --> 00:38:26,989
esta

620
00:38:26,989 --> 00:38:29,849
claro

621
00:38:29,849 --> 00:38:33,719
es más, tú

622
00:38:33,719 --> 00:38:36,280
aquí puedes declarar dos o tres variables

623
00:38:36,280 --> 00:38:37,320
si tú quieres, haces

624
00:38:37,320 --> 00:38:40,059
int i es igual a uno, j es igual a tres

625
00:38:40,059 --> 00:38:42,039
coma k es igual a nueve

626
00:38:42,039 --> 00:38:44,019
y luego haces las actualizaciones

627
00:38:44,019 --> 00:38:45,739
con varias cosas, la actualización

628
00:38:45,739 --> 00:38:47,380
nosotros solemos usar i más más

629
00:38:47,380 --> 00:38:48,500
Pero puede ser I más

630
00:38:48,500 --> 00:38:51,340
O sea, I igual a I más 7

631
00:38:51,340 --> 00:38:54,079
O I igual a I por 54

632
00:38:54,079 --> 00:38:56,079
Lo importante es que cambie I

633
00:38:56,079 --> 00:38:59,059
Porque si no cambia esta cosa

634
00:38:59,059 --> 00:39:00,239
Estoy en un for

635
00:39:00,239 --> 00:39:06,539
Entonces, vamos a ver si entendemos esto

636
00:39:06,539 --> 00:39:13,119
A ver, ¿cómo lo escribo yo?

637
00:39:21,289 --> 00:39:21,670
Eint

638
00:39:21,670 --> 00:39:32,119
Vale

639
00:39:32,119 --> 00:39:35,000
Vamos a ver qué pasa

640
00:39:35,000 --> 00:39:40,119
entonces

641
00:39:40,119 --> 00:39:43,679
los for anidados son un for dentro de un for

642
00:39:43,679 --> 00:39:45,320
es una de las cosas

643
00:39:45,320 --> 00:39:47,119
más peligrosas que podéis hacer

644
00:39:47,119 --> 00:39:49,059
en ámbito computacional

645
00:39:49,059 --> 00:39:51,579
¿vale? cuando for entra en the for

646
00:39:51,579 --> 00:39:53,199
y while entra dentro de while

647
00:39:53,199 --> 00:39:53,840
la

648
00:39:53,840 --> 00:39:57,260
el número de ciclos

649
00:39:57,260 --> 00:39:59,159
que se hace es posible

650
00:39:59,159 --> 00:40:01,679
que explote exponencialmente

651
00:40:02,219 --> 00:40:02,880
entonces cuidado

652
00:40:02,880 --> 00:40:05,860
For dentro de for

653
00:40:05,860 --> 00:40:07,280
Hay que hacerlos bien

654
00:40:07,280 --> 00:40:08,619
Además no se tiene que hacer

655
00:40:08,619 --> 00:40:09,800
Sí, se tiene que hacer

656
00:40:09,800 --> 00:40:10,579
Hay cosas que

657
00:40:10,579 --> 00:40:12,519
Las tienes que hacer con un for dentro de un for

658
00:40:12,519 --> 00:40:14,119
Y un for dentro de un for dentro de un for

659
00:40:14,119 --> 00:40:16,699
Pero cuando empiezas con cosas así

660
00:40:16,699 --> 00:40:18,099
Es posible que

661
00:40:18,099 --> 00:40:20,679
Problemas relativamente sencillos

662
00:40:20,679 --> 00:40:23,760
Pues tarden mucho tiempo en acabarse

663
00:40:23,760 --> 00:40:26,800
Porque estás haciendo un montón de ciclos ahí dentro

664
00:40:26,800 --> 00:40:27,360
¿Vale?

665
00:40:27,639 --> 00:40:30,139
La idea es que aquí hay dos for

666
00:40:30,139 --> 00:40:31,280
Uno aquí

667
00:40:31,280 --> 00:40:35,980
uno

668
00:40:35,980 --> 00:41:01,389
¿cómo se quita esta cosa aquí al lado?

669
00:41:02,329 --> 00:41:03,909
quítate, no te quiero

670
00:41:03,909 --> 00:41:13,780
entonces

671
00:41:13,780 --> 00:41:17,400
uno es este

672
00:41:17,400 --> 00:41:18,920
Ford de aquí

673
00:41:18,920 --> 00:41:23,559
y dentro

674
00:41:23,559 --> 00:41:25,739
hay otro Ford

675
00:41:25,739 --> 00:41:30,210
esto quiere decir que por cada uno

676
00:41:30,210 --> 00:41:31,590
de los ciclos

677
00:41:31,590 --> 00:41:33,289
negros

678
00:41:33,289 --> 00:41:35,929
se harán varios

679
00:41:35,929 --> 00:41:37,389
ciclos rojos.

680
00:41:39,150 --> 00:41:39,690
¿Entiende?

681
00:41:40,269 --> 00:41:42,090
Vamos a probar

682
00:41:42,090 --> 00:41:42,889
a entenderlo.

683
00:41:44,130 --> 00:41:46,150
Entro en la parte negra,

684
00:41:46,329 --> 00:41:47,550
¿vale? Donde

685
00:41:47,550 --> 00:41:49,769
creo una variable y

686
00:41:49,769 --> 00:41:54,469
y

687
00:41:54,469 --> 00:41:56,630
que vale

688
00:41:56,630 --> 00:41:59,269
y

689
00:41:59,269 --> 00:42:06,949
¿cuánto vale?

690
00:42:06,949 --> 00:42:07,809
Uno.

691
00:42:11,059 --> 00:42:11,539
¿Están de acuerdo?

692
00:42:12,340 --> 00:42:16,079
Vale. Me dice, ¿y es menor o igual a dos?

693
00:42:17,179 --> 00:42:22,260
Sí. Por lo tanto, entro dentro de este bloque, el bloque negro.

694
00:42:23,000 --> 00:42:26,360
¿Vale? Y encuentro un for, que me dice, oye, mira,

695
00:42:27,440 --> 00:42:33,239
creo una variable j, que vale uno.

696
00:42:34,340 --> 00:42:36,880
Y me pregunto, ¿uno es menor o igual que dos?

697
00:42:37,539 --> 00:42:39,920
Sí. Por lo tanto, entro aquí dentro.

698
00:42:39,920 --> 00:42:47,380
y me encuentro un system.auto.println que me escribe i, j y i más j, i por j, ¿vale?

699
00:42:47,380 --> 00:43:03,360
Entonces, i vale 1, este es el resultado, ¿vale? 1, j vale 1, y 1 por 1, 1.

700
00:43:03,360 --> 00:43:07,239
He acabado el suelo interno

701
00:43:07,239 --> 00:43:08,539
Por lo tanto

702
00:43:08,539 --> 00:43:10,159
Actualizo

703
00:43:10,159 --> 00:43:11,079
J

704
00:43:11,079 --> 00:43:13,559
J

705
00:43:13,559 --> 00:43:15,579
Uno más uno

706
00:43:15,579 --> 00:43:17,260
Dos

707
00:43:17,260 --> 00:43:20,159
Vuelvo aquí y me pregunto

708
00:43:20,159 --> 00:43:21,679
¿Dos es menor o igual que dos?

709
00:43:22,440 --> 00:43:23,079
Sí

710
00:43:23,079 --> 00:43:26,059
Por lo tanto entro otra vez aquí dentro

711
00:43:26,059 --> 00:43:27,420
Y escribo I

712
00:43:27,420 --> 00:43:32,760
Uno

713
00:43:32,760 --> 00:43:34,099
Y es uno

714
00:43:34,099 --> 00:43:36,550
J

715
00:43:36,550 --> 00:43:51,610
¿Cuánto vale j? 2. ¿Y 2 por 1? 2. Llego al final, actualizo j. Por lo tanto, j se transforma en 3.

716
00:43:52,210 --> 00:44:04,989
Y me pregunto, ¿3 es menor o igual que 2? No. Por lo tanto, salgo del bloque rojo. Llego aquí y vuelvo

717
00:44:04,989 --> 00:44:12,250
arriba donde actualizó y entonces y ahora se transforma en

718
00:44:12,250 --> 00:44:19,670
2 teniendo en cuenta que al salir de este for este j

719
00:44:19,670 --> 00:44:26,230
está perdido ya no existe entonces actualizó y a dos me pregunto

720
00:44:26,230 --> 00:44:31,789
dos es menor o igual que dos si entonces centro dentro y me dice hoy mira hay un

721
00:44:31,789 --> 00:44:46,269
for, crea j, veo j, ¿cuánto vale j? 1. Y ahora llego aquí y dice, ¿cuánto vale i? 2. ¿Cuánto

722
00:44:46,269 --> 00:44:56,650
vale j? 1. Y 2 por 1, 2. Llego al final aquí, vuelvo aquí y me dice, oye, actualiza j. Vale,

723
00:44:56,650 --> 00:44:58,489
j se vuelve 2.

724
00:44:58,849 --> 00:45:00,230
2 es menor o igual que 2.

725
00:45:00,710 --> 00:45:02,889
Sí. Entro dentro

726
00:45:02,889 --> 00:45:04,829
y digo, vale, muy bien.

727
00:45:05,090 --> 00:45:06,369
Escribo estas cosas aquí.

728
00:45:06,650 --> 00:45:08,989
Entonces me sale, i es 2,

729
00:45:09,750 --> 00:45:10,650
j es 2,

730
00:45:11,269 --> 00:45:12,469
y 2 por 2 es 4.

731
00:45:13,869 --> 00:45:14,030
Bien.

732
00:45:14,630 --> 00:45:16,809
Ahora llego aquí y actualizo

733
00:45:16,809 --> 00:45:18,829
j. j se transforma

734
00:45:18,829 --> 00:45:20,989
en 3. 3 es menor o igual

735
00:45:20,989 --> 00:45:22,530
que 2. No.

736
00:45:22,949 --> 00:45:24,769
Por lo tanto salgo del bloque rojo

737
00:45:24,769 --> 00:45:26,489
y j desaparece.

738
00:45:26,650 --> 00:45:28,909
porque estoy fuera de su ámbito

739
00:45:28,909 --> 00:45:30,050
ya no existe

740
00:45:30,050 --> 00:45:32,889
vuelvo aquí arriba y actualizo

741
00:45:32,889 --> 00:45:37,639
i, vale 3i

742
00:45:37,639 --> 00:45:39,480
y me pregunto, 3

743
00:45:39,480 --> 00:45:41,059
es menor o igual que 2

744
00:45:41,059 --> 00:45:43,420
no, por lo tanto salgo

745
00:45:43,420 --> 00:45:45,400
también de este bloque y ya no

746
00:45:45,400 --> 00:45:46,860
existe y esto es lo que

747
00:45:46,860 --> 00:45:48,539
he escrito en pantalla

748
00:45:48,539 --> 00:45:54,980
esta parte divertida

749
00:45:54,980 --> 00:45:55,800
si

750
00:46:03,559 --> 00:46:12,420
la variable existe

751
00:46:12,420 --> 00:46:14,480
por favor chicos, que lo vamos a preguntar

752
00:46:14,480 --> 00:46:16,260
7000 veces, la variable existe

753
00:46:16,260 --> 00:46:17,400
solo en su ámbito

754
00:46:17,400 --> 00:46:20,059
en su ámbito, vale

755
00:46:20,059 --> 00:46:22,400
entonces cuando yo entro en este for y creo

756
00:46:22,400 --> 00:46:24,059
j, j existe

757
00:46:24,059 --> 00:46:25,860
mientras que esté en este bloque

758
00:46:25,860 --> 00:46:27,219
en este bloque aquí

759
00:46:27,219 --> 00:46:30,099
si, en el momento

760
00:46:30,099 --> 00:46:31,739
en que salgo de este bloque

761
00:46:31,739 --> 00:46:33,320
esa variable

762
00:46:33,320 --> 00:46:35,599
se destruye, ya no existe

763
00:46:35,599 --> 00:46:37,699
ya, yo podría

764
00:46:37,699 --> 00:46:39,460
declarar aquí otra variable j

765
00:46:39,460 --> 00:46:41,780
que ya no existe, ahora si vuelvo

766
00:46:41,780 --> 00:46:43,679
a entrar allí dentro, declaro

767
00:46:43,679 --> 00:46:45,579
otra variable j, pero no es

768
00:46:45,579 --> 00:46:47,619
la anterior, es nueva, es otro bloque de memoria

769
00:46:47,619 --> 00:46:49,719
con dentro el valor que me metí

770
00:46:49,719 --> 00:46:50,059
aquí

771
00:46:50,059 --> 00:46:53,480
si yo quisiera

772
00:46:53,480 --> 00:46:54,739
que persistiera

773
00:46:54,739 --> 00:46:57,239
la declaración la debería hacer fuera

774
00:46:57,239 --> 00:46:59,440
y entonces j existe

775
00:46:59,440 --> 00:47:06,010
No sé si me explico de qué.

776
00:47:06,010 --> 00:47:07,010
¿Dudas?

777
00:47:07,010 --> 00:47:08,010
Súper fácil.

778
00:47:08,010 --> 00:47:11,010
Hacemos algún ejercicio de prueba.

779
00:47:11,010 --> 00:47:12,010
¡Venga!

780
00:47:12,010 --> 00:47:27,719
¿Se puede hacer un sistema de planchac con esto ya?

781
00:47:27,719 --> 00:47:30,719
Sí, es ilegal hacerlo en la escuela.

782
00:47:30,719 --> 00:47:37,300
vamos a hacer

783
00:47:37,300 --> 00:47:37,679
a ver

784
00:47:37,679 --> 00:47:38,800
es posible que

785
00:47:38,800 --> 00:47:40,059
alguno de estos ejercicios

786
00:47:40,059 --> 00:47:40,860
que haga ahora

787
00:47:40,860 --> 00:47:41,900
sean ejercicios

788
00:47:41,900 --> 00:47:42,960
que luego os mando

789
00:47:42,960 --> 00:47:43,539
para casa

790
00:47:43,539 --> 00:47:43,860
¿vale?

791
00:47:43,940 --> 00:47:45,659
porque no me da la vida

792
00:47:45,659 --> 00:47:47,280
de recordarme

793
00:47:47,280 --> 00:47:47,940
cuáles están

794
00:47:47,940 --> 00:47:48,320
en la

795
00:47:48,320 --> 00:47:49,780
en los enunciados

796
00:47:49,780 --> 00:47:50,539
¿vale?

797
00:47:51,000 --> 00:47:51,559
entonces

798
00:47:51,559 --> 00:47:53,380
no, no

799
00:47:53,380 --> 00:47:54,000
si estos vienen

800
00:47:54,000 --> 00:47:54,579
de mil años

801
00:47:54,579 --> 00:47:55,239
hace mil años

802
00:47:55,239 --> 00:47:56,300
pero son siempre los mismos

803
00:47:56,300 --> 00:47:56,840
porque son

804
00:47:56,840 --> 00:47:58,559
ejercicio

805
00:47:58,559 --> 00:48:01,219
pido al usuario

806
00:48:01,219 --> 00:48:03,280
10 números

807
00:48:03,280 --> 00:48:04,519
y los sumo

808
00:48:04,519 --> 00:48:05,960
¿sí?

809
00:48:06,599 --> 00:48:08,000
¿cómo lo hago?

810
00:48:09,360 --> 00:48:11,460
scanner, scan es igual a

811
00:48:11,460 --> 00:48:12,579
new scanner

812
00:48:12,579 --> 00:48:14,420
existen punto int

813
00:48:14,420 --> 00:48:16,980
normalmente vosotros

814
00:48:16,980 --> 00:48:18,860
habríais hecho antes

815
00:48:18,860 --> 00:48:24,199
int

816
00:48:24,199 --> 00:48:26,599
n1 es igual a

817
00:48:26,599 --> 00:48:28,340
scan punto next int

818
00:48:28,340 --> 00:48:31,139
¿sí?

819
00:48:31,820 --> 00:48:33,320
y luego habríais hecho esto

820
00:48:33,320 --> 00:48:43,289
Y dos, tres, cuatro, ¿si? Se entiende el sentido.

821
00:48:43,289 --> 00:48:46,289
Y yo os digo, vale, entonces si es así, pues dame cien números.

822
00:48:46,289 --> 00:48:52,289
Y vosotros, porque sois trabajadores, uno, dos, ene, uno, ene, dos, ene, tres, ene, cuatro, ene, cinco, hasta ene, cien.

823
00:48:52,289 --> 00:48:54,289
Dame diez mil números.

824
00:48:54,289 --> 00:48:56,289
Llega un momento en que esto no se puede hacer.

825
00:48:56,289 --> 00:48:58,289
¿Cómo se hace?

826
00:48:58,289 --> 00:49:10,889
Pues int o final, int, si usamos una cosa, números, adendos, ¿cómo se dice?

827
00:49:10,889 --> 00:49:16,010
Números es igual a 10. Este es el número que voy a pedir.

828
00:49:16,670 --> 00:49:18,289
Esto sería mayúsculo, num.

829
00:49:19,909 --> 00:49:24,829
Entonces ahora en vez de pedirlo 10 veces, digo, follow int.

830
00:49:28,289 --> 00:49:29,369
¿For o why?

831
00:49:29,969 --> 00:49:31,010
¿Por qué for?

832
00:49:32,329 --> 00:49:34,210
Porque sé que son este num.

833
00:49:34,889 --> 00:49:35,050
¿Sí?

834
00:49:35,510 --> 00:49:44,730
Entonces digo, for int i es igual a cero, i menor que num, i más más.

835
00:49:45,670 --> 00:49:46,869
¿Cuántas veces lo hago esto?

836
00:49:52,269 --> 00:49:56,829
¿Cuántas veces se ejecutará este ciclo?

837
00:49:56,829 --> 00:50:06,820
¿cuántas veces repito

838
00:50:06,820 --> 00:50:07,699
este bloque?

839
00:50:08,260 --> 00:50:08,679
12

840
00:50:08,679 --> 00:50:18,619
pongamos nomba 1

841
00:50:18,619 --> 00:50:19,380
¿vale?

842
00:50:20,599 --> 00:50:22,820
y es igual a 0, 0 es menor

843
00:50:22,820 --> 00:50:24,940
que 1, una vez

844
00:50:24,940 --> 00:50:26,860
1 es menor que 1

845
00:50:26,860 --> 00:50:30,360
no, por lo tanto lo he ejecutado una vez

846
00:50:30,360 --> 00:50:32,159
si pongo esta 3

847
00:50:32,159 --> 00:50:34,340
Entra aquí

848
00:50:34,340 --> 00:50:34,980
0

849
00:50:34,980 --> 00:50:36,380
0 es menor que 3

850
00:50:36,380 --> 00:50:38,059
Sí, una vez

851
00:50:38,059 --> 00:50:39,420
Sumo 1

852
00:50:39,420 --> 00:50:40,659
1 es menor que 3

853
00:50:40,659 --> 00:50:41,619
Sí

854
00:50:41,619 --> 00:50:43,159
2 es menor que 3

855
00:50:43,159 --> 00:50:45,159
3 es menor que 3

856
00:50:45,159 --> 00:50:46,320
¿Cuántas veces?

857
00:50:47,260 --> 00:50:49,079
Entonces, ¿cuántas veces se ejecuta esto?

858
00:50:52,139 --> 00:50:52,639
Y ahora

859
00:50:52,639 --> 00:50:55,300
Y ahora

860
00:50:55,300 --> 00:50:58,059
Entonces, ¿cuántas veces se ejecuta esto?

861
00:51:01,059 --> 00:51:01,940
¿Cuántas veces son?

862
00:51:04,280 --> 00:51:05,320
Nun veces

863
00:51:05,320 --> 00:51:06,000
¿Vale?

864
00:51:06,119 --> 00:51:15,090
No lo sé cuánto es NUM, pero éste se ejecuta NUM veces.

865
00:51:15,090 --> 00:51:18,090
Podría hacer así.

866
00:51:18,090 --> 00:51:21,090
¿Cuántas veces se ejecuta esto?

867
00:51:21,090 --> 00:51:23,090
NUM veces.

868
00:51:23,090 --> 00:51:25,090
¿Cuántas veces se ejecuta esto?

869
00:51:25,090 --> 00:51:29,090
Menos uno NUM veces.

870
00:51:29,090 --> 00:51:31,090
NUM veces menos uno.

871
00:51:31,090 --> 00:51:33,090
NUM menos uno veces.

872
00:51:33,090 --> 00:51:35,090
Dile como quieras.

873
00:51:35,090 --> 00:51:37,090
¿Sí? ¿Está claro?

874
00:51:37,090 --> 00:51:39,090
¿Dudas?

875
00:51:39,090 --> 00:51:44,510
por razones prácticas

876
00:51:44,510 --> 00:51:45,869
legadas o no sabréis

877
00:51:45,869 --> 00:51:47,889
os aconsejo que hagáis así

878
00:51:47,889 --> 00:51:48,769
¿vale?

879
00:51:49,710 --> 00:51:51,070
¿y qué hago aquí?

880
00:51:51,530 --> 00:51:52,409
leo un número

881
00:51:52,409 --> 00:51:59,369
interresultado

882
00:51:59,369 --> 00:52:00,510
por favor chicos

883
00:52:00,510 --> 00:52:03,050
es igual a cero

884
00:52:03,050 --> 00:52:05,309
y aquí te digo que resultado

885
00:52:05,309 --> 00:52:07,349
más igual

886
00:52:07,349 --> 00:52:37,659
Y podría poner, dame el siguiente número para sumar.

887
00:52:37,659 --> 00:52:54,079
Y estamos a más y más uno, más, sobre, más uno.

888
00:52:55,880 --> 00:52:56,679
¡Maravilla!

889
00:52:59,170 --> 00:53:00,010
Empezamos.

890
00:53:02,590 --> 00:53:05,070
Pues, trescientos cincuenta y cinco son muchos, ¿vale?

891
00:53:05,150 --> 00:53:06,889
Vamos a meter un poquito menos.

892
00:53:07,489 --> 00:53:08,670
Vamos, ¿eh? Cinco números.

893
00:53:10,130 --> 00:53:10,530
¡Tazo!

894
00:53:10,530 --> 00:53:12,090
me dice

895
00:53:12,090 --> 00:53:14,570
dame el siguiente

896
00:53:14,570 --> 00:53:16,750
número para sumar 1 de 5

897
00:53:16,750 --> 00:53:18,670
¿vale? sumo 1

898
00:53:18,670 --> 00:53:20,909
dame el 2 de 5

899
00:53:20,909 --> 00:53:21,789
1

900
00:53:21,789 --> 00:53:23,869
dame el 3 de 5, 1

901
00:53:23,869 --> 00:53:25,469
4 de 5, 1

902
00:53:25,469 --> 00:53:26,929
5 de 5, 1

903
00:53:26,929 --> 00:53:28,289
o sea que resulta 5

904
00:53:28,289 --> 00:53:32,340
obviamente funciona con cualquier número

905
00:53:32,340 --> 00:53:34,699
yo hago 55

906
00:53:34,699 --> 00:53:37,300
55

907
00:53:37,300 --> 00:53:39,059
55 más

908
00:53:39,059 --> 00:53:52,320
solo que así no tengo ni idea de si esto es correcto. Si le pongo todos unos, sí. Entonces,

909
00:53:52,320 --> 00:54:00,739
vamos a mirar bien el código. ¿Qué hemos hecho? Hemos fijado un número, vale, ok. Hemos puesto un

910
00:54:00,739 --> 00:54:10,460
resultado inicial a cero, vale, diciendo empiezo desde cero, pi por numvejes, lo que he hecho es

911
00:54:10,460 --> 00:54:19,420
escribir, dame el siguiente número. Aquí he usado num, que es el número máximo sobre 5, ¿vale? Y este

912
00:54:19,420 --> 00:54:26,519
de aquí le he puesto i más 1, porque esto va de 0 a num menos 1. Entonces le sumo 1. Si hubiese

913
00:54:26,519 --> 00:54:39,460
ido así, de 1 a mayor o igual, pues entonces aquí le pongo i, porque el número será 1, 2, 3, 4, hasta el último.

914
00:54:39,460 --> 00:54:41,440
Y lo que hago es

915
00:54:41,440 --> 00:54:43,739
Resultado más igual scan.nexint

916
00:54:43,739 --> 00:54:45,500
Esto es equivalente a poner

917
00:54:45,500 --> 00:54:48,320
Resultado es igual a lo que hay en resultado

918
00:54:48,320 --> 00:54:50,539
Más lo que lees de teclado

919
00:54:50,539 --> 00:54:51,019
Como int

920
00:54:51,019 --> 00:54:55,389
Esto es equivalente a poner

921
00:54:55,389 --> 00:54:57,889
Resultado es igual

922
00:54:57,889 --> 00:54:59,349
A resultado

923
00:54:59,349 --> 00:55:02,130
Más scan.nexint

924
00:55:02,130 --> 00:55:13,539
¿Lo tenéis?

925
00:55:14,800 --> 00:55:15,099
¿Si?

926
00:55:18,239 --> 00:55:20,739
La multiplicación

927
00:55:20,739 --> 00:55:21,840
De los primeros

928
00:55:21,840 --> 00:55:33,380
cinco números que te pongo por teclado, lo mismo pero es con multiplicación. Dame cinco

929
00:55:33,380 --> 00:55:45,059
números y te lo multiplico entre ellos. ¿Cómo se hace? ¿Quién lo sabe hacer? Levante la

930
00:55:45,059 --> 00:55:54,239
mano. Veo una mano, pero no veo quién es. Venga, Samir, venga.

931
00:55:54,239 --> 00:56:02,920
esto

932
00:56:02,920 --> 00:56:08,340
esta parte de aquí

933
00:56:08,340 --> 00:56:09,880
vale

934
00:56:09,880 --> 00:56:11,539
tú escribes esto

935
00:56:11,539 --> 00:56:16,010
dame el siguiente número para sumar

936
00:56:16,010 --> 00:56:17,070
ya está

937
00:56:17,070 --> 00:56:19,269
y funcionaría, ¿no?

938
00:56:20,010 --> 00:56:22,590
dice 1, 1, 1, 1, 1

939
00:56:22,590 --> 00:56:24,409
pero no sé cuántos

940
00:56:24,409 --> 00:56:25,389
tengo que poner

941
00:56:25,389 --> 00:56:31,809
porque no me lo está diciendo aquí vale y entonces yo me he inventado y digo mira de

942
00:56:33,070 --> 00:56:40,449
en cada vez que me pide un número me diga a qué punto del algoritmo soy el punto del algoritmo

943
00:56:40,449 --> 00:56:47,010
que soy me lo dice y porque la primera vez valdrá 1 la segunda vez vale 2 la tercera vez vale 3

944
00:56:47,010 --> 00:57:03,869
Entonces le sumo detrás y esto me daría, me pega, lo que hace es, uno, si yo le pongo un número,

945
00:57:03,869 --> 00:57:12,809
me dice dos, si yo le pongo un número, tres, cuatro, cinco. Esto me está diciendo que cada

946
00:57:12,809 --> 00:57:18,750
vez es un ciclo distinto pero no me dice cuántos son en total está diciendo este

947
00:57:18,750 --> 00:57:23,130
es el primero de 7 el primero de 95 todavía no lo sé entonces yo le pegó

948
00:57:23,130 --> 00:57:33,050
detrás de si uno de y cuánto cuántos son todos

949
00:57:33,050 --> 00:57:49,190
esto me pondrá a sumar 1 de 5 2 de 5 3 de 5 entonces ahora lo tengo así 1 de 5 con vuelta

950
00:57:49,190 --> 00:58:02,900
aquí 2 de 5 3 de 5 4 de 5 y el último sí make sense más dudas entonces ejercicio para vosotros

951
00:58:02,900 --> 00:58:15,869
quiero hacer lo mismo pero en vez de sumar, multiplicando. ¿Qué hago? La i de final

952
00:58:15,869 --> 00:58:22,849
deformo cambiando. ¿Qué? Esta i, esta i.

953
00:58:22,849 --> 00:58:35,699
Cambiar los dos signos que hay de la i final, de esa misma línea, a la de num, punto y coma, i, no, arriba, línea 11,

954
00:58:35,699 --> 00:58:43,260
N, NUM, punto y coma, esa que está ahí, cambias los más más por asterisco, asterisco, ¿no?

955
00:58:43,260 --> 00:58:48,579
No, porque esto siempre lo tengo que hacer cinco veces, esto no cambia.

956
00:58:50,059 --> 00:58:54,099
Solo que lo que hago es que en vez de sumar los números que leo, los multiplico.

957
00:58:55,119 --> 00:58:56,980
Justo. Entonces, ¿qué hago?

958
00:58:57,219 --> 00:59:01,800
Es cambiar el más de resultados, más de cal, next, fin, en vez de más, eso.

959
00:59:01,800 --> 00:59:04,199
¿Lo lanzo? ¿Funciona?

960
00:59:04,880 --> 00:59:06,960
¿Quién dice que funciona sin hablar?

961
00:59:07,119 --> 00:59:07,679
¿No podéis hablar?

962
00:59:08,579 --> 00:59:09,500
¿Quién dice que funciona?

963
00:59:12,980 --> 00:59:14,519
¿Quién dice que no sabe las reglas

964
00:59:14,519 --> 00:59:16,800
más básicas de la multiplicación

965
00:59:16,800 --> 00:59:18,800
y que multiplicar por cero da siempre cero?

966
00:59:21,139 --> 00:59:23,139
¿Y quién dice que como resultado

967
00:59:23,139 --> 00:59:25,039
de cero al principio, por lo tanto

968
00:59:25,039 --> 00:59:26,280
esto me dará siempre cero?

969
00:59:30,369 --> 00:59:31,809
Cuidado, señores, ¿eh?

970
00:59:31,809 --> 00:59:34,789
Es verdad, multiplicar multiplicar.

971
00:59:35,389 --> 00:59:37,309
No, porque cero yo no lo he dado nunca.

972
00:59:40,469 --> 00:59:43,550
Yo cero no lo he dado nunca, pero no me da resultado cero.

973
00:59:43,829 --> 00:59:46,409
Cuando multiplica, no, porque no es mi ejercicio.

974
00:59:47,929 --> 00:59:50,250
Yo le doy uno por uno por uno por uno por uno.

975
00:59:50,510 --> 00:59:51,489
¿Cuánto debería dar?

976
00:59:52,769 --> 00:59:54,030
Uno, me da cero.

977
00:59:55,429 --> 00:59:57,449
Cuidado con estas cosillas, ¿vale?

978
00:59:57,889 --> 00:59:59,849
Es verdad, el profe me da un ejercicio fácil,

979
00:59:59,849 --> 01:00:02,469
ah, sí, solo tengo que poner el más el peor de aquí.

980
01:00:02,590 --> 01:00:04,190
No, pensadlo.

981
01:00:05,389 --> 01:00:11,429
Si el resultado empieza con 0 en la multiplicación, cuando hago esta cosa de aquí,

982
01:00:11,849 --> 01:00:14,230
será siempre 0 independientemente del número que pongo.

983
01:00:15,570 --> 01:00:22,940
Entonces si quiero que esto funcione, le pongo el neutro de la multiplicación, el neutro de la suma.

984
01:00:26,599 --> 01:00:30,639
Ahora ya, 2 por 2 por 2 por 2 por 2, 32.

985
01:00:32,639 --> 01:00:33,980
Se sabe que hay que cambiar el 0.

986
01:00:35,139 --> 01:00:38,320
Este 0, pero cuidado, que si ahora vuelvo a la suma,

987
01:00:38,320 --> 01:00:40,460
esto no funciona

988
01:00:40,460 --> 01:00:42,820
¿sí?

989
01:00:43,019 --> 01:00:44,420
porque si yo doy

990
01:00:44,420 --> 01:00:46,800
cinco veces

991
01:00:46,800 --> 01:00:48,179
uno más uno más uno más uno más uno

992
01:00:48,179 --> 01:00:48,760
me dice seis

993
01:00:48,760 --> 01:00:51,219
cuidado con lo que hacéis

994
01:00:51,219 --> 01:00:52,420
¿sí?

995
01:00:53,960 --> 01:00:55,519
si es con la suma aquí va cero

996
01:00:55,519 --> 01:00:57,019
si es con la multiplicación aquí va uno

997
01:00:57,019 --> 01:00:58,980
¿sí?

998
01:01:02,099 --> 01:01:02,500
vale

999
01:01:02,500 --> 01:01:03,880
entonces

1000
01:01:03,880 --> 01:01:07,000
dame

1001
01:01:07,000 --> 01:01:08,679
un número

1002
01:01:08,679 --> 01:01:11,119
nueve

1003
01:01:11,119 --> 01:01:13,099
y yo te sumo nueve números.

1004
01:01:17,260 --> 01:01:17,980
Dame tres

1005
01:01:17,980 --> 01:01:19,400
y yo te sumo tres números.

1006
01:01:19,719 --> 01:01:20,840
Dame cincuenta y ocho

1007
01:01:20,840 --> 01:01:22,219
y yo te sumo cincuenta y ocho números.

1008
01:01:23,219 --> 01:01:23,760
¿Qué cambio?

1009
01:01:31,300 --> 01:01:31,920
Lo quito.

1010
01:01:32,920 --> 01:01:33,519
¿Qué hago?

1011
01:01:40,139 --> 01:01:40,900
Refactor,

1012
01:01:41,679 --> 01:01:42,380
rename

1013
01:01:42,380 --> 01:01:43,920
y lo llamo end.

1014
01:01:44,380 --> 01:01:45,800
Vale, perfecto.

1015
01:01:47,539 --> 01:01:48,099
¿Y ahora qué hago?

1016
01:01:51,659 --> 01:01:53,699
Hola, en vez de hablar entre vosotros

1017
01:01:53,699 --> 01:01:54,920
podéis hacerme caso.

1018
01:01:55,420 --> 01:02:14,599
¿Cuántos números quieres sumar?

1019
01:02:19,730 --> 01:02:22,550
Entonces me dice, ¿cuántos números quieres sumar?

1020
01:02:26,230 --> 01:02:26,670
Siete.

1021
01:02:28,449 --> 01:02:30,610
Y me dice, dame el uno de siete.

1022
01:02:32,389 --> 01:02:33,530
Bueno, vamos con uno.

1023
01:02:33,530 --> 01:02:37,849
2 de 7, 3 de 7, 4 de 7, 5 de 7, 6 de 7, 7 de 7

1024
01:02:37,849 --> 01:02:38,469
7

1025
01:02:38,469 --> 01:02:40,389
que guapo

1026
01:02:40,389 --> 01:02:42,170
gracias

1027
01:02:42,170 --> 01:02:42,329
gracias

1028
01:02:42,329 --> 01:02:50,489
si

1029
01:02:50,489 --> 01:02:53,690
entonces ahora

1030
01:02:53,690 --> 01:02:56,150
yo ya no estoy solucionando

1031
01:02:56,150 --> 01:02:57,190
un problema

1032
01:02:57,190 --> 01:03:00,630
mas estoy solucionando una clase de problemas

1033
01:03:00,630 --> 01:03:04,670
aquí no hago la suma de cinco números

1034
01:03:04,670 --> 01:03:07,829
aquí hago la suma de una serie de números

1035
01:03:07,829 --> 01:03:12,650
de una serie larga N de números

1036
01:03:12,650 --> 01:03:18,449
esto, la potencia de los problemitas que puedo solucionar

1037
01:03:18,449 --> 01:03:20,670
acaba de explotar

1038
01:03:20,670 --> 01:03:25,769
puedo hacer problemas mucho más complejos que antes

1039
01:03:25,769 --> 01:03:27,449
¿dudas?

1040
01:03:30,630 --> 01:03:35,230
Vale