1
00:00:00,110 --> 00:00:07,110
Voy a grabar, por lo tanto, todo lo que digáis puede estar grabado y me autorizáis a grabarlo, ¿vale?

2
00:00:08,070 --> 00:00:14,910
Entonces, las otras veces estuvimos mirando las estructuras condicionales, ¿vale?

3
00:00:14,929 --> 00:00:19,649
Entonces hemos visto dos tipos de estructuras condicionales, que son por un lado el IF y por otro lado el SWITCH.

4
00:00:19,989 --> 00:00:27,670
Esto me permite hacer una cosa u otra en función de una condición, ¿vale?

5
00:00:27,670 --> 00:00:33,850
El concepto de condición o de expresión booleana a este punto debería ser relativamente claro, ¿vale?

6
00:00:34,229 --> 00:00:39,670
En el sentido que hemos hecho ya muchos ejemplos de condiciones desde muy sencillas a menor que 3

7
00:00:39,670 --> 00:00:46,670
a cosas más complejas que involucran también el AND, el OR y combinaciones de varios AND, OR, NOT, etc.

8
00:00:47,450 --> 00:00:52,149
La idea es que con esto tenéis que familiarizaros porque casi todo en la informática

9
00:00:52,149 --> 00:00:57,890
está basado sobre el concepto de encontrar la condición que quiero comprobar

10
00:00:57,890 --> 00:01:02,549
y si la condición que quiero comprobar es verdadera, pasará una cosa y si no, pasará otra.

11
00:01:04,129 --> 00:01:10,530
Además de las estructuras condicionales, necesitamos otra herramienta para poder hacer nuestros programas,

12
00:01:10,590 --> 00:01:16,209
que es una herramienta muy potente, es la que nos abrirá la vía a poder hacer un mogollón de ejercicios

13
00:01:16,209 --> 00:01:21,049
y un mogollón de prácticas, porque es lo que nos faltaba hasta ahora,

14
00:01:21,049 --> 00:01:23,310
¿Vale? Que son las estructuras iterativas

15
00:01:23,310 --> 00:01:25,489
¿Qué nos faltaba hasta ahora?

16
00:01:25,810 --> 00:01:31,530
Vosotros habéis visto ejercicios que empiezan, hacen una cosa y acaban

17
00:01:31,530 --> 00:01:33,609
¿Vale? Son los ejercicios más sencillitos

18
00:01:33,609 --> 00:01:38,530
Lo que nos falta es poder decir, vale, pero cuando llegas al final, por ejemplo

19
00:01:38,530 --> 00:01:43,129
Vuelves al principio y pídeme otra vez lo mismo

20
00:01:43,129 --> 00:01:46,209
Sin que yo tenga que arrancar otra vez el programa

21
00:01:46,209 --> 00:01:52,969
Estoy haciendo un programa que mira si los triángulos son isósceles, escalenos o equiláteros

22
00:01:52,969 --> 00:01:53,750
Vale, fenomenal

23
00:01:53,750 --> 00:01:55,049
Te doy tres números

24
00:01:55,049 --> 00:01:57,150
Me dices, esto sería isócele

25
00:01:57,150 --> 00:01:59,730
En vez de acabar y que tú tengas que lanzarlo otra vez

26
00:01:59,730 --> 00:02:01,530
Vuelve arriba y te pregunte

27
00:02:01,530 --> 00:02:04,870
Oye, mira, ¿quieres darme otro triángulo?

28
00:02:04,950 --> 00:02:06,269
Y yo te digo, ¿cómo es?

29
00:02:06,430 --> 00:02:07,670
O ya has acabado

30
00:02:07,670 --> 00:02:09,169
Y tú puedes decir, no, he acabado

31
00:02:09,169 --> 00:02:10,289
Entonces se acaba el programa

32
00:02:10,289 --> 00:02:12,370
O que si tú le dices, sí, otro triángulo

33
00:02:12,370 --> 00:02:15,009
Pues él te vuelve a decir, venga, dame otra vez tres números

34
00:02:15,009 --> 00:02:18,389
Y yo te digo si es como más excepcional

35
00:02:18,389 --> 00:02:22,009
Para hacer esto necesitamos una herramienta

36
00:02:22,590 --> 00:02:25,030
Que me diga que un bloque de código

37
00:02:25,030 --> 00:02:27,370
Se repita varias veces

38
00:02:27,370 --> 00:02:31,930
Que el flujo de ejecución del programa

39
00:02:31,930 --> 00:02:36,689
Reitere, haga varias iteraciones

40
00:02:36,689 --> 00:02:39,530
Sobre ese trozo de código

41
00:02:39,530 --> 00:02:40,870
Sobre ese bloque de código

42
00:02:40,870 --> 00:02:44,870
Y esto se logra con las estructuras iterativas

43
00:02:44,870 --> 00:02:48,610
Permite repetir un determinado bloque

44
00:02:48,610 --> 00:02:49,909
Más de una vez

45
00:02:49,909 --> 00:02:51,090
¿Cuántas veces?

46
00:02:51,449 --> 00:02:52,210
Pues depende

47
00:02:52,210 --> 00:02:57,229
Hay dos estructuras más conocidas

48
00:02:57,229 --> 00:02:59,229
Que son el while y el for

49
00:02:59,229 --> 00:03:01,569
El while se suele utilizar

50
00:03:01,569 --> 00:03:03,689
Cuando tú tienes una condición

51
00:03:03,689 --> 00:03:06,330
Que dices, mientras esta condición es verdadera

52
00:03:06,330 --> 00:03:08,449
Yo quiero repetir y repetir

53
00:03:08,449 --> 00:03:09,550
Y repetir este bloque

54
00:03:09,550 --> 00:03:13,330
Cuando esta condición

55
00:03:13,330 --> 00:03:15,289
se hará de repente falta

56
00:03:15,289 --> 00:03:16,969
pues dejo de

57
00:03:16,969 --> 00:03:19,509
gestionar, de repetir

58
00:03:19,509 --> 00:03:21,770
este bloque y salgo de este bloque

59
00:03:21,770 --> 00:03:23,189
¿vale? esto sería el while

60
00:03:23,189 --> 00:03:24,650
ahora lo veremos más en detalle

61
00:03:24,650 --> 00:03:27,069
el for es igual

62
00:03:27,069 --> 00:03:29,669
todo lo que puedo hacer con el while lo puedo hacer con el for

63
00:03:29,669 --> 00:03:31,530
y todo lo que hago con el for lo puedo hacer con el while

64
00:03:31,530 --> 00:03:33,650
pero es más cómodo

65
00:03:33,650 --> 00:03:35,729
cuando yo a priori sé ya

66
00:03:35,729 --> 00:03:37,969
cuántas veces quiero repetir

67
00:03:37,969 --> 00:03:38,590
este bloque

68
00:03:38,590 --> 00:03:41,949
si yo sé que este bloque se tendrá que repetir 10 veces

69
00:03:41,949 --> 00:03:43,330
Pues el for

70
00:03:43,330 --> 00:03:45,689
Es más cómodo que el while

71
00:03:45,689 --> 00:03:47,030
Eremos por aquí

72
00:03:47,030 --> 00:03:48,590
¿Vale? Entonces

73
00:03:48,590 --> 00:03:51,389
While y for son estructuras iterativas

74
00:03:51,389 --> 00:03:53,650
Las dos son equivalentes, hacen lo mismo

75
00:03:53,650 --> 00:03:55,729
¿Vale? Solo que si yo tengo

76
00:03:55,729 --> 00:03:57,770
Que hacer este bloque, repetirlo

77
00:03:57,770 --> 00:03:59,289
Mientras que una condición sea verdadera

78
00:03:59,289 --> 00:04:01,650
Mejor el while, o sea, es más fácil utilizar el while

79
00:04:01,650 --> 00:04:03,849
Si yo en vez quiero, tengo un bloque

80
00:04:03,849 --> 00:04:05,370
Lo quiero repetir cuatro veces

81
00:04:05,370 --> 00:04:06,990
Sé cuántas veces lo quiero repetir

82
00:04:06,990 --> 00:04:08,469
Pues utilizo el for

83
00:04:08,469 --> 00:04:12,379
Este es el while, ¿vale?

84
00:04:12,379 --> 00:04:13,900
El comando while

85
00:04:13,900 --> 00:04:17,220
Yo tengo el flujo de ejecución

86
00:04:17,220 --> 00:04:18,319
Que viene desde aquí arriba

87
00:04:18,319 --> 00:04:19,980
Llega a una condición

88
00:04:19,980 --> 00:04:22,560
Por ejemplo, a menor que 3

89
00:04:22,560 --> 00:04:25,819
Si esta condición es verdadera

90
00:04:25,819 --> 00:04:28,519
Ejecuto un bloque de instrucciones

91
00:04:28,519 --> 00:04:33,680
Y vuelvo antes de la comprobación de la condición

92
00:04:33,680 --> 00:04:39,699
Si en vez de esta condición es falsa

93
00:04:39,699 --> 00:04:41,800
Me salto el bloque de instrucciones

94
00:04:41,800 --> 00:04:42,600
Y se sigue adelante

95
00:04:42,600 --> 00:04:47,139
Entonces, una vez que yo entro en el while

96
00:04:47,139 --> 00:04:49,240
Yo estaré aquí para siempre

97
00:04:49,240 --> 00:04:51,759
Mientras que esta condición sea verdadera

98
00:04:51,759 --> 00:04:53,920
Cuidado

99
00:04:53,920 --> 00:04:56,899
Si yo pongo aquí una condición

100
00:04:56,899 --> 00:05:00,040
Y esta condición no cambia

101
00:05:00,040 --> 00:05:01,860
Dentro de este bloque

102
00:05:01,860 --> 00:05:04,800
Estoy en un bucle infinito

103
00:05:04,800 --> 00:05:06,980
Si yo digo

104
00:05:06,980 --> 00:05:09,959
Mientras que a sea menor que cero

105
00:05:09,959 --> 00:05:11,199
Haz esto

106
00:05:11,199 --> 00:05:14,480
Y aquí dentro no cambio el valor de A

107
00:05:14,480 --> 00:05:16,560
No lo toco el valor de A

108
00:05:16,560 --> 00:05:18,660
Entonces si A es menor que 0

109
00:05:18,660 --> 00:05:20,519
Cuando hará estas instrucciones

110
00:05:20,519 --> 00:05:22,199
No cambiará el valor de A

111
00:05:22,199 --> 00:05:24,100
Y cuando vuelva a comprobar la condición

112
00:05:24,100 --> 00:05:26,279
Sigue siendo menor que 0

113
00:05:26,279 --> 00:05:27,420
Porque nadie lo ha cambiado

114
00:05:27,420 --> 00:05:29,379
Entonces entraría otra vez aquí

115
00:05:29,379 --> 00:05:30,259
Y nadie lo cambia

116
00:05:30,259 --> 00:05:31,699
Entonces volvería a la condición

117
00:05:31,699 --> 00:05:33,279
Y sería siempre menor que 0

118
00:05:33,279 --> 00:05:36,240
Y me quedaría aquí dentro para siempre

119
00:05:36,240 --> 00:05:38,980
Los bucles infinitos

120
00:05:38,980 --> 00:05:41,620
Si no quiero hacerlos

121
00:05:41,620 --> 00:05:42,379
Mal

122
00:05:42,379 --> 00:05:43,959
¿Vale?

123
00:05:44,079 --> 00:05:46,540
Porque hay situaciones en que quiero un bucle infinito

124
00:05:46,540 --> 00:05:47,939
¿Vale?

125
00:05:49,199 --> 00:05:51,399
Un cajero automático

126
00:05:51,399 --> 00:05:53,439
Tiene su programa

127
00:05:53,439 --> 00:05:55,439
Viene un usuario

128
00:05:55,439 --> 00:05:56,759
Mete la tarjeta

129
00:05:56,759 --> 00:05:58,379
Pilla los dineros

130
00:05:58,379 --> 00:05:59,879
Y vuelve arriba

131
00:05:59,879 --> 00:06:02,560
No quiere decir, ah, he dado el dinero para hoy

132
00:06:02,560 --> 00:06:04,279
Y he acabado hasta que me rearranque

133
00:06:04,279 --> 00:06:06,300
No, es un bucle infinito

134
00:06:06,300 --> 00:06:08,339
Que se puede parar

135
00:06:08,339 --> 00:06:09,699
Solo en una situación

136
00:06:09,699 --> 00:06:12,459
Absurda en el que va un

137
00:06:12,459 --> 00:06:14,259
Técnico y lo para de alguna forma

138
00:06:14,259 --> 00:06:15,800
¿Vale?

139
00:06:15,800 --> 00:06:17,660
Pero técnicamente es como si fuera

140
00:06:17,660 --> 00:06:19,620
Un bucle infinito, casi

141
00:06:19,620 --> 00:06:21,660
¿Vale? Puede haber otros

142
00:06:21,660 --> 00:06:23,779
Programas que por la naturaleza de ese programa

143
00:06:23,779 --> 00:06:25,439
Tiene que ser activado, una vez activado

144
00:06:25,439 --> 00:06:27,459
No cabe nunca, servidor

145
00:06:27,459 --> 00:06:29,720
No sé, ¿vale? Siempre

146
00:06:29,720 --> 00:06:31,500
Por debajo hay

147
00:06:31,500 --> 00:06:33,759
Un acceso secundario en el que un

148
00:06:33,759 --> 00:06:35,699
Un administrador de ese sistema

149
00:06:35,699 --> 00:06:37,180
Puede decirle, oye, que sería

150
00:06:37,180 --> 00:06:38,699
La condición de este Y

151
00:06:38,699 --> 00:06:41,500
Mientras que el administrador nos ha dicho que pare

152
00:06:41,500 --> 00:06:43,279
Y yo sigo adelante, aquí, aquí, aquí

153
00:06:43,279 --> 00:06:45,480
Y aquí dentro a lo mejor no se modifica

154
00:06:45,480 --> 00:06:46,660
Se modifica de otro lado

155
00:06:46,660 --> 00:06:49,500
Que viene, se activa algo en otro lado

156
00:06:49,500 --> 00:06:51,740
Y al activar algo en otro lado, esta condición cambia

157
00:06:51,740 --> 00:06:52,720
Y entonces sale

158
00:06:52,720 --> 00:06:53,980
¿Sí?

159
00:06:54,620 --> 00:06:57,839
Estos son usos avanzados, lo veremos cuando haremos clases

160
00:06:57,839 --> 00:06:58,860
Y cosas por el estilo

161
00:06:58,860 --> 00:07:01,199
O el próximo año cuando haremos interrupciones, etc.

162
00:07:02,199 --> 00:07:02,680
¿Sí?

163
00:07:03,620 --> 00:07:05,259
Por ahora, la idea es esta

164
00:07:05,259 --> 00:07:07,899
en todos nuestros ejercicios

165
00:07:07,899 --> 00:07:09,540
al menos de esta evaluación

166
00:07:09,540 --> 00:07:11,480
si dentro de este bloque

167
00:07:11,480 --> 00:07:13,699
de instrucciones no actualizáis

168
00:07:13,699 --> 00:07:15,360
la condición, mal

169
00:07:15,360 --> 00:07:17,379
¿si?

170
00:07:17,519 --> 00:07:19,319
porque quiere decir que se quedará ahí para siempre

171
00:07:19,319 --> 00:07:21,339
y eso lo veréis porque encendéis

172
00:07:21,339 --> 00:07:23,139
y veis, empieza a escribir cosas

173
00:07:23,139 --> 00:07:25,399
un millón de cosas y no se para nunca

174
00:07:25,399 --> 00:07:27,860
y, ¿os acordáis el cuadradito rojo?

175
00:07:28,300 --> 00:07:29,360
eso que os hacía ver

176
00:07:29,360 --> 00:07:31,639
si estaba encendido o no el programa

177
00:07:31,639 --> 00:07:33,519
pues eso se os quedaba encendido

178
00:07:33,519 --> 00:07:35,420
Pero el procesador está a tope

179
00:07:35,420 --> 00:07:37,519
Porque está procesando esta condición

180
00:07:37,519 --> 00:07:38,759
Millones de veces por segundo

181
00:07:38,759 --> 00:07:40,459
Ahora lo hacemos

182
00:07:40,459 --> 00:07:41,259
¿Vale?

183
00:07:41,300 --> 00:07:41,920
Vemos que pasa

184
00:07:41,920 --> 00:07:43,899
¿Sí?

185
00:07:44,779 --> 00:07:45,300
Entonces

186
00:07:45,300 --> 00:07:48,959
La idea, pero, es siempre esta

187
00:07:48,959 --> 00:07:51,259
Yo llego con mi flujo de ejecución

188
00:07:51,259 --> 00:07:52,120
Llego a la condición

189
00:07:52,120 --> 00:07:53,500
Si la condición es falsa

190
00:07:53,500 --> 00:07:54,279
Salgo ya

191
00:07:54,279 --> 00:07:57,199
O sea, no necesariamente tengo que ejecutar

192
00:07:57,199 --> 00:07:58,319
Estas instrucciones una vez

193
00:07:58,319 --> 00:08:01,259
Si la condición cuando llega aquí es falsa

194
00:08:01,259 --> 00:08:02,680
Pues me lo salto y sigo adelante

195
00:08:02,680 --> 00:08:10,180
Si es verdadera, empiezo a girar en este bucle las veces que sean necesarias

196
00:08:10,180 --> 00:08:16,139
En principio, dentro del bloque de instrucciones, esta condición podrá cambiar

197
00:08:16,139 --> 00:08:20,540
Por ejemplo, si yo digo a es menor que 3, mientras que a es menor que 3, hace esto

198
00:08:20,540 --> 00:08:24,339
Y aquí le digo a más más, a igual a a más 1

199
00:08:24,339 --> 00:08:27,399
Entonces cada vez que pasa por las instrucciones, suma 1a

200
00:08:27,399 --> 00:08:31,759
Y llegará un momento en que este a no será menor que 3 y por lo tanto sale

201
00:08:31,759 --> 00:08:37,210
Pero habré hecho varias veces

202
00:08:37,210 --> 00:08:38,809
Estas instrucciones, más de una

203
00:08:38,809 --> 00:08:40,610
Dependiendo de cuánto valía

204
00:08:40,610 --> 00:08:42,129
A al principio

205
00:08:42,129 --> 00:08:45,190
Si A valía 0, habré hecho 0, 1, 2

206
00:08:45,190 --> 00:08:46,809
Y a la 3 ha salido

207
00:08:46,809 --> 00:08:47,850
Por lo tanto 3 veces

208
00:08:47,850 --> 00:08:50,370
Si A cuando ha entrado la primera vez valía 2

209
00:08:50,370 --> 00:08:51,789
Pues lo ha hecho una vez sola

210
00:08:51,789 --> 00:08:53,809
¿Sí?

211
00:08:54,590 --> 00:08:55,090
Más o menos

212
00:08:55,090 --> 00:08:58,710
Segundo, cuando quiero repetir

213
00:08:58,710 --> 00:09:00,389
Un cierto bloque de instrucciones

214
00:09:00,389 --> 00:09:01,769
Me interesa ver la condición

215
00:09:01,769 --> 00:09:07,529
Esta es un ejemplo de un while

216
00:09:07,529 --> 00:09:09,110
Pregunta para vosotros

217
00:09:09,110 --> 00:09:10,509
¿Qué hace este programa?

218
00:09:14,200 --> 00:09:15,059
No lo sé

219
00:09:15,059 --> 00:09:15,879
¿Qué hace este programa?

220
00:09:16,399 --> 00:09:18,759
Tú dime qué sale de este programa

221
00:09:18,759 --> 00:09:21,440
Por favor dejad de jugar también los demás niños

222
00:09:21,440 --> 00:09:23,080
Pensadlo un momento

223
00:09:23,080 --> 00:09:23,679
Y ahora luego

224
00:09:23,679 --> 00:09:26,600
Que todos puedan pensar

225
00:09:26,600 --> 00:09:28,860
Yo quiero saber, lanzo este programa

226
00:09:28,860 --> 00:09:30,600
¿Qué veo en la consola?

227
00:09:41,789 --> 00:09:42,750
Y si ya sabéis

228
00:09:42,750 --> 00:09:43,750
¿Qué veo en la consola?

229
00:09:43,990 --> 00:09:47,649
La pregunta es, ¿cuántas veces repito este bloque?

230
00:09:48,970 --> 00:09:49,570
Diez.

231
00:09:50,190 --> 00:09:52,389
Deja jugar los otros niños.

232
00:09:52,529 --> 00:09:53,870
Mira que están grabados, ¿eh?

233
00:09:54,889 --> 00:10:04,580
¿Quién sabe qué escribe este en pantalla?

234
00:10:05,000 --> 00:10:06,120
Yo, yo, yo.

235
00:10:06,639 --> 00:10:07,679
¿Qué escribe este en pantalla?

236
00:10:11,340 --> 00:10:12,019
Uno.

237
00:10:14,240 --> 00:10:15,519
Uno, dos, tres.

238
00:10:17,559 --> 00:10:19,019
Desde cero, ¿vale?

239
00:10:19,740 --> 00:10:22,620
La primera vez, int vale cero.

240
00:10:23,019 --> 00:10:24,600
¿Cero es menor o igual que diez?

241
00:10:25,299 --> 00:10:30,919
Sí, lo escribo en pantalla, cero, y sumo uno a este valor.

242
00:10:31,919 --> 00:10:35,480
Por lo tanto, vuelvo al principio del while, y ahora ahí vale uno,

243
00:10:35,480 --> 00:10:38,220
y me pregunto, ¿uno es menor o igual que diez?

244
00:10:38,460 --> 00:10:42,899
Sí, por lo tanto, entro aquí, escribo uno, y sumo uno, y voy a dos.

245
00:10:43,899 --> 00:10:46,620
Y vuelvo aquí, ¿dos es menor o igual que diez?

246
00:10:46,980 --> 00:10:49,500
Y así, así, así, ¿hasta cuándo?

247
00:10:50,960 --> 00:10:51,539
¿Hasta diez?

248
00:10:51,539 --> 00:10:54,899
hasta 9

249
00:10:54,899 --> 00:10:57,940
9 es menor o igual que 10

250
00:10:57,940 --> 00:11:02,730
10 es menor o igual que 10

251
00:11:02,730 --> 00:11:05,850
si

252
00:11:05,850 --> 00:11:08,490
por lo tanto entraría, escribe 10

253
00:11:08,490 --> 00:11:10,690
suma 1, va a 11

254
00:11:10,690 --> 00:11:12,909
11 es menor o igual que 10

255
00:11:12,909 --> 00:11:14,830
falso

256
00:11:14,830 --> 00:11:18,710
si, o sea que este programa

257
00:11:18,710 --> 00:11:20,129
de aquí escribe los números

258
00:11:20,129 --> 00:11:22,210
desde el 0 hasta el 11

259
00:11:22,210 --> 00:11:23,490
hasta el 10, perdón

260
00:11:23,490 --> 00:11:26,350
y el 11 sale

261
00:11:26,350 --> 00:11:28,690
Es decir, que aquí debajo

262
00:11:28,690 --> 00:11:29,929
¿Cuánto vale i?

263
00:11:32,169 --> 00:11:32,889
11

264
00:11:32,889 --> 00:11:36,049
Cuando yo salgo de este while

265
00:11:36,049 --> 00:11:37,350
i vale 11

266
00:11:37,350 --> 00:11:40,350
Pero me ha escrito los números

267
00:11:40,350 --> 00:11:43,169
De 0 a 10

268
00:11:43,169 --> 00:11:44,929
¿Si?

269
00:11:45,269 --> 00:11:48,350
Y si yo escribiera este system.auto.println

270
00:11:48,350 --> 00:11:50,710
Debajo de este i++

271
00:11:50,710 --> 00:11:54,539
¿Y entonces que me escribe?

272
00:11:55,360 --> 00:11:58,909
Desde el 1

273
00:11:58,909 --> 00:12:04,710
Porque con el 10 entraría

274
00:12:04,710 --> 00:12:06,669
Más un 11, lo escribo

275
00:12:06,669 --> 00:12:08,570
Escribo 11 y luego salgo

276
00:12:08,570 --> 00:12:16,460
Entonces la idea es esta

277
00:12:16,460 --> 00:12:20,419
Tengo esta condición

278
00:12:20,419 --> 00:12:23,759
Mientras que esta condición es verdadera

279
00:12:23,759 --> 00:12:26,159
Estoy aquí haciendo esto una y otra vez

280
00:12:26,159 --> 00:12:29,600
Y por algún lado dentro de este bloque

281
00:12:29,600 --> 00:12:31,740
Actualizo la condición

282
00:12:31,740 --> 00:12:33,620
¿Vale? Este I++

283
00:12:33,620 --> 00:12:35,980
Es el que me hace que sea posible

284
00:12:35,980 --> 00:12:37,460
Que esta condición cambie

285
00:12:37,460 --> 00:12:38,539
Si yo la quito

286
00:12:38,539 --> 00:12:41,799
¿Qué haría este programa?

287
00:12:42,419 --> 00:12:43,480
Sigue en esta línea de aquí

288
00:12:43,480 --> 00:12:47,850
Escribiría por infinitas veces

289
00:12:47,850 --> 00:12:49,230
¿Qué? Cero

290
00:12:49,230 --> 00:12:51,330
Cero, cero, cero, cero

291
00:12:51,330 --> 00:12:52,129
Y no para nunca

292
00:12:52,129 --> 00:12:55,190
Porque como aquí esta condición

293
00:12:55,190 --> 00:12:57,309
No se modifica, pues se quedaría

294
00:12:57,309 --> 00:12:58,110
Siempre cero

295
00:12:58,110 --> 00:13:03,029
¿Qué es esto?

296
00:13:03,049 --> 00:13:04,990
Un bloque

297
00:13:04,990 --> 00:13:06,669
¿Y qué puedo poner en un bloque?

298
00:13:07,590 --> 00:13:09,789
If, declaración de variables

299
00:13:09,789 --> 00:13:12,230
While, for

300
00:13:12,230 --> 00:13:13,809
¿Puedo ir un while dentro de un while?

301
00:13:14,330 --> 00:13:14,850
¡Claro!

302
00:13:16,850 --> 00:13:17,169
¿Sí?

303
00:13:17,370 --> 00:13:18,690
Y es lo que complica las cosas

304
00:13:18,690 --> 00:13:19,610
Lo veremos dentro de un rato

305
00:13:19,610 --> 00:13:21,649
¿Dudas sobre esto?

306
00:13:22,289 --> 00:13:22,990
¿Se entiende la idea?

307
00:13:23,549 --> 00:13:24,649
¿Para qué me puede servir?

308
00:13:25,309 --> 00:13:25,850
Lo veremos

309
00:13:25,850 --> 00:13:28,830
El ejemplo más básico que se puede dar

310
00:13:28,830 --> 00:13:32,129
Es para que un ejercicio de todo lo que habéis hecho vosotros

311
00:13:32,129 --> 00:13:34,529
En vez de hacerse una vez sola

312
00:13:34,529 --> 00:13:35,730
Se puede repetir

313
00:13:35,730 --> 00:13:37,149
Cuando haya acabado el ejercicio

314
00:13:37,149 --> 00:13:38,190
Vuelvo arriba y digo

315
00:13:38,190 --> 00:13:43,909
¿Quieres volver a hacer el ejercicio?

316
00:13:44,190 --> 00:13:45,389
Y si tú le escribes uno

317
00:13:45,389 --> 00:13:46,750
Pues te va arriba

318
00:13:46,750 --> 00:13:47,370
Y te lo haces

319
00:13:47,370 --> 00:13:48,549
Y escribes cualquier otro número

320
00:13:48,549 --> 00:13:50,029
Pues no

321
00:13:50,029 --> 00:13:51,929
Lo haremos ahora como

322
00:13:51,929 --> 00:13:53,250
¿Cuándo?

323
00:13:55,889 --> 00:13:56,450
¿Cómo?

324
00:13:59,110 --> 00:13:59,669
No

325
00:13:59,669 --> 00:14:01,230
Porque yo aquí debajo

326
00:14:01,230 --> 00:14:03,370
Me haré una lectura

327
00:14:03,370 --> 00:14:04,190
De un fichero

328
00:14:04,190 --> 00:14:07,570
De un número

329
00:14:07,570 --> 00:14:09,330
Y ese número lo guardo dentro de ahí

330
00:14:09,330 --> 00:14:11,929
Y aquí pongo que mientras si es igual a cero

331
00:14:11,929 --> 00:14:13,269
Sigue aquí delante

332
00:14:13,269 --> 00:14:15,590
Aquí dentro, entonces aquí está todo mi programa

333
00:14:15,590 --> 00:14:17,389
Y al final pediré al usuario

334
00:14:17,389 --> 00:14:18,029
¿Quieres seguir?

335
00:14:18,570 --> 00:14:20,210
Si pones un número que no es cero

336
00:14:20,210 --> 00:14:23,409
Pues te paras y sales y vas adelante

337
00:14:23,409 --> 00:14:24,210
O acabas

338
00:14:24,210 --> 00:14:26,549
Y si en vez pones un número que es cero

339
00:14:26,549 --> 00:14:28,870
Pues como la condición sigue siendo verdadera

340
00:14:28,870 --> 00:14:29,669
Pues entro otra vez

341
00:14:29,669 --> 00:14:30,809
lo haremos

342
00:14:30,809 --> 00:14:33,129
¿cómo?

343
00:14:34,169 --> 00:14:34,990
estos son boolean

344
00:14:34,990 --> 00:14:37,210
ok

345
00:14:37,210 --> 00:14:39,809
normalmente leer un booleano

346
00:14:39,809 --> 00:14:41,850
por teclado es una cosa que se hace

347
00:14:41,850 --> 00:14:42,929
muy poco, ¿vale?

348
00:14:43,289 --> 00:14:45,230
por teclado se suele leer un número

349
00:14:45,230 --> 00:14:48,129
dando un menú de 1 sí, 2 no

350
00:14:48,129 --> 00:14:49,129
y tú pones 1 y 2

351
00:14:49,129 --> 00:14:50,750
o directamente la palabra

352
00:14:50,750 --> 00:14:52,990
pero nosotros tenemos todavía un problemita

353
00:14:52,990 --> 00:14:54,590
que a lo mejor ahora lo solucionamos

354
00:14:54,590 --> 00:14:57,149
que es como comparamos string

355
00:14:57,149 --> 00:14:59,210
porque hemos dicho que 2 string

356
00:14:59,210 --> 00:15:00,990
no se comparan con igual igual

357
00:15:00,990 --> 00:15:05,700
entonces

358
00:15:05,700 --> 00:15:07,759
otro

359
00:15:07,759 --> 00:15:10,399
otra

360
00:15:10,399 --> 00:15:11,700
estructura iterativa

361
00:15:11,700 --> 00:15:13,740
es el do while

362
00:15:13,740 --> 00:15:15,799
¿vale? que es igual al while

363
00:15:15,799 --> 00:15:17,460
solo que fijaos

364
00:15:17,460 --> 00:15:19,799
el while

365
00:15:19,799 --> 00:15:22,720
podría ser que esta instrucción

366
00:15:22,720 --> 00:15:24,100
no se ejecute nunca

367
00:15:24,100 --> 00:15:26,399
si cuando yo llego a la condición

368
00:15:26,399 --> 00:15:27,779
la condición es falsa

369
00:15:27,779 --> 00:15:30,539
Este bloque no se ejecutará nunca

370
00:15:30,539 --> 00:15:32,340
Se salta

371
00:15:32,340 --> 00:15:32,980
Y nada más

372
00:15:32,980 --> 00:15:35,620
Y si yo quisiera hacer

373
00:15:35,620 --> 00:15:37,600
Algo que me diga, oye mira

374
00:15:37,600 --> 00:15:39,840
Una vez hace este bloque

375
00:15:39,840 --> 00:15:41,139
Ejecuta

376
00:15:41,139 --> 00:15:44,000
Y después de haberlo ejecutado una vez

377
00:15:44,000 --> 00:15:46,419
A ese punto te vas a preguntar algo

378
00:15:46,419 --> 00:15:48,379
Y si ese algo es verdadero

379
00:15:48,379 --> 00:15:50,399
Sigues ejecutando este bloque

380
00:15:50,399 --> 00:15:51,440
Una y otra vez, otra vez

381
00:15:51,440 --> 00:15:52,340
Y si no, no

382
00:15:52,340 --> 00:15:53,879
¿Entendéis la diferencia?

383
00:15:54,480 --> 00:15:57,279
Aquí podría ser cero o más veces

384
00:15:57,279 --> 00:16:00,240
En vez de la otra sería una vez

385
00:16:00,240 --> 00:16:01,480
O más

386
00:16:01,480 --> 00:16:04,259
¿Sí? ¿Cómo lo hago?

387
00:16:04,600 --> 00:16:06,419
Pues en vez de utilizar el while

388
00:16:06,419 --> 00:16:09,080
Uso la operación do while

389
00:16:09,080 --> 00:16:09,700
¿Vale?

390
00:16:10,519 --> 00:16:12,340
Sostancialmente entro en el do while

391
00:16:12,340 --> 00:16:13,779
El bloque de instrucciones está antes

392
00:16:13,779 --> 00:16:16,139
Este bloque de instrucciones se ejecutará una vez siempre

393
00:16:16,139 --> 00:16:18,639
Y al final me llega la condición

394
00:16:18,639 --> 00:16:20,600
Si la condición es verdadera

395
00:16:20,600 --> 00:16:23,340
Vuelvo antes del bloque de instrucciones

396
00:16:23,340 --> 00:16:24,580
Y lo ejecuto otra vez

397
00:16:24,580 --> 00:16:26,700
Si en vez de esa condición es falsa

398
00:16:26,700 --> 00:16:33,360
sigue adelante. ¿Se entiende la diferencia? Se suele utilizar más el while que el do while, ¿vale?

399
00:16:33,480 --> 00:17:00,940
Pero a veces hay condiciones en que el do while puede ser cómodo. ¿Qué hace esto? Escribe en

400
00:17:00,940 --> 00:17:07,700
pantalla contador, ¿cuántas veces? La primera vez escribe cero, suma uno, uno es menor que diez,

401
00:17:07,819 --> 00:17:15,140
menor o igual que diez, sí, entonces vuelve al principio del do y escribe uno y suma dos, ¿vale?

402
00:17:15,140 --> 00:17:17,779
Y me pregunta, ¿2 es menor o igual que 10?

403
00:17:18,319 --> 00:17:20,900
Y así, así, así, así, así, ¿cuántas veces?

404
00:17:25,009 --> 00:17:29,829
Hasta que esto sea 11, el contador sea 11, y entonces que he escrito 10.

405
00:17:30,230 --> 00:17:32,609
O sea, que este es exactamente el ejercicio de antes.

406
00:17:32,950 --> 00:17:34,890
Me escribe los números de 0 a 10.

407
00:17:36,049 --> 00:17:46,519
La diferencia es que si yo pongo aquí 11, esto me escribe una vez 11, y luego sigue adelante.

408
00:17:46,519 --> 00:17:49,319
Mientras que si yo pongo

409
00:17:49,319 --> 00:17:50,700
Aquí 11

410
00:17:50,700 --> 00:17:52,779
No me escribe nada en pantalla

411
00:17:52,779 --> 00:17:55,950
¿Sí?

412
00:17:56,789 --> 00:17:59,680
Vale

413
00:17:59,680 --> 00:18:01,940
Claro el while

414
00:18:01,940 --> 00:18:04,940
Tengo una condición, while ¿qué quiere decir en inglés?

415
00:18:05,880 --> 00:18:06,559
Mientras

416
00:18:06,559 --> 00:18:07,480
¿Vale?

417
00:18:07,960 --> 00:18:11,099
Mientras esta condición es verdadera, hace esto

418
00:18:11,099 --> 00:18:13,380
Este es el sentido del while

419
00:18:13,380 --> 00:18:14,400
¿Sí?

420
00:18:14,400 --> 00:18:16,579
Y luego está

421
00:18:16,579 --> 00:18:17,599
Otra

422
00:18:17,599 --> 00:18:20,799
Otra estructura

423
00:18:20,799 --> 00:18:23,039
¿Vale? Un poquito distinta

424
00:18:23,039 --> 00:18:24,480
Que hace más o menos lo mismo

425
00:18:24,480 --> 00:18:25,960
¿Vale? Y que

426
00:18:25,960 --> 00:18:28,819
Si tú cambias algunas

427
00:18:28,819 --> 00:18:30,740
Cosas dentro, ¿eh? Puedes usar

428
00:18:30,740 --> 00:18:32,140
Un for donde está un while

429
00:18:32,140 --> 00:18:34,400
Y un while donde está un for, no cambia nada

430
00:18:34,400 --> 00:18:36,500
¿Vale? Pero este es más práctico

431
00:18:36,500 --> 00:18:38,779
Para otras cosas, hemos dicho, cuando yo ya sé

432
00:18:38,779 --> 00:18:40,559
Que quiero ejecutar

433
00:18:40,559 --> 00:18:42,680
Este bloque 10 veces, sé que son

434
00:18:42,680 --> 00:18:44,380
10 de las veces que quiero ejecutar

435
00:18:44,380 --> 00:18:46,640
Pues un for se hace más

436
00:18:46,640 --> 00:18:48,660
Útil

437
00:18:48,660 --> 00:18:50,579
Para quien sabe

438
00:18:50,579 --> 00:18:51,599
Algo de programación

439
00:18:51,599 --> 00:18:54,019
Cuando yo gestiono por ejemplo un array

440
00:18:54,019 --> 00:18:56,720
Que sé cuantas posiciones tiene un array

441
00:18:56,720 --> 00:18:59,059
Como sé que tengo que entrar en todas las posiciones

442
00:18:59,059 --> 00:19:01,220
De array y son 25 posiciones

443
00:19:01,220 --> 00:19:02,660
Pues puedo usar un for

444
00:19:02,660 --> 00:19:04,140
Desde 0 hasta 24

445
00:19:04,140 --> 00:19:06,960
Si no sabéis que es un array no importa

446
00:19:06,960 --> 00:19:08,119
Lo veremos

447
00:19:08,119 --> 00:19:10,779
Entonces que hace el for

448
00:19:10,779 --> 00:19:12,920
El for pasa por

449
00:19:12,920 --> 00:19:14,420
Tres fases

450
00:19:14,420 --> 00:19:16,819
Hay una fase de inicialización

451
00:19:16,819 --> 00:19:18,220
Inicializa algo

452
00:19:18,220 --> 00:19:20,400
Inicializa como un contador

453
00:19:20,400 --> 00:19:21,759
Normalmente, vale

454
00:19:21,759 --> 00:19:24,599
Se pregunta una condición

455
00:19:24,599 --> 00:19:26,599
Si esta condición es

456
00:19:26,599 --> 00:19:28,519
Falsa, salgo fuera

457
00:19:28,519 --> 00:19:30,400
Y he acabado, si esta condición

458
00:19:30,400 --> 00:19:31,920
Es verdadera, como en el while

459
00:19:31,920 --> 00:19:34,599
Voy a ejecutar un bloque de instrucciones

460
00:19:34,599 --> 00:19:36,579
Pero al final

461
00:19:36,579 --> 00:19:37,960
De este bloque de instrucción

462
00:19:37,960 --> 00:19:40,839
Antes de volver a la condición

463
00:19:40,839 --> 00:19:42,359
Hay una fase

464
00:19:42,359 --> 00:19:44,380
De actualización, actualización de que?

465
00:19:44,619 --> 00:19:46,079
De lo que he inicializado aquí

466
00:19:46,079 --> 00:19:48,299
Vale, es como si

467
00:19:48,299 --> 00:19:50,119
Dentro de este for

468
00:19:50,119 --> 00:19:51,819
Hubiese un contador

469
00:19:51,819 --> 00:19:54,000
¿Vale? Que al principio le digo

470
00:19:54,000 --> 00:19:55,599
Oye mira, tú al principio vales 0

471
00:19:55,599 --> 00:19:58,200
Y que cada vez que pasa

472
00:19:58,200 --> 00:19:59,519
Por la fase de actualización

473
00:19:59,519 --> 00:20:00,920
Le digo yo, oye mira

474
00:20:00,920 --> 00:20:03,319
Incrementa este valor de 1

475
00:20:03,319 --> 00:20:05,039
O incrementa este valor de 3

476
00:20:05,039 --> 00:20:06,559
O resta este valor de 1

477
00:20:06,559 --> 00:20:09,480
Lo que estamos haciendo es actualizar el valor

478
00:20:09,480 --> 00:20:11,380
De lo que uso aquí en la condición

479
00:20:11,380 --> 00:20:15,700
Así a lo mejor se entiende mejor

480
00:20:15,700 --> 00:20:16,700
Este es el FOC

481
00:20:16,700 --> 00:20:18,559
Inicialización

482
00:20:18,559 --> 00:20:21,099
Me creo una variable i

483
00:20:21,099 --> 00:20:23,319
¿Vale? Que está por índice normalmente

484
00:20:23,319 --> 00:20:24,700
Que es igual a 0

485
00:20:24,700 --> 00:20:27,279
Al principio, estoy aquí

486
00:20:27,279 --> 00:20:29,740
He dicho que i vale 0

487
00:20:29,740 --> 00:20:31,200
Punto y coma

488
00:20:31,200 --> 00:20:32,400
¿Vale?

489
00:20:33,240 --> 00:20:34,700
i menor que 10

490
00:20:34,700 --> 00:20:36,799
La condición, ¿vale?

491
00:20:36,880 --> 00:20:39,259
Mientras que esta condición sea verdadera

492
00:20:39,259 --> 00:20:41,000
Tú vete ciclando de aquí

493
00:20:41,000 --> 00:20:43,440
i más más

494
00:20:43,440 --> 00:20:45,720
Esto es la actualización

495
00:20:45,720 --> 00:20:48,539
Cada vez que vuelves aquí arriba

496
00:20:48,539 --> 00:20:50,039
Y compruebas

497
00:20:50,039 --> 00:20:51,720
Antes de comprobar

498
00:20:51,720 --> 00:20:53,440
Ejecuta esta cosa de aquí

499
00:20:53,440 --> 00:20:55,900
Entonces

500
00:20:55,900 --> 00:20:58,480
Por cada ciclo que yo giro

501
00:20:58,480 --> 00:20:59,740
Mi

502
00:20:59,740 --> 00:21:01,619
Se incrementará de 1

503
00:21:01,619 --> 00:21:04,559
Es parecido a lo que hacía aquí

504
00:21:04,559 --> 00:21:07,799
Que sumaba 1

505
00:21:07,799 --> 00:21:10,000
Pero lo tenía que poner explícitamente

506
00:21:10,000 --> 00:21:12,400
Como instrucción dentro del bloque de instrucción

507
00:21:12,400 --> 00:21:13,740
En vez ahora

508
00:21:13,740 --> 00:21:16,279
Lo saco en la declaración

509
00:21:16,279 --> 00:21:18,079
Del for diciendo que mi for

510
00:21:18,079 --> 00:21:19,480
Tiene que ir desde 0

511
00:21:19,480 --> 00:21:23,119
Cada ciclo incrementa de 1

512
00:21:23,119 --> 00:21:25,740
Y que ciclaré

513
00:21:25,740 --> 00:21:26,900
Estaré en el ciclo

514
00:21:26,900 --> 00:21:28,539
Mientras que i sea menor que 10

515
00:21:28,539 --> 00:21:30,299
Que yo vea las condiciones

516
00:21:30,299 --> 00:21:31,619
Para que funcione

517
00:21:31,619 --> 00:21:34,279
Y yo entro aquí dentro y escribo i

518
00:21:34,279 --> 00:21:35,880
¿Qué hace este programa?

519
00:21:43,329 --> 00:21:44,250
Escribe los números

520
00:21:44,250 --> 00:21:46,690
Es 0 al 9

521
00:21:46,690 --> 00:21:48,069
Un poquito distinto

522
00:21:48,069 --> 00:21:49,650
Porque he puesto aquí menor estricto

523
00:21:49,650 --> 00:21:52,369
Si pusiera menor igual

524
00:21:52,369 --> 00:21:54,650
Haría exactamente lo mismo que los demás

525
00:21:54,650 --> 00:21:57,769
Pero, ¿y dónde hay aquí que incrementa I?

526
00:21:58,029 --> 00:21:59,650
Pues no lo incrementa en el bloque

527
00:21:59,650 --> 00:22:04,990
Lo incrementa aquí en fase, digamos, de incrementación

528
00:22:04,990 --> 00:22:06,869
Después de haber ejecutado el bloque

529
00:22:06,869 --> 00:22:09,109
Ejecuta lo que yo he escrito aquí

530
00:22:09,109 --> 00:22:10,789
Y vuelve a seguir

531
00:22:10,789 --> 00:22:17,089
Cuando yo, por ejemplo, sé cuántas veces quiero hacer esta operación de aquí

532
00:22:17,089 --> 00:22:18,750
Pues esto es muy práctico

533
00:22:18,750 --> 00:22:21,450
Porque si pongo de 0 menor que 10

534
00:22:21,450 --> 00:22:23,390
Pues esto se ejecutará 10 veces

535
00:22:23,390 --> 00:22:26,849
¿Sí? 0, 1, 2, 3, 4, 5

536
00:22:26,849 --> 00:22:28,349
Hasta 9, 10 veces

537
00:22:28,349 --> 00:22:31,349
¿Dudas?

538
00:22:32,710 --> 00:22:34,069
¿Es lo mismo que antes? Sí

539
00:22:34,069 --> 00:22:36,789
¿Vale? Cambia un poco el formato

540
00:22:36,789 --> 00:22:38,470
Y cambia un poco que aquí

541
00:22:38,470 --> 00:22:39,309
Hay un

542
00:22:39,309 --> 00:22:42,490
Aquí yo puedo declarar, mientras antes

543
00:22:42,490 --> 00:22:44,430
Lo tenía que declarar

544
00:22:44,430 --> 00:22:46,890
Fuera, luego utilizarlo

545
00:22:46,890 --> 00:22:48,130
En cada ciclo

546
00:22:48,130 --> 00:22:49,809
Y incrementarlo yo

547
00:22:49,809 --> 00:22:52,089
Y estar yo pendiente

548
00:22:52,089 --> 00:22:53,329
De estas cosas de aquí

549
00:22:53,329 --> 00:22:55,089
Pues aquí dentro

550
00:22:55,089 --> 00:22:57,150
El mismo for

551
00:22:57,150 --> 00:22:59,829
Me da la posibilidad de declarar un contador

552
00:22:59,829 --> 00:23:00,990
De declarar un índice

553
00:23:00,990 --> 00:23:03,910
Que me dice en cuál iteración estoy

554
00:23:03,910 --> 00:23:06,410
Si está en la tercera en 0, la tercera en 1, la tercera en 2

555
00:23:06,410 --> 00:23:07,289
Y me dice

556
00:23:07,289 --> 00:23:09,450
Este número de aquí, ¿cómo se actualiza?

557
00:23:09,750 --> 00:23:10,990
Si aquí en vez de i más más

558
00:23:10,990 --> 00:23:13,990
Hubiese puesto i igual a i más 2

559
00:23:13,990 --> 00:23:16,369
Cada ciclo suma 2

560
00:23:16,369 --> 00:23:17,549
No 1

561
00:23:17,549 --> 00:23:19,410
¿Sí?

562
00:23:20,589 --> 00:23:21,109
¿Dudas?

563
00:23:23,990 --> 00:23:24,289
Vale

564
00:23:24,289 --> 00:23:30,220
¿Qué hace esta cosa aquí?

565
00:23:38,369 --> 00:23:39,529
Vale, perdonadme

566
00:23:39,529 --> 00:23:41,029
Pasamos antes de aquí

567
00:23:41,029 --> 00:23:41,910
Pregunta

568
00:23:41,910 --> 00:23:47,339
Puedo usar i

569
00:23:47,339 --> 00:23:49,720
Aquí fuera del while

570
00:23:49,720 --> 00:23:51,119
Después del while

571
00:23:51,119 --> 00:23:54,730
¿Existe i aquí?

572
00:23:55,569 --> 00:23:56,950
¿Por qué existe i aquí?

573
00:23:58,589 --> 00:24:00,089
Porque está declarada afuera

574
00:24:00,089 --> 00:24:00,809
¿Vale?

575
00:24:00,990 --> 00:24:03,049
Y si yo esta i la declaro aquí dentro

576
00:24:03,049 --> 00:24:04,549
No funciona

577
00:24:04,549 --> 00:24:05,589
¿Vale?

578
00:24:07,829 --> 00:24:10,730
¿Puedo usar contador aquí fuera?

579
00:24:11,529 --> 00:24:12,509
Mínima situación.

580
00:24:14,269 --> 00:24:16,869
¿Puedo usar i fuera del for?

581
00:24:17,609 --> 00:24:18,289
No.

582
00:24:19,349 --> 00:24:19,589
¿Vale?

583
00:24:20,269 --> 00:24:24,390
Esta variable de aquí está creada solo dentro de este for.

584
00:24:24,670 --> 00:24:28,269
Cuando yo salga de este for, está ahí como si no existiera.

585
00:24:28,630 --> 00:24:30,269
Es local a este for.

586
00:24:32,430 --> 00:24:34,950
¿Y si quisiera ponerla fuera?

587
00:24:39,269 --> 00:24:42,369
Imaginaos que yo después de haber hecho esto

588
00:24:42,369 --> 00:24:43,789
Quiero utilizar i

589
00:24:43,789 --> 00:24:45,230
¿Vale?

590
00:24:45,690 --> 00:24:47,630
Entonces no la puedo declarar aquí

591
00:24:47,630 --> 00:24:48,509
Entonces ¿Cómo lo hago?

592
00:24:48,829 --> 00:24:52,130
Pues declaro que int i fuera

593
00:24:52,130 --> 00:24:54,630
Luego entro en el for

594
00:24:54,630 --> 00:24:56,890
Y inicialización de esta i

595
00:24:56,890 --> 00:24:58,069
Condición

596
00:24:58,069 --> 00:24:59,829
Y actualización de esta i

597
00:24:59,829 --> 00:25:01,410
La uso aquí dentro

598
00:25:01,410 --> 00:25:02,950
Esto me escribiría 0

599
00:25:02,950 --> 00:25:05,450
Luego suma 1 va a 1

600
00:25:05,450 --> 00:25:08,289
Entonces si 1 es menor que 3 me escribe 1

601
00:25:08,289 --> 00:25:11,150
Luego va 2, me escribe 2

602
00:25:11,150 --> 00:25:13,130
Luego va 3, 3 no es

603
00:25:13,130 --> 00:25:15,069
Menor que 3, entonces saldría aquí fuera

604
00:25:15,069 --> 00:25:17,369
En este punto de aquí

605
00:25:17,369 --> 00:25:18,410
Fuera del bloque

606
00:25:18,410 --> 00:25:20,089
Y valdría 3

607
00:25:20,089 --> 00:25:21,970
¿Si?

608
00:25:23,190 --> 00:25:25,089
Y luego la sobreescribo con Y

609
00:25:25,089 --> 00:25:27,230
¿Vale? Entonces lo que me escribe por pantalla

610
00:25:27,230 --> 00:25:27,970
Es 0, 1, 2

611
00:25:27,970 --> 00:25:38,529
Esta cosa aquí no la puedo hacer

612
00:25:38,529 --> 00:25:40,490
¿Vale? Esto me da error

613
00:25:40,490 --> 00:25:42,450
Es lo mismo

614
00:25:42,450 --> 00:25:43,750
Lógicamente

615
00:25:43,750 --> 00:25:50,750
Pero a nivel de ámbito de la variable, este int i la declara solo dentro del for

616
00:25:50,750 --> 00:25:54,990
Entonces si intento luego utilizarla fuera, pues no me vale

617
00:25:54,990 --> 00:26:02,779
Y aquí os hace ver también una pequeña diferencia entre el for y el while

618
00:26:02,779 --> 00:26:11,539
Imaginaos que yo tenga un while y este int i no la quiero declarar

619
00:26:11,539 --> 00:26:13,380
Porque luego después no la uso nunca

620
00:26:13,380 --> 00:26:16,779
¿Puedo yo no declararla afuera

621
00:26:16,779 --> 00:26:17,660
Para hacer una cosa así?

622
00:26:21,299 --> 00:26:22,339
¿Dónde la declaro?

623
00:26:22,640 --> 00:26:23,900
Si aquí la estoy utilizando

624
00:26:23,900 --> 00:26:30,759
Si la declaro aquí dentro

625
00:26:30,759 --> 00:26:31,859
Aquí me va a dar un problema

626
00:26:31,859 --> 00:26:32,579
Dice no existe

627
00:26:32,579 --> 00:26:35,579
Si la declaro aquí afuera

628
00:26:35,579 --> 00:26:36,920
Luego existe en todo el ámbito

629
00:26:36,920 --> 00:26:38,140
Y a lo mejor no lo quería

630
00:26:38,140 --> 00:26:40,059
Entonces en este caso sería un problema

631
00:26:40,059 --> 00:26:41,680
Si no quisiera

632
00:26:41,680 --> 00:26:45,779
Mientras el for te da esta posibilidad de aquí

633
00:26:45,779 --> 00:26:47,920
La estoy declarando

634
00:26:47,920 --> 00:26:49,319
En su fase de declaración

635
00:26:49,319 --> 00:26:51,200
Y me vale local al forzo

636
00:26:51,200 --> 00:26:59,869
Lo estás haciendo

637
00:26:59,869 --> 00:27:02,369
Porque lo estás haciendo

638
00:27:02,369 --> 00:27:04,710
Inicialización

639
00:27:04,710 --> 00:27:06,289
Condición

640
00:27:06,289 --> 00:27:07,549
Actualización

641
00:27:07,549 --> 00:27:11,210
Aquí declararla

642
00:27:11,210 --> 00:27:13,630
No le pronuncio

643
00:27:13,630 --> 00:27:16,329
No se suele hacer

644
00:27:16,329 --> 00:27:17,309
Vamos a partir de aquí

645
00:27:17,309 --> 00:27:21,319
Vale

646
00:27:21,319 --> 00:27:29,750
Está claro que la complejidad

647
00:27:29,750 --> 00:27:31,150
De esta cosa

648
00:27:31,150 --> 00:27:32,490
Surge

649
00:27:32,490 --> 00:27:35,029
En el momento en que yo empiezo a poner

650
00:27:35,029 --> 00:27:38,930
Números dentro de

651
00:27:38,930 --> 00:27:40,730
O sea, for dentro de for

652
00:27:40,730 --> 00:27:42,309
While dentro de while

653
00:27:42,309 --> 00:27:43,410
¿Vale?

654
00:27:44,490 --> 00:27:47,789
Si queréis un poco de cabraderos de cabeza

655
00:27:47,789 --> 00:27:48,930
¿Vale?

656
00:27:49,789 --> 00:27:50,750
Os ponéis aquí

657
00:27:50,750 --> 00:27:53,490
Y veis que esta cosa aquí

658
00:27:53,490 --> 00:27:54,890
Os escribe esta cosa aquí

659
00:27:54,890 --> 00:27:57,759
¿Sí?

660
00:27:58,259 --> 00:28:00,460
Y esto es pararse un momento

661
00:28:00,460 --> 00:28:02,759
Razonar cuánto vale i

662
00:28:02,759 --> 00:28:03,599
Cuánto vale j

663
00:28:03,599 --> 00:28:07,740
Y entender por qué sale esta cosa aquí

664
00:28:07,740 --> 00:28:08,319
¿Vale?

665
00:28:08,779 --> 00:28:12,859
Tened en cuenta que por cada ciclo del for externo

666
00:28:12,859 --> 00:28:16,599
Se hacen todos los ciclos del for interno

667
00:28:16,599 --> 00:28:19,940
O sea, por i que vale 1

668
00:28:19,940 --> 00:28:23,160
Haré 1 y 2 de j

669
00:28:23,160 --> 00:28:25,559
Luego acaba j

670
00:28:25,559 --> 00:28:26,900
Acaba i

671
00:28:26,900 --> 00:28:28,500
Sumo 1 a i

672
00:28:28,500 --> 00:28:29,980
Entonces i ahora vale 2

673
00:28:29,980 --> 00:28:32,319
Y entro otra vez aquí dentro en este for

674
00:28:32,319 --> 00:28:42,779
y hago otra vez dos ciclos de estos si os fijáis los primeros dos ciclos y vale 1 porque lo está

675
00:28:42,779 --> 00:28:51,019
haciendo aquí dentro y no se está actualizando los segundos dos ciclos y vale 2 mientras aquí

676
00:28:51,019 --> 00:28:58,799
si yo guardo el for cuando durante el primer ciclo del for externo el for interno el dj pasa

677
00:28:58,799 --> 00:28:59,380
De 1 a 2

678
00:28:59,380 --> 00:29:01,460
Luego acaba

679
00:29:01,460 --> 00:29:04,420
Aumenta 1 el i

680
00:29:04,420 --> 00:29:05,799
Vuelve arriba

681
00:29:05,799 --> 00:29:07,599
1 y 2

682
00:29:07,599 --> 00:29:11,000
Y esto no es sencillísimo

683
00:29:11,000 --> 00:29:12,019
¿Vale?

684
00:29:12,500 --> 00:29:14,700
Esto es pensarlo un poco

685
00:29:14,700 --> 00:29:15,960
Y de vez en cuando

686
00:29:15,960 --> 00:29:17,579
Tened en cuenta que

687
00:29:17,579 --> 00:29:20,200
Poner for dentro de for

688
00:29:20,200 --> 00:29:22,380
Y while dentro de while

689
00:29:22,380 --> 00:29:24,099
Es peligroso

690
00:29:24,099 --> 00:29:25,539
A veces es necesario

691
00:29:25,539 --> 00:29:27,500
No es que no lo veremos nunca

692
00:29:27,500 --> 00:29:31,740
Hay veces que algunos ejercicios necesitan una estructura de esto

693
00:29:31,740 --> 00:29:33,539
Un for dentro de un for, un while dentro de un while

694
00:29:33,539 --> 00:29:34,619
Un for dentro de un while

695
00:29:34,619 --> 00:29:36,980
Para que puedan funcionar, para que se pueda hacer

696
00:29:36,980 --> 00:29:39,720
Pero cuando meto while dentro de while

697
00:29:39,720 --> 00:29:43,000
Me expongo a que la complejidad de mi programa

698
00:29:43,000 --> 00:29:45,680
Sea demasiado grande

699
00:29:45,680 --> 00:29:46,920
Sea exponencial

700
00:29:46,920 --> 00:29:50,380
Cuando la complejidad es exponencial

701
00:29:50,380 --> 00:29:54,900
Quiere decir que el tiempo que tarda el programa en hacer su trabajo

702
00:29:54,900 --> 00:29:57,480
es exponencial con respecto

703
00:29:57,480 --> 00:29:58,920
a los datos que le pongo

704
00:29:58,920 --> 00:30:01,640
pongo pocos datos, va bastante rápido

705
00:30:01,640 --> 00:30:03,660
pero cuanto aumente los datos

706
00:30:03,660 --> 00:30:05,019
la

707
00:30:05,019 --> 00:30:07,359
complejidad aumenta exponencialmente

708
00:30:07,359 --> 00:30:09,319
entonces a lo mejor con 10 datos

709
00:30:09,319 --> 00:30:11,619
ya me hace, se me hace lentísimo

710
00:30:11,619 --> 00:30:12,619
y con 100

711
00:30:12,619 --> 00:30:14,900
mogollón de veces más

712
00:30:14,900 --> 00:30:17,400
lento, no 100 veces más lento

713
00:30:17,400 --> 00:30:19,259
va exponencialmente más lento

714
00:30:19,259 --> 00:30:21,650
así se me explica

715
00:30:21,650 --> 00:30:24,710
entonces, hay que tener

716
00:30:24,710 --> 00:30:26,309
cuidado a meter while dentro while

717
00:30:26,309 --> 00:30:28,869
for dentro for, porque podrían causar

718
00:30:28,869 --> 00:30:30,190
una explosión

719
00:30:30,190 --> 00:30:32,710
exponencial de la complejidad

720
00:30:32,710 --> 00:30:34,309
de mi programa, ¿vale?

721
00:30:34,549 --> 00:30:36,329
es decir, que mi programa empieza a ir lentísimo

722
00:30:36,329 --> 00:30:45,880
ya está, hacemos un ejemplo

723
00:30:45,880 --> 00:30:50,859
pillamos

724
00:30:50,859 --> 00:30:53,019
un ejercicio

725
00:30:53,019 --> 00:30:55,140
cualquiera, ¿vale? de los sencillos

726
00:30:55,680 --> 00:30:56,259
mejor

727
00:30:56,259 --> 00:31:00,990
este es el ejemplo del libro

728
00:31:00,990 --> 00:31:02,910
vale, este

729
00:31:02,910 --> 00:31:04,650
te doy dos números

730
00:31:04,650 --> 00:31:06,529
y me dices si son

731
00:31:06,529 --> 00:31:09,450
divisibles, ¿os acordáis? este de aquí

732
00:31:09,450 --> 00:31:11,109
¿vale? este de aquí

733
00:31:11,109 --> 00:31:13,230
normalmente lo que hacía es hacerlo

734
00:31:13,230 --> 00:31:14,630
una vez, ya está

735
00:31:14,630 --> 00:31:17,230
pues vamos a intentar hacer, no, mira

736
00:31:17,230 --> 00:31:19,150
yo quiero que cuando esto

737
00:31:19,150 --> 00:31:20,049
haya acabado

738
00:31:20,049 --> 00:31:22,529
vuelva a

739
00:31:22,529 --> 00:31:25,329
te pregunte, oye mira, ¿has acabado

740
00:31:25,329 --> 00:31:27,170
de verdad? o ¿quieres

741
00:31:27,170 --> 00:31:29,230
comprobar otros dos

742
00:31:29,230 --> 00:31:31,130
números? y si quieres comprobar

743
00:31:31,130 --> 00:31:33,170
otros dos números, pues lo vuelves

744
00:31:33,170 --> 00:31:34,829
a pedir, entonces

745
00:31:34,829 --> 00:31:36,769
La primera pregunta que os hago es

746
00:31:36,769 --> 00:31:40,569
¿Cuál es el bloque

747
00:31:40,569 --> 00:31:43,109
De instrucciones

748
00:31:43,109 --> 00:31:45,170
Que pensáis que se va a repetir

749
00:31:45,170 --> 00:31:46,910
Una y otra vez y otra vez y otra vez

750
00:31:46,910 --> 00:31:52,440
¿Desde dónde?

751
00:31:57,039 --> 00:31:59,359
¿Cuál es el bloque de estas instrucciones

752
00:31:59,359 --> 00:32:00,619
Que quiero repetir? ¿Esto?

753
00:32:01,019 --> 00:32:02,579
¿Esto es lo que se repite mil veces?

754
00:32:04,160 --> 00:32:04,680
Pregunto

755
00:32:04,680 --> 00:32:05,859
No, ¿cuál?

756
00:32:08,779 --> 00:32:10,319
Desde la línea 6

757
00:32:10,319 --> 00:32:11,259
Hasta

758
00:32:11,259 --> 00:32:15,259
La 9

759
00:32:15,259 --> 00:32:18,039
Esto es lo que se repite mil veces

760
00:32:18,039 --> 00:32:23,049
De la 6 hasta la 18

761
00:32:23,049 --> 00:32:25,069
Este de aquí

762
00:32:25,069 --> 00:32:29,190
Es el bloque que yo quiero hacer una y otra vez

763
00:32:29,190 --> 00:32:30,529
Cada vez le diré

764
00:32:30,529 --> 00:32:33,069
Dame dos números y te digo si son divisibles

765
00:32:33,069 --> 00:32:35,109
Y luego te volveré a pedir dos números

766
00:32:35,109 --> 00:32:36,349
Y te diré si son divisibles

767
00:32:36,349 --> 00:32:38,970
Y te pediré dos números y te diré si son divisibles

768
00:32:38,970 --> 00:32:41,309
¿Si?

769
00:32:42,150 --> 00:32:44,289
Esto es lo que yo quiero repetir

770
00:32:44,289 --> 00:32:46,710
fijaos, scanner teclado

771
00:32:46,710 --> 00:32:47,809
lo quiero repetir

772
00:32:47,809 --> 00:32:50,869
no, porque yo creo una vez

773
00:32:50,869 --> 00:32:52,769
esta cosa que me permite

774
00:32:52,769 --> 00:32:54,849
leer de teclado, y luego uso

775
00:32:54,849 --> 00:32:56,789
el leerlo con el nextint

776
00:32:56,789 --> 00:32:58,730
pero no tengo que crear

777
00:32:58,730 --> 00:33:00,309
cada vez un nuevo teclado

778
00:33:00,309 --> 00:33:02,130
el teclado ya lo tengo, vale

779
00:33:02,130 --> 00:33:04,029
entonces, esto

780
00:33:04,029 --> 00:33:09,339
hasta aquí

781
00:33:09,339 --> 00:33:14,099
es lo que quiero que se repita

782
00:33:14,099 --> 00:33:14,680
vale

783
00:33:14,680 --> 00:33:18,220
¿Sí?

784
00:33:19,000 --> 00:33:21,019
Ahora, ¿cuántas veces quiero que se repita?

785
00:33:22,640 --> 00:33:23,279
Infinitas

786
00:33:23,279 --> 00:33:26,019
Entonces, tendré que crearme una condición

787
00:33:26,019 --> 00:33:26,900
¿Vale?

788
00:33:27,240 --> 00:33:29,539
Por ejemplo, me puedo crear un booleano

789
00:33:29,539 --> 00:33:31,079
Un int

790
00:33:31,079 --> 00:33:33,140
¿Cómo queréis hacerlo?

791
00:33:33,779 --> 00:33:34,140
Da igual

792
00:33:34,140 --> 00:33:35,720
Un int

793
00:33:35,720 --> 00:33:38,900
Int sigue

794
00:33:38,900 --> 00:33:40,519
Es igual

795
00:33:40,519 --> 00:33:42,039
Cero

796
00:33:42,039 --> 00:33:43,740
¿Sí?

797
00:33:44,799 --> 00:33:45,759
Mientras

798
00:33:45,759 --> 00:33:47,960
Sigue

799
00:33:47,960 --> 00:33:50,319
Es igual a cero

800
00:33:50,319 --> 00:33:53,750
Hace esto

801
00:33:53,750 --> 00:33:55,430
¿Cuántas veces lo hace?

802
00:33:58,859 --> 00:34:00,039
Actualmente infinita

803
00:34:00,039 --> 00:34:01,000
¿Por qué infinita?

804
00:34:01,779 --> 00:34:05,240
Porque no estoy actualizando

805
00:34:05,240 --> 00:34:06,200
Sigue aquí dentro

806
00:34:06,200 --> 00:34:11,929
En ningún sitio

807
00:34:11,929 --> 00:34:13,989
Aquí dentro estoy utilizando sigue

808
00:34:13,989 --> 00:34:15,989
Por lo tanto sigue siempre

809
00:34:15,989 --> 00:34:17,650
Valdrá cero para el resto de su vida

810
00:34:17,650 --> 00:34:19,369
Y esta condición de aquí

811
00:34:19,369 --> 00:34:21,250
Siempre será verdadera

812
00:34:21,250 --> 00:34:22,989
Y por lo tanto me quedaré que aquí

813
00:34:22,989 --> 00:34:23,869
Para siempre

814
00:34:23,869 --> 00:34:26,989
Entonces vamos a solucionar esto

815
00:34:26,989 --> 00:34:29,610
Al final del programa

816
00:34:29,610 --> 00:34:31,610
Voy a preguntar al usuario

817
00:34:31,610 --> 00:34:33,110
Si quiere seguir o no

818
00:34:33,110 --> 00:34:38,860
¿Quieres

819
00:34:38,860 --> 00:34:40,320
Hacer

820
00:34:40,320 --> 00:34:43,000
Ejecutar

821
00:34:43,000 --> 00:34:44,260
El programa

822
00:34:44,260 --> 00:34:47,380
Otra vez

823
00:34:47,380 --> 00:34:51,590
Barra n

824
00:34:51,590 --> 00:34:53,909
Cero

825
00:34:53,909 --> 00:34:55,070
Si

826
00:34:55,070 --> 00:34:57,869
Barra n

827
00:34:57,869 --> 00:35:01,840
Otro número

828
00:35:01,840 --> 00:35:03,119
No

829
00:35:03,119 --> 00:35:05,480
¿Qué me hacen estas barra N?

830
00:35:07,480 --> 00:35:08,400
Salto de línea

831
00:35:08,400 --> 00:35:10,119
¿Vale?

832
00:35:10,820 --> 00:35:13,579
Y ahora, después de haber escrito esta cosa

833
00:35:13,579 --> 00:35:15,099
Me pregunto

834
00:35:15,099 --> 00:35:17,019
O sea, leo un número

835
00:35:17,019 --> 00:35:18,380
¿Qué número será?

836
00:35:19,099 --> 00:35:20,639
Bueno, para leer un número sería

837
00:35:20,639 --> 00:35:22,340
Scanna.nextint

838
00:35:22,340 --> 00:35:24,440
¿Dónde lo guardo?

839
00:35:28,780 --> 00:35:29,199
Sigue

840
00:35:29,199 --> 00:35:33,730
De esta forma

841
00:35:33,730 --> 00:35:35,829
Si el usuario me pone cero

842
00:35:35,829 --> 00:35:42,579
Si el usuario me pone cero

843
00:35:42,579 --> 00:35:44,440
Que corresponde a sí

844
00:35:44,440 --> 00:35:46,340
Pues entonces

845
00:35:46,340 --> 00:35:47,619
Sigue valdrá sí

846
00:35:47,619 --> 00:35:48,980
Vuelvo aquí arriba

847
00:35:48,980 --> 00:35:50,440
Sigue es igual a cero

848
00:35:50,440 --> 00:35:51,400
Y lo hago otra vez

849
00:35:51,400 --> 00:35:55,500
Si el usuario me pone otro número

850
00:35:55,500 --> 00:35:56,179
Uno

851
00:35:56,179 --> 00:35:58,000
Pues sigue valdrá uno

852
00:35:58,000 --> 00:35:59,380
Vuelvo aquí arriba

853
00:35:59,380 --> 00:36:02,099
Uno no es igual a cero

854
00:36:02,099 --> 00:36:03,239
Y por lo tanto acabo

855
00:36:03,239 --> 00:36:04,980
Y escribo aquí abajo

856
00:36:04,980 --> 00:36:12,230
Programa terminado

857
00:36:12,230 --> 00:36:19,099
Vamos a ver si funciona

858
00:36:19,099 --> 00:36:21,679
Lanzo mi programa

859
00:36:21,679 --> 00:36:27,829
Dame un int

860
00:36:27,829 --> 00:36:29,250
Dos

861
00:36:29,250 --> 00:36:30,610
Dame otro int

862
00:36:30,610 --> 00:36:31,409
Cuatro

863
00:36:31,409 --> 00:36:33,130
Son divisibles

864
00:36:33,130 --> 00:36:34,010
¿Vale?

865
00:36:34,389 --> 00:36:35,070
Y luego dice

866
00:36:35,070 --> 00:36:37,309
¿Quieres ejecutar el programa otra vez?

867
00:36:38,090 --> 00:36:38,849
Barra n

868
00:36:38,849 --> 00:36:40,789
Cero dos puntos sí

869
00:36:40,789 --> 00:36:41,789
Barra n

870
00:36:41,789 --> 00:36:42,769
¿Otro número no?

871
00:36:43,429 --> 00:36:44,190
¿Qué le doy?

872
00:36:47,719 --> 00:36:48,179
Dame uno

873
00:36:48,179 --> 00:36:50,260
Para ver que funciona

874
00:36:50,260 --> 00:36:51,719
Ah no, perdón, cero

875
00:36:51,719 --> 00:36:55,639
Tenía idea

876
00:36:55,639 --> 00:36:58,260
Uno, uno, son divisibles

877
00:36:58,260 --> 00:36:59,219
Le doy cero

878
00:36:59,219 --> 00:37:01,460
Y veis que

879
00:37:01,460 --> 00:37:04,420
No ha acabado, sigue funcionando

880
00:37:04,420 --> 00:37:06,559
Y me vuelve a decir, vale, dame un int

881
00:37:06,559 --> 00:37:10,260
Y que int le doy

882
00:37:10,260 --> 00:37:12,500
Uno, dos

883
00:37:12,500 --> 00:37:14,920
Y dice, son divisibles

884
00:37:14,920 --> 00:37:16,199
¿Vale?

885
00:37:16,760 --> 00:37:17,320
¿Quieres seguir?

886
00:37:18,099 --> 00:37:19,059
Sí, cero

887
00:37:19,059 --> 00:37:21,139
25

888
00:37:21,139 --> 00:37:23,780
y 15

889
00:37:23,780 --> 00:37:26,179
no es divisible, quiere seguir

890
00:37:26,179 --> 00:37:28,260
no

891
00:37:28,260 --> 00:37:32,980
se entiende

892
00:37:32,980 --> 00:37:36,039
y esta es una forma básica

893
00:37:36,039 --> 00:37:37,420
de como usar

894
00:37:37,420 --> 00:37:38,519
el while

895
00:37:38,519 --> 00:37:41,739
que no es

896
00:37:41,739 --> 00:37:42,940
parte del

897
00:37:42,940 --> 00:37:46,139
en este caso el while no lo estoy usando como parte

898
00:37:46,139 --> 00:37:48,300
del algoritmo para solucionar el problema

899
00:37:48,300 --> 00:37:50,260
sino que estoy mejorando

900
00:37:50,260 --> 00:37:52,400
la calidad de mi programa

901
00:37:52,400 --> 00:37:53,960
En el sentido que cuando el programa acaba

902
00:37:53,960 --> 00:37:55,739
Si el usuario

903
00:37:55,739 --> 00:37:58,179
Quiere hacer más operaciones

904
00:37:58,179 --> 00:38:00,559
No necesita rearrancar el programa

905
00:38:00,559 --> 00:38:01,840
Sino que directamente aquí dice

906
00:38:01,840 --> 00:38:02,320
Sí, adelante

907
00:38:02,320 --> 00:38:17,409
Y ahora nos voy a dar

908
00:38:17,409 --> 00:38:18,889
Ejercicios del Wild

909
00:38:18,889 --> 00:38:20,269
Os lo voy a dar el miércoles

910
00:38:20,269 --> 00:38:22,449
Para ahora me interesa que entendáis la cosa

911
00:38:22,449 --> 00:38:23,489
¿Queréis probarlo?

912
00:38:23,849 --> 00:38:26,750
Pues lo que podéis intentar hacer es lo que he hecho yo

913
00:38:26,750 --> 00:38:27,550
En otro programa

914
00:38:27,550 --> 00:38:28,510
¿Vale?

915
00:38:30,309 --> 00:38:30,869
También

916
00:38:30,869 --> 00:38:33,429
Quiero que veáis

917
00:38:33,429 --> 00:38:34,230
Otra cosa

918
00:38:34,230 --> 00:38:35,469
Clash

919
00:38:35,469 --> 00:38:39,590
Prueba

920
00:38:39,590 --> 00:38:40,230
Wille

921
00:38:40,230 --> 00:38:49,349
Ese es un programita, no hace nada

922
00:38:49,349 --> 00:38:51,010
¿Vale?

923
00:38:52,230 --> 00:38:53,750
Pongamos que yo pongo

924
00:38:53,750 --> 00:38:55,309
Aquí int x

925
00:38:55,309 --> 00:38:56,849
Es igual a 0

926
00:38:56,849 --> 00:38:59,030
Wille

927
00:38:59,030 --> 00:39:01,110
X

928
00:39:01,110 --> 00:39:02,650
Menor

929
00:39:02,650 --> 00:39:04,269
Que 100

930
00:39:04,269 --> 00:39:09,070
Lo que hago es que x

931
00:39:09,070 --> 00:39:10,969
X

932
00:39:10,969 --> 00:39:15,650
¿Qué pasa si ejecuto esto?

933
00:39:32,679 --> 00:39:34,159
¿Lo veis? ¿Cómo está mi pobre CPU?

934
00:39:38,940 --> 00:39:41,119
¿Lo veis? ¿Quién está gastando

935
00:39:41,119 --> 00:39:42,119
Un mogollón de

936
00:39:42,119 --> 00:39:44,260
De CPU?

937
00:39:47,849 --> 00:39:48,590
¿Por qué?

938
00:39:51,739 --> 00:39:52,800
Porque este señor

939
00:39:52,800 --> 00:39:55,539
Que es un procesador y es potente

940
00:39:55,539 --> 00:39:57,059
Está todo el rato

941
00:39:57,059 --> 00:39:59,500
Escribiendo un 0 y comprobando

942
00:39:59,500 --> 00:40:02,320
Si es menor que 100

943
00:40:02,320 --> 00:40:03,860
si, escribo un 0

944
00:40:03,860 --> 00:40:06,420
y como lo puede hacer

945
00:40:06,420 --> 00:40:07,539
millones de veces

946
00:40:07,539 --> 00:40:10,019
al segundo, pues aquí

947
00:40:10,019 --> 00:40:11,960
yo miro esto y digo, no sé qué hacer

948
00:40:11,960 --> 00:40:14,119
lo lanzo otra vez, porque así funciona

949
00:40:14,119 --> 00:40:14,420
mejor

950
00:40:14,420 --> 00:40:17,900
ahora tengo dos procesos

951
00:40:17,900 --> 00:40:19,079
que hacen esta cosa aquí

952
00:40:19,079 --> 00:40:25,300
y este es útil

953
00:40:25,300 --> 00:40:30,599
si, si, está aquí debajo

954
00:40:30,599 --> 00:40:31,500
computándose también

955
00:40:31,500 --> 00:40:33,800
y esto para qué es útil

956
00:40:33,800 --> 00:40:37,199
Para en invierno

957
00:40:37,199 --> 00:40:38,599
Cuando hace frío

958
00:40:38,599 --> 00:40:39,559
¿Vale?

959
00:40:39,920 --> 00:40:41,619
Te metes 5 o 6 de estos

960
00:40:41,619 --> 00:40:43,179
Y te acercas a tu ordenador

961
00:40:43,179 --> 00:40:44,760
¿Vale?

962
00:40:44,940 --> 00:40:46,119
Por otra cosa no

963
00:40:46,119 --> 00:40:47,280
¿Sí?

964
00:40:48,280 --> 00:40:49,699
Entonces, ¿cómo lo paro ahora?

965
00:40:49,699 --> 00:40:50,980
Aquí, ¿vale?

966
00:40:51,159 --> 00:40:52,079
Esto lo para

967
00:40:52,079 --> 00:40:54,699
Y si os fijáis, el otro sigue funcionando

968
00:40:55,380 --> 00:40:56,519
Y ahora paro el segundo

969
00:40:56,519 --> 00:40:58,460
Y cuando ha parado el segundo

970
00:40:58,460 --> 00:41:00,000
Esto se baja

971
00:41:00,000 --> 00:41:01,139
Y respira

972
00:41:01,139 --> 00:41:02,780
Esto es en verano

973
00:41:02,780 --> 00:41:09,360
¿Cómo soluciono esta cosa?

974
00:41:09,900 --> 00:41:11,980
Pues tengo que aquí dentro

975
00:41:11,980 --> 00:41:13,340
Dentro de este bloque

976
00:41:13,340 --> 00:41:16,320
Actualizar de alguna forma

977
00:41:16,320 --> 00:41:17,159
X

978
00:41:17,159 --> 00:41:20,599
Y otra cosa que es importante

979
00:41:20,599 --> 00:41:22,019
Es que tengo que aprender

980
00:41:22,019 --> 00:41:24,059
A mirar este cuadrado de aquí

981
00:41:24,059 --> 00:41:25,940
Si yo lanzo

982
00:41:25,940 --> 00:41:27,579
Imaginaos esto

983
00:41:27,579 --> 00:41:31,860
Lanzo

984
00:41:31,860 --> 00:41:34,000
Oye, no funciona

985
00:41:34,000 --> 00:41:35,139
No hace nada

986
00:41:35,139 --> 00:41:37,239
¿Si?

987
00:41:38,239 --> 00:41:38,619
¿A que si?

988
00:41:39,219 --> 00:41:39,619
Pues nada

989
00:41:39,619 --> 00:41:40,119
Ah si

990
00:41:40,119 --> 00:41:41,639
Se me ha olvidado el system

991
00:41:41,639 --> 00:41:43,099
Ahora lo pongo

992
00:41:43,099 --> 00:41:43,699
Si

993
00:41:43,699 --> 00:41:44,619
Ah si si

994
00:41:44,619 --> 00:41:44,900
Ok

995
00:41:44,900 --> 00:41:45,639
Perfecto

996
00:41:45,639 --> 00:41:46,639
Pongo X

997
00:41:46,639 --> 00:41:47,579
Ah se me ha olvidado

998
00:41:47,579 --> 00:41:48,460
X más más

999
00:41:48,460 --> 00:41:49,519
Vale perfecto

1000
00:41:49,519 --> 00:41:50,039
Ahora si

1001
00:41:50,039 --> 00:41:51,300
Ahora lo he arreglado

1002
00:41:51,300 --> 00:41:52,820
Venga lo ejecuto

1003
00:41:52,820 --> 00:41:55,820
Aquí mira

1004
00:41:55,820 --> 00:41:56,599
Me ha funcionado

1005
00:41:56,599 --> 00:41:57,780
Hasta se ha parado

1006
00:41:57,780 --> 00:41:59,780
Perfecto

1007
00:41:59,780 --> 00:42:04,099
Aquí eh

1008
00:42:04,099 --> 00:42:04,559
Detrás

1009
00:42:04,559 --> 00:42:06,099
Trabajando

1010
00:42:06,099 --> 00:42:08,139
Saca hasta menos

1011
00:42:08,139 --> 00:42:10,239
Pero hasta allí no es normal

1012
00:42:10,239 --> 00:42:12,500
Que mi CPU esté a 38% siempre

1013
00:42:12,500 --> 00:42:14,699
¿Y quién es el malvado que hace esto?

1014
00:42:15,420 --> 00:42:19,599
No lo está ejecutando

1015
00:42:19,599 --> 00:42:22,599
Porque aquí detrás

1016
00:42:22,599 --> 00:42:23,440
Está

1017
00:42:23,440 --> 00:42:25,800
¿Veis que está?

1018
00:42:31,739 --> 00:42:31,960
¿Sí?

1019
00:42:32,519 --> 00:42:34,400
Solo que como este programa aquí

1020
00:42:34,400 --> 00:42:36,480
El que había escrito antes

1021
00:42:36,480 --> 00:42:38,260
Era esto, que no hace nada

1022
00:42:38,260 --> 00:42:40,420
Solo está dando vueltas inútiles

1023
00:42:40,420 --> 00:42:41,760
Para aquí, pero sigue

1024
00:42:41,760 --> 00:42:43,519
Si esto hace algo

1025
00:42:43,519 --> 00:42:46,019
o por ejemplo, x más más

1026
00:42:46,019 --> 00:42:47,820
no, x menos menos

1027
00:42:47,820 --> 00:42:52,929
vale, lo paro

1028
00:42:52,929 --> 00:42:54,989
este programa aquí, escribe algo

1029
00:42:54,989 --> 00:42:56,349
lo lanzo

1030
00:42:56,349 --> 00:42:58,809
ah, no escribe nada, no escribe nada

1031
00:42:58,809 --> 00:43:00,710
ah, pues sí, lo cambio

1032
00:43:00,710 --> 00:43:02,809
ah, no, porque era menos menos, era más más

1033
00:43:02,809 --> 00:43:04,690
vale, ok, ahora lo ejecuto

1034
00:43:04,690 --> 00:43:06,949
venga, aquí, ahora funciona

1035
00:43:06,949 --> 00:43:08,869
ha acabado, sí, ha perfecto

1036
00:43:08,869 --> 00:43:10,630
ha acabado porque con más más

1037
00:43:10,630 --> 00:43:12,489
llegará un momento en que esta

1038
00:43:12,489 --> 00:43:14,690
será falsa, pero por debajo

1039
00:43:14,690 --> 00:43:16,869
El x++ sigue por allí

1040
00:43:16,869 --> 00:43:20,860
¿Hasta cuándo?

1041
00:43:20,940 --> 00:43:21,800
¿Por qué ahora ha

1042
00:43:21,800 --> 00:43:24,199
Probablemente acabado, no lo sé

1043
00:43:24,199 --> 00:43:25,579
Vamos a ver si acaba

1044
00:43:25,579 --> 00:43:30,880
Bueno, el menos menos podría dar

1045
00:43:30,880 --> 00:43:32,760
Que a un cierto momento pase de los int

1046
00:43:32,760 --> 00:43:34,639
Entonces explota

1047
00:43:34,639 --> 00:43:40,400
Me explico lo que quiero decir

1048
00:43:40,400 --> 00:43:43,280
O sea, tened siempre cuidado con los while

1049
00:43:43,280 --> 00:43:46,019
Tengo que hacer algo

1050
00:43:46,019 --> 00:43:48,500
No solo que aquí actualice la x

1051
00:43:48,500 --> 00:43:51,539
Sino que el objetivo de actualizar

1052
00:43:51,539 --> 00:43:53,059
La X es que antes o después

1053
00:43:53,059 --> 00:43:54,179
Esto se quede falso

1054
00:43:54,179 --> 00:43:56,460
Si yo pongo esto

1055
00:43:56,460 --> 00:43:59,039
Se quedará

1056
00:43:59,039 --> 00:44:01,559
Esto falso alguna vez

1057
00:44:01,559 --> 00:44:05,940
No puede

1058
00:44:05,940 --> 00:44:09,579
A lo mejor

1059
00:44:09,579 --> 00:44:10,960
A lo mejor ha hecho eso

1060
00:44:10,960 --> 00:44:13,019
Si

1061
00:44:13,019 --> 00:44:15,340
Pero en principio mal

1062
00:44:15,340 --> 00:44:17,760
Si, entonces tened cuidado con eso

1063
00:44:17,760 --> 00:44:19,780
Ahora, a veces os pasará

1064
00:44:19,780 --> 00:44:21,099
Lanzáis un programa

1065
00:44:21,099 --> 00:44:22,840
Y se os pone en un bucle infinito

1066
00:44:22,840 --> 00:44:24,000
Y se queda allí mil veces

1067
00:44:24,000 --> 00:44:26,579
Entonces lo que hacéis, pues lo paráis

1068
00:44:26,579 --> 00:44:27,659
Aquí, con el rojo

1069
00:44:27,659 --> 00:44:32,340
Vale, entonces, no, esto está bien

1070
00:44:32,340 --> 00:44:34,860
Entonces, para que veáis este programita

1071
00:44:34,860 --> 00:44:35,940
Aquí, vale

1072
00:44:35,940 --> 00:44:37,360
Luego escribimos

1073
00:44:37,360 --> 00:44:40,179
X

1074
00:44:40,179 --> 00:44:41,960
Y lo que hace

1075
00:44:41,960 --> 00:44:44,239
Funciona, hace sus cosas

1076
00:44:44,239 --> 00:44:46,599
Y veis que ha escrito los números

1077
00:44:46,599 --> 00:44:50,789
De 1 a 100

1078
00:44:50,789 --> 00:44:55,230
Y yo le puedo poner aquí

1079
00:44:55,230 --> 00:44:55,929
Mil

1080
00:44:55,929 --> 00:44:57,510
Y él lo hace

1081
00:44:57,510 --> 00:45:06,000
Y puedo disfrutar

1082
00:45:06,000 --> 00:45:07,579
A ver, cuando

1083
00:45:07,579 --> 00:45:10,119
¿Cuánto tiempo tardan en escribir

1084
00:45:10,119 --> 00:45:10,800
Todos estos números?

1085
00:45:11,119 --> 00:45:12,239
Que ahora ya se ve algo

1086
00:45:12,239 --> 00:45:15,099
Que antes lo hacía instantáneo

1087
00:45:15,099 --> 00:45:16,460
Ahora ya se ve que escribe algo

1088
00:45:16,460 --> 00:45:26,090
¿Veis?

1089
00:45:27,269 --> 00:45:30,510
Esto es computacionalmente

1090
00:45:30,510 --> 00:45:31,610
Linear

1091
00:45:31,610 --> 00:45:32,929
¿Vale?

1092
00:45:32,929 --> 00:45:50,690
Es decir, si tarda un tiempo en escribir un número, tarda cien veces más en escribir cien números. Mil veces más en escribir mil números. Es lineal la complejidad.

1093
00:45:50,690 --> 00:45:53,469
Ahora, si fuera exponencial

1094
00:45:53,469 --> 00:45:55,349
Para escribir un número no tarda nada

1095
00:45:55,349 --> 00:45:57,369
Para escribir 10 números tarda un segundo

1096
00:45:57,369 --> 00:45:59,849
Para escribir 100 números

1097
00:45:59,849 --> 00:46:01,570
Pues a lo mejor tarda 6 minutos

1098
00:46:01,570 --> 00:46:03,030
No el doble

1099
00:46:03,030 --> 00:46:04,409
O 100 veces más

1100
00:46:04,409 --> 00:46:05,889
¿Entiendes?

1101
00:46:09,199 --> 00:46:10,780
Y ya está, más o menos