1
00:00:00,000 --> 00:00:06,000
Bueno, pues lo que decíamos, vamos a resolver entonces algunos para ir comentando algunas

2
00:00:06,000 --> 00:00:14,560
cosas. Empezamos proyecto, ejercicios, bucles, luego para el aula virtual.

3
00:00:14,560 --> 00:00:21,560
Uy, bucles no, arrays, perdón.

4
00:00:44,560 --> 00:01:01,560
Pues venga, ejercicio 1, entonces aquí recordad que cuando leemos los ejercicios ahora ya

5
00:01:01,560 --> 00:01:10,560
tenemos que leerlos primero para entender bien lo que hay que hacer y ya segundo poniéndonos

6
00:01:10,560 --> 00:01:18,560
en el chip de tengo que después de las sucesivas lecturas ver más o menos qué tengo que hacer,

7
00:01:18,560 --> 00:01:24,560
qué patrones hacer, un bucle o no sé qué y también tengo que ver qué estructura de datos

8
00:01:24,560 --> 00:01:30,560
necesito, si me vale con variables sueltas, si voy a necesitar un array, etcétera.

9
00:01:30,560 --> 00:01:37,560
Vale, pues después de leer este ejercicio leer N mayúscula números y mostrarlos en

10
00:01:37,560 --> 00:01:43,560
orden inverso al introducido, donde N es un dato que también se pide, ¿vale?

11
00:01:43,560 --> 00:01:48,560
Entonces como este programa no sabe a priori los números que va a leer, en cada ejecución

12
00:01:48,560 --> 00:01:53,560
le da una cantidad, la que le di al usuario, pues no tendría sentido plantearnos este

13
00:01:53,560 --> 00:01:59,560
programa como diciendo, voy a declarar una variable primitiva para cada número, ¿no?

14
00:01:59,560 --> 00:02:04,560
Porque si el ejercicio fuera leer 10 números enteros y mostrarlos en orden inverso,

15
00:02:04,560 --> 00:02:11,560
uno podría intentar plantearse la patata de decir, vale, declaro int N1, int N2, int N3,

16
00:02:11,560 --> 00:02:17,560
10, las leo, 10 sentencias de leer y ahora muestro primero la última variable,

17
00:02:17,560 --> 00:02:22,560
luego la otra, 10 sentencias de mostrar. Uno podría planteárselo a hacer así,

18
00:02:22,560 --> 00:02:26,560
pero ¿qué es lo que hemos dicho siempre? Que ahora el ejercicio te lo cambian y te dicen,

19
00:02:26,560 --> 00:02:32,560
ahora hazme lo mismo para 100, pues modificar eso implicaría añadir 90 sentencias, ¿no?

20
00:02:33,560 --> 00:02:39,560
¿Vale? Entonces, como nosotros tenemos que leer N mayúscula números, que a priori no sabemos

21
00:02:39,560 --> 00:02:45,560
cuántos, porque ese dato lo pedimos también en el programa, ya es que de partida no podemos

22
00:02:45,560 --> 00:02:49,560
hacerlo así, con variables primitivas, porque ¿cuántas declaramos? ¿Cuántas declaramos?

23
00:02:49,560 --> 00:02:54,560
No sé cuántas voy a necesitar, entonces con variables primitivas sueltas no podemos hacerlo.

24
00:02:55,560 --> 00:03:05,560
Entonces, eso ya se complica un poco. Siguiente cosa, vamos a imaginar que N mayúscula fuera 10

25
00:03:05,560 --> 00:03:11,560
y nos dicen, venga, pues lee 10 números por teclado y una vez que los has leído,

26
00:03:11,560 --> 00:03:17,560
muéstralos en orden inverso al introducido, entonces de nuevo, de nuevo eso implica

27
00:03:17,560 --> 00:03:22,560
que cuando yo he terminado de leerlos tengo que tener los 10 ahí conservados,

28
00:03:22,560 --> 00:03:26,560
los tengo que tener, porque ya los tengo que mostrar en orden inverso.

29
00:03:26,560 --> 00:03:30,560
Si yo los tuviera que mostrar en el mismo orden en que los he introducido, los números,

30
00:03:30,560 --> 00:03:34,560
podría usar una sola variable, ¿no? Leo un número, muestro, ya está.

31
00:03:34,560 --> 00:03:39,560
Leo el siguiente usando la misma variable y muestro, y ya está.

32
00:03:39,560 --> 00:03:42,560
Leo el siguiente usando la misma variable y muestro, y ya está.

33
00:03:42,560 --> 00:03:46,560
Entonces, si yo no tuviera que mostrar en orden inverso, sino en el mismo orden,

34
00:03:47,560 --> 00:03:52,560
Andoni, te callas. Si yo no tuviera que mostrar en orden inverso, sino en el mismo orden

35
00:03:52,560 --> 00:03:57,560
en el que llega, con una única variable sería suficiente, ¿verdad? Una única variable.

36
00:03:57,560 --> 00:04:03,560
Recibe valor, muestro. Recibe valor pisando el anterior, que ya me da igual porque lo he mostrado, muestro.

37
00:04:03,560 --> 00:04:08,560
Recibe valor pisando el anterior, que me da igual porque ya lo he mostrado, muestro.

38
00:04:08,560 --> 00:04:11,560
Pero el problema viene que hay que mostrarlos en orden inverso.

39
00:04:11,560 --> 00:04:14,560
Entonces, al mostrarlos en orden inverso, después de haberlos leído,

40
00:04:14,560 --> 00:04:18,560
los tengo que tener yo todos conservados. Los tengo que tener todos conservados.

41
00:04:18,560 --> 00:04:22,560
Para empezar por el último. Entonces, si los tengo que tener todos conservados,

42
00:04:22,560 --> 00:04:26,560
obviamente mejor un array, porque tengo que tener muchos enteros.

43
00:04:26,560 --> 00:04:29,560
Hay conservados todos, muchos. ¿Vale?

44
00:04:29,560 --> 00:04:34,560
Entonces, cuando en un ejercicio distinguimos que los datos de entrada, que son un montón,

45
00:04:34,560 --> 00:04:39,560
los tengo que tener todos disponibles, todos disponibles luego para hacer cosas,

46
00:04:39,560 --> 00:04:42,560
pues ver cuál es el máximo, lo que sea.

47
00:04:42,560 --> 00:04:46,560
Si yo identifico que los tengo que tener todos disponibles después de haberlos leído,

48
00:04:46,560 --> 00:04:51,560
pues entonces un array, porque entonces necesito muchos valores que estén disponibles.

49
00:04:51,560 --> 00:04:54,560
Pues entonces un array directamente.

50
00:04:54,560 --> 00:04:57,560
Entonces, por todas estas cuestiones decidimos que es un array lo que necesitamos

51
00:04:57,560 --> 00:05:00,560
y no variables sueltas, porque variables sueltas, ¿cuántas?

52
00:05:00,560 --> 00:05:02,560
¿N? Pues no, no lo sé.

53
00:05:02,560 --> 00:05:07,560
Entonces, ya haber decidido que es un array lo que necesitamos,

54
00:05:07,560 --> 00:05:10,560
ya es una parte importante del ejercicio.

55
00:05:10,560 --> 00:05:13,560
Bueno, pues entonces uno hace este ejercicio de aquí.

56
00:05:29,560 --> 00:05:36,560
Vale, entonces, ya hemos decidido que donde yo voy a guardar los datos es en un array.

57
00:05:37,560 --> 00:05:40,560
Y esa decisión ya condiciona muchísimo el programa.

58
00:05:40,560 --> 00:05:44,560
Luego es una decisión importantísima, la decisión sobre la estructura de datos

59
00:05:44,560 --> 00:05:46,560
que yo voy a usar, porque condiciona mucho el programa.

60
00:05:46,560 --> 00:05:48,560
Entonces hay que a su vez decidirlo bien.

61
00:05:48,560 --> 00:05:50,560
Bueno, aquí lo hemos decidido bien.

62
00:05:50,560 --> 00:05:54,560
Yo necesito muchos enteros, los tengo que tener todos disponibles

63
00:05:54,560 --> 00:05:58,560
para luego mostrarlos en orden inverso, todos disponibles, pues un array.

64
00:05:58,560 --> 00:06:01,560
¿Vale? Esa decisión en principio parece bien tomada.

65
00:06:01,560 --> 00:06:05,560
Pues vamos a declarar esa estructura de datos, un array de números enteros.

66
00:06:07,560 --> 00:06:14,560
Con esto recordad que simplemente teníamos declarada esa variable, ¿verdad?

67
00:06:14,560 --> 00:06:16,560
Con esto, con esta declaración de aquí.

68
00:06:19,560 --> 00:06:23,560
Con esta declaración, lo único que tenemos declarada es

69
00:06:25,560 --> 00:06:30,560
una variable que se llama números, una variable que se llama números

70
00:06:32,560 --> 00:06:35,560
que está pensada para contener una dirección de memoria.

71
00:06:37,560 --> 00:06:40,560
Para eso está pensada esa variable números.

72
00:06:40,560 --> 00:06:44,560
¿Vale? Esa variable números de ahí está pensada para eso,

73
00:06:44,560 --> 00:06:46,560
para contener una dirección de memoria, pero ahora mismo

74
00:06:46,560 --> 00:06:50,560
esa dirección de memoria no apunta a nada, a nada.

75
00:06:51,560 --> 00:06:57,560
¿Vale? Lo que hemos hecho con esta declaración es hacer aparecer esto y solo esto.

76
00:06:58,560 --> 00:07:00,560
Pero ahora para que los números puedan ir a algún lado,

77
00:07:00,560 --> 00:07:03,560
ahora falta declarar el espacio para esos números.

78
00:07:03,560 --> 00:07:10,560
Falta esto. Falta declarar, ahora ya sí, este espacio para que vayan todos los números.

79
00:07:11,560 --> 00:07:12,560
Los que sean.

80
00:07:14,560 --> 00:07:15,560
Ese espacio es el que falta.

81
00:07:16,560 --> 00:07:19,560
¿Vale? Pues este espacio ya sabemos cómo declararlo.

82
00:07:20,560 --> 00:07:21,560
Este espacio lo declaramos así.

83
00:07:24,560 --> 00:07:25,560
Ahora viene la gran pregunta.

84
00:07:26,560 --> 00:07:27,560
La gran pregunta.

85
00:07:27,560 --> 00:07:28,560
La gran pregunta.

86
00:07:30,560 --> 00:07:34,560
En el momento de declarar el espacio ese de ahí, que lo hacemos así.

87
00:07:35,560 --> 00:07:39,560
¿Vale? En el momento de declarar esto, ese espacio de ahí,

88
00:07:39,560 --> 00:07:43,560
en el momento de declarar ese espacio de ahí, ese que es el que importa

89
00:07:43,560 --> 00:07:44,560
porque ahí van los números.

90
00:07:45,560 --> 00:07:49,560
En el momento de declararlo, ya hemos dicho, y esto sí que no podemos obviarlo,

91
00:07:49,560 --> 00:07:51,560
que tenemos que poner ahí una cantidad.

92
00:07:52,560 --> 00:07:54,560
¿Vale? Que tenemos que poner ahí una cantidad.

93
00:07:55,560 --> 00:07:56,560
¿Y qué cantidad es?

94
00:07:57,560 --> 00:07:58,560
Pues es que no lo sé.

95
00:07:58,560 --> 00:08:04,560
Porque en una ejecución a lo mejor el usuario me dice que va a querer leer 20.

96
00:08:06,560 --> 00:08:08,560
Vale. Pero en otra ejecución a lo mejor me dice que 10.

97
00:08:09,560 --> 00:08:10,560
En otra ejecución a lo mejor me dice que 15.

98
00:08:11,560 --> 00:08:13,560
Entonces se me plantea aquí un problema, ¿verdad?

99
00:08:14,560 --> 00:08:16,560
No lo sé a priori cuántos va a usar.

100
00:08:17,560 --> 00:08:18,560
Vale, pues los que lo habéis hecho.

101
00:08:19,560 --> 00:08:20,560
¿Por qué solución habéis optado?

102
00:08:21,560 --> 00:08:22,560
¿Eh?

103
00:08:24,560 --> 00:08:27,560
Claro, pero si luego ejecutas el programa y te dice

104
00:08:28,560 --> 00:08:29,560
¿Qué cantidad de números va a introducir?

105
00:08:29,560 --> 00:08:32,560
Y te dice uno que es mayor que ese, pues no podrías.

106
00:08:33,560 --> 00:08:36,560
Te saldría un Arraying desbord exception si es que intentas meter más que esos.

107
00:08:37,560 --> 00:08:39,560
Vale. ¿Alguno más de los que habéis hecho?

108
00:08:39,560 --> 00:08:41,560
¿Qué solución habéis optado?

109
00:08:43,560 --> 00:08:44,560
Muy bien.

110
00:08:44,560 --> 00:08:48,560
Claro, es decir, a ver, es que yo en el momento de abrir el espacio,

111
00:08:49,560 --> 00:08:51,560
todavía no sé.

112
00:08:51,560 --> 00:08:55,560
Pues voy a primero a pedirle al usuario cuántos va a usar

113
00:08:56,560 --> 00:08:57,560
y luego ya declaro el espacio.

114
00:08:58,560 --> 00:08:59,560
¿Vale?

115
00:09:00,560 --> 00:09:04,560
Vale, pues entonces pues le podemos decir lo primero de todo.

116
00:09:08,560 --> 00:09:11,560
Vamos a coger el escáner por ahí.

117
00:09:14,560 --> 00:09:18,560
Claro, el programa dice que primero se le pregunta cuántos números va a usar

118
00:09:19,560 --> 00:09:21,560
y luego ya se piden los números.

119
00:09:22,560 --> 00:09:24,560
Entonces vamos a preguntarle primero cuántos números va a usar

120
00:09:25,560 --> 00:09:27,560
y luego ya declaramos el espacio para el Array.

121
00:09:28,560 --> 00:09:31,560
Entonces, le podemos decirlo primero eso.

122
00:09:37,560 --> 00:09:41,560
¿Cuántos números va a introducir?

123
00:09:43,560 --> 00:09:46,560
Y ahora, esa cantidad de números que va a introducir,

124
00:09:46,560 --> 00:09:49,560
ya vemos la N como nos dé la gana, pues la leemos.

125
00:09:52,560 --> 00:09:57,560
Vale, pues ahora ya en este punto ya sabemos cuántos números va a introducir el usuario.

126
00:09:57,560 --> 00:09:58,560
¿Vale?

127
00:09:58,560 --> 00:10:00,560
Pues declaremos ahora ya el Array.

128
00:10:01,560 --> 00:10:03,560
Y entonces, ¿qué tamaño va a tener este Array?

129
00:10:03,560 --> 00:10:05,560
Yo ahí le tengo que dar un número entero.

130
00:10:05,560 --> 00:10:07,560
Esa es mi única restricción, mi única obligación.

131
00:10:07,560 --> 00:10:09,560
Darle un número entero.

132
00:10:09,560 --> 00:10:11,560
Vale, pero es que N mayúscula es un número entero.

133
00:10:12,560 --> 00:10:14,560
No hay ningún problema en que yo le dé N mayúscula.

134
00:10:15,560 --> 00:10:18,560
Como si le doy 100, 20, con tal de que le dé un número entero.

135
00:10:19,560 --> 00:10:21,560
Y N mayúscula lo es.

136
00:10:22,560 --> 00:10:23,560
¿Vale?

137
00:10:23,560 --> 00:10:25,560
En una ejecución, a lo mejor eso es 20.

138
00:10:25,560 --> 00:10:27,560
Pues ya está, se crea un espacio para 20.

139
00:10:27,560 --> 00:10:29,560
Pero en otra ejecución a lo mejor es 100.

140
00:10:29,560 --> 00:10:31,560
Bueno, pues se crea un espacio para 100.

141
00:10:31,560 --> 00:10:32,560
No pasa nada.

142
00:10:32,560 --> 00:10:33,560
¿Vale?

143
00:10:36,560 --> 00:10:39,560
Claro, no podría haber adoptado otra solución y haber dicho

144
00:10:39,560 --> 00:10:42,560
Vale, voy a declararme un Array de un número muy grandote.

145
00:10:42,560 --> 00:10:44,560
30.000.

146
00:10:46,560 --> 00:10:48,560
Y luego le digo al usuario

147
00:10:48,560 --> 00:10:50,560
¿Cuántos números va a ingresar?

148
00:10:50,560 --> 00:10:52,560
Por favor que no sean más de 30.000.

149
00:10:54,560 --> 00:10:56,560
Y así me aseguro de no salirme del Array.

150
00:10:56,560 --> 00:10:58,560
Pero bueno, le estamos forzando

151
00:10:59,560 --> 00:11:01,560
a que no se pase de un límite superior.

152
00:11:01,560 --> 00:11:02,560
Eso por un lado.

153
00:11:04,560 --> 00:11:06,560
Y luego además, si yo declaro uno de 30.000

154
00:11:06,560 --> 00:11:07,560
y luego él me dice 3.

155
00:11:07,560 --> 00:11:11,560
Pues tengo ahí 29.997 espacios que están para nada.

156
00:11:12,560 --> 00:11:14,560
Menudo desperdicio de memoria.

157
00:11:14,560 --> 00:11:16,560
Entonces esta sería mejor opción.

158
00:11:16,560 --> 00:11:19,560
La mejor opción es que si tenemos la posibilidad

159
00:11:19,560 --> 00:11:22,560
de reservar el Array exactamente para el tamaño que necesito

160
00:11:22,560 --> 00:11:23,560
pues mejor.

161
00:11:24,560 --> 00:11:26,560
Vale, y ahora ya ¿qué hemos dicho que hay que hacer?

162
00:11:26,560 --> 00:11:28,560
Leer los números y mostrarlos en orden inverso.

163
00:11:29,560 --> 00:11:32,560
Pues ¿para qué hemos dicho que los necesitamos guardar todos?

164
00:11:33,560 --> 00:11:36,560
Pues necesitamos guardar todos porque según vamos leyendo los números

165
00:11:36,560 --> 00:11:39,560
el 3, el menos 1, los que sean

166
00:11:40,560 --> 00:11:42,560
yo luego los voy a mostrar en orden inverso.

167
00:11:42,560 --> 00:11:44,560
Luego tenemos que tenerlos todos disponibles.

168
00:11:44,560 --> 00:11:45,560
Todos disponibles.

169
00:11:46,560 --> 00:11:48,560
Para una vez que ya he terminado de leer

170
00:11:48,560 --> 00:11:49,560
empezar de abajo arriba.

171
00:11:49,560 --> 00:11:50,560
Los tenemos que tener todos disponibles.

172
00:11:50,560 --> 00:11:52,560
Para eso es por lo que queríamos el Array.

173
00:11:53,560 --> 00:11:55,560
Pues venga, ahora ya le podemos decir

174
00:11:55,560 --> 00:11:56,560
vamos a rellenar el Array

175
00:11:58,560 --> 00:12:00,560
y ahora ya este Array lo podemos rellenar así.

176
00:12:04,560 --> 00:12:06,560
Números.length ¿verdad?

177
00:12:06,560 --> 00:12:07,560
Que esto era directamente

178
00:12:08,560 --> 00:12:12,560
Números.length era directamente el tamaño con el que se había declarado el Array.

179
00:12:15,560 --> 00:12:17,560
Y ahora ¿qué hacíamos aquí?

180
00:12:29,560 --> 00:12:32,560
Introduzca entero

181
00:12:33,560 --> 00:12:34,560
y leemos el entero.

182
00:12:34,560 --> 00:12:36,560
Y ese entero ¿a dónde lo llevamos?

183
00:12:36,560 --> 00:12:38,560
Lo llevamos a números de i.

184
00:12:39,560 --> 00:12:40,560
¿verdad?

185
00:12:46,560 --> 00:12:48,560
Vale, pues esto es para rellenar el Array.

186
00:12:49,560 --> 00:12:51,560
Entonces aquí no voy mostrando según relleno

187
00:12:51,560 --> 00:12:55,560
porque entonces no voy mostrando en orden inverso como me piden

188
00:12:55,560 --> 00:12:58,560
sino que voy mostrando en el mismo orden en el que han llegado.

189
00:12:58,560 --> 00:13:01,560
Entonces este bucle es solo para rellenar el Array.

190
00:13:01,560 --> 00:13:03,560
Y cuando ya lo tenga todo

191
00:13:03,560 --> 00:13:05,560
ya me puedo plantear mostrar

192
00:13:05,560 --> 00:13:07,560
porque al ser el orden inverso

193
00:13:07,560 --> 00:13:09,560
para mostrar necesito tenerlos todos primero

194
00:13:09,560 --> 00:13:10,560
porque tengo que empezar por el último.

195
00:13:11,560 --> 00:13:12,560
Entonces antes de empezar a mostrar

196
00:13:12,560 --> 00:13:13,560
tengo que tenerlos todos.

197
00:13:14,560 --> 00:13:16,560
No puedo mostrar aquí según me llegan

198
00:13:16,560 --> 00:13:18,560
porque entonces estaría mostrando en orden de llegada.

199
00:13:18,560 --> 00:13:20,560
En orden inverso de llegada.

200
00:13:21,560 --> 00:13:22,560
Bueno, este bucle es solo para rellenar

201
00:13:22,560 --> 00:13:23,560
vale, pues ya está

202
00:13:23,560 --> 00:13:26,560
el bucle de toda la vida para rellenar un Array.

203
00:13:27,560 --> 00:13:28,560
Ahora ya

204
00:13:31,560 --> 00:13:32,560
¿verdad?

205
00:13:39,560 --> 00:13:42,560
Vale, pues ahora vamos a recorrer el Array para mostrarlo.

206
00:13:44,560 --> 00:13:47,560
Pero claro, como queremos mostrar en orden inverso

207
00:13:47,560 --> 00:13:49,560
ahora no vamos a recorrer el Array

208
00:13:49,560 --> 00:13:50,560
primero la posición cero

209
00:13:50,560 --> 00:13:51,560
luego la uno

210
00:13:51,560 --> 00:13:52,560
luego la dos

211
00:13:52,560 --> 00:13:53,560
no.

212
00:13:53,560 --> 00:13:55,560
Queremos recorrer primero la última

213
00:13:55,560 --> 00:13:56,560
luego la penúltima

214
00:13:56,560 --> 00:13:57,560
luego la otra.

215
00:13:58,560 --> 00:13:59,560
Entonces esto

216
00:13:59,560 --> 00:14:01,560
pues tenemos muchas posibilidades de hacerlo.

217
00:14:01,560 --> 00:14:04,560
Un For que empiece con el índice en la última posición

218
00:14:04,560 --> 00:14:06,560
se vaya decrementando

219
00:14:06,560 --> 00:14:08,560
hasta que llegue a cero.

220
00:14:08,560 --> 00:14:10,560
Bueno, lo que importa es

221
00:14:10,560 --> 00:14:12,560
cómo hacemos para que

222
00:14:12,560 --> 00:14:13,560
el índice

223
00:14:13,560 --> 00:14:14,560
de recorrido del Array

224
00:14:14,560 --> 00:14:15,560
sea este primero

225
00:14:15,560 --> 00:14:16,560
luego este

226
00:14:16,560 --> 00:14:17,560
luego este

227
00:14:17,560 --> 00:14:18,560
luego este

228
00:14:18,560 --> 00:14:19,560
que eso es lo que tenemos que hacer.

229
00:14:20,560 --> 00:14:21,560
Bueno, pues la opción más clara

230
00:14:21,560 --> 00:14:23,560
para recorrer en orden inverso el Array

231
00:14:23,560 --> 00:14:24,560
sería esta.

232
00:14:24,560 --> 00:14:26,560
Yo empiezo con una posición

233
00:14:26,560 --> 00:14:27,560
que sea

234
00:14:27,560 --> 00:14:29,560
la última.

235
00:14:29,560 --> 00:14:30,560
¿Y la última cuál es?

236
00:14:30,560 --> 00:14:32,560
La última posición de este Array.

237
00:14:33,560 --> 00:14:35,560
Venga, que alguien me lo diga.

238
00:14:35,560 --> 00:14:37,560
N mayúscula menos uno

239
00:14:37,560 --> 00:14:39,560
es la última, ¿verdad?

240
00:14:43,560 --> 00:14:45,560
Mientras si sea

241
00:14:45,560 --> 00:14:46,560
¿cómo?

242
00:14:48,560 --> 00:14:49,560
Mayor o igual que cero

243
00:14:49,560 --> 00:14:51,560
para que se pare en cero

244
00:14:51,560 --> 00:14:54,560
porque cero sería la última que quiero mostrar.

245
00:14:54,560 --> 00:14:55,560
Y ahora

246
00:14:56,560 --> 00:14:57,560
decrementando.

247
00:14:57,560 --> 00:14:58,560
Y

248
00:14:58,560 --> 00:14:59,560
ahora ya

249
00:14:59,560 --> 00:15:01,560
iba pasando de esto.

250
00:15:01,560 --> 00:15:03,560
Entonces, este N mayúscula

251
00:15:03,560 --> 00:15:05,560
si lo queremos generalizar

252
00:15:05,560 --> 00:15:07,560
recordad que este N mayúscula es esto.

253
00:15:07,560 --> 00:15:09,560
Es eso de ahí.

254
00:15:09,560 --> 00:15:10,560
¿Vale? Entonces este

255
00:15:10,560 --> 00:15:12,560
esto quedaría un poquito más bonito.

256
00:15:13,560 --> 00:15:14,560
Así.

257
00:15:14,560 --> 00:15:15,560
Porque sería más genérico.

258
00:15:15,560 --> 00:15:17,560
Sería más genérico.

259
00:15:17,560 --> 00:15:18,560
¿Vale?

260
00:15:19,560 --> 00:15:21,560
¿Vale? O sea, la última posición del Array

261
00:15:21,560 --> 00:15:23,560
siempre es

262
00:15:23,560 --> 00:15:25,560
el length del Array menos uno.

263
00:15:25,560 --> 00:15:27,560
¿No? Si un Array

264
00:15:27,560 --> 00:15:29,560
su número de posiciones

265
00:15:29,560 --> 00:15:30,560
un Array A

266
00:15:30,560 --> 00:15:32,560
su número de posiciones es A punto length

267
00:15:32,560 --> 00:15:34,560
pues las posiciones van desde cero

268
00:15:34,560 --> 00:15:36,560
hasta punto length menos uno.

269
00:15:36,560 --> 00:15:37,560
Obviamente.

270
00:15:37,560 --> 00:15:39,560
Si el length del Array es diez

271
00:15:39,560 --> 00:15:41,560
van desde cero hasta nueve.

272
00:15:41,560 --> 00:15:43,560
Luego las posiciones de un Array van siempre

273
00:15:43,560 --> 00:15:45,560
desde cero

274
00:15:45,560 --> 00:15:47,560
hasta su longitud menos uno.

275
00:15:47,560 --> 00:15:49,560
¿Vale? Desde cero hasta su longitud menos uno.

276
00:15:49,560 --> 00:15:51,560
Entonces yo voy desde la última

277
00:15:51,560 --> 00:15:53,560
que es su longitud menos uno, es la última

278
00:15:53,560 --> 00:15:55,560
mientras sea mayor o igual que cero

279
00:15:55,560 --> 00:15:57,560
que cero es la primera de todas

280
00:15:57,560 --> 00:15:59,560
y decrementando.

281
00:16:01,560 --> 00:16:03,560
Y ahora ya pues

282
00:16:03,560 --> 00:16:05,560
mostramos las posiciones

283
00:16:05,560 --> 00:16:07,560
sí del Array.

284
00:16:15,560 --> 00:16:17,560
A ver.

285
00:16:17,560 --> 00:16:19,560
Joder.

286
00:16:19,560 --> 00:16:21,560
Si es que como arrastro esto ya no hay manera.

287
00:16:23,560 --> 00:16:25,560
¿Vale?

288
00:16:25,560 --> 00:16:27,560
Números de i

289
00:16:27,560 --> 00:16:29,560
lo voy a poner seguido

290
00:16:29,560 --> 00:16:31,560
para que quede más bonito.

291
00:16:33,560 --> 00:16:35,560
Con un espacio.

292
00:16:35,560 --> 00:16:37,560
Y este.

293
00:16:37,560 --> 00:16:39,560
¿Vale? Pues esta ya sería una opción.

294
00:16:39,560 --> 00:16:41,560
Ya está.

295
00:16:41,560 --> 00:16:43,560
Recorremos en orden inverso.

296
00:16:43,560 --> 00:16:45,560
¿Vale? De aquí lo que nos importa es entender

297
00:16:45,560 --> 00:16:47,560
el funcionamiento de los índices del Array.

298
00:16:47,560 --> 00:16:49,560
Eso por un lado.

299
00:16:49,560 --> 00:16:51,560
Y por otro lado entender que el for

300
00:16:51,560 --> 00:16:53,560
es un bucle que uno usa

301
00:16:53,560 --> 00:16:55,560
como le dé la gana.

302
00:16:55,560 --> 00:16:57,560
Siempre y cuando

303
00:16:57,560 --> 00:16:59,560
entendamos que el bucle for es un bucle

304
00:16:59,560 --> 00:17:01,560
que tiene aquí

305
00:17:01,560 --> 00:17:03,560
tres cositas

306
00:17:03,560 --> 00:17:05,560
y que uno pone en ellas lo que le interesa.

307
00:17:05,560 --> 00:17:07,560
Si es que quiere poner algo.

308
00:17:07,560 --> 00:17:09,560
Si no, no. ¿Vale? Pone en ellas

309
00:17:09,560 --> 00:17:11,560
lo que le interesa.

310
00:17:13,560 --> 00:17:15,560
¿Vale?

311
00:17:15,560 --> 00:17:17,560
De hecho se admite

312
00:17:17,560 --> 00:17:19,560
como curiosidad del for

313
00:17:19,560 --> 00:17:21,560
se admite hasta poner esto, que es las tres vacías.

314
00:17:25,560 --> 00:17:27,560
¿Vale? Este es un for

315
00:17:27,560 --> 00:17:29,560
que no hace ninguna sentencia

316
00:17:29,560 --> 00:17:31,560
al principio.

317
00:17:31,560 --> 00:17:33,560
Que no hace ninguna sentencia en cada iteración.

318
00:17:33,560 --> 00:17:35,560
Y la condición

319
00:17:35,560 --> 00:17:37,560
esa vacía

320
00:17:37,560 --> 00:17:39,560
eso es poco intuitivo

321
00:17:39,560 --> 00:17:41,560
porque uno dirá, oye, aquí tengo que poner una condición

322
00:17:41,560 --> 00:17:43,560
el vacío no es ni true ni falso.

323
00:17:43,560 --> 00:17:45,560
Bueno, aún así se permite esa sintaxis

324
00:17:45,560 --> 00:17:47,560
porque es una forma rápida de poner un bucle infinito.

325
00:17:47,560 --> 00:17:49,560
Cuando esto está vacío es como si fuera true.

326
00:17:49,560 --> 00:17:51,560
Entonces esto es una forma

327
00:17:51,560 --> 00:17:53,560
pues que está ahí de herencia

328
00:17:53,560 --> 00:17:55,560
para hacer un bucle infinito.

329
00:17:55,560 --> 00:17:57,560
Que es una tontería, no usamos para nada.

330
00:17:57,560 --> 00:17:59,560
Pero lo pongo aquí

331
00:17:59,560 --> 00:18:01,560
para que veáis que el for es una estructura

332
00:18:01,560 --> 00:18:03,560
que uno pone en cada zona

333
00:18:03,560 --> 00:18:05,560
de las tres que tienen

334
00:18:05,560 --> 00:18:07,560
lo que le interese. Lo que le interese

335
00:18:07,560 --> 00:18:09,560
y se adapte a lo que tiene que resolver.

336
00:18:09,560 --> 00:18:11,560
¿Vale? Siempre y cuando esto sea

337
00:18:11,560 --> 00:18:13,560
una o varias sentencias separadas por coma

338
00:18:13,560 --> 00:18:15,560
esto una condición

339
00:18:15,560 --> 00:18:17,560
algo que pueda ser true o falso

340
00:18:17,560 --> 00:18:19,560
me da igual que sea muy grande o muy pequeña

341
00:18:19,560 --> 00:18:21,560
y esto

342
00:18:21,560 --> 00:18:23,560
una o varias sentencias separadas por coma.

343
00:18:23,560 --> 00:18:25,560
Entonces

344
00:18:25,560 --> 00:18:27,560
el uso del for habitual

345
00:18:27,560 --> 00:18:29,560
que no el obligatorio, obviamente

346
00:18:29,560 --> 00:18:31,560
es el uso del for con una variable

347
00:18:31,560 --> 00:18:33,560
que empieza teniendo un valor

348
00:18:33,560 --> 00:18:35,560
llega hasta otro y se la va incrementando y decrementando

349
00:18:35,560 --> 00:18:37,560
es el uso habitual.

350
00:18:37,560 --> 00:18:39,560
Porque nos viene muy bien para recorrerlos a raíz.

351
00:18:39,560 --> 00:18:41,560
Porque nos viene muy bien para recorrerlos.

352
00:18:41,560 --> 00:18:43,560
Pero el for uno si

353
00:18:43,560 --> 00:18:45,560
quiere usarlo para hacer otras cosas

354
00:18:45,560 --> 00:18:47,560
lo usa para lo que quiera.

355
00:18:47,560 --> 00:18:49,560
Vale.

356
00:18:49,560 --> 00:18:51,560
Entonces uno debería ejecutar

357
00:18:51,560 --> 00:18:53,560
una vez visto que esto

358
00:18:53,560 --> 00:18:55,560
parece que tiene buena pinta

359
00:18:55,560 --> 00:18:57,560
debería ejecutarlo para ver si efectivamente

360
00:18:59,560 --> 00:19:01,560
a través de las primeras

361
00:19:01,560 --> 00:19:03,560
pruebas que hace, pues ve si esto falla

362
00:19:03,560 --> 00:19:05,560
o no falla. No, 10 son muchos.

363
00:19:05,560 --> 00:19:07,560
5. Venga, 2

364
00:19:07,560 --> 00:19:09,560
menos 5, 0

365
00:19:09,560 --> 00:19:11,560
9 y 2.

366
00:19:11,560 --> 00:19:13,560
Y si, me lo ha mostrado

367
00:19:13,560 --> 00:19:15,560
en el orden inverso, ¿verdad? 2, 9, 0, menos 5 y 2.

368
00:19:17,560 --> 00:19:19,560
¿Vale? Me los ha mostrado

369
00:19:19,560 --> 00:19:21,560
en el orden inverso a la introducción que hemos

370
00:19:21,560 --> 00:19:23,560
hecho.

371
00:19:27,560 --> 00:19:29,560
¿Vale?

372
00:19:29,560 --> 00:19:31,560
Bueno, esto en cuanto a

373
00:19:31,560 --> 00:19:33,560
recorridos, para uno y para otro.

374
00:19:37,560 --> 00:19:39,560
Vale, vamos a poner aquí

375
00:19:39,560 --> 00:19:41,560
otro planteamiento.

376
00:19:47,560 --> 00:19:49,560
Vale, imaginaos

377
00:19:49,560 --> 00:19:51,560
que decidimos adoptar la solución

378
00:19:51,560 --> 00:19:53,560
de decir, a ver,

379
00:19:53,560 --> 00:19:55,560
voy a reservar un array

380
00:19:55,560 --> 00:19:57,560
lo suficientemente grande

381
00:19:57,560 --> 00:19:59,560
y luego el usuario

382
00:19:59,560 --> 00:20:01,560
ya que me diga los que

383
00:20:01,560 --> 00:20:03,560
va a usar y solo uso esa parte del array.

384
00:20:05,560 --> 00:20:07,560
¿Vale? Podría ser una solución.

385
00:20:07,560 --> 00:20:09,560
Es decir, imaginaos que

386
00:20:09,560 --> 00:20:11,560
por alguna razón

387
00:20:11,560 --> 00:20:13,560
yo tengo que tener el array reservado

388
00:20:13,560 --> 00:20:15,560
antes, pero la información

389
00:20:15,560 --> 00:20:17,560
de cuántas casillas realmente se van a

390
00:20:17,560 --> 00:20:19,560
usar no me va a llegar hasta después.

391
00:20:19,560 --> 00:20:21,560
Podría ser una solución real porque

392
00:20:21,560 --> 00:20:23,560
es un programa que tiene varias partes, etc.

393
00:20:23,560 --> 00:20:25,560
Vale.

394
00:20:27,560 --> 00:20:29,560
Voy a ponerlo aquí.

395
00:20:29,560 --> 00:20:31,560
En este caso,

396
00:20:33,560 --> 00:20:35,560
el número

397
00:20:37,560 --> 00:20:39,560
sería el caso en el cual

398
00:20:39,560 --> 00:20:41,560
el número de

399
00:20:41,560 --> 00:20:43,560
sería el caso

400
00:20:45,560 --> 00:20:47,560
en el que

401
00:20:49,560 --> 00:20:51,560
la cantidad de números que va a introducir el usuario

402
00:20:51,560 --> 00:20:53,560
no la podemos saber

403
00:20:53,560 --> 00:20:55,560
por lo que sea que podría ocurrir, no la podemos saber

404
00:20:55,560 --> 00:20:57,560
hasta después de haber declarado el array.

405
00:20:57,560 --> 00:20:59,560
¿Vale?

406
00:21:05,560 --> 00:21:07,560
Que se van a usar

407
00:21:07,560 --> 00:21:09,560
no la

408
00:21:09,560 --> 00:21:11,560
podemos saber

409
00:21:11,560 --> 00:21:13,560
hasta

410
00:21:15,560 --> 00:21:17,560
después de haber

411
00:21:17,560 --> 00:21:19,560
declarado

412
00:21:19,560 --> 00:21:21,560
el array.

413
00:21:21,560 --> 00:21:23,560
Vale. Entonces,

414
00:21:23,560 --> 00:21:25,560
este podría ser un caso

415
00:21:25,560 --> 00:21:27,560
perfectamente real. Yo tengo que hacer un programa

416
00:21:27,560 --> 00:21:29,560
en el que

417
00:21:29,560 --> 00:21:31,560
necesito un array

418
00:21:31,560 --> 00:21:33,560
pero no sé

419
00:21:33,560 --> 00:21:35,560
cuántas posiciones

420
00:21:35,560 --> 00:21:37,560
realmente voy a necesitar

421
00:21:37,560 --> 00:21:39,560
porque esa información me va a llegar después

422
00:21:39,560 --> 00:21:41,560
a través de un

423
00:21:41,560 --> 00:21:43,560
método, una función, bueno, podría ocurrir

424
00:21:43,560 --> 00:21:45,560
en otras situaciones. Repito,

425
00:21:45,560 --> 00:21:47,560
no es el caso de este programa, por eso es un programa

426
00:21:47,560 --> 00:21:49,560
único. Yo aquí puedo decidir

427
00:21:49,560 --> 00:21:51,560
si esto lo leo antes o después. Pues lo

428
00:21:51,560 --> 00:21:53,560
leo antes y fenomenal. Al leerlo antes

429
00:21:53,560 --> 00:21:55,560
ya tengo el tamaño. ¿Vale?

430
00:21:55,560 --> 00:21:57,560
Pero hay otra situación real, repito,

431
00:21:57,560 --> 00:21:59,560
en la cual uno necesita el array, lo

432
00:21:59,560 --> 00:22:01,560
necesita, declararlo,

433
00:22:01,560 --> 00:22:03,560
pero todavía no sabe cuántas posiciones se van a

434
00:22:03,560 --> 00:22:05,560
usar realmente. Vale, vamos a hacer

435
00:22:05,560 --> 00:22:07,560
este programa planteándonoslo así.

436
00:22:07,560 --> 00:22:09,560
Bueno, entonces, estamos en la

437
00:22:09,560 --> 00:22:11,560
situación en la cual el array lo tenemos que

438
00:22:11,560 --> 00:22:13,560
declarar antes

439
00:22:13,560 --> 00:22:15,560
lo voy a llamar de otra manera

440
00:22:15,560 --> 00:22:17,560
para que no se mezcle con el de arriba

441
00:22:17,560 --> 00:22:19,560
lo tenemos que declarar antes

442
00:22:19,560 --> 00:22:21,560
de saber realmente cuántas posiciones

443
00:22:21,560 --> 00:22:23,560
se van a usar, de saberlo.

444
00:22:23,560 --> 00:22:25,560
Entonces, ahí solo

445
00:22:25,560 --> 00:22:27,560
hay una solución, que es

446
00:22:27,560 --> 00:22:29,560
lo voy a declarar muy grande, enorme

447
00:22:29,560 --> 00:22:31,560
y luego le digo al usuario, por favor,

448
00:22:31,560 --> 00:22:33,560
no te pases de esta cantidad.

449
00:22:33,560 --> 00:22:35,560
No hay otra solución.

450
00:22:35,560 --> 00:22:37,560
¿Vale?

451
00:22:37,560 --> 00:22:39,560
Entonces, uno podría decir, venga,

452
00:22:39,560 --> 00:22:41,560
como estoy segura

453
00:22:41,560 --> 00:22:43,560
de que no va a estar ahí introduciendo más de 10.000

454
00:22:43,560 --> 00:22:45,560
números, pues lo declaro de 10.000

455
00:22:45,560 --> 00:22:47,560
y se acabó.

456
00:22:47,560 --> 00:22:49,560
Y ahora

457
00:22:49,560 --> 00:22:51,560
ya le digo al usuario

458
00:22:57,560 --> 00:22:59,560
¿Cuántos números va a introducir?

459
00:22:59,560 --> 00:23:01,560
Y le aviso

460
00:23:01,560 --> 00:23:03,560
menos de 10.000, por favor.

461
00:23:03,560 --> 00:23:05,560
Porque no hay espacio para más.

462
00:23:05,560 --> 00:23:07,560
Tendría que decírselo

463
00:23:07,560 --> 00:23:09,560
y confiar.

464
00:23:09,560 --> 00:23:11,560
Vamos a llamarlo N1 para que no se mezcle con el otro.

465
00:23:11,560 --> 00:23:13,560
¿Vale?

466
00:23:13,560 --> 00:23:15,560
Porque como el usuario meta más de 10.000

467
00:23:15,560 --> 00:23:17,560
malamente.

468
00:23:17,560 --> 00:23:19,560
¿Vale? Y ahora ya el programa

469
00:23:19,560 --> 00:23:21,560
vamos a suponer que

470
00:23:21,560 --> 00:23:23,560
ya el programa lo hacemos igual.

471
00:23:23,560 --> 00:23:25,560
Vamos a copiar y pegar

472
00:23:25,560 --> 00:23:27,560
la lectura de números y el mostrado

473
00:23:27,560 --> 00:23:29,560
en orden inverso.

474
00:23:29,560 --> 00:23:31,560
¿Vale?

475
00:23:31,560 --> 00:23:33,560
Aquí la lectura

476
00:23:33,560 --> 00:23:35,560
de números ahora es N2

477
00:23:37,560 --> 00:23:39,560
N2

478
00:23:39,560 --> 00:23:41,560
Y ahora

479
00:23:41,560 --> 00:23:43,560
mostramos el orden inverso N2

480
00:23:43,560 --> 00:23:45,560
N2

481
00:23:45,560 --> 00:23:47,560
¿Vale?

482
00:23:47,560 --> 00:23:49,560
Entonces hemos declarado

483
00:23:49,560 --> 00:23:51,560
de un tamaño resumidamente grande

484
00:23:51,560 --> 00:23:53,560
¿Cuántos números va a introducir?

485
00:23:55,560 --> 00:23:57,560
Y ahora

486
00:23:57,560 --> 00:23:59,560
recorremos el array

487
00:23:59,560 --> 00:24:01,560
primero para leer los datos

488
00:24:01,560 --> 00:24:03,560
y ahora en orden inverso

489
00:24:03,560 --> 00:24:05,560
para mostrar.

490
00:24:05,560 --> 00:24:07,560
¿Vale?

491
00:24:11,560 --> 00:24:13,560
Entonces

492
00:24:15,560 --> 00:24:17,560
¿Qué veis de raro en este programa?

493
00:24:17,560 --> 00:24:19,560
Para que funcione exactamente

494
00:24:19,560 --> 00:24:21,560
como me han pedido.

495
00:24:21,560 --> 00:24:23,560
¿Qué tendríais que cambiar aquí?

496
00:24:23,560 --> 00:24:25,560
¡Claro!

497
00:24:25,560 --> 00:24:27,560
Ahora si yo sigo poniendo aquí

498
00:24:27,560 --> 00:24:29,560
N2.length

499
00:24:29,560 --> 00:24:31,560
N2.length se refiere a 10.000

500
00:24:31,560 --> 00:24:33,560
se refiere a 10.000

501
00:24:33,560 --> 00:24:35,560
Yo quiero que rellene

502
00:24:35,560 --> 00:24:37,560
solo hasta la posición N1

503
00:24:39,560 --> 00:24:41,560
Entonces aquí

504
00:24:41,560 --> 00:24:43,560
sí que tendríamos que poner esto

505
00:24:43,560 --> 00:24:45,560
porque si no va a pedir hasta 10.000

506
00:24:45,560 --> 00:24:47,560
Lo que quiero decir es que siempre

507
00:24:47,560 --> 00:24:49,560
el nombre del array .length

508
00:24:49,560 --> 00:24:51,560
va a ser siempre

509
00:24:51,560 --> 00:24:53,560
esa cantidad, la que se reservó

510
00:24:53,560 --> 00:24:55,560
Siempre, independientemente de que

511
00:24:55,560 --> 00:24:57,560
se hayan usado solo o inicializado

512
00:24:57,560 --> 00:24:59,560
solo las 20 primeras, me da igual

513
00:24:59,560 --> 00:25:01,560
Siempre

514
00:25:01,560 --> 00:25:03,560
esta variable .length de ahí

515
00:25:05,560 --> 00:25:07,560
Siempre va a ser el tamaño

516
00:25:07,560 --> 00:25:09,560
que se ha reservado, no el tamaño que

517
00:25:09,560 --> 00:25:11,560
está ocupado

518
00:25:11,560 --> 00:25:13,560
¿Vale? Tenerlo claro porque a veces

519
00:25:13,560 --> 00:25:15,560
se producen errores por eso

520
00:25:15,560 --> 00:25:17,560
Entonces

521
00:25:17,560 --> 00:25:19,560
cuando un array solo está ocupado

522
00:25:19,560 --> 00:25:21,560
hasta cierta cantidad, cuidado

523
00:25:21,560 --> 00:25:23,560
entonces no se recorre hasta

524
00:25:23,560 --> 00:25:25,560
length, no se recorre hasta length

525
00:25:25,560 --> 00:25:27,560
se recorre

526
00:25:27,560 --> 00:25:29,560
hasta la cantidad que a mí me interesa

527
00:25:29,560 --> 00:25:31,560
porque es la que está ocupada de forma efectiva

528
00:25:31,560 --> 00:25:33,560
la otra tiene valores indefinidos

529
00:25:33,560 --> 00:25:35,560
no es que me vaya a dar error

530
00:25:35,560 --> 00:25:37,560
cosas tendrá, pero son indefinidas

531
00:25:37,560 --> 00:25:39,560
no están inicializadas, no es que me haya salido

532
00:25:39,560 --> 00:25:41,560
del array

533
00:25:41,560 --> 00:25:43,560
¿Vale? Pues entonces

534
00:25:43,560 --> 00:25:45,560
ese es el problema

535
00:25:45,560 --> 00:25:47,560
de los arrays, que si yo a priori

536
00:25:47,560 --> 00:25:49,560
no sé cuantos datos tengo

537
00:25:49,560 --> 00:25:51,560
pues es un problema

538
00:25:51,560 --> 00:25:53,560
¿De qué tamaño los declaro? Porque tengo que daros

539
00:25:53,560 --> 00:25:55,560
un tamaño, pues tendrás que declarar un tamaño

540
00:25:55,560 --> 00:25:57,560
muy grandote y luego ya

541
00:25:57,560 --> 00:25:59,560
usar la parte que sea

542
00:25:59,560 --> 00:26:01,560
y eso sí, luego al hacer

543
00:26:01,560 --> 00:26:03,560
los recorridos

544
00:26:03,560 --> 00:26:05,560
tendrás que recorrer solo hasta la parte válida

545
00:26:05,560 --> 00:26:07,560
hasta la parte usada, el resto no te vale para nada

546
00:26:07,560 --> 00:26:09,560
y está ahí molestando

547
00:26:09,560 --> 00:26:11,560
¿Vale? Pues ese es el problema de los arrays

548
00:26:13,560 --> 00:26:15,560
que son estáticos

549
00:26:15,560 --> 00:26:17,560
son estructuras de datos estáticos

550
00:26:17,560 --> 00:26:19,560
estáticas que se llaman, que se reserva

551
00:26:19,560 --> 00:26:21,560
un tamaño y ahí se queda

552
00:26:21,560 --> 00:26:23,560
¿Vale?

553
00:26:23,560 --> 00:26:25,560
Vale, entonces este programa

554
00:26:25,560 --> 00:26:27,560
ahora ya sí que funcionaría bien

555
00:26:27,560 --> 00:26:29,560
pero acordándonos de que solo hasta N1

556
00:26:31,560 --> 00:26:33,560
Entonces, aunque haga lo mismo que

557
00:26:33,560 --> 00:26:35,560
el de arriba, este es mucho

558
00:26:35,560 --> 00:26:37,560
peor, porque está reservando

559
00:26:37,560 --> 00:26:39,560
está dejando ahí en memoria

560
00:26:39,560 --> 00:26:41,560
10.000 espacios que no valen

561
00:26:41,560 --> 00:26:43,560
para nada

562
00:26:43,560 --> 00:26:45,560
Entonces, aparentemente este programa

563
00:26:45,560 --> 00:26:47,560
y el de arriba hacen lo mismo, sí, para el usuario

564
00:26:47,560 --> 00:26:49,560
hacen lo mismo, para el usuario hacen lo mismo

565
00:26:49,560 --> 00:26:51,560
pero físicamente

566
00:26:51,560 --> 00:26:53,560
en el ordenador no está ocurriendo lo mismo

567
00:26:53,560 --> 00:26:55,560
Físicamente no está ocurriendo lo mismo

568
00:26:55,560 --> 00:26:57,560
Físicamente, en el ordenador

569
00:26:57,560 --> 00:26:59,560
aquí están reservándose solo exactamente

570
00:26:59,560 --> 00:27:01,560
los que se van a usar, luego estupendo

571
00:27:01,560 --> 00:27:03,560
y maravilloso

572
00:27:03,560 --> 00:27:05,560
y aquí se están reservando

573
00:27:05,560 --> 00:27:07,560
mogollón, que está ahí la memoria muerta de risa

574
00:27:07,560 --> 00:27:09,560
con todos esos espacios ahí para nada

575
00:27:09,560 --> 00:27:11,560
¿Vale?

576
00:27:17,560 --> 00:27:19,560
Vale

577
00:27:23,560 --> 00:27:25,560
Vale

578
00:27:29,560 --> 00:27:31,560
Vale

579
00:27:33,560 --> 00:27:35,560
Voy a ir insertando aquí

580
00:27:35,560 --> 00:27:37,560
ejercicios que os voy a ir pidiendo

581
00:27:37,560 --> 00:27:39,560
ahora

582
00:27:47,560 --> 00:27:49,560
Vale, estos cuatro

583
00:27:49,560 --> 00:27:51,560
son los que os dije

584
00:27:51,560 --> 00:27:53,560
que deberíais hacer

585
00:27:53,560 --> 00:27:55,560
¿Vale? que tenéis que hacer

586
00:27:55,560 --> 00:27:57,560
que vamos, que iremos corrigiendo

587
00:27:57,560 --> 00:27:59,560
pero ahora para cambiar

588
00:27:59,560 --> 00:28:01,560
de tanto número, como aquí es todo

589
00:28:01,560 --> 00:28:03,560
números, números, voy a

590
00:28:03,560 --> 00:28:05,560
insertar aquí un ejercicio, es el que quiero

591
00:28:05,560 --> 00:28:07,560
que dediquéis ahora un rato para hacer

592
00:28:11,560 --> 00:28:13,560
Declarar un

593
00:28:13,560 --> 00:28:15,560
array para

594
00:28:15,560 --> 00:28:17,560
contener

595
00:28:19,560 --> 00:28:21,560
diez cadenas

596
00:28:23,560 --> 00:28:25,560
de texto

597
00:28:25,560 --> 00:28:27,560
Vale

598
00:28:27,560 --> 00:28:29,560
Solicitará

599
00:28:31,560 --> 00:28:33,560
dichas

600
00:28:33,560 --> 00:28:35,560
cadenas por teclado

601
00:28:35,560 --> 00:28:37,560
y ahora

602
00:28:37,560 --> 00:28:39,560
¿Qué va a hacer después?

603
00:28:39,560 --> 00:28:41,560
A continuación

604
00:28:41,560 --> 00:28:43,560
mostrará

605
00:28:47,560 --> 00:28:49,560
todas las cadenas

606
00:28:49,560 --> 00:28:51,560
concatenadas

607
00:28:51,560 --> 00:28:53,560
concatenadas

608
00:28:53,560 --> 00:28:55,560
empezando

609
00:28:55,560 --> 00:28:57,560
por la

610
00:28:57,560 --> 00:28:59,560
última

611
00:28:59,560 --> 00:29:01,560
de

612
00:29:09,560 --> 00:29:11,560
¿Vale? entonces el tamaño de la raya

613
00:29:11,560 --> 00:29:13,560
aquí no es problema, ya nos dicen que 10, pues 10

614
00:29:13,560 --> 00:29:15,560
ahora las rellenamos

615
00:29:15,560 --> 00:29:17,560
cadenas de texto, 10 cadenas de texto

616
00:29:17,560 --> 00:29:19,560
y luego cuando ya las tenemos

617
00:29:19,560 --> 00:29:21,560
tiene que mostrar la concatenación de todas ellas

618
00:29:21,560 --> 00:29:23,560
la concatenación de todas

619
00:29:23,560 --> 00:29:25,560
pero empezando por la última

620
00:29:25,560 --> 00:29:27,560
¿Vale?

621
00:29:27,560 --> 00:29:29,560
Pues venga

622
00:29:29,560 --> 00:29:31,560
ponéis a hacer

623
00:29:31,560 --> 00:29:33,560
este ejercicio ahora