1
00:00:00,000 --> 00:00:05,000
Vale, pues vamos con el siguiente.

2
00:00:05,000 --> 00:00:08,000
Números hasta que te resulta negativo.

3
00:00:08,000 --> 00:00:11,000
Por lo de siempre un bucle, vale, número, número, número, negativo.

4
00:00:11,000 --> 00:00:13,000
¿Y ahora qué tiene que hacer?

5
00:00:13,000 --> 00:00:15,000
Mostrar cuantas de algo, pues un contador.

6
00:00:15,000 --> 00:00:19,000
Un bucle, le número, cuenta lo que sea, le número, cuenta lo que sea,

7
00:00:19,000 --> 00:00:22,000
un contador, empieza a cero, bucle, voy leyendo, cuento, voy leyendo, cuento.

8
00:00:22,000 --> 00:00:24,000
Cuando acabo el bucle, muestro la cuenta.

9
00:00:24,000 --> 00:00:26,000
¿Vale? Es el ejercicio.

10
00:00:26,000 --> 00:00:31,000
Ahora lo que hay que meter dentro es cuando incremento el contador.

11
00:00:31,000 --> 00:00:35,000
Entonces incrementar el contador cuando me encuentro una cifra cero.

12
00:00:35,000 --> 00:00:37,000
¿Vale?

13
00:00:37,000 --> 00:00:39,000
Pero la estructura del programa es esa.

14
00:00:39,000 --> 00:00:41,000
Entonces...

15
00:00:57,000 --> 00:01:01,000
Vale, pues entonces, como vamos a leer del teclado, pues venga,

16
00:01:01,000 --> 00:01:04,000
ponemos lo de siempre.

17
00:01:17,000 --> 00:01:20,000
Uy, de verdad, estoy hoy...

18
00:01:21,000 --> 00:01:23,000
A ver...

19
00:01:24,000 --> 00:01:26,000
Esto...

20
00:01:35,000 --> 00:01:37,000
Vale, pues ya está, hemos dicho.

21
00:01:37,000 --> 00:01:39,000
Vamos a contar.

22
00:01:39,000 --> 00:01:42,000
Pues venga, ya avanzamos.

23
00:01:42,000 --> 00:01:44,000
Ponemos ya el contador.

24
00:01:44,000 --> 00:01:46,000
Y ahora bucle, que está todo el rato.

25
00:01:46,000 --> 00:01:48,000
Leo, cuento, leo, cuento, leo, cuento.

26
00:01:48,000 --> 00:01:50,000
Cuando termino, muestro la cuenta y ya está.

27
00:01:50,000 --> 00:01:52,000
Pues venga, un bucle que está todo el rato.

28
00:01:52,000 --> 00:01:55,000
¿Qué está haciendo este bucle todo el rato?

29
00:01:55,000 --> 00:01:58,000
Pues este bucle está todo el rato pidiendo un número.

30
00:02:07,000 --> 00:02:09,000
Leyendo el número.

31
00:02:14,000 --> 00:02:16,000
Leyendo el número.

32
00:02:16,000 --> 00:02:18,000
Y ahora ya sí.

33
00:02:18,000 --> 00:02:20,000
Si pasa algo con este número,

34
00:02:20,000 --> 00:02:22,000
pues incrementa la cuenta.

35
00:02:22,000 --> 00:02:24,000
Ahora ya viene la parte

36
00:02:24,000 --> 00:02:26,000
que hay que programar,

37
00:02:26,000 --> 00:02:28,000
que es, pues esta ya.

38
00:02:29,000 --> 00:02:31,000
Cont, hay que incrementarlo.

39
00:02:31,000 --> 00:02:33,000
Se incrementa.

40
00:02:41,000 --> 00:02:44,000
Con cada cifra de n,

41
00:02:44,000 --> 00:02:46,000
que es cero.

42
00:02:46,000 --> 00:02:48,000
¿Vale?

43
00:02:48,000 --> 00:02:50,000
Esa es la parte que hay que hacer aquí.

44
00:02:50,000 --> 00:02:52,000
Incrementar cont con cada cifra de n

45
00:02:52,000 --> 00:02:54,000
que sea cero.

46
00:02:54,000 --> 00:02:56,000
Y así todo el rato, así todo el rato, así todo el rato.

47
00:02:56,000 --> 00:02:58,000
¿Así hasta cuándo?

48
00:02:58,000 --> 00:03:00,000
Mientras el numerito n

49
00:03:00,000 --> 00:03:02,000
sea mayor o igual que cero.

50
00:03:02,000 --> 00:03:04,000
Porque esto acaba cuando n es negativo, ¿verdad?

51
00:03:06,000 --> 00:03:08,000
Pues mientras n es mayor o igual que cero,

52
00:03:08,000 --> 00:03:10,000
leo número, cuento sus cifras, cero.

53
00:03:10,000 --> 00:03:12,000
Leo número, cuento sus cifras, cero.

54
00:03:12,000 --> 00:03:14,000
Aquí de nuevo me doy cuenta.

55
00:03:14,000 --> 00:03:16,000
Uy, claro, si yo voy a usar n aquí,

56
00:03:16,000 --> 00:03:18,000
no puedo declararlo aquí dentro,

57
00:03:18,000 --> 00:03:20,000
tengo que declararlo antes.

58
00:03:20,000 --> 00:03:22,000
Lo de siempre, pues venga, tendremos que declararlo antes.

59
00:03:22,000 --> 00:03:24,000
Otra vez lo de siempre.

60
00:03:24,000 --> 00:03:26,000
Uy, pero me necesita que esté inicializado.

61
00:03:26,000 --> 00:03:28,000
Vale, pues inicializo algo

62
00:03:28,000 --> 00:03:30,000
para asegurarme que va a entrar

63
00:03:30,000 --> 00:03:32,000
la primera vez seguro.

64
00:03:32,000 --> 00:03:34,000
Con cero va a entrar.

65
00:03:34,000 --> 00:03:36,000
Bueno, pues entonces,

66
00:03:36,000 --> 00:03:38,000
cuando este bucle termine,

67
00:03:38,000 --> 00:03:40,000
ahora ya podemos mostrar el resultado.

68
00:03:42,000 --> 00:03:44,000
Las cifras decimales,

69
00:03:44,000 --> 00:03:46,000
las cifras cero, perdón,

70
00:03:46,000 --> 00:03:48,000
las cifras cero son

71
00:03:48,000 --> 00:03:50,000
y las mostramos.

72
00:03:52,000 --> 00:03:54,000
¿Vale? Este sería el ejercicio.

73
00:03:54,000 --> 00:03:56,000
A falta de hacer esta parte.

74
00:03:56,000 --> 00:03:58,000
Claro, que es la complicada,

75
00:03:58,000 --> 00:04:00,000
pero la estructura es la de siempre.

76
00:04:00,000 --> 00:04:02,000
Bucle que está, lee número, opera con él.

77
00:04:02,000 --> 00:04:04,000
Mientras el número sea mayor o igual que cero.

78
00:04:04,000 --> 00:04:06,000
Cuando ya has terminado, muestra el resultado.

79
00:04:06,000 --> 00:04:08,000
Pues en este caso,

80
00:04:08,000 --> 00:04:10,000
el resultado es una cuenta.

81
00:04:10,000 --> 00:04:12,000
Pues entonces, ¿qué tenemos que hacer aquí dentro?

82
00:04:14,000 --> 00:04:16,000
Mirar todas las cifras

83
00:04:16,000 --> 00:04:18,000
de n

84
00:04:18,000 --> 00:04:20,000
y cada cifra que encontremos que sea cero,

85
00:04:20,000 --> 00:04:22,000
incrementar count en una unidad.

86
00:04:22,000 --> 00:04:24,000
Hacer un count más más.

87
00:04:24,000 --> 00:04:26,000
Vale, por eso se puede hacer de muchas maneras.

88
00:04:26,000 --> 00:04:28,000
Nosotros ya hicimos

89
00:04:28,000 --> 00:04:30,000
un ejercicio en el cual vimos

90
00:04:30,000 --> 00:04:32,000
cómo recorrer las cifras

91
00:04:32,000 --> 00:04:34,000
decimales de un número.

92
00:04:34,000 --> 00:04:36,000
Con sucesivas divisiones entre 10, ¿verdad?

93
00:04:36,000 --> 00:04:38,000
Entonces podemos reproducir

94
00:04:38,000 --> 00:04:40,000
eso mismo

95
00:04:40,000 --> 00:04:42,000
y cada cifra decimal

96
00:04:42,000 --> 00:04:44,000
que yo me encuentre que es cero,

97
00:04:44,000 --> 00:04:46,000
la utilizo para incrementar count.

98
00:04:46,000 --> 00:04:48,000
Esa es una manera de hacerlo.

99
00:04:48,000 --> 00:04:50,000
Otra manera, pues que si alguien

100
00:04:50,000 --> 00:04:52,000
se acuerda del charad, pues dice,

101
00:04:52,000 --> 00:04:54,000
anda, pues convierto eso a string,

102
00:04:54,000 --> 00:04:56,000
lo recorro con charad y cada

103
00:04:56,000 --> 00:04:58,000
carácter igual al cero lo incremento.

104
00:04:58,000 --> 00:05:00,000
Es más fácil, bastante más fácil.

105
00:05:00,000 --> 00:05:02,000
Pero seguramente lo hayáis hecho

106
00:05:02,000 --> 00:05:04,000
sacando las cifras decimales.

107
00:05:04,000 --> 00:05:06,000
Porque lo hicimos

108
00:05:06,000 --> 00:05:08,000
un par de ejercicios en clase.

109
00:05:08,000 --> 00:05:10,000
Pues venga, ¿cómo sacábamos

110
00:05:10,000 --> 00:05:12,000
las cifras decimales?

111
00:05:12,000 --> 00:05:14,000
¿Vale? ¿Cómo sacábamos

112
00:05:14,000 --> 00:05:16,000
las cifras decimales?

113
00:05:16,000 --> 00:05:18,000
¿Cómo resolvíamos esto de sacar cifras decimales?

114
00:05:18,000 --> 00:05:20,000
Pues decíamos,

115
00:05:20,000 --> 00:05:22,000
vamos haciendo sucesivas

116
00:05:22,000 --> 00:05:24,000
divisiones entre 10, ¿vale? Ya lo explicamos

117
00:05:24,000 --> 00:05:26,000
allá en su momento.

118
00:05:26,000 --> 00:05:28,000
Cada cifra decimal es los restos que voy obteniendo.

119
00:05:28,000 --> 00:05:30,000
Los restos que voy obteniendo.

120
00:05:30,000 --> 00:05:32,000
Y así voy operando mientras el

121
00:05:32,000 --> 00:05:34,000
cociente de esas divisiones sea mayor que cero.

122
00:05:34,000 --> 00:05:36,000
Ese ejercicio que ya hicimos

123
00:05:36,000 --> 00:05:38,000
su resultado

124
00:05:38,000 --> 00:05:40,000
era algo así. Vamos a suponer que nos quedamos con él.

125
00:05:40,000 --> 00:05:42,000
Lo voy a hacer muy detallado

126
00:05:42,000 --> 00:05:44,000
aunque no hacen falta

127
00:05:44,000 --> 00:05:46,000
tantas variables.

128
00:05:46,000 --> 00:05:48,000
Pero para que lo recordéis.

129
00:05:48,000 --> 00:05:50,000
El cociente inicial

130
00:05:50,000 --> 00:05:52,000
es el propio numerito.

131
00:05:52,000 --> 00:05:54,000
Y ahora int es el resto.

132
00:05:54,000 --> 00:05:56,000
Que van a ser las cifras decimales.

133
00:05:56,000 --> 00:05:58,000
Las sucesivas cifras decimales.

134
00:05:58,000 --> 00:06:00,000
¿Vale? ¿Esto cómo lo hacíamos?

135
00:06:00,000 --> 00:06:02,000
Mientras el cociente

136
00:06:04,000 --> 00:06:06,000
sea mayor que cero.

137
00:06:06,000 --> 00:06:08,000
¿Qué hacíamos?

138
00:06:08,000 --> 00:06:10,000
Dividir.

139
00:06:10,000 --> 00:06:12,000
Primero sacar la cifra decimal.

140
00:06:12,000 --> 00:06:14,000
Que era

141
00:06:14,000 --> 00:06:16,000
el resto y dividirlo entre 10.

142
00:06:16,000 --> 00:06:18,000
Esta es una cifra decimal, el primer resto.

143
00:06:18,000 --> 00:06:20,000
Sacamos el resto.

144
00:06:20,000 --> 00:06:22,000
Y aquí ya teníamos

145
00:06:22,000 --> 00:06:24,000
la primera cifra decimal.

146
00:06:24,000 --> 00:06:26,000
Ahora hacemos

147
00:06:26,000 --> 00:06:28,000
lo del contador.

148
00:06:28,000 --> 00:06:30,000
Y ahora actualizamos el cociente.

149
00:06:30,000 --> 00:06:32,000
Cociente

150
00:06:32,000 --> 00:06:34,000
igual a cociente

151
00:06:34,000 --> 00:06:36,000
entre 10.

152
00:06:36,000 --> 00:06:38,000
¿Vale? Este es el ejercicio de sacar las cifras decimales

153
00:06:38,000 --> 00:06:40,000
que está en la hoja que hicimos el otro día.

154
00:06:40,000 --> 00:06:42,000
Era esto mismo.

155
00:06:42,000 --> 00:06:44,000
¿Vale? Pues este ejercicio

156
00:06:44,000 --> 00:06:46,000
iba sacando las sucesivas cifras decimales.

157
00:06:46,000 --> 00:06:48,000
La primera que saca

158
00:06:48,000 --> 00:06:50,000
son las unidades, luego saca las decenas

159
00:06:50,000 --> 00:06:52,000
así hasta las centenas.

160
00:06:52,000 --> 00:06:54,000
¿Vale? Pero en el ejercicio que hicimos

161
00:06:54,000 --> 00:06:56,000
lo que hacía con estas cifras decimales

162
00:06:56,000 --> 00:06:58,000
era mostrarlas por pantalla. ¿Verdad?

163
00:06:58,000 --> 00:07:00,000
En este caso no queremos mostrarlas por pantalla.

164
00:07:00,000 --> 00:07:02,000
En este caso lo que queremos es contarlas si son 0.

165
00:07:02,000 --> 00:07:04,000
Es lo que queremos.

166
00:07:04,000 --> 00:07:06,000
Contarlas si son 0. Pues vamos a contarlas.

167
00:07:08,000 --> 00:07:10,000
Si resto

168
00:07:10,000 --> 00:07:12,000
igual a 0 con más más.

169
00:07:14,000 --> 00:07:16,000
¿Vale? Y ya está.

170
00:07:16,000 --> 00:07:18,000
Ya hemos terminado el ejercicio.

171
00:07:18,000 --> 00:07:20,000
¿Vale? Leemos el número.

172
00:07:20,000 --> 00:07:22,000
Sacamos sus cifras decimales

173
00:07:22,000 --> 00:07:24,000
como vimos que se sacaban.

174
00:07:24,000 --> 00:07:26,000
Cuando me encuentro una cifra que es 0

175
00:07:26,000 --> 00:07:28,000
incremento el contador.

176
00:07:28,000 --> 00:07:30,000
En lugar de mostrarla por consola que era lo que hacíamos el otro día.

177
00:07:36,000 --> 00:07:38,000
Entonces yo aquí he puesto

178
00:07:38,000 --> 00:07:40,000
muchas variables, pero en realidad

179
00:07:40,000 --> 00:07:42,000
no haría falta tantos.

180
00:07:42,000 --> 00:07:44,000
Puedo partir directamente de N, porque

181
00:07:44,000 --> 00:07:46,000
yo no lo uso luego ya más.

182
00:07:46,000 --> 00:07:48,000
Meter aquí directamente esto

183
00:07:48,000 --> 00:07:50,000
en vez de ponerlo con una variable adicional.

184
00:07:52,000 --> 00:07:54,000
¿Vale? O sea una versión más

185
00:07:54,000 --> 00:07:56,000
corta. Voy a volver a hacer

186
00:07:56,000 --> 00:07:58,000
lo mismo de arriba pero con menos variables.

187
00:07:58,000 --> 00:08:00,000
Más cortito.

188
00:08:04,000 --> 00:08:06,000
Más cortito.

189
00:08:10,000 --> 00:08:12,000
Lo mismo de arriba sería

190
00:08:14,000 --> 00:08:16,000
mientras N sea mayor que 0.

191
00:08:16,000 --> 00:08:18,000
¿Qué hacemos?

192
00:08:18,000 --> 00:08:20,000
¿Qué hacemos?

193
00:08:20,000 --> 00:08:22,000
Si

194
00:08:24,000 --> 00:08:26,000
N

195
00:08:26,000 --> 00:08:28,000
por 110

196
00:08:28,000 --> 00:08:30,000
es igual a 0

197
00:08:30,000 --> 00:08:32,000
cont

198
00:08:32,000 --> 00:08:34,000
más más. Y ahora actualizo N.

199
00:08:34,000 --> 00:08:36,000
N entre igual

200
00:08:36,000 --> 00:08:38,000
10.

201
00:08:38,000 --> 00:08:40,000
Lo de arriba y lo de abajo es lo mismo.

202
00:08:40,000 --> 00:08:42,000
Aquí usando menos variables intermedias.

203
00:08:42,000 --> 00:08:44,000
Pero es lo mismo.

204
00:08:44,000 --> 00:08:46,000
El mismo N es el que

205
00:08:46,000 --> 00:08:48,000
voy sacando de él las cifras decimales.

206
00:08:48,000 --> 00:08:50,000
Si la cifra decimal es 0

207
00:08:50,000 --> 00:08:52,000
la cuento. Y ahora actualizo

208
00:08:52,000 --> 00:08:54,000
N para sacar el siguiente cociente.

209
00:08:54,000 --> 00:08:56,000
Y así mientras N sea mayor que 0.

210
00:08:56,000 --> 00:08:58,000
¿Vale? Aquí esto está más resumido con menos variables

211
00:08:58,000 --> 00:09:00,000
que lo de arriba.

212
00:09:00,000 --> 00:09:02,000
Pero es el ejercicio de sacar cifras decimales.

213
00:09:02,000 --> 00:09:04,000
Entonces es ejercicio.

214
00:09:04,000 --> 00:09:06,000
Con la diferencia de que

215
00:09:06,000 --> 00:09:08,000
ahora las cifras decimales las cuento.

216
00:09:10,000 --> 00:09:12,000
Vale. Bueno, lo pongo esto aquí

217
00:09:12,000 --> 00:09:14,000
en comentario para que

218
00:09:16,000 --> 00:09:18,000
para no hacer dos veces lo mismo

219
00:09:18,000 --> 00:09:20,000
en el programa cuando lo probemos.

220
00:09:20,000 --> 00:09:22,000
¿Vale?

221
00:09:22,000 --> 00:09:24,000
Pues ahora ya, ya está. Ya las muestro

222
00:09:24,000 --> 00:09:26,000
y las cifras son 0.

223
00:09:26,000 --> 00:09:28,000
¿Vale? Pues ese bucle es el ejercicio.

224
00:09:28,000 --> 00:09:30,000
Aquí en versión más larga abajo

225
00:09:30,000 --> 00:09:32,000
sería más corta.

226
00:09:32,000 --> 00:09:34,000
Pero me da igual.

227
00:09:34,000 --> 00:09:36,000
¿Vale? Este era el de sacar cifras decimales.

228
00:09:36,000 --> 00:09:38,000
Era ese. Lo que pasa es que

229
00:09:38,000 --> 00:09:40,000
aplicado a contarlas, vamos a hacerlas por consola.

230
00:09:40,000 --> 00:09:42,000
Nada más. Aplicado a contarlas

231
00:09:42,000 --> 00:09:44,000
en vez de vamos a hacerlas por consola.

232
00:09:44,000 --> 00:09:46,000
Las cifras decimales.

233
00:09:50,000 --> 00:09:52,000
Vale. Entonces ahora haciendo

234
00:09:52,000 --> 00:09:54,000
alguna prueba igual nos damos cuenta de que

235
00:09:54,000 --> 00:09:56,000
algo hemos hecho mal.

236
00:09:56,000 --> 00:09:58,000
Vamos a

237
00:09:58,000 --> 00:10:00,000
probar.

238
00:10:02,000 --> 00:10:04,000
A ver si ejecuto este ejercicio.

239
00:10:06,000 --> 00:10:08,000
Introduzca

240
00:10:08,000 --> 00:10:10,000
número 200.

241
00:10:10,000 --> 00:10:12,000
Introduzca número 23.

242
00:10:12,000 --> 00:10:14,000
Introduzca número 10.

243
00:10:14,000 --> 00:10:16,000
Introduzca número 701.

244
00:10:16,000 --> 00:10:18,000
Llevo

245
00:10:18,000 --> 00:10:20,000
2, 3, 4 cifras decimales.

246
00:10:20,000 --> 00:10:22,000
Y ahora voy a poner

247
00:10:22,000 --> 00:10:24,000
un negativo para salir ya.

248
00:10:24,000 --> 00:10:26,000
Esta prueba me la he hecho bien.

249
00:10:26,000 --> 00:10:28,000
Pues sí. Han sido 0, 4.

250
00:10:28,000 --> 00:10:30,000
A ver, en un caso real

251
00:10:30,000 --> 00:10:32,000
que necesitáramos, pues haríamos

252
00:10:32,000 --> 00:10:34,000
pruebas con combinaciones más

253
00:10:34,000 --> 00:10:36,000
extrañas a ver si nos sale algo raro.

254
00:10:36,000 --> 00:10:38,000
Pero bueno.

255
00:10:38,000 --> 00:10:40,000
Como un programa de tan pocas líneas, pues con esta prueba

256
00:10:40,000 --> 00:10:42,000
podemos concluir que sí.

257
00:10:46,000 --> 00:10:48,000
Vale. Pues ya está.

258
00:10:48,000 --> 00:10:50,000
Estos eran los tres ejercicios.

259
00:10:50,000 --> 00:10:52,000
El anterior, ya le he puesto

260
00:10:52,000 --> 00:10:54,000
los next line que faltarían

261
00:10:54,000 --> 00:10:56,000
para que funcionara bien.

262
00:10:56,000 --> 00:10:58,000
Después de leer el número,

263
00:10:58,000 --> 00:11:00,000
un next line en esta opción, para que cuando

264
00:11:00,000 --> 00:11:02,000
vuelva arriba a leerlo,

265
00:11:02,000 --> 00:11:04,000
no se chupe el salto de línea.

266
00:11:04,000 --> 00:11:06,000
Y aquí igual, en el caso B,

267
00:11:06,000 --> 00:11:08,000
después del next in, un next line

268
00:11:08,000 --> 00:11:10,000
que vuelva arriba.

269
00:11:14,000 --> 00:11:16,000
Vale.

270
00:11:16,000 --> 00:11:18,000
Vamos a hacer,

271
00:11:18,000 --> 00:11:20,000
por si alguno lo habéis hecho,

272
00:11:20,000 --> 00:11:22,000
que yo imagino que no,

273
00:11:22,000 --> 00:11:24,000
que habréis tirado por aquí, porque como este ejercicio

274
00:11:24,000 --> 00:11:26,000
lo tenemos hecho, sacar cifras decimales.

275
00:11:26,000 --> 00:11:28,000
Ya dijimos eso, ya sabemos cómo hacerlo.

276
00:11:28,000 --> 00:11:30,000
Ahora lo reutilizamos siempre que queramos.

277
00:11:30,000 --> 00:11:32,000
Pues aquí lo reutilizamos para contar.

278
00:11:32,000 --> 00:11:34,000
Yo imagino que habréis tirado por aquí.

279
00:11:34,000 --> 00:11:36,000
Pero si alguien ha tirado

280
00:11:36,000 --> 00:11:38,000
porque le gustan los streams

281
00:11:38,000 --> 00:11:40,000
o lo recuerda del año pasado,

282
00:11:40,000 --> 00:11:42,000
o si ya está el año pasado en el programa en algún sitio,

283
00:11:42,000 --> 00:11:44,000
lo que sea, si alguien ha tirado por stream,

284
00:11:44,000 --> 00:11:46,000
pues vamos a hacer esta versión

285
00:11:46,000 --> 00:11:48,000
de otra manera.

286
00:11:48,000 --> 00:11:50,000
Dios, que sustos me llevo.

287
00:11:50,000 --> 00:11:52,000
Vamos a hacer esta versión

288
00:11:52,000 --> 00:11:54,000
ejercicio 3B,

289
00:11:54,000 --> 00:11:56,000
con stream, para que vayamos cogiendo...

290
00:11:56,000 --> 00:11:58,000
3B, venga.

291
00:12:10,000 --> 00:12:12,000
Venga, voy a copiar y pegar lo de dentro,

292
00:12:12,000 --> 00:12:14,000
pero voy a hacer la versión

293
00:12:16,000 --> 00:12:18,000
otra forma de hacerlo, pero con cadenas.

294
00:12:18,000 --> 00:12:20,000
Quedándose con...

295
00:12:20,000 --> 00:12:22,000
Vale.

296
00:12:22,000 --> 00:12:24,000
Entonces,

297
00:12:24,000 --> 00:12:26,000
el número

298
00:12:26,000 --> 00:12:28,000
lo leemos igual, el contador igual,

299
00:12:28,000 --> 00:12:30,000
todo igual. Ahora lo que cambia es

300
00:12:30,000 --> 00:12:32,000
cómo contamos las cifras decimales.

301
00:12:32,000 --> 00:12:34,000
Esto es lo que cambia.

302
00:12:34,000 --> 00:12:36,000
El programa es el mismo.

303
00:12:36,000 --> 00:12:38,000
Cambia cómo las cuento.

304
00:12:38,000 --> 00:12:40,000
A lo mejor a uno, ya digo,

305
00:12:40,000 --> 00:12:42,000
se le ha ocurrido

306
00:12:42,000 --> 00:12:44,000
a lo mejor hacerlo de esta manera.

307
00:12:44,000 --> 00:12:46,000
Decir, a ver,

308
00:12:46,000 --> 00:12:48,000
ese numerito n,

309
00:12:48,000 --> 00:12:50,000
si yo lo convierto a stream,

310
00:12:50,000 --> 00:12:52,000
a cadena, si yo lo convierto a stream,

311
00:12:52,000 --> 00:12:54,000
lo que puedo hacer es recorrer

312
00:12:54,000 --> 00:12:56,000
sus posiciones, y cada

313
00:12:56,000 --> 00:12:58,000
posición que tenga el char

314
00:12:58,000 --> 00:13:00,000
número cero, la cuento.

315
00:13:00,000 --> 00:13:02,000
A uno se le podría haber ocurrido a lo mejor

316
00:13:02,000 --> 00:13:04,000
hacer esto. Entonces,

317
00:13:08,000 --> 00:13:10,000
¿cómo convertíamos

318
00:13:10,000 --> 00:13:12,000
un número a una

319
00:13:12,000 --> 00:13:14,000
cadena?

320
00:13:14,000 --> 00:13:16,000
Esto es lo que es raro que se

321
00:13:16,000 --> 00:13:18,000
os haya ocurrido si no habéis

322
00:13:18,000 --> 00:13:20,000
contado con ello, porque lo hemos usado dos veces solo.

323
00:13:20,000 --> 00:13:22,000
Dos o tres en dos ejercicios.

324
00:13:22,000 --> 00:13:24,000
Pero dijimos, la forma más sencilla

325
00:13:24,000 --> 00:13:26,000
es concatenar

326
00:13:26,000 --> 00:13:28,000
con una cadena.

327
00:13:28,000 --> 00:13:30,000
Porque recordad que la concatenación,

328
00:13:30,000 --> 00:13:32,000
cuando uno concatena cadenas y números,

329
00:13:32,000 --> 00:13:34,000
pesa la cadena, se concatena en cadena.

330
00:13:34,000 --> 00:13:36,000
¿Vale? ¿Lo recordáis?

331
00:13:36,000 --> 00:13:38,000
Entonces, esto es

332
00:13:38,000 --> 00:13:40,000
la cadena

333
00:13:40,000 --> 00:13:42,000
que contiene el numerito

334
00:13:42,000 --> 00:13:44,000
este. Si es 301, será el stream

335
00:13:44,000 --> 00:13:46,000
301.

336
00:13:46,000 --> 00:13:48,000
¿Vale?

337
00:13:48,000 --> 00:13:50,000
Y ahora ya recorrer una cadena

338
00:13:50,000 --> 00:13:52,000
y contamos los caracteres que son cero.

339
00:13:52,000 --> 00:13:54,000
Bueno, esto lo hicimos

340
00:13:54,000 --> 00:13:56,000
el día anterior y luego otro día,

341
00:13:56,000 --> 00:13:58,000
hacía una semana.

342
00:13:58,000 --> 00:14:00,000
Desde igual a cero, mientras i sea

343
00:14:00,000 --> 00:14:02,000
menor que

344
00:14:02,000 --> 00:14:04,000
nunca.length

345
00:14:06,000 --> 00:14:08,000
incrementando i

346
00:14:08,000 --> 00:14:10,000
¿qué tenemos que hacer?

347
00:14:10,000 --> 00:14:12,000
Pues sí.

348
00:14:12,000 --> 00:14:14,000
El carácter

349
00:14:16,000 --> 00:14:18,000
en la posición

350
00:14:18,000 --> 00:14:20,000
iésima resulta

351
00:14:20,000 --> 00:14:22,000
que es igual al

352
00:14:22,000 --> 00:14:24,000
carácter cero

353
00:14:24,000 --> 00:14:26,000
pues cont++

354
00:14:28,000 --> 00:14:30,000
¿Vale? Otra forma de hacerlo, pero que no

355
00:14:30,000 --> 00:14:32,000
espero que

356
00:14:32,000 --> 00:14:34,000
lo hayáis hecho así.

357
00:14:34,000 --> 00:14:36,000
Porque con cadenas hemos trabajado menos.

358
00:14:36,000 --> 00:14:38,000
Pero bueno, para que tengáis

359
00:14:38,000 --> 00:14:40,000
lo convierto a cadena,

360
00:14:40,000 --> 00:14:42,000
recorro todos y cada uno de los caracteres

361
00:14:42,000 --> 00:14:44,000
de la cadena, según voy

362
00:14:44,000 --> 00:14:46,000
encontrando caracteres que son el numerito

363
00:14:46,000 --> 00:14:48,000
cero, incremento

364
00:14:48,000 --> 00:14:50,000
el contador.

365
00:15:10,000 --> 00:15:12,000
¿Vale?

366
00:15:18,000 --> 00:15:20,000
Vale, pues ya está.

367
00:15:20,000 --> 00:15:22,000
Pues este...

368
00:15:22,000 --> 00:15:24,000
A ver, dudas

369
00:15:24,000 --> 00:15:26,000
o preguntas.

370
00:15:32,000 --> 00:15:34,000
Nada, ¿alguien ha

371
00:15:34,000 --> 00:15:36,000
hecho algo de otra manera y tiene

372
00:15:36,000 --> 00:15:38,000
dudas o alguien o yo qué sé?

373
00:15:38,000 --> 00:15:40,000
Cualquier comentario.

374
00:15:42,000 --> 00:15:44,000
Bueno,

375
00:15:44,000 --> 00:15:46,000
pues nada, dejamos aquí la corrección

376
00:15:46,000 --> 00:15:48,000
entonces.

377
00:15:48,000 --> 00:15:50,000
Sí, sí, sí, esto lo subo a la ola virtual.

378
00:15:54,000 --> 00:15:56,000
Ah, sí, sí, sí.

379
00:15:56,000 --> 00:15:58,000
Vale, entonces.

380
00:15:58,000 --> 00:16:00,000
Lo pusimos solo en este

381
00:16:00,000 --> 00:16:02,000
para que no os volvíáis locos en todos.

382
00:16:02,000 --> 00:16:04,000
Pero sacar a funciones y a uno

383
00:16:04,000 --> 00:16:06,000
leer cómo lo hacía. Entonces,

384
00:16:06,000 --> 00:16:08,000
si alguno para aumentar

385
00:16:08,000 --> 00:16:10,000
la legibilidad del código, efectivamente,

386
00:16:10,000 --> 00:16:12,000
pues lo sacaba a una

387
00:16:12,000 --> 00:16:14,000
función, eso

388
00:16:14,000 --> 00:16:16,000
da ese cero cinco, ¿vale? Entonces

389
00:16:16,000 --> 00:16:18,000
aquí, por ejemplo, el ejercicio tres, que era

390
00:16:18,000 --> 00:16:20,000
el que lo habíamos aplicado para que los demás no os volvíáis

391
00:16:20,000 --> 00:16:22,000
locos ahí sacando a funciones todo.

392
00:16:22,000 --> 00:16:24,000
Vale, pues en este.

393
00:16:24,000 --> 00:16:26,000
Recordad que sacar a funciones

394
00:16:26,000 --> 00:16:28,000
sobre todo tenía utilidad

395
00:16:28,000 --> 00:16:30,000
a la hora de hacer más legible el código cuando teníamos

396
00:16:30,000 --> 00:16:32,000
un bucle dentro de otro, pero cuando tenemos un

397
00:16:32,000 --> 00:16:34,000
bucle dentro de otro, ya

398
00:16:34,000 --> 00:16:36,000
la cosa se empezaba a complicar, ¿verdad?

399
00:16:36,000 --> 00:16:38,000
Que era esta situación.

400
00:16:38,000 --> 00:16:40,000
Entonces aquí, tengo un bucle

401
00:16:40,000 --> 00:16:42,000
que me lee números, y aquí otro bucle

402
00:16:42,000 --> 00:16:44,000
para contar cifras decimales.

403
00:16:44,000 --> 00:16:46,000
Pues decimos, oye, pues voy a sacar esto a una función

404
00:16:46,000 --> 00:16:48,000
y que me haga una función

405
00:16:48,000 --> 00:16:50,000
que me cuente las cifras decimales de un

406
00:16:50,000 --> 00:16:52,000
número. Pues tengo una función

407
00:16:52,000 --> 00:16:54,000
que me cuenta las cifras decimales de un número y me lo devuelve,

408
00:16:54,000 --> 00:16:56,000
llama a la función y ya está. ¿Vale? Que es lo que hemos

409
00:16:56,000 --> 00:16:58,000
estado haciendo. Pues venga, vamos a hacer

410
00:16:58,000 --> 00:17:00,000
una función aquí fuera

411
00:17:00,000 --> 00:17:02,000
que

412
00:17:02,000 --> 00:17:04,000
me devuelve

413
00:17:04,000 --> 00:17:06,000
como valor de retorno las cifras

414
00:17:06,000 --> 00:17:08,000
decimales de un numerito

415
00:17:08,000 --> 00:17:10,000
que yo le paso.

416
00:17:12,000 --> 00:17:14,000
¿Vale? ¿Qué le vamos a pasar?

417
00:17:14,000 --> 00:17:16,000
Un numerito n. ¿Qué va

418
00:17:16,000 --> 00:17:18,000
a hacer esta función? Devolverme con

419
00:17:18,000 --> 00:17:20,000
el return el número de cifras decimales.

420
00:17:20,000 --> 00:17:22,000
Pues venga, o sea,

421
00:17:22,000 --> 00:17:24,000
esto vamos a copiar y pegar

422
00:17:24,000 --> 00:17:26,000
y luego llamamos a la función.

423
00:17:26,000 --> 00:17:28,000
¿Vale? Entonces

424
00:17:28,000 --> 00:17:30,000
el numerito n

425
00:17:30,000 --> 00:17:32,000
saca

426
00:17:32,000 --> 00:17:34,000
sus cifras decimales y las guarda en cont

427
00:17:34,000 --> 00:17:36,000
que aquí me falta

428
00:17:36,000 --> 00:17:38,000
declararlo porque

429
00:17:38,000 --> 00:17:40,000
y ahora ya devuelvo cont.

430
00:17:42,000 --> 00:17:44,000
Fuera del while.

431
00:17:46,000 --> 00:17:48,000
Esto es del while

432
00:17:48,000 --> 00:17:50,000
y ahora aquí

433
00:17:50,000 --> 00:17:52,000
return cont.

434
00:17:52,000 --> 00:17:54,000
¡Hala!

435
00:17:56,000 --> 00:17:58,000
Pues esta función

436
00:17:58,000 --> 00:18:00,000
me ha sacado aparte lo de

437
00:18:00,000 --> 00:18:02,000
coger un número entero n

438
00:18:02,000 --> 00:18:04,000
contar sus cifras decimales

439
00:18:10,000 --> 00:18:12,000
este compilador

440
00:18:12,000 --> 00:18:14,000
como este compilador no me

441
00:18:14,000 --> 00:18:16,000
dice que cont no esté inicializado.

442
00:18:22,000 --> 00:18:24,000
¿Vale? A ver, no me lo dice

443
00:18:24,000 --> 00:18:26,000
porque como está en un while

444
00:18:26,000 --> 00:18:28,000
podrían ejecutarse nunca. Entonces ¿quién se activa?

445
00:18:28,000 --> 00:18:30,000
Sona, que es otro plugin de Eclipse

446
00:18:30,000 --> 00:18:32,000
que lo que me dice es, cuidado, esto no es un error de compilación

447
00:18:32,000 --> 00:18:34,000
no te puedo

448
00:18:34,000 --> 00:18:36,000
decir que es un error de compilación

449
00:18:36,000 --> 00:18:38,000
porque yo no sé si vas a entrar en el while alguna vez o no.

450
00:18:38,000 --> 00:18:40,000
Entonces lo digo

451
00:18:40,000 --> 00:18:42,000
con información, no es una cosa tan duro que sea.

452
00:18:42,000 --> 00:18:44,000
Y te dice como

453
00:18:44,000 --> 00:18:46,000
si no entras nunca me da igual que cont esté

454
00:18:46,000 --> 00:18:48,000
inicializado o que no lo esté.

455
00:18:48,000 --> 00:18:50,000
Entonces el compilador es muy

456
00:18:50,000 --> 00:18:52,000
problemático y dice, a ver, bucle

457
00:18:52,000 --> 00:18:54,000
a lo mejor no entras nunca. Si no entras nunca

458
00:18:54,000 --> 00:18:56,000
me da igual que cont no esté inicializado

459
00:18:56,000 --> 00:18:58,000
porque no lo va a necesitar.

460
00:18:58,000 --> 00:19:00,000
Entonces no se atreve a dar error de compilación

461
00:19:00,000 --> 00:19:02,000
pero te saca un error de sonar que es otra historia rara.

462
00:19:02,000 --> 00:19:04,000
¿Vale? En fin,

463
00:19:04,000 --> 00:19:06,000
en nuestro caso, pasemos de eso

464
00:19:06,000 --> 00:19:08,000
nosotros

465
00:19:08,000 --> 00:19:10,000
queremos inicializarlo a cero

466
00:19:10,000 --> 00:19:12,000
porque hombre, aquí va a entrar

467
00:19:12,000 --> 00:19:14,000
aquí va a entrar para contar las cifras

468
00:19:14,000 --> 00:19:16,000
decimales

469
00:19:16,000 --> 00:19:18,000
porque si yo meto un número, ese número como poco

470
00:19:18,000 --> 00:19:20,000
va a entrar una cifra decimal.

471
00:19:20,000 --> 00:19:22,000
¿Vale? Solo no entraría

472
00:19:22,000 --> 00:19:24,000
si el numerito fuera cero.

473
00:19:24,000 --> 00:19:26,000
Pero es que si el numerito fuera cero no entraría

474
00:19:26,000 --> 00:19:28,000
pero yo quiero que entonces me devuelva

475
00:19:28,000 --> 00:19:30,000
lo que

476
00:19:30,000 --> 00:19:32,000
el usuario diga.

477
00:19:32,000 --> 00:19:34,000
¿Vale? Entonces lo digo porque

478
00:19:34,000 --> 00:19:36,000
no me sale el error de compilación y podríais

479
00:19:36,000 --> 00:19:38,000
decir, ostras, pero como

480
00:19:38,000 --> 00:19:40,000
no te dice que inicializa me cont

481
00:19:40,000 --> 00:19:42,000
como yo voy a empezar a sumar

482
00:19:42,000 --> 00:19:44,000
vale, no te sale el error de compilación

483
00:19:44,000 --> 00:19:46,000
pero como veis se ha activado esto

484
00:19:46,000 --> 00:19:48,000
que es otra especie de vigilante

485
00:19:48,000 --> 00:19:50,000
que tiene ahí Eclipse, tiene varios vigilantes

486
00:19:54,000 --> 00:19:56,000
pero vamos, yo sé que lo tengo que inicializar

487
00:19:56,000 --> 00:19:58,000
porque si no esto no me va a funcionar

488
00:19:58,000 --> 00:20:00,000
¿Vale? Pues entonces

489
00:20:00,000 --> 00:20:02,000
lo saco aparte el código, lo saco aparte

490
00:20:02,000 --> 00:20:04,000
este código me va contando

491
00:20:04,000 --> 00:20:06,000
todas las cifras de este numerito

492
00:20:06,000 --> 00:20:08,000
N que yo le paso entero

493
00:20:08,000 --> 00:20:10,000
que son cero y cuando ya las

494
00:20:10,000 --> 00:20:12,000
tenga todas las devuelve.

495
00:20:12,000 --> 00:20:14,000
¿Vale? Y ahora ya que hago

496
00:20:14,000 --> 00:20:16,000
¿Llamo a la función?

497
00:20:16,000 --> 00:20:18,000
Llamo a la función

498
00:20:18,000 --> 00:20:20,000
Entonces vamos a hacerlo aquí

499
00:20:20,000 --> 00:20:22,000
vamos a poner aquí, llamando a la función

500
00:20:22,000 --> 00:20:24,000
¿Cómo sería?

501
00:20:26,000 --> 00:20:28,000
Llamando a la función

502
00:20:28,000 --> 00:20:30,000
sería

503
00:20:30,000 --> 00:20:32,000
pues mucho más fácil

504
00:20:32,000 --> 00:20:34,000
porque a cont le incremento

505
00:20:36,000 --> 00:20:38,000
con el resultado de llamar a la función

506
00:20:40,000 --> 00:20:42,000
Bueno, vamos a hacerlo con variables

507
00:20:42,000 --> 00:20:44,000
adicionales

508
00:20:44,000 --> 00:20:46,000
para que no os liéis

509
00:20:46,000 --> 00:20:48,000
No un cifras, no un cifras va a ser

510
00:20:48,000 --> 00:20:50,000
igual a cuánto, al resultado de llamar a la función

511
00:20:54,000 --> 00:20:56,000
¿Para qué numerito?

512
00:20:56,000 --> 00:20:58,000
Para el numerito N que he leído

513
00:20:58,000 --> 00:21:00,000
para el numerito N que he leído

514
00:21:00,000 --> 00:21:02,000
¿Vale? Pues entonces

515
00:21:02,000 --> 00:21:04,000
aquí en lugar de todo este bucle, repito

516
00:21:04,000 --> 00:21:06,000
en lugar de todo este bucle lo tengo mucho más fácil

517
00:21:06,000 --> 00:21:08,000
Llamo a la función pasándole

518
00:21:08,000 --> 00:21:10,000
el numerito N leído

519
00:21:10,000 --> 00:21:12,000
Llamo a la función

520
00:21:12,000 --> 00:21:14,000
y ya me da las cifras decimales

521
00:21:14,000 --> 00:21:16,000
Actualizo cont y se acabó

522
00:21:16,000 --> 00:21:18,000
cont más

523
00:21:18,000 --> 00:21:20,000
igual, no un cifras

524
00:21:20,000 --> 00:21:22,000
no un cifras cero

525
00:21:24,000 --> 00:21:26,000
perdón, estoy

526
00:21:26,000 --> 00:21:28,000
así, no un cifras cero

527
00:21:28,000 --> 00:21:30,000
son las que estoy contando, ¿verdad?

528
00:21:30,000 --> 00:21:32,000
Bueno, pues esto me sustituiría

529
00:21:32,000 --> 00:21:34,000
a todo esto

530
00:21:34,000 --> 00:21:36,000
¿Vale?

531
00:21:37,000 --> 00:21:39,000
Todo esto de aquí

532
00:21:39,000 --> 00:21:41,000
si lo hago con una función adicional

533
00:21:41,000 --> 00:21:43,000
se me queda en esto

534
00:21:43,000 --> 00:21:45,000
Cuento las cifras decimales

535
00:21:45,000 --> 00:21:47,000
del numerito N llamando a la función

536
00:21:47,000 --> 00:21:49,000
las guardo aquí

537
00:21:49,000 --> 00:21:51,000
e incremento cont con esas cifras decimales

538
00:21:53,000 --> 00:21:55,000
¿Vale?

539
00:21:58,000 --> 00:22:00,000
Y esta función le pasa un numerito

540
00:22:00,000 --> 00:22:02,000
trabaja con él

541
00:22:02,000 --> 00:22:04,000
cuenta las cifras que son cero

542
00:22:04,000 --> 00:22:06,000
y las devuelve

543
00:22:06,000 --> 00:22:08,000
y en alguna de estas me he comido la llave

544
00:22:08,000 --> 00:22:10,000
que me falta aquí

545
00:22:12,000 --> 00:22:14,000
Vale

546
00:22:30,000 --> 00:22:32,000
Vale, pues ahora sí que

547
00:22:35,000 --> 00:22:37,000
está todo

548
00:22:50,000 --> 00:22:52,000
Vale, pues nada, ya subimos

549
00:22:52,000 --> 00:22:54,000
esto a la hora virtual

550
00:22:54,000 --> 00:22:56,000
¿Más cosas?

551
00:23:00,000 --> 00:23:02,000
No hay preguntas

552
00:23:02,000 --> 00:23:04,000
ni nada, bueno

553
00:23:04,000 --> 00:23:06,000
Vale, pues nada

554
00:23:06,000 --> 00:23:08,000
pues

555
00:23:08,000 --> 00:23:10,000
vamos a seguir

556
00:23:32,000 --> 00:23:34,000
Vale

557
00:23:48,000 --> 00:23:50,000
Vale

558
00:23:50,000 --> 00:23:52,000
Borrador

559
00:23:52,000 --> 00:23:54,000
¿Dónde está?

560
00:24:02,000 --> 00:24:04,000
Vale

561
00:24:22,000 --> 00:24:24,000
Bueno, pues

562
00:24:24,000 --> 00:24:26,000
seguimos todavía

563
00:24:26,000 --> 00:24:28,000
pero ya es lo último

564
00:24:28,000 --> 00:24:30,000
antes de entrar en clases y objetos

565
00:24:30,000 --> 00:24:32,000
con programación estructurada

566
00:24:32,000 --> 00:24:34,000
con conceptos de la programación estructurada de toda la vida

567
00:24:34,000 --> 00:24:36,000
¿Vale?

568
00:24:36,000 --> 00:24:38,000
Y la programación estructurada de toda la vida

569
00:24:38,000 --> 00:24:40,000
es la que se basa en la construcción de programas

570
00:24:40,000 --> 00:24:42,000
que es

571
00:24:42,000 --> 00:24:44,000
una línea tras otra

572
00:24:44,000 --> 00:24:46,000
una línea tras otra, una línea tras otra

573
00:24:46,000 --> 00:24:48,000
o sea una secuencia de instrucciones

574
00:24:48,000 --> 00:24:50,000
y esas instrucciones

575
00:24:52,000 --> 00:24:54,000
solamente es necesario utilizar

576
00:24:54,000 --> 00:24:56,000
declaraciones de variables

577
00:24:56,000 --> 00:24:58,000
y asignaciones, por supuesto

578
00:24:58,000 --> 00:25:00,000
no está en ningún sitio

579
00:25:00,000 --> 00:25:02,000
decisiones y bucles

580
00:25:02,000 --> 00:25:04,000
y ya está

581
00:25:04,000 --> 00:25:06,000
combinando esas sentencias

582
00:25:06,000 --> 00:25:08,000
declaración de variables con asignaciones

583
00:25:08,000 --> 00:25:10,000
bucles y decisiones

584
00:25:10,000 --> 00:25:12,000
se puede construir cualquier

585
00:25:12,000 --> 00:25:14,000
algoritmo

586
00:25:14,000 --> 00:25:16,000
para resolver cualquier problema que tengamos

587
00:25:16,000 --> 00:25:18,000
Vale, entonces

588
00:25:18,000 --> 00:25:20,000
a esa estructura

589
00:25:20,000 --> 00:25:22,000
hemos incorporado una pequeña ruptura

590
00:25:22,000 --> 00:25:24,000
porque es lo que se hace de toda la vida en programación

591
00:25:24,000 --> 00:25:26,000
que es cuando el código es muy muy muy muy largo

592
00:25:26,000 --> 00:25:28,000
puedo sacar parte

593
00:25:28,000 --> 00:25:30,000
a lo que tradicionalmente se ha llamado función

594
00:25:30,000 --> 00:25:32,000
puedo sacar parte a lo que se ha llamado función

595
00:25:32,000 --> 00:25:34,000
y entonces en este código

596
00:25:34,000 --> 00:25:36,000
cuando quiera hacer esto, llamo ahí

597
00:25:36,000 --> 00:25:38,000
se hace y volvemos otra vez

598
00:25:38,000 --> 00:25:40,000
una vez que ha terminado

599
00:25:40,000 --> 00:25:42,000
Entonces ese concepto de función

600
00:25:42,000 --> 00:25:44,000
que es este trozo de código

601
00:25:44,000 --> 00:25:46,000
lo saco aparte, le pongo un nombre

602
00:25:46,000 --> 00:25:48,000
y ahora desde el programa lo llamo con su nombre

603
00:25:48,000 --> 00:25:50,000
cuando ha terminado vuelvo

604
00:25:50,000 --> 00:25:52,000
ese es un concepto también que se ha usado

605
00:25:52,000 --> 00:25:54,000
toda la vida en programación estructurada

606
00:25:54,000 --> 00:25:56,000
y en esa función va a lo que uno quiera

607
00:25:56,000 --> 00:25:58,000
obviamente cualquier trozo de código

608
00:25:58,000 --> 00:26:00,000
que haga lo que necesitamos nosotros

609
00:26:02,000 --> 00:26:04,000
Bueno, pues hay otro concepto

610
00:26:04,000 --> 00:26:06,000
que se ha usado en programación estructurada siempre

611
00:26:06,000 --> 00:26:08,000
porque es que

612
00:26:08,000 --> 00:26:10,000
a la hora de trabajar ya

613
00:26:10,000 --> 00:26:12,000
con un volumen de datos

614
00:26:12,000 --> 00:26:14,000
es imprescindible

615
00:26:14,000 --> 00:26:16,000
no podemos trabajar con variables

616
00:26:16,000 --> 00:26:18,000
sueltas como hemos venido trabajando hasta ahora

617
00:26:18,000 --> 00:26:20,000
Entonces

618
00:26:20,000 --> 00:26:22,000
hasta ahora hemos venido trabajando

619
00:26:22,000 --> 00:26:24,000
con variables sueltas por ahí

620
00:26:24,000 --> 00:26:26,000
¿Que yo necesitaba números enteros?

621
00:26:26,000 --> 00:26:28,000
Pues me declaraba una variable suelta

622
00:26:28,000 --> 00:26:30,000
para cada entero

623
00:26:30,000 --> 00:26:32,000
¿Que necesitaba dos números n1 y n2?

624
00:26:32,000 --> 00:26:34,000
Pues ala, me declaraba dos variables sueltas

625
00:26:34,000 --> 00:26:36,000
¿Que ahora necesitaba una variable cadena

626
00:26:36,000 --> 00:26:38,000
para guardar un nombre?

627
00:26:38,000 --> 00:26:40,000
Pues venga, me declaraba una variable

628
00:26:40,000 --> 00:26:42,000
cadena o stream

629
00:26:42,000 --> 00:26:44,000
para un nombre

630
00:26:44,000 --> 00:26:46,000
y así hemos trabajado, con variables

631
00:26:46,000 --> 00:26:48,000
que yo he ido declarando de los tipos que conocemos

632
00:26:48,000 --> 00:26:50,000
los ocho primitivos

633
00:26:50,000 --> 00:26:52,000
byte, short, int, long

634
00:26:52,000 --> 00:26:54,000
float, double, char y boolean

635
00:26:54,000 --> 00:26:56,000
más este

636
00:26:56,000 --> 00:26:58,000
que es medio rarito, porque es objeto

637
00:26:58,000 --> 00:27:00,000
pero bueno, ya iremos viendo sus particularidades

638
00:27:02,000 --> 00:27:04,000
y así hemos hecho, declarando las variables sueltas

639
00:27:04,000 --> 00:27:06,000
y así hemos tirado

640
00:27:06,000 --> 00:27:08,000
Claro, pero que pasa si llega un programa

641
00:27:08,000 --> 00:27:10,000
y me dice, programa que

642
00:27:12,000 --> 00:27:14,000
recorra

643
00:27:14,000 --> 00:27:16,000
que genere

644
00:27:16,000 --> 00:27:18,000
o que recorra mil números enteros

645
00:27:18,000 --> 00:27:20,000
para ver

646
00:27:20,000 --> 00:27:22,000
la media de esos números, por ejemplo

647
00:27:22,000 --> 00:27:24,000
programa que lea los nombres

648
00:27:24,000 --> 00:27:26,000
de los alumnos de un instituto

649
00:27:26,000 --> 00:27:28,000
y los alumnos de un instituto son 300

650
00:27:28,000 --> 00:27:30,000
entonces que hacemos

651
00:27:30,000 --> 00:27:32,000
300 variables de estas

652
00:27:32,000 --> 00:27:34,000
o programa que tiene que trabajar

653
00:27:34,000 --> 00:27:36,000
con mil números enteros, porque son

654
00:27:36,000 --> 00:27:38,000
los mil precios

655
00:27:38,000 --> 00:27:40,000
de los productos, que hacemos, nos declaramos

656
00:27:40,000 --> 00:27:42,000
mil de estas, n1, n2, n3

657
00:27:42,000 --> 00:27:44,000
escribimos así hasta n1000

658
00:27:44,000 --> 00:27:46,000
o sea, es imposible

659
00:27:46,000 --> 00:27:48,000
tener un cierto volumen de datos

660
00:27:48,000 --> 00:27:50,000
cuando hay un montón de números enteros

661
00:27:50,000 --> 00:27:52,000
o un montón de cadenas

662
00:27:52,000 --> 00:27:54,000
que es un caso real, obviamente

663
00:27:54,000 --> 00:27:56,000
no podemos tirar de meter

664
00:27:56,000 --> 00:27:58,000
esos datos en variables sueltas

665
00:27:58,000 --> 00:28:00,000
sería implanteable

666
00:28:00,000 --> 00:28:02,000
ya no solo porque no podemos estar aquí

667
00:28:02,000 --> 00:28:04,000
escribiendo hasta el infinito

668
00:28:04,000 --> 00:28:06,000
sino porque luego a la hora de asignar

669
00:28:06,000 --> 00:28:08,000
¿qué hacemos? n1 igual a tal, n2 igual a tal

670
00:28:08,000 --> 00:28:10,000
n3 igual a tal y así hasta n1000

671
00:28:10,000 --> 00:28:12,000
o sea, mil líneas es lo único que hacen

672
00:28:12,000 --> 00:28:14,000
¿qué hacen n1 igual a tal, n2 igual a tal?

673
00:28:14,000 --> 00:28:16,000
no, es implanteable

674
00:28:16,000 --> 00:28:18,000
entonces eso desde ya

675
00:28:18,000 --> 00:28:20,000
tenemos que poder solucionarlo

676
00:28:20,000 --> 00:28:22,000
desde ya, y desde ya se ha solucionado

677
00:28:22,000 --> 00:28:24,000
la programación estructurada, esto no tiene que ver

678
00:28:24,000 --> 00:28:26,000
con clases, ni con objetos, ni con nada

679
00:28:26,000 --> 00:28:28,000
vale, pues ¿cómo se soluciona esto?

680
00:28:28,000 --> 00:28:30,000
se soluciona con el concepto

681
00:28:30,000 --> 00:28:32,000
de Arrays

682
00:28:34,000 --> 00:28:36,000
Arrays, lo que en literatura

683
00:28:36,000 --> 00:28:38,000
por ahí, pues a veces

684
00:28:38,000 --> 00:28:40,000
por herencia del pasado

685
00:28:40,000 --> 00:28:42,000
muchas veces lo llaman

686
00:28:42,000 --> 00:28:44,000
vectores

687
00:28:44,000 --> 00:28:46,000
pero bueno, esto por la herencia

688
00:28:46,000 --> 00:28:48,000
de literatura antigua, pero su nombre

689
00:28:48,000 --> 00:28:50,000
está en Darés Arrays

690
00:28:50,000 --> 00:28:52,000
y los que lo quieren traducir

691
00:28:52,000 --> 00:28:54,000
que muchas veces

692
00:28:54,000 --> 00:28:56,000
en fuentes bibliográficas, sobre todo

693
00:28:56,000 --> 00:28:58,000
si son latinoamericanas

694
00:28:58,000 --> 00:29:00,000
estarán traducidas

695
00:29:00,000 --> 00:29:02,000
pues si lo quieren traducir

696
00:29:02,000 --> 00:29:04,000
a veces lo traducen así

697
00:29:04,000 --> 00:29:06,000
esta sería su traducción, Arrays

698
00:29:06,000 --> 00:29:08,000
pero es que es un término muy feo, muy raro

699
00:29:08,000 --> 00:29:10,000
lo normal, el término con el que

700
00:29:10,000 --> 00:29:12,000
nos entendemos, es con este

701
00:29:12,000 --> 00:29:14,000
vale, es con este

702
00:29:14,000 --> 00:29:16,000
pero vamos, si estudiáis por ahí

703
00:29:16,000 --> 00:29:18,000
o lo que sea

704
00:29:18,000 --> 00:29:20,000
pues podéis encontraros esto

705
00:29:20,000 --> 00:29:22,000
como traducción, o esto

706
00:29:22,000 --> 00:29:24,000
porque todavía se arrastra un poquito

707
00:29:24,000 --> 00:29:26,000
porque en origen eran vectores

708
00:29:26,000 --> 00:29:28,000
si recordáis la física

709
00:29:28,000 --> 00:29:30,000
del bachillerato

710
00:29:30,000 --> 00:29:32,000
pues un vector es

711
00:29:32,000 --> 00:29:34,000
un montón de valores

712
00:29:34,000 --> 00:29:36,000
puede ser bidimensional, tridimensional

713
00:29:36,000 --> 00:29:38,000
pues eso es un Arrays

714
00:29:38,000 --> 00:29:40,000
un Arrays es un montón de valores

715
00:29:40,000 --> 00:29:42,000
porque eso es justo

716
00:29:42,000 --> 00:29:44,000
para lo que lo queremos

717
00:29:44,000 --> 00:29:46,000
bueno, pues ¿qué es un Arrays?

718
00:29:48,000 --> 00:29:50,000
un Arrays es

719
00:29:50,000 --> 00:29:52,000
una variable también, una variable

720
00:29:52,000 --> 00:29:54,000
eso es una variable, pero es una variable

721
00:29:54,000 --> 00:29:56,000
especial, es una variable

722
00:29:56,000 --> 00:29:58,000
especial porque en lugar de servirnos

723
00:29:58,000 --> 00:30:00,000
para guardar un único valor

724
00:30:00,000 --> 00:30:02,000
¿verdad Moisés?

725
00:30:02,000 --> 00:30:04,000
en lugar de ser una, hasta ahora

726
00:30:04,000 --> 00:30:06,000
todas las variables que hemos declarado

727
00:30:06,000 --> 00:30:08,000
servían para guardar sólo un valor

728
00:30:08,000 --> 00:30:10,000
me da igual que sea un número

729
00:30:10,000 --> 00:30:12,000
me da igual que sea un char

730
00:30:12,000 --> 00:30:14,000
o me da igual que sea una cadena, pero sólo un valor

731
00:30:14,000 --> 00:30:16,000
bueno, pues un Arrays es una variable

732
00:30:16,000 --> 00:30:18,000
pero es especial porque me permite guardar

733
00:30:18,000 --> 00:30:20,000
muchos valores

734
00:30:20,000 --> 00:30:22,000
bajo su mismo nombre

735
00:30:22,000 --> 00:30:24,000
bajo un único nombre

736
00:30:24,000 --> 00:30:26,000
vale, eso es un Arrays

737
00:30:26,000 --> 00:30:28,000
es una variable

738
00:30:32,000 --> 00:30:34,000
que permite guardar

739
00:30:36,000 --> 00:30:38,000
guardar o almacenar

740
00:30:38,000 --> 00:30:40,000
como lo entendáis mejor

741
00:30:42,000 --> 00:30:44,000
un montón de valores

742
00:30:44,000 --> 00:30:46,000
un montón de valores

743
00:30:46,000 --> 00:30:48,000
y no sólo una diferencia de las que hemos visto

744
00:30:50,000 --> 00:30:52,000
de un mismo tipo

745
00:31:06,000 --> 00:31:08,000
¿vale?

746
00:31:08,000 --> 00:31:10,000
esto es importante

747
00:31:10,000 --> 00:31:12,000
lo de un mismo tipo

748
00:31:12,000 --> 00:31:14,000
porque luego Java con la herencia

749
00:31:14,000 --> 00:31:16,000
pues ha apañado

750
00:31:16,000 --> 00:31:18,000
un poco para que sea un poquito más

751
00:31:18,000 --> 00:31:20,000
flexible y puedan ser diferentes tipos, pero con ciertas

752
00:31:20,000 --> 00:31:22,000
restricciones, pero eso ya en su momento

753
00:31:22,000 --> 00:31:24,000
con Java, con objetos, con clases, con todo

754
00:31:24,000 --> 00:31:26,000
ya lo veremos

755
00:31:26,000 --> 00:31:28,000
ahora mismo nos quedamos

756
00:31:28,000 --> 00:31:30,000
con que es una variable

757
00:31:30,000 --> 00:31:32,000
que permite guardar un montón

758
00:31:32,000 --> 00:31:34,000
pero de un mismo tipo, es decir

759
00:31:34,000 --> 00:31:36,000
un montón de enteros, todos juntos, ahí en la misma variable

760
00:31:36,000 --> 00:31:38,000
un montón de cadenas, todos juntos

761
00:31:38,000 --> 00:31:40,000
en la misma variable, un montón de decimales

762
00:31:40,000 --> 00:31:42,000
todos juntos en la misma variable, eso es lo que permite un Arrays

763
00:31:42,000 --> 00:31:44,000
entonces al ser una única

764
00:31:44,000 --> 00:31:46,000
variable, porque un Arrays es una única variable

765
00:31:46,000 --> 00:31:48,000
tiene un único nombre

766
00:31:48,000 --> 00:31:50,000
vale, pues bajo ese

767
00:31:50,000 --> 00:31:52,000
nombre, bajo ese único

768
00:31:52,000 --> 00:31:54,000
nombre, podemos guardar un montón de números

769
00:31:54,000 --> 00:31:56,000
imaginamos que declaramos un Arrays

770
00:31:56,000 --> 00:31:58,000
ya veremos cómo, que ese Arrays se llama

771
00:31:58,000 --> 00:32:00,000
números

772
00:32:00,000 --> 00:32:02,000
pues ese será el nombre de la variable

773
00:32:02,000 --> 00:32:04,000
ArraysNumeros, su único nombre

774
00:32:04,000 --> 00:32:06,000
números, igual que mi variable n1

775
00:32:06,000 --> 00:32:08,000
cuando yo guardaba un número se llamaba n1

776
00:32:08,000 --> 00:32:10,000
n1 solo me

777
00:32:10,000 --> 00:32:12,000
permitía guardar un número, pues ahora

778
00:32:12,000 --> 00:32:14,000
números, al ser de tipo

779
00:32:14,000 --> 00:32:16,000
ArraysNumeros, me permite guardar un montón

780
00:32:16,000 --> 00:32:18,000
me permite guardar muchos

781
00:32:18,000 --> 00:32:20,000
nos viene la duda de, y como lo hago yo

782
00:32:20,000 --> 00:32:22,000
a través de ese nombre

783
00:32:22,000 --> 00:32:24,000
como accedo yo al primero, o al segundo

784
00:32:24,000 --> 00:32:26,000
o al quinto, se tiene un montón, bajo el mismo

785
00:32:26,000 --> 00:32:28,000
nombre, como distingo yo

786
00:32:28,000 --> 00:32:30,000
dentro de ese único nombre, números

787
00:32:30,000 --> 00:32:32,000
a cual me refiero de todos ellos

788
00:32:32,000 --> 00:32:34,000
porque hay un único nombre

789
00:32:34,000 --> 00:32:36,000
para todos los números que tiene guardados

790
00:32:36,000 --> 00:32:38,000
vale, pues ahí viene

791
00:32:38,000 --> 00:32:40,000
como ahora

792
00:32:40,000 --> 00:32:42,000
declaramos

793
00:32:42,000 --> 00:32:44,000
usamos y

794
00:32:48,000 --> 00:32:50,000
y utilizamos esta

795
00:32:50,000 --> 00:32:52,000
este tipo de variable

796
00:32:52,000 --> 00:32:54,000
bueno, pues entonces

797
00:32:54,000 --> 00:32:56,000
repito, uno tiene que tener claro que problema

798
00:32:56,000 --> 00:32:58,000
le soluciona, porque las cosas existen

799
00:32:58,000 --> 00:33:00,000
si no solucionan problemas

800
00:33:00,000 --> 00:33:02,000
si no solucionan problemas

801
00:33:02,000 --> 00:33:04,000
no necesitamos que existan, necesitamos

802
00:33:04,000 --> 00:33:06,000
conocerlas, nos dan igual

803
00:33:06,000 --> 00:33:08,000
entonces esta nos soluciona un problema

804
00:33:08,000 --> 00:33:10,000
vale, para eso está, no está porque tenga que estar ahí

805
00:33:10,000 --> 00:33:12,000
nos soluciona el problema de guardar

806
00:33:12,000 --> 00:33:14,000
un montón de datos

807
00:33:14,000 --> 00:33:16,000
sin tener yo que declarar variables

808
00:33:16,000 --> 00:33:18,000
por separado para cada uno de ellos

809
00:33:18,000 --> 00:33:20,000
eso me soluciona, que es interesante

810
00:33:20,000 --> 00:33:22,000
bueno, pues ahora

811
00:33:22,000 --> 00:33:24,000
cuando yo la necesito

812
00:33:24,000 --> 00:33:26,000
porque me he dado cuenta que esa es mi situación

813
00:33:26,000 --> 00:33:28,000
que mi situación es que tengo que trabajar con 100 enteros

814
00:33:28,000 --> 00:33:30,000
pues cuando yo me

815
00:33:30,000 --> 00:33:32,000
identifico que la necesito

816
00:33:32,000 --> 00:33:34,000
porque tengo que trabajar con 100 enteros

817
00:33:34,000 --> 00:33:36,000
y hacer num1, num2, num3

818
00:33:36,000 --> 00:33:38,000
hasta 100, no es operativo, cuando yo la identifico

819
00:33:38,000 --> 00:33:40,000
ahora digo, vale, muy bien, ¿cómo la declaro?

820
00:33:40,000 --> 00:33:42,000
¿qué hago? vale, pues

821
00:33:42,000 --> 00:33:44,000
vamos a ver, ¿cómo la usamos y cómo la declaramos?

822
00:33:44,000 --> 00:33:46,000
como todas las variables

823
00:33:46,000 --> 00:33:48,000
hay que declararla

824
00:33:48,000 --> 00:33:50,000
primero, antes de usarla

825
00:33:50,000 --> 00:33:52,000
primero se la declara, como todas las variables

826
00:33:52,000 --> 00:33:54,000
luego ya se le dan valor, se opera con ella

827
00:33:54,000 --> 00:33:56,000
lo que uno quiera, pero primero se la declara

828
00:33:56,000 --> 00:33:58,000
y luego ya se le asigna valores

829
00:33:58,000 --> 00:34:00,000
y se la usa en expresiones

830
00:34:00,000 --> 00:34:02,000
o lo que uno quiera

831
00:34:02,000 --> 00:34:04,000
¿ha llamado?

832
00:34:04,000 --> 00:34:06,000
dime

833
00:34:08,000 --> 00:34:10,000
un segundo, dime