1
00:00:00,000 --> 00:00:10,000
Vale, pues venga, ¿este cuál era? Ejercicio 5, ¿no?

2
00:00:10,000 --> 00:00:26,000
Ejercicio 5, ¿vale? 5, pues venga, esto de aquí.

3
00:00:40,000 --> 00:00:55,000
Vale, pues venga, leemos dos arrays de números enteros. Bueno, voy a copiar el escáner y

4
00:00:55,000 --> 00:01:13,000
lo de leer el array de otro ejercicio. Venga, pues declaramos un array de enteros, array 1.

5
00:01:13,000 --> 00:01:23,000
¿De qué tamaño me dice? Ah, de números enteros n. Luego vamos a leer primero, vamos a leer primero

6
00:01:23,000 --> 00:01:33,000
cuántos números va a introducir antes de declararlo. Antes de nada, ¿cuántos números va a tener el array?

7
00:01:33,000 --> 00:01:47,000
Vale, pues entonces números 1 y números 2, pues los dos van a ser dos arrays de n. Números 2 igual a new int de n.

8
00:01:47,000 --> 00:02:03,000
Vale, entonces dos arrays. Y ahora habrá que hacer el array resultado, el array resultado será un array con el doble de posiciones, 2 por n.

9
00:02:03,000 --> 00:02:25,000
Y ahora ya, si yo me planteo hacer, bueno, vamos a leerlos. Leemos el primer array que es números 1 y ahora vamos a leer el segundo también.

10
00:02:25,000 --> 00:02:39,000
Vale, voy a hacer en el mismo, bueno no, dos por separados para que se vea claro que son los dos arrays distintos.

11
00:02:39,000 --> 00:02:54,000
Y ahora rellenamos el segundo. Vale, me falta esta llave. Vale, pues ya tenemos este bucle para rellenar el primer array y este otro bucle para rellenar el segundo array.

12
00:02:54,000 --> 00:03:00,000
Y ahora ya, si hacemos lo que hemos hecho en la pizarra, pues ahora yo voy recorriendo todas y cada una de esas posiciones.

13
00:03:00,000 --> 00:03:04,000
Desde i igual a cero, mientras i sea menor que n mayúscula y que aumentando i.

14
00:03:04,000 --> 00:03:13,000
Y para cada posición relleno la una del array resultado más su siguiente.

15
00:03:13,000 --> 00:03:32,000
Es decir, tendría que hacer, el array resultado de i sería esto. El de i, perdón, la posición 2i viene de la i de uno de los arrays.

16
00:03:32,000 --> 00:03:37,000
Y la posición 2i más 1 viene de la i del otro de los arrays. Ahora escrito a lo mejor se ve más claro.

17
00:03:37,000 --> 00:03:51,000
A ver, la posición 2 por i va a ser igual a números 1 de i.

18
00:03:51,000 --> 00:04:03,000
Y la posición siguiente a esta, la consecutiva, la siguiente a esta, 2 por i más 1, la consecutiva, viene de la misma posición i pero del otro.

19
00:04:03,000 --> 00:04:12,000
Y ya está, ya hemos terminado. Esto es exactamente lo que yo he puesto aquí.

20
00:04:12,000 --> 00:04:22,000
Para cada i rellenamos la 2i y la 2i más 1. La 2i viene de la i del primer array y la consecutiva, la 2i más 1, viene de la i del segundo array.

21
00:04:23,000 --> 00:04:30,000
Para cada i del primero y para cada i del segundo rellenamos la 2i y su consecutiva.

22
00:04:30,000 --> 00:04:38,000
Para i igual a 0 rellenamos la 0 y la 1. Para i igual a 1 rellenamos la 2 y la 3.

23
00:04:38,000 --> 00:04:43,000
Para i igual a 2 rellenamos la 4 y la 5, que es justo lo que queremos.

24
00:04:43,000 --> 00:04:49,000
Para i igual a 3 rellenamos la 6 y la 7, que es justo lo que queremos.

25
00:04:49,000 --> 00:04:54,000
Vamos a comprobarlo por si algo hubiéramos hecho mal.

26
00:04:54,000 --> 00:05:01,000
Mostramos el resultado del segundo array desde i igual a 0.

27
00:05:01,000 --> 00:05:06,000
Ahora vamos a mostrar el segundo array y el resultado punto length.

28
00:05:06,000 --> 00:05:26,000
Vamos a mostrar el resultado de i y concatenado con un espacio para que se vea seguido, i menor.

29
00:05:26,000 --> 00:05:32,000
Esto es para mostrar el array resultado, todas sus posiciones, las que he ido rellenando.

30
00:05:36,000 --> 00:05:42,000
Vamos a ejecutarlo por si acaso algo estuviera mal. Vamos a poner 3 solo.

31
00:05:42,000 --> 00:05:47,000
Ese es el primer array. 1, 2 y 3.

32
00:05:47,000 --> 00:05:52,000
Ahora viene el segundo array. 4, 5 y 6.

33
00:05:52,000 --> 00:05:59,000
Y es el definitivo. 1 y 4, 2 y 5, 3 y 6. Lo ha ido haciendo correctamente.

34
00:05:59,000 --> 00:06:04,000
Esta es la forma más compacta de hacerlo.

35
00:06:04,000 --> 00:06:17,000
Si no la veis clara, dedicais un ratito luego en casa a terminar de...

36
00:06:17,000 --> 00:06:31,000
Antes de irnos, vamos a ponerlo aquí.

37
00:06:31,000 --> 00:06:46,000
Hay otra forma de recorrer arrays diferente al bucle for con el índice que hemos visto.

38
00:06:46,000 --> 00:06:58,000
Se le suele llamar el bucle for each. Se le llama así, aunque no es que aparezca con ese nombre luego.

39
00:06:58,000 --> 00:07:05,000
Esta es una sintaxis de for que hay específica solo para recorrer arrays.

40
00:07:05,000 --> 00:07:09,000
Porque esta sintaxis de for es genérica.

41
00:07:09,000 --> 00:07:13,000
Yo aquí pongo lo que me dé la gana. Aquí pongo lo que quiera.

42
00:07:13,000 --> 00:07:16,000
Aquí pongo lo que quiera y aquí pongo lo que quiera. Esta es genérica.

43
00:07:16,000 --> 00:07:19,000
Y pongo lo que me interesa para lo que yo quiera hacer.

44
00:07:19,000 --> 00:07:23,000
¿Que quiero recorrer un array? Pues si quiero recorrerlo, lo que me interesa es esto.

45
00:07:23,000 --> 00:07:27,000
Pero si quiero hacer cualquier otra cosa, pongo ahí lo que me interese.

46
00:07:27,000 --> 00:07:32,000
Hay una sintaxis de for que es así que es solo para recorrer arrays.

47
00:07:32,000 --> 00:07:36,000
Solo para eso y para nada más. No como esa que es genérica para lo que me dé la gana.

48
00:07:36,000 --> 00:07:40,000
Hay una que es solo para recorrer arrays. Pongo aquí para recorrer arrays.

49
00:07:40,000 --> 00:07:44,000
En general es para recorrer colecciones de datos. Pero como solo conocemos la de arrays,

50
00:07:44,000 --> 00:07:48,000
pues por eso pongo que es solo para recorrer arrays.

51
00:07:48,000 --> 00:07:53,000
Lo pongo ahí. No vale esta sentencia para ninguna otra cosa. No es como un for genérico.

52
00:07:53,000 --> 00:08:00,000
No es un bucle genérico. Es un bucle solo para esto.

53
00:08:00,000 --> 00:08:04,000
No es un bucle genérico como el while, como el for, que lo uso para lo que quiera.

54
00:08:04,000 --> 00:08:09,000
No. Es un bucle solo para recorrer arrays. Vale. ¿Y cuál es su sintaxis?

55
00:08:09,000 --> 00:08:15,000
Pues vamos a recorrer el array resultado en lugar de con este for de índice.

56
00:08:15,000 --> 00:08:19,000
Vamos a recorrerlo con esta otra sintaxis. Vamos a recorrerlo.

57
00:08:19,000 --> 00:08:28,000
Esa sintaxis sería for y ahora entre paréntesis pongo dos cosas.

58
00:08:28,000 --> 00:08:32,000
Separadas por dos puntos. No por punto y coma esta vez.

59
00:08:32,000 --> 00:08:37,000
Separadas por dos puntos. ¿Qué pongo ahí?

60
00:08:37,000 --> 00:08:44,000
Separadas por dos puntos. Primero pongo el tipo de dato del array que voy a recorrer.

61
00:08:44,000 --> 00:08:48,000
Y aquí un nombrecito de variable, el que me dé la gana. El que yo quiera.

62
00:08:48,000 --> 00:08:54,000
X y N, un nombrecito de variable. Y aquí pongo el nombre del array.

63
00:08:55,000 --> 00:08:59,000
El nombre del array que en mi caso el que quiero recorrer es resultado.

64
00:08:59,000 --> 00:09:06,000
Esta es la sintaxis. Y siempre es esta. El tipo de dato del array que voy a recorrer.

65
00:09:06,000 --> 00:09:09,000
El tipo de dato. Si es string, es string. Si es double, es double.

66
00:09:09,000 --> 00:09:12,000
Un nombre de variable el que a mí me dé la gana.

67
00:09:12,000 --> 00:09:16,000
Y aquí el nombre del array que quiero resolver. Recorrer.

68
00:09:16,000 --> 00:09:20,000
Porque esto, repito, es una sintaxis solo para recorrer arrays.

69
00:09:20,000 --> 00:09:22,000
Para ninguna otra cosa. Solo para eso.

70
00:09:22,000 --> 00:09:27,000
¿Qué significa esto? Ahora ya este bucle va haciendo iteraciones.

71
00:09:27,000 --> 00:09:32,000
Y va haciendo una iteración por cada posición del bucle.

72
00:09:32,000 --> 00:09:36,000
Sí o sí. Hace una iteración por cada posición del bucle.

73
00:09:36,000 --> 00:09:42,000
No es como el for genérico. El for genérico, si yo en lugar de resultado.lenc pongo 2,

74
00:09:42,000 --> 00:09:44,000
pues recorro solo hasta 2. Estupendo.

75
00:09:44,000 --> 00:09:47,000
Si pongo 3, recorro solo hasta 3. Estupendo.

76
00:09:47,000 --> 00:09:53,000
Pero este no. Este bucle se ejecuta una vez por cada posición.

77
00:09:53,000 --> 00:09:57,000
Y eso es inamovible. A menos que no ponga un break ahí.

78
00:09:57,000 --> 00:09:59,000
Pero el del break por ahora nos lo hemos olvidado.

79
00:09:59,000 --> 00:10:01,000
Es que ni sabemos que existe, solo para el case.

80
00:10:01,000 --> 00:10:06,000
Vale. Solo lo sabe el mal programador.

81
00:10:06,000 --> 00:10:12,000
Bueno, pues entonces, este bucle se ejecuta una vez por cada iteración.

82
00:10:12,000 --> 00:10:16,000
Perdón, por cada posición de resultado. Si tiene 20, 20. Eso es así.

83
00:10:16,000 --> 00:10:23,000
Y ahora, en cada iteración, esta variable X toma el valor de esa posición.

84
00:10:23,000 --> 00:10:29,000
Es decir, es como esta variable X es una copia como si fuera resultado de Y.

85
00:10:29,000 --> 00:10:31,000
Si Y fuera la posición.

86
00:10:31,000 --> 00:10:36,000
En la primera iteración, X es una copia de resultado de 0.

87
00:10:36,000 --> 00:10:41,000
En la segunda iteración, X es una copia de resultado de 1.

88
00:10:41,000 --> 00:10:45,000
En la siguiente iteración, X es una copia de resultado de 2.

89
00:10:45,000 --> 00:10:49,000
Entonces, para hacer un recorrido que muestre rápidamente, es más rápido escribir esto.

90
00:10:49,000 --> 00:10:54,000
Entonces, si yo hago esto de aquí, vamos a ponerlo aquí.

91
00:10:54,000 --> 00:11:01,000
X es una copia de cada posición del array.

92
00:11:01,000 --> 00:11:07,000
De hecho, si lo mostramos, vamos a ver que efectivamente...

93
00:11:07,000 --> 00:11:14,000
Vamos a poner aquí un system.println para que se vaya a la siguiente línea.

94
00:11:14,000 --> 00:11:23,000
Si lo mostramos, efectivamente...

95
00:11:23,000 --> 00:11:27,000
Si mostramos esto, veremos que también me muestra el array.

96
00:11:27,000 --> 00:11:31,000
Pero ved que solo vale para eso, para mostrar un array.

97
00:11:31,000 --> 00:11:34,000
Y se ejecuta una vez por cada posición sí o sí.

98
00:11:34,000 --> 00:11:37,000
Y X es una copia de cada posición.

99
00:11:37,000 --> 00:11:41,000
En la primera iteración, X es una copia de la primera posición.

100
00:11:41,000 --> 00:11:45,000
Y en la segunda, X es una copia de la segunda posición.

101
00:11:45,000 --> 00:11:48,000
Vamos a ejecutarlo.

102
00:11:48,000 --> 00:11:50,000
¿Cuándo me va a introducir? 3.

103
00:11:50,000 --> 00:11:55,000
Vale, 1, 2, 3, 4, 5 y 6.

104
00:11:55,000 --> 00:12:00,000
¿Veis? Aquí he mostrado el resultado con el bucle for de índice.

105
00:12:00,000 --> 00:12:03,000
Y aquí lo he mostrado con el for each.

106
00:12:03,000 --> 00:12:10,000
Es lo mismo.

107
00:12:10,000 --> 00:12:14,000
Este bucle for es muy práctico porque es muy rápido cuando yo quiero recorrer un array

108
00:12:14,000 --> 00:12:17,000
de arriba a abajo y todas las posiciones.

109
00:12:17,000 --> 00:12:22,000
Y a veces uno tiene muchas tentaciones de usarlo así alegremente para recorrer.

110
00:12:22,000 --> 00:12:29,000
Pero cuidado importantísimo, que la clave está en que X no es la posición del array.

111
00:12:29,000 --> 00:12:31,000
X es una copia.

112
00:12:31,000 --> 00:12:38,000
Con lo cual, si yo intento rellenar un array con el bucle for asignándole cosas a X,

113
00:12:38,000 --> 00:12:43,000
el array no se entera porque se lo estoy asignando a la variable X que es copia,

114
00:12:43,000 --> 00:12:45,000
no al verdadero array.

115
00:12:45,000 --> 00:12:50,000
Es decir, vamos a suponer que ahora yo hago esto.

116
00:12:50,000 --> 00:12:54,000
Voy a cambiar este array resultado, lo voy a cambiar para que tenga...

117
00:12:54,000 --> 00:12:57,000
Perdonadme.

118
00:13:11,000 --> 00:13:13,000
Vale, pues venga, vamos a plantearnos.

119
00:13:13,000 --> 00:13:16,000
Rellenar de nuevo el array resultado de la lobestia con números cualquiera.

120
00:13:16,000 --> 00:13:17,000
A rellenarlo.

121
00:13:17,000 --> 00:13:20,000
Pero en lugar de recorrerlo para rellenar con el for de índice,

122
00:13:20,000 --> 00:13:22,000
vamos a recorrerlo para rellenar con éste.

123
00:13:22,000 --> 00:13:24,000
A ver qué nos saldría.

124
00:13:24,000 --> 00:13:27,000
Venga, pues la sintaxis de éste es que sí o sí es ésta, no cambia.

125
00:13:27,000 --> 00:13:29,000
Y un tipo de dato del array.

126
00:13:29,000 --> 00:13:31,000
Aquí el nombrecito que a mí me dé la gana.

127
00:13:31,000 --> 00:13:33,000
El que yo quiera.

128
00:13:33,000 --> 00:13:39,000
Porque éste es el nombre de la variable que va a ir siendo una copia de cada posición.

129
00:13:39,000 --> 00:13:41,000
Y ahora aquí el nombre del array.

130
00:13:41,000 --> 00:13:43,000
Y ahora yo hago.

131
00:13:43,000 --> 00:13:46,000
Pues a n asígnale 3.

132
00:13:47,000 --> 00:13:55,000
Vale, con esto yo podría creer que estoy realmente asignando el valor 3

133
00:13:55,000 --> 00:13:59,000
a cada posición del array resultado, ¿verdad?

134
00:13:59,000 --> 00:14:01,000
Podría creer que estoy haciendo eso.

135
00:14:01,000 --> 00:14:03,000
Que estoy haciendo lo mismo que esto de aquí.

136
00:14:03,000 --> 00:14:06,000
Porque vamos a rellenarlo con el for normal.

137
00:14:11,000 --> 00:14:13,000
No tengo más n para allá arriba, ¿no? Para que no haya confusión.

138
00:14:13,000 --> 00:14:16,000
Vamos a rellenar resultado con el for normal aquí abajo.

139
00:14:20,000 --> 00:14:28,000
Las i sea menor que resultado.len

140
00:14:29,000 --> 00:14:31,000
Incrementando i.

141
00:14:33,000 --> 00:14:38,000
Resultado de i igual a 3.

142
00:14:39,000 --> 00:14:41,000
Vale, pues repito.

143
00:14:41,000 --> 00:14:44,000
Cuidado porque uno podría pensar que está haciendo lo mismo.

144
00:14:44,000 --> 00:14:49,000
Está recorriendo el array y a cada posición le asigna el 3.

145
00:14:49,000 --> 00:14:52,000
Está recorriendo el array y a cada posición le asigna el 3.

146
00:14:52,000 --> 00:14:54,000
No estamos haciendo lo mismo.

147
00:14:54,000 --> 00:14:58,000
Aquí realmente el resultado de i sí es la posición real del array.

148
00:14:58,000 --> 00:15:00,000
Sí es la posición real.

149
00:15:00,000 --> 00:15:05,000
Allá arriba n es una variable que se ha creado localmente.

150
00:15:06,000 --> 00:15:09,000
Que en cada iteración va cogiendo una copia de lo que hay ahí.

151
00:15:09,000 --> 00:15:12,000
En la primera iteración coge x1.

152
00:15:12,000 --> 00:15:14,000
Si es para mostrar, muestro x1.

153
00:15:14,000 --> 00:15:16,000
Perfecto, estupendo.

154
00:15:16,000 --> 00:15:19,000
En la siguiente iteración ahora ya coge lo que hay aquí.

155
00:15:19,000 --> 00:15:21,000
Si es para mostrar, estupendo.

156
00:15:21,000 --> 00:15:22,000
Es una copia, lo muestra.

157
00:15:22,000 --> 00:15:24,000
En la siguiente iteración coge lo que hay aquí.

158
00:15:24,000 --> 00:15:26,000
Si es para mostrar, muy bien, lo muestro.

159
00:15:26,000 --> 00:15:29,000
Pero ojo, si es para rellenar, lo de arriba no.

160
00:15:29,000 --> 00:15:32,000
Porque a quien le estoy asignando los 3 es a esta copia, no al array.

161
00:15:32,000 --> 00:15:34,000
El array no se está enterando.

162
00:15:34,000 --> 00:15:36,000
Le estoy asignando los 3 es aquí.

163
00:15:36,000 --> 00:15:38,000
Esta variable no vale para nada.

164
00:15:38,000 --> 00:15:41,000
Cuando el for each ha terminado, eso ha desaparecido.

165
00:15:41,000 --> 00:15:44,000
Y el array seguía con lo que tenía.

166
00:15:46,000 --> 00:15:50,000
Vamos, de hecho, a mostrar lo que tiene después de haber esto este for.

167
00:15:50,000 --> 00:15:56,000
Vamos a mostrar lo que tiene.

168
00:15:56,000 --> 00:16:00,000
Vamos a volver a mostrarlo.

169
00:16:01,000 --> 00:16:05,000
Vamos a volver a mostrarlo.

170
00:16:05,000 --> 00:16:08,000
Voy a mostrar lo que tiene el array.

171
00:16:16,000 --> 00:16:21,000
Voy a poner aquí para que no nos liemos de que estamos en la última parte.

172
00:16:21,000 --> 00:16:22,000
Un más, más, más.

173
00:16:22,000 --> 00:16:24,000
Estamos en la última parte.

174
00:16:27,000 --> 00:16:29,000
Ya hemos entrado en la última parte.

175
00:16:29,000 --> 00:16:30,000
En la última parte.

176
00:16:30,000 --> 00:16:31,000
Hacemos esto.

177
00:16:31,000 --> 00:16:34,000
Que uno podría pensar que está rellenando el array con 3 posiciones.

178
00:16:34,000 --> 00:16:37,000
Ahora, vamos a mostrar lo que tiene ese array.

179
00:16:37,000 --> 00:16:39,000
A ver qué tiene.

180
00:16:39,000 --> 00:16:46,000
Y ahora vamos a volver a rellenarlo con 3 es.

181
00:16:46,000 --> 00:16:48,000
Pero ahora con este for de aquí.

182
00:16:48,000 --> 00:16:50,000
Y vamos a volver a mostrar lo que tiene.

183
00:16:50,000 --> 00:16:55,000
Para mostrar, ya hemos dicho que el for each es perfecto.

184
00:16:55,000 --> 00:16:57,000
Vamos a volver a mostrarlo.

185
00:16:58,000 --> 00:17:02,000
Pues venga, vamos a ver qué pasa aquí.

186
00:17:07,000 --> 00:17:09,000
Dos números para que sea más fácil.

187
00:17:09,000 --> 00:17:10,000
Ese es el primer array.

188
00:17:10,000 --> 00:17:12,000
Uno y dos.

189
00:17:12,000 --> 00:17:13,000
Ese es el segundo array.

190
00:17:13,000 --> 00:17:14,000
Tres y cuatro.

191
00:17:16,000 --> 00:17:19,000
Esto es lo de intercalados con un método.

192
00:17:19,000 --> 00:17:21,000
Intercalados con otro.

193
00:17:22,000 --> 00:17:32,000
Y ahora, esto es el resultado del array después de haber hecho esto.

194
00:17:32,000 --> 00:17:34,000
Después de haber hecho esto.

195
00:17:34,000 --> 00:17:36,000
Como veis, el array ni se ha enterado.

196
00:17:36,000 --> 00:17:38,000
El array resultado ni se ha enterado.

197
00:17:38,000 --> 00:17:41,000
Sigue teniendo lo que tenía antes.

198
00:17:41,000 --> 00:17:42,000
Esto de aquí.

199
00:17:42,000 --> 00:17:43,000
Ni se ha enterado.

200
00:17:43,000 --> 00:17:48,000
Claro, porque a lo que le hemos estado dando el 3 es a esta variable n

201
00:17:48,000 --> 00:17:50,000
que va teniendo la copia de cada posición.

202
00:17:50,000 --> 00:17:51,000
Ni se ha enterado.

203
00:17:51,000 --> 00:17:54,000
Pero ahora, cuando yo ya lo relleno así, ahora sí que se ha enterado.

204
00:17:54,000 --> 00:17:57,000
Porque esto ya sí que es la verdadera posición del array.

205
00:17:57,000 --> 00:17:58,000
Ahora ya sí que se ha enterado.

206
00:17:58,000 --> 00:18:00,000
Y por eso cuando lo muestro, ahora ya sí.

207
00:18:02,000 --> 00:18:06,000
Entonces, esta sintaxis es muy cómoda para recorrer arrays.

208
00:18:06,000 --> 00:18:07,000
Muy cómoda.

209
00:18:07,000 --> 00:18:15,000
Pero su uso se limita cuando yo quiero recorrer para mostrar simplemente.

210
00:18:15,000 --> 00:18:17,000
Si es para asignarle valores, no.

211
00:18:17,000 --> 00:18:19,000
Porque entonces estaréis asignando la copia.

212
00:18:20,000 --> 00:18:21,000
Vale.

213
00:18:24,000 --> 00:18:25,000
Bueno.

214
00:18:28,000 --> 00:18:30,000
Pero entonces, ¿para qué usas un for each?

215
00:18:30,000 --> 00:18:34,000
O sea, si tú luego quieres, te tendrás que declararte un i arriba.

216
00:18:34,000 --> 00:18:37,000
Porque en el for each no puedes declararte ningún i.

217
00:18:37,000 --> 00:18:39,000
Entonces, tienes que un i arriba.

218
00:18:39,000 --> 00:18:40,000
Irlo incrementando.

219
00:18:40,000 --> 00:18:41,000
Ir poniendo.

220
00:18:41,000 --> 00:18:43,000
Pero es que todo esto no te vale para nada.

221
00:18:43,000 --> 00:18:44,000
Aparece un for each y ya está.

222
00:18:44,000 --> 00:18:46,000
Claro, ¿a qué?

223
00:18:47,000 --> 00:18:50,000
Entonces, esa es una forma rápida de recorrer un array para mostrarlo.

224
00:18:50,000 --> 00:18:52,000
Pero con la limitación.

225
00:18:52,000 --> 00:18:54,000
Pero que no se olvide que ese es su uso.

226
00:18:55,000 --> 00:18:56,000
Vale.

227
00:18:56,000 --> 00:18:57,000
Venga, pues ya está.

228
00:18:57,000 --> 00:18:58,000
Pues vamos a...