1
00:00:03,819 --> 00:00:16,679
Bueno, pues esto de nuevo, como ya desde hace varios meses, es un problema para el que ya tenemos un algoritmo que siempre usamos.

2
00:00:17,019 --> 00:00:25,219
¿Qué problema es este? De un conjunto de datos, calcular el que más hace lo que sea, el que más tiene lo que sea.

3
00:00:25,219 --> 00:00:28,059
Ese es el problema del máximo de algo

4
00:00:28,059 --> 00:00:29,699
Tengo un conjunto de datos

5
00:00:29,699 --> 00:00:31,719
Y tengo que recorrerlo

6
00:00:31,719 --> 00:00:33,979
Para ver el que más hace patatín

7
00:00:33,979 --> 00:00:36,159
Pues es justo esto

8
00:00:36,159 --> 00:00:37,820
Eso lo resolvíamos

9
00:00:37,820 --> 00:00:40,000
Con el algoritmo para calcular el máximo de algo

10
00:00:40,000 --> 00:00:42,299
Igual que hemos hecho

11
00:00:42,299 --> 00:00:43,700
Algoritmos de sumas acumulativas

12
00:00:43,700 --> 00:00:45,799
De no sé qué, pues ese algoritmo también lo teníamos

13
00:00:45,799 --> 00:00:47,579
Un conjunto de datos

14
00:00:47,579 --> 00:00:48,759
El que más hace algo

15
00:00:48,759 --> 00:00:51,640
¿Cómo era ese algoritmo en general?

16
00:00:53,960 --> 00:00:55,320
Pues ese algoritmo en general era

17
00:00:55,320 --> 00:00:56,780
aquí que queremos

18
00:00:56,780 --> 00:00:59,219
el alumno que más

19
00:00:59,219 --> 00:01:01,439
o sea el resultado máximo es un alumno

20
00:01:01,439 --> 00:01:03,399
un alumno va a ser el que más

21
00:01:03,399 --> 00:01:05,019
cumpla algo, lo que sea

22
00:01:05,019 --> 00:01:07,439
en este caso tener más asignaturas

23
00:01:07,439 --> 00:01:08,920
bueno pues aquí

24
00:01:08,920 --> 00:01:11,219
el resultado final

25
00:01:11,219 --> 00:01:14,549
lo podemos guardar

26
00:01:14,549 --> 00:01:17,010
preparamos esta variable para guardar

27
00:01:17,010 --> 00:01:17,849
el resultado final

28
00:01:17,849 --> 00:01:19,849
el resultado final va a ser

29
00:01:19,849 --> 00:01:23,010
el alumno que más cumpla una condición

30
00:01:23,010 --> 00:01:24,549
la que sea

31
00:01:24,549 --> 00:01:27,230
porque es el alumno con más asignaturas

32
00:01:27,230 --> 00:01:29,269
luego mi resultado final

33
00:01:29,269 --> 00:01:30,969
va a ser el alumno que más

34
00:01:30,969 --> 00:01:33,209
cumpla algo, luego otra cosa es que el método

35
00:01:33,209 --> 00:01:35,329
me devuelva solo el nombre, bueno luego en el método

36
00:01:35,329 --> 00:01:36,109
yo hago el retun

37
00:01:36,109 --> 00:01:41,310
luego en el método yo hago el retun

38
00:01:41,310 --> 00:01:42,250
solo del nombre

39
00:01:42,250 --> 00:01:45,370
y ya está, pero bueno podría ser que el método

40
00:01:45,370 --> 00:01:47,030
me dijera que devolvía al alumno completo

41
00:01:47,030 --> 00:01:49,510
da igual, bueno pues entonces

42
00:01:49,510 --> 00:01:51,469
está claro, tengo que recorrer

43
00:01:51,469 --> 00:01:53,629
una colección de alumnos para ver el que más

44
00:01:53,629 --> 00:01:55,390
cumple algo, luego el resultado final

45
00:01:55,390 --> 00:01:57,569
va a ser un alumno, el que más cumple algo, ¿vale?

46
00:01:58,010 --> 00:02:00,489
Pues esta variable se queda aquí preparada para eso.

47
00:02:01,650 --> 00:02:04,030
Ahora, ¿cómo hacíamos esto?

48
00:02:04,150 --> 00:02:06,890
¿Cómo programamos el algoritmo de máximo de algo?

49
00:02:08,800 --> 00:02:12,919
Pues primero, asumíamos que el máximo inicial

50
00:02:12,919 --> 00:02:14,599
era el primero de todos.

51
00:02:14,819 --> 00:02:16,280
El primero de todos es el máximo inicial.

52
00:02:16,960 --> 00:02:19,659
Y ahora recorríamos todos los demás, uno por uno.

53
00:02:20,199 --> 00:02:23,240
En cuanto encontrábamos uno que superaba a ese,

54
00:02:23,979 --> 00:02:24,960
teníamos nuevo máximo.

55
00:02:25,240 --> 00:02:26,340
Ese es el algoritmo.

56
00:02:26,699 --> 00:02:28,960
¿vale? o sea el máximo inicial

57
00:02:28,960 --> 00:02:30,719
es el primero de todos

58
00:02:30,719 --> 00:02:32,780
y ahora recorro los demás

59
00:02:32,780 --> 00:02:35,439
¿este supera el primero? tengo nuevo máximo

60
00:02:35,439 --> 00:02:37,120
me voy al siguiente

61
00:02:37,120 --> 00:02:38,620
¿este lo supera? no, pues nada

62
00:02:38,620 --> 00:02:41,300
me voy al siguiente, ¿este lo supera? tengo nuevo máximo

63
00:02:41,300 --> 00:02:42,979
así era el algoritmo

64
00:02:42,979 --> 00:02:45,319
y cuando ya habíamos terminado de recorrer todo

65
00:02:45,319 --> 00:02:46,439
en esa variable

66
00:02:46,439 --> 00:02:48,740
se había quedado el máximo

67
00:02:48,740 --> 00:02:50,960
esa era la idea ¿no?

68
00:02:52,360 --> 00:02:52,840
repito

69
00:02:52,840 --> 00:02:54,860
buscamos el objeto que más

70
00:02:54,860 --> 00:02:55,599
cumple algo

71
00:02:55,599 --> 00:02:57,740
una variable para él

72
00:02:57,740 --> 00:02:59,840
porque es el resultado final

73
00:02:59,840 --> 00:03:00,840
una variable para él

74
00:03:00,840 --> 00:03:03,759
ahora, esa variable se inicializa al primero de todos

75
00:03:03,759 --> 00:03:05,759
y ahora ya voy con los demás

76
00:03:05,759 --> 00:03:07,199
este supera a este

77
00:03:07,199 --> 00:03:09,180
nuevo, para aquí

78
00:03:09,180 --> 00:03:11,680
sigo, este supera a este

79
00:03:11,680 --> 00:03:12,979
nuevo, para aquí, sigo

80
00:03:12,979 --> 00:03:15,639
ese es el algoritmo, pues vamos a programar eso

81
00:03:15,639 --> 00:03:18,139
vale, pues entonces

82
00:03:18,139 --> 00:03:19,259
inicialmente

83
00:03:19,259 --> 00:03:22,120
el máximo inicial

84
00:03:22,120 --> 00:03:23,599
es el primero de todos

85
00:03:23,599 --> 00:03:25,879
vale, el primero de todos, ¿cuál es?

86
00:03:26,419 --> 00:03:27,860
el primero de todos es

87
00:03:27,860 --> 00:03:32,199
alumnos.getDeCero

88
00:03:32,199 --> 00:03:33,219
¿verdad?

89
00:03:33,680 --> 00:03:41,599
ups, vale

90
00:03:41,599 --> 00:03:43,840
este es el primer alumno de todos

91
00:03:43,840 --> 00:03:46,360
pues ese es el máximo inicial

92
00:03:46,360 --> 00:03:48,060
el que más asignaturas tiene

93
00:03:48,060 --> 00:03:50,259
y ahora vamos a recorrer el resto

94
00:03:50,259 --> 00:03:52,539
a ver si alguno supera a ese

95
00:03:52,539 --> 00:03:56,620
pues venga, recorremos el resto

96
00:03:56,620 --> 00:03:58,039
¿cómo lo recorremos?

97
00:03:58,699 --> 00:04:00,639
pues desde i igual a 1

98
00:04:00,639 --> 00:04:01,419
porque el 0

99
00:04:01,419 --> 00:04:03,379
ya lo tengo

100
00:04:03,379 --> 00:04:04,960
desde igual a 1

101
00:04:04,960 --> 00:04:06,599
mientras i sea menor que

102
00:04:06,599 --> 00:04:10,159
alumnos.size

103
00:04:10,159 --> 00:04:12,819
incrementando i

104
00:04:12,819 --> 00:04:15,360
con esto recorro todos

105
00:04:15,360 --> 00:04:16,319
y ahora

106
00:04:16,319 --> 00:04:17,759
¿qué hago con cada uno de ellos?

107
00:04:21,089 --> 00:04:22,790
pues si alumnos.get i

108
00:04:22,790 --> 00:04:27,319
supera

109
00:04:27,319 --> 00:04:29,060
si este

110
00:04:29,060 --> 00:04:30,620
supera a este

111
00:04:30,620 --> 00:04:32,079
tengo nuevo máximo

112
00:04:32,079 --> 00:04:34,000
y ahora es cuando tenemos que pensar

113
00:04:34,000 --> 00:04:36,220
¿qué significa que éste supere a éste?

114
00:04:37,579 --> 00:04:38,560
¿Qué significa?

115
00:04:38,980 --> 00:04:39,959
Pues en nuestro caso

116
00:04:39,959 --> 00:04:42,339
que le supere el número de asignaturas.

117
00:04:43,459 --> 00:04:44,699
Podría ser en otra cosa

118
00:04:44,699 --> 00:04:45,740
que hubiera dicho el alumno

119
00:04:45,740 --> 00:04:47,079
de mayor edad.

120
00:04:48,240 --> 00:04:50,360
Pues entonces aquí tendría que compararlos por edad.

121
00:04:50,879 --> 00:04:52,399
A éste con el máximo.

122
00:04:53,040 --> 00:04:54,000
Pero me han dicho el de más asignaturas.

123
00:04:55,339 --> 00:04:56,379
Luego tendría que comparar

124
00:04:56,379 --> 00:04:57,920
el número de asignaturas de éste

125
00:04:57,920 --> 00:04:59,759
con el número de asignaturas de éste.

126
00:05:00,399 --> 00:05:02,220
Si lo supera, tengo nuevo máximo.

127
00:05:02,220 --> 00:05:04,579
vale, el número de asignaturas de este

128
00:05:04,579 --> 00:05:06,439
¿cómo es? pues facilísimo de encontrar

129
00:05:06,439 --> 00:05:08,800
porque yo me saco

130
00:05:08,800 --> 00:05:10,300
su

131
00:05:10,300 --> 00:05:14,290
array de asignaturas

132
00:05:14,290 --> 00:05:15,670
su list de asignaturas

133
00:05:15,670 --> 00:05:17,269
y me saco su tamaño

134
00:05:17,269 --> 00:05:20,350
luego este es el número de asignaturas de este

135
00:05:20,350 --> 00:05:22,149
pues si el número

136
00:05:22,149 --> 00:05:24,189
de asignaturas de este es mayor

137
00:05:24,189 --> 00:05:26,170
que el número de asignaturas

138
00:05:26,170 --> 00:05:28,009
de este, tengo un nuevo máximo

139
00:05:28,009 --> 00:05:29,709
que es este de aquí, y a correr

140
00:05:29,709 --> 00:05:31,170
sigo con el siguiente

141
00:05:31,170 --> 00:05:33,850
y ya está, ya he programado ese algoritmo

142
00:05:33,850 --> 00:05:35,689
pues entonces

143
00:05:35,689 --> 00:05:36,509
es mayor

144
00:05:36,509 --> 00:05:39,990
voy a poner el, aunque quede feo

145
00:05:39,990 --> 00:05:41,689
el mayor

146
00:05:41,689 --> 00:05:43,730
aquí debajo para que se vea

147
00:05:43,730 --> 00:05:45,949
pues si es mayor que

148
00:05:45,949 --> 00:05:49,389
alumno máximo

149
00:05:49,389 --> 00:05:51,350
punto get asignaturas

150
00:05:51,350 --> 00:05:53,449
punto size

151
00:05:53,449 --> 00:05:57,930
pues si las asignaturas

152
00:05:57,930 --> 00:05:59,089
del de posición y

153
00:05:59,089 --> 00:06:02,029
son más que las asignaturas

154
00:06:02,029 --> 00:06:03,829
del que es máximo hasta ese

155
00:06:03,829 --> 00:06:06,170
momento, tengo nuevo máximo.

156
00:06:07,750 --> 00:06:10,029
Pues venga, tengo nuevo máximo que sustituye

157
00:06:10,029 --> 00:06:14,110
al anterior, que es este.

158
00:06:16,050 --> 00:06:18,350
Y ala, programado el algoritmo, terminado.

159
00:06:19,850 --> 00:06:21,149
Como lo hemos hecho siempre.

160
00:06:21,970 --> 00:06:24,009
Es el objeto que más

161
00:06:24,009 --> 00:06:24,709
cumple algo.

162
00:06:25,709 --> 00:06:28,129
Que más cumple algo dentro de una colección de objetos.

163
00:06:28,250 --> 00:06:29,430
No da igual que sea un array, lo que sea.

164
00:06:31,129 --> 00:06:32,029
Resultado final irá

165
00:06:32,029 --> 00:06:32,629
a una variable.

166
00:06:33,470 --> 00:06:35,790
Esa variable inicialmente es la del primero de todos.

167
00:06:35,970 --> 00:06:37,350
Y ahora recorro los demás.

168
00:06:38,589 --> 00:06:41,889
En cuanto encuentre uno que supera al que es máximo,

169
00:06:42,110 --> 00:06:42,990
tengo nuevo máximo.

170
00:06:43,430 --> 00:06:43,850
Y sigo.

171
00:06:45,509 --> 00:06:47,050
Entonces, cuando este bucle termine,

172
00:06:47,670 --> 00:06:50,110
pues como ya vimos esto en la primera evaluación

173
00:06:50,110 --> 00:06:51,810
y lo explicamos, cuando este bucle termine,

174
00:06:52,850 --> 00:06:54,550
pues ¿qué habrá en alumno máximo?

175
00:06:54,850 --> 00:06:58,529
Habrá de todos estos el que tenía más asignaturas.

176
00:06:58,670 --> 00:06:59,269
Eso es lo que habrá.

177
00:06:59,370 --> 00:07:00,829
Porque ese es el que se habrá quedado aquí.

178
00:07:01,310 --> 00:07:02,410
Ese es el que se habrá quedado aquí.

179
00:07:02,790 --> 00:07:04,389
De todos los que he recorrido,

180
00:07:04,389 --> 00:07:07,250
el que tenga más, ese es el que se habrá quedado ahí

181
00:07:07,250 --> 00:07:08,970
luego una vez terminado el for

182
00:07:08,970 --> 00:07:11,189
el for termina aquí, no he puesto

183
00:07:11,189 --> 00:07:13,110
llaves porque solo quiero la sentencia if

184
00:07:13,110 --> 00:07:13,589
dentro

185
00:07:13,589 --> 00:07:17,189
una vez llegados ahí, sé que en alumno máximo

186
00:07:17,189 --> 00:07:18,769
tengo el alumno con más asignaturas

187
00:07:18,769 --> 00:07:21,470
vale, como me han pedido que devuelva el nombre

188
00:07:21,470 --> 00:07:22,230
solamente

189
00:07:22,230 --> 00:07:25,529
bueno, pues devuelvo solamente el nombre

190
00:07:25,529 --> 00:07:29,189
alumno máximo punto

191
00:07:29,189 --> 00:07:32,740
getNombre, vale, ya tengo

192
00:07:32,740 --> 00:07:33,500
el método hecho

193
00:07:33,500 --> 00:07:36,720
vamos a ahorrarle una línea

194
00:07:36,720 --> 00:07:38,620
así

195
00:07:38,620 --> 00:07:40,899
para que se vea todo junto

196
00:07:40,899 --> 00:07:43,620
vale, lo declaro, lo inicializo

197
00:07:43,620 --> 00:07:45,680
al primero

198
00:07:45,680 --> 00:07:47,360
recorro los demás

199
00:07:47,360 --> 00:07:49,699
en cuanto alguno supera el número de asignaturas

200
00:07:49,699 --> 00:07:57,800
y efectivamente

201
00:07:57,800 --> 00:07:58,720
no necesita parámetros

202
00:07:58,720 --> 00:07:59,879
así que

203
00:07:59,879 --> 00:08:01,939
eso fuera

204
00:08:01,939 --> 00:08:09,930
vale, entonces no olvidéis nada de todo lo que hemos visto

205
00:08:09,930 --> 00:08:12,370
porque es necesario usarlo todo el rato

206
00:08:12,370 --> 00:08:15,389
tenemos que saber hacer los máximos de algo

207
00:08:15,389 --> 00:08:21,420
aquí otra vez lo de siempre

208
00:08:21,420 --> 00:08:22,620
si uno mira esto y dice

209
00:08:22,620 --> 00:08:25,459
uff, como el array de alumnos

210
00:08:25,459 --> 00:08:27,279
este es inicializar, el que llame

211
00:08:27,279 --> 00:08:29,120
al método lo lleva, claro, porque le va a salir

212
00:08:29,120 --> 00:08:31,060
un null pointer de step y se va a parar la aplicación

213
00:08:31,060 --> 00:08:32,779
entonces, hombre

214
00:08:32,779 --> 00:08:35,220
efectivamente

215
00:08:35,220 --> 00:08:36,759
pues

216
00:08:36,759 --> 00:08:38,899
este método está un poquito

217
00:08:38,899 --> 00:08:39,879
desprotegido

218
00:08:39,879 --> 00:08:42,879
hombre, si lo queremos proteger un poquito

219
00:08:42,879 --> 00:08:46,460
Pues estaría bien hacer esto

220
00:08:46,460 --> 00:08:51,399
Si alumnos

221
00:08:51,399 --> 00:08:52,500
Es igual a null

222
00:08:52,500 --> 00:08:57,590
Pues entonces

223
00:08:57,590 --> 00:09:00,690
Podríamos avisar

224
00:09:00,690 --> 00:09:01,049
Así

225
00:09:01,049 --> 00:09:04,529
No hay alumnos

226
00:09:04,529 --> 00:09:07,570
Y en ese caso ya salir del método

227
00:09:07,570 --> 00:09:10,320
¿Vale?

228
00:09:10,639 --> 00:09:12,440
Pero aquí sí que tenemos que devolver algo

229
00:09:12,440 --> 00:09:14,639
Porque el método devuelve un string si o si

230
00:09:14,639 --> 00:09:17,080
Aquí no se puede poner de tu un punto pelota

231
00:09:17,080 --> 00:09:17,820
Hay que devolver algo

232
00:09:17,820 --> 00:09:20,539
Pero aquí lo natural sería devolver null

233
00:09:20,539 --> 00:09:22,200
no hay nada que devolver, devuelvo null

234
00:09:22,200 --> 00:09:26,539
devuelvo null

235
00:09:26,539 --> 00:09:28,720
lo que pasa es que hombre, entonces

236
00:09:28,720 --> 00:09:30,340
por favor

237
00:09:30,340 --> 00:09:31,620
avisemos aquí

238
00:09:31,620 --> 00:09:35,629
si el método no

239
00:09:35,629 --> 00:09:38,090
o sea, si no hay alumnos, devolverá null

240
00:09:38,090 --> 00:09:40,190
avisemos aquí, para que el que

241
00:09:40,190 --> 00:09:41,730
use el método vea en la ayuda

242
00:09:41,730 --> 00:09:43,490
que esto puede devolver null

243
00:09:43,490 --> 00:09:45,730
no vaya a ser que al que le salga el null pointer

244
00:09:45,730 --> 00:09:46,929
este es el que llama a ese

245
00:09:46,929 --> 00:09:52,159
vale, entonces aquí

246
00:09:52,159 --> 00:09:58,200
cuidadín

247
00:09:58,200 --> 00:10:01,120
Haríamos una documentación

248
00:10:01,120 --> 00:10:01,919
Donde pondríamos

249
00:10:01,919 --> 00:10:03,899
Devuelve a uno con más asignaturas

250
00:10:03,899 --> 00:10:10,580
El alumno, no el nombre

251
00:10:10,580 --> 00:10:17,360
Y return, y aquí pondríamos

252
00:10:17,360 --> 00:10:18,580
Null

253
00:10:18,580 --> 00:10:20,679
Si no hay alumnos

254
00:10:20,679 --> 00:10:24,820
Null si no hay alumnos

255
00:10:24,820 --> 00:10:26,700
Entonces el que nos use

256
00:10:26,700 --> 00:10:27,720
Dirá, uy, cuidado

257
00:10:27,720 --> 00:10:30,039
Si yo llamo al método

258
00:10:30,039 --> 00:10:32,019
Y no hay alumnos, no pasa nada

259
00:10:32,019 --> 00:10:33,440
No hay un null pointer exception

260
00:10:33,440 --> 00:10:34,860
Pero él me va a devolver null

261
00:10:34,860 --> 00:10:38,320
Cuidado, no vaya yo a usar ese objeto

262
00:10:38,320 --> 00:10:42,539
es la forma de comunicarse

263
00:10:42,539 --> 00:10:44,720
avisar, decir, si no hay alumnos te devuelvo

264
00:10:44,720 --> 00:10:47,100
porque es que no tengo nombre que devolverte

265
00:10:47,100 --> 00:10:55,700
vale, pues bueno

266
00:10:55,700 --> 00:10:58,120
digamos que son las dinámicas

267
00:10:58,120 --> 00:10:59,259
de programación

268
00:10:59,259 --> 00:11:01,960
estas son las diferentes dinámicas

269
00:11:01,960 --> 00:11:03,659
a las que os tenéis que acostumbrar

270
00:11:03,659 --> 00:11:06,860
vale, aún así

271
00:11:06,860 --> 00:11:11,279
bueno, seguimos siendo el jefe

272
00:11:11,279 --> 00:11:12,279
que vemos este método

273
00:11:12,279 --> 00:11:16,409
¿le haríamos algún otro comentario?

274
00:11:22,269 --> 00:11:24,250
¿Algún otro comentario le haríais sobre este método?

275
00:11:26,009 --> 00:11:29,750
Este método, tampoco te creas que es muy, muy, muy...

276
00:11:29,750 --> 00:11:31,470
¿Alguna cosa más se podría pulir?

277
00:11:34,870 --> 00:11:36,710
¿No os ocurre algún comentario más que hacerle?

278
00:11:40,350 --> 00:11:42,809
A ver, puede ocurrir que alumnos no sean NULL,

279
00:11:45,090 --> 00:11:46,529
pero no haya ninguno dentro.

280
00:11:47,029 --> 00:11:47,909
Es decir, una lista,

281
00:11:48,789 --> 00:11:50,049
y una RAI, cualquier colección,

282
00:11:50,529 --> 00:11:52,090
en realidad tiene tres situaciones distintas.

283
00:11:52,330 --> 00:11:54,450
Una, ser NULL, o sea, no existir, ser NULL.

284
00:11:55,029 --> 00:11:57,090
Otra, existir, pero no tener nada.

285
00:11:57,090 --> 00:11:58,970
y otra

286
00:11:58,970 --> 00:12:00,210
existir y tener elementos

287
00:12:00,210 --> 00:12:02,649
¿verdad? son tres situaciones distintas

288
00:12:02,649 --> 00:12:05,090
bueno, pues si la lista existe y no tiene

289
00:12:05,090 --> 00:12:07,350
nada, porque la hemos inicializado, new linked list

290
00:12:07,350 --> 00:12:09,029
y ya está, existe y no tiene nada

291
00:12:09,029 --> 00:12:10,870
no va a ser null

292
00:12:10,870 --> 00:12:13,049
no va a ser null, pero claro

293
00:12:13,049 --> 00:12:15,070
al irse aquí y buscar el

294
00:12:15,070 --> 00:12:17,169
primero, nos va

295
00:12:17,169 --> 00:12:18,970
a una excepción, nos va a una

296
00:12:18,970 --> 00:12:21,169
excepción de tipo index bound exception

297
00:12:21,169 --> 00:12:22,809
me dice, oye, que en la 0 no hay nadie

298
00:12:22,809 --> 00:12:25,029
la lista no es null

299
00:12:25,029 --> 00:12:26,110
luego aquí llegamos

300
00:12:26,110 --> 00:12:28,509
y esto no da null pointer exception

301
00:12:28,509 --> 00:12:29,830
null pointer exception no da

302
00:12:29,830 --> 00:12:32,549
porque alumnos no es null, no da null pointer exception

303
00:12:32,549 --> 00:12:35,049
pero da index bound exception

304
00:12:35,049 --> 00:12:36,889
me dice, eh, tratas de hacer

305
00:12:36,889 --> 00:12:38,649
una posición en la que no hay nadie

306
00:12:38,649 --> 00:12:40,330
lo que nos pasaba con un array

307
00:12:40,330 --> 00:12:42,870
si tenía tres posiciones y empezamos a hacer a la cuatro

308
00:12:42,870 --> 00:12:44,090
nos decían, a la cuatro no hay nada

309
00:12:44,090 --> 00:12:46,889
pues si la lista existe, no es null

310
00:12:46,889 --> 00:12:48,830
pero no tiene nada dentro

311
00:12:48,830 --> 00:12:51,250
la posición get0 no existe

312
00:12:51,250 --> 00:12:52,149
get0 es la primera

313
00:12:52,149 --> 00:12:53,450
si no hay ni primera

314
00:12:53,450 --> 00:12:56,110
pues aquí saldría un index bound exception

315
00:12:56,110 --> 00:12:57,210
entonces esto

316
00:12:57,210 --> 00:13:00,110
lo podríamos proteger

317
00:13:00,110 --> 00:13:01,350
mucho mejor así

318
00:13:01,350 --> 00:13:03,350
si alumnos es igual a null

319
00:13:03,350 --> 00:13:04,009
o

320
00:13:04,009 --> 00:13:07,269
vale, no es null

321
00:13:07,269 --> 00:13:07,970
pero

322
00:13:07,970 --> 00:13:11,750
alumnos.size es igual a 0

323
00:13:11,750 --> 00:13:14,769
que son dos cosas distintas

324
00:13:14,769 --> 00:13:17,490
una cosa es que alumnos sea null

325
00:13:17,490 --> 00:13:18,870
y otra cosa es que no lo sea

326
00:13:18,870 --> 00:13:21,210
pero que su tamaño sea 0

327
00:13:21,210 --> 00:13:22,169
es distinto

328
00:13:22,169 --> 00:13:25,250
si su tamaño es cero no queremos bajar aquí

329
00:13:25,250 --> 00:13:27,450
no queremos bajar aquí porque esto nos dará

330
00:13:27,450 --> 00:13:29,309
un index bound exceso, no queremos bajar ahí

331
00:13:29,309 --> 00:13:35,799
vale, entonces ahora esto ya

332
00:13:35,799 --> 00:13:37,539
ya sí que quedaría bonito

333
00:13:37,539 --> 00:14:02,559
¿le seguiríais haciendo algún otro comentario

334
00:14:02,559 --> 00:14:03,480
al que hizo este método?

335
00:14:06,679 --> 00:14:07,200
claro

336
00:14:07,200 --> 00:14:10,039
el array tiene alumnos

337
00:14:10,039 --> 00:14:12,159
estupendo, y ahora empezamos

338
00:14:12,159 --> 00:14:14,159
a comparar las asignaturas

339
00:14:14,159 --> 00:14:15,399
el tamaño del array

340
00:14:15,399 --> 00:14:18,159
si hay algún alumno que no tenga ninguna

341
00:14:18,159 --> 00:14:19,620
porque no se le ha matriculado de ninguna

342
00:14:19,620 --> 00:14:22,500
todavía y además es null

343
00:14:22,500 --> 00:14:23,539
esa lista es null

344
00:14:23,539 --> 00:14:26,220
el null pointer exception va a salir aquí

345
00:14:26,220 --> 00:14:28,960
aquí no va a salir

346
00:14:28,960 --> 00:14:30,659
el null pointer exception porque ya hemos visto

347
00:14:30,659 --> 00:14:33,139
que alumno ni es null ni tiene tamaño 0

348
00:14:33,139 --> 00:14:34,720
luego este for no me va a dar

349
00:14:34,720 --> 00:14:35,759
aquí null pointer exception

350
00:14:35,759 --> 00:14:38,980
pero aquí si me lo puede dar

351
00:14:38,980 --> 00:14:40,600
entonces si ya lo queremos

352
00:14:40,600 --> 00:14:42,159
dejar hiper mega arreglado

353
00:14:42,159 --> 00:14:44,179
hiper mega arreglado

354
00:14:44,179 --> 00:14:47,259
pues podríamos hacer

355
00:14:47,259 --> 00:14:56,500
Si alumnos, etiquetas y naturas es diferente de null y entonces ya se quedaría hipermega arregladísimo.

356
00:14:59,019 --> 00:15:18,159
Entonces aquí lo ideal sería comparar solo con los alumnos que realmente es diferente de null.

357
00:15:18,159 --> 00:15:24,440
y siendo

358
00:15:24,440 --> 00:15:25,460
diferente de null

359
00:15:25,460 --> 00:15:29,620
siendo diferente de null

360
00:15:29,620 --> 00:15:32,480
ahora ya no es null, luego puedo ver su tamaño

361
00:15:32,480 --> 00:15:34,600
su tamaño, que puede ser cero

362
00:15:34,600 --> 00:15:35,639
ahí no me importa que sea cero

363
00:15:35,639 --> 00:15:37,919
el número de asignaturas es mayor

364
00:15:37,919 --> 00:15:39,379
que las de este

365
00:15:39,379 --> 00:15:46,960
¿vale? entonces esto es bueno

366
00:15:46,960 --> 00:15:49,480
para que vayáis viendo un poco las cosas en el examen

367
00:15:49,480 --> 00:15:51,480
lo indicaremos

368
00:15:51,480 --> 00:15:52,600
de todas maneras, pero

369
00:15:52,600 --> 00:15:55,100
la idea no es que tengáis que

370
00:15:55,100 --> 00:15:57,759
protegeros de cualquier situación de null

371
00:15:57,759 --> 00:15:58,659
no

372
00:15:58,659 --> 00:16:02,240
no es la idea, no es necesario

373
00:16:02,240 --> 00:16:04,519
que tengáis que hacer los códigos

374
00:16:04,519 --> 00:16:06,720
de manera que os protejáis de cualquier caso especial

375
00:16:06,720 --> 00:16:08,899
no, simplemente

376
00:16:08,899 --> 00:16:10,539
el código que funcione, que esté bien hecho

377
00:16:10,539 --> 00:16:11,879
que recorra, que haga lo que tenga que hacer

378
00:16:11,879 --> 00:16:14,480
no hace falta verificar que para cualquier

379
00:16:14,480 --> 00:16:16,659
caso especial no va a salir un pointer excepto

380
00:16:16,659 --> 00:16:18,279
no va a salir, pero eso no significa

381
00:16:18,279 --> 00:16:20,259
que no tengáis que ser conscientes de ello

382
00:16:20,259 --> 00:16:22,899
porque una cosa es el examen

383
00:16:22,899 --> 00:16:23,519
y otra cosa es aprender

384
00:16:23,519 --> 00:16:33,330
y de hecho aquí este ni siquiera

385
00:16:33,330 --> 00:16:35,470
estaría del todo protegido este código

386
00:16:35,470 --> 00:16:37,129
porque puñetera mala suerte

387
00:16:37,129 --> 00:16:39,809
si el primer alumno de la colección

388
00:16:39,809 --> 00:16:41,690
ese, sus asignaturas es nul

389
00:16:41,690 --> 00:16:43,250
si ese es nul

390
00:16:43,250 --> 00:16:45,409
me va a salir por aquí, cuando comparo

391
00:16:45,409 --> 00:16:46,389
con el primero de todos

392
00:16:46,389 --> 00:16:49,509
entonces tendríamos que coger como alumno

393
00:16:49,509 --> 00:16:50,730
máximo el primero

394
00:16:50,730 --> 00:16:52,870
que sus asignaturas no es nul

395
00:16:52,870 --> 00:16:55,169
entonces ya sí que se quedaría

396
00:16:55,169 --> 00:16:56,950
protegido de cualquier inclemencia

397
00:16:56,950 --> 00:16:59,289
este código

398
00:16:59,289 --> 00:17:01,009
¿entendéis la problemática que os digo?

399
00:17:01,009 --> 00:17:03,889
yo aquí he cogido el primero

400
00:17:03,889 --> 00:17:04,789
es el máximo

401
00:17:04,789 --> 00:17:07,369
me voy a comparar con todos los demás

402
00:17:07,369 --> 00:17:09,349
si alguno, su número de asignaturas

403
00:17:09,349 --> 00:17:11,630
cuando existe es mayor

404
00:17:11,630 --> 00:17:12,670
que el número de asignaturas

405
00:17:12,670 --> 00:17:15,089
del que es máximo hasta ese momento

406
00:17:15,089 --> 00:17:17,210
pero claro, si el que he cogido de partida

407
00:17:17,210 --> 00:17:18,289
ya ese tiene null

408
00:17:18,289 --> 00:17:21,589
entonces aquí habría que sustituir

409
00:17:21,589 --> 00:17:22,549
este por un for

410
00:17:22,549 --> 00:17:25,829
que estuviera

411
00:17:25,829 --> 00:17:27,609
avanzando hasta que encontrara

412
00:17:27,609 --> 00:17:29,549
un alumno y diferente

413
00:17:29,549 --> 00:17:30,009
de null

414
00:17:30,009 --> 00:17:34,549
para practicar programación vamos a hacerlo

415
00:17:34,549 --> 00:17:36,750
pero no es la idea del examen, insisto

416
00:17:36,750 --> 00:17:39,490
¿qué queremos hacer aquí?

417
00:17:40,710 --> 00:17:43,309
queremos inicializar alumnos

418
00:17:43,309 --> 00:17:46,109
alumno máximo al primer alumno que tenga

419
00:17:46,109 --> 00:17:48,670
una RAI de asignatura es diferente de null

420
00:17:48,670 --> 00:17:54,940
inicializamos alumno max

421
00:17:54,940 --> 00:17:57,319
al primer

422
00:17:57,319 --> 00:18:00,160
alumno

423
00:18:00,160 --> 00:18:02,400
de la lista

424
00:18:02,400 --> 00:18:10,470
cuya

425
00:18:10,470 --> 00:18:12,750
lista de asignaturas

426
00:18:12,750 --> 00:18:14,809
no

427
00:18:14,809 --> 00:18:15,630
sea

428
00:18:15,630 --> 00:18:17,990
nul

429
00:18:17,990 --> 00:18:20,089
eso es lo que queremos aquí

430
00:18:20,089 --> 00:18:22,910
no inicializar al primero sin más

431
00:18:22,910 --> 00:18:23,930
no al primero sin más

432
00:18:23,930 --> 00:18:26,369
sino al primero cuya lista no sea nul

433
00:18:26,369 --> 00:18:29,009
y a partir de ahí ya recorrer para hacerlo del máximo

434
00:18:29,009 --> 00:18:30,670
los que eran nul pasamos de ellos

435
00:18:30,670 --> 00:18:32,410
no van a ser del máximo en cualquier caso

436
00:18:32,410 --> 00:18:35,049
inicializar al primero cuya lista de asignaturas no sea nul

437
00:18:35,049 --> 00:18:36,809
bueno pues aquí podemos hacer

438
00:18:36,809 --> 00:18:38,990
un for

439
00:18:38,990 --> 00:18:40,910
vamos a quedarnos

440
00:18:40,910 --> 00:18:42,349
inicialmente una posición

441
00:18:42,349 --> 00:18:44,930
esta es la posición inicial

442
00:18:44,930 --> 00:18:46,190
y le vamos a ir avanzando

443
00:18:46,190 --> 00:18:48,069
mientras

444
00:18:48,069 --> 00:18:51,420
y podemos hacer

445
00:18:51,420 --> 00:18:54,279
por ejemplo así si lo veis más claro

446
00:18:54,279 --> 00:18:55,940
mientras

447
00:18:55,940 --> 00:19:00,059
alumnos.get

448
00:19:00,059 --> 00:19:00,680
y

449
00:19:00,680 --> 00:19:04,259
.get

450
00:19:04,259 --> 00:19:06,059
asignaturas

451
00:19:06,059 --> 00:19:09,900
get asignaturas

452
00:19:09,900 --> 00:19:12,519
sea igual a nul

453
00:19:12,519 --> 00:19:15,019
y más más.

454
00:19:16,619 --> 00:19:16,819
¡Hala!

455
00:19:17,579 --> 00:19:18,400
Este bucle

456
00:19:18,400 --> 00:19:21,619
y me falta el punto y coma en el c.

457
00:19:23,579 --> 00:19:25,279
Espera, no voy a llamarla i

458
00:19:25,279 --> 00:19:26,720
para no confundir con la de abajo.

459
00:19:27,819 --> 00:19:29,259
La voy a llamar pos,

460
00:19:33,029 --> 00:19:34,130
pos y pos.

461
00:19:34,630 --> 00:19:34,890
Vale.

462
00:19:37,960 --> 00:19:39,960
Entonces, con el punto y coma.

463
00:19:42,920 --> 00:19:43,700
Vale, este bucle

464
00:19:43,700 --> 00:19:46,000
va avanzando posición

465
00:19:46,000 --> 00:19:47,700
mientras

466
00:19:47,700 --> 00:19:50,619
el alumno de la lista

467
00:19:50,619 --> 00:19:52,559
sus asignaturas sean null

468
00:19:52,559 --> 00:19:53,279
lo va avanzando

469
00:19:53,279 --> 00:19:55,640
en cuanto ya se encuentre uno

470
00:19:55,640 --> 00:19:58,160
que su array de asignaturas no es null

471
00:19:58,160 --> 00:20:00,460
no es null, ahí ya pues se queda parado

472
00:20:00,460 --> 00:20:02,359
vale

473
00:20:02,359 --> 00:20:04,299
pues entonces

474
00:20:04,299 --> 00:20:06,079
ahora ya si podemos hacer esto

475
00:20:06,079 --> 00:20:14,680
alumno

476
00:20:14,680 --> 00:20:19,299
max igual a

477
00:20:19,299 --> 00:20:23,049
alumnos.get

478
00:20:23,049 --> 00:20:24,309
de posición

479
00:20:24,309 --> 00:20:27,549
ahí ya lo dejo

480
00:20:27,549 --> 00:20:37,519
y ahora este for cambia

481
00:20:37,519 --> 00:20:39,359
¿en qué cambio este for? que tengo que cambiar aquí

482
00:20:39,359 --> 00:20:46,299
¿en qué línea cambio algo?

483
00:20:46,420 --> 00:20:46,880
¿y qué cambio?

484
00:20:49,059 --> 00:20:50,640
en esta línea ¿no? cambio algo

485
00:20:50,640 --> 00:20:53,099
¿eh?

486
00:20:53,880 --> 00:20:54,819
desde cero

487
00:20:54,819 --> 00:20:57,460
¿desde cero?

488
00:20:57,619 --> 00:20:59,640
desde pos más uno

489
00:20:59,640 --> 00:21:01,480
me he colocado en el pos

490
00:21:01,480 --> 00:21:03,079
y ahora desde él

491
00:21:03,079 --> 00:21:05,079
empiezo a trabajar desde él

492
00:21:05,079 --> 00:21:07,619
pues desde igual a

493
00:21:07,619 --> 00:21:10,240
pos más 1

494
00:21:10,240 --> 00:21:15,589
y ahora ya más protegido imposible

495
00:21:15,589 --> 00:21:18,069
de null pointer exception, de index bound exception

496
00:21:18,069 --> 00:21:18,609
de todo

497
00:21:18,609 --> 00:21:28,960
¿vale? entonces

498
00:21:28,960 --> 00:21:31,019
si hago el máximo sin más

499
00:21:31,019 --> 00:21:33,500
pues bueno, me quedaba un método muy cortito

500
00:21:33,500 --> 00:21:35,660
ya está, si luego intento protegerlo

501
00:21:35,660 --> 00:21:37,559
de null pointer exception, de index bound, pues ya se va

502
00:21:37,559 --> 00:21:39,660
alargando, pero a ver, no pasa

503
00:21:39,660 --> 00:21:41,460
nada, se supone que todo esto lo sabemos

504
00:21:41,460 --> 00:21:43,119
hacer, ya tenemos soltura con ello

505
00:21:43,119 --> 00:21:46,880
entonces aquí simplemente hemos hecho

506
00:21:46,880 --> 00:21:49,839
revisamos

507
00:21:49,839 --> 00:21:52,279
pues que es null

508
00:21:52,279 --> 00:21:53,640
o su tamaño es cero

509
00:21:53,640 --> 00:21:56,000
no hay alumnos, devuelvo null

510
00:21:56,000 --> 00:21:58,779
y aviso para que el que me use

511
00:21:58,779 --> 00:22:00,500
vea la documentación

512
00:22:00,500 --> 00:22:02,819
porque si hace bien las cosas, cuando uno usa un método

513
00:22:02,819 --> 00:22:04,099
mira la documentación del método

514
00:22:04,099 --> 00:22:05,960
porque si no la mira, pues está usando la mal

515
00:22:05,960 --> 00:22:07,680
mira la documentación

516
00:22:07,680 --> 00:22:10,380
y dice

517
00:22:10,380 --> 00:22:13,099
ah, cuidado, este método me va a devolver null

518
00:22:13,099 --> 00:22:15,099
si no hay alumnos, téngalo yo en cuenta

519
00:22:15,099 --> 00:22:16,599
no vaya a ser que

520
00:22:16,599 --> 00:22:18,839
ahora el resultado de ese método

521
00:22:18,839 --> 00:22:20,359
llame a otra cosa y me diga

522
00:22:20,359 --> 00:22:22,119
no es point of exception, verifique yo que no es

523
00:22:22,119 --> 00:22:24,160
vale, pues esa parte

524
00:22:24,160 --> 00:22:25,200
primero ya la tendríamos

525
00:22:25,200 --> 00:22:27,740
a ver, ¿cómo os gusta más?

526
00:22:28,839 --> 00:22:30,420
¿con dos rayas o con una?

527
00:22:38,460 --> 00:22:39,779
pronunciados, con criterio

528
00:22:39,779 --> 00:22:45,279
es que con una es

529
00:22:45,279 --> 00:22:47,380
horroroso, os tendría que hacer daño a la vista

530
00:22:47,380 --> 00:22:49,099
porque con una sola

531
00:22:49,099 --> 00:22:50,299
¿qué ocurría?

532
00:22:50,940 --> 00:22:53,059
que la máquina virtual evalúa

533
00:22:53,059 --> 00:22:55,180
las dos sí o sí, da igual que le

534
00:22:55,180 --> 00:22:55,859
haga falta o no

535
00:22:55,859 --> 00:22:59,180
entonces, situación en la cual alumnos es null

536
00:22:59,180 --> 00:23:00,980
esto ya le da true

537
00:23:00,980 --> 00:23:03,480
como ya le da true, el or va a ser true

538
00:23:03,480 --> 00:23:04,680
no le haría falta entrar

539
00:23:04,680 --> 00:23:07,539
pero como solo hemos puesto una barrita

540
00:23:07,539 --> 00:23:08,859
voy a quitar el cursor de ahí

541
00:23:08,859 --> 00:23:11,900
como solo hemos puesto una barrita

542
00:23:11,900 --> 00:23:13,680
la máquina virtual se metía

543
00:23:13,680 --> 00:23:14,400
al segundo igual

544
00:23:14,400 --> 00:23:17,099
y entonces aquí ya le viene el null pointer escéptico

545
00:23:17,099 --> 00:23:19,599
y eso, entonces no hemos arreglado nada

546
00:23:19,599 --> 00:23:21,680
entonces ese or

547
00:23:21,680 --> 00:23:22,380
no nos gusta

548
00:23:22,380 --> 00:23:24,599
el or con una sola barrita

549
00:23:24,599 --> 00:23:27,339
nos gustaba, si nos interesa

550
00:23:27,339 --> 00:23:29,000
por alguna razón, que se hagan

551
00:23:29,000 --> 00:23:31,400
las dos cláusulas siempre

552
00:23:31,400 --> 00:23:32,299
siempre

553
00:23:32,299 --> 00:23:35,019
porque aquí además de esto se haga

554
00:23:35,019 --> 00:23:36,900
una lectura por teclado, lo que sea

555
00:23:36,900 --> 00:23:39,359
pero no es el caso, aquí si esta ya es true

556
00:23:39,359 --> 00:23:41,319
esta no queremos ni evaluarla

557
00:23:41,319 --> 00:23:43,259
porque ya el or true con cualquier cosa

558
00:23:43,259 --> 00:23:45,240
es true, no hace falta, no queremos evaluarla

559
00:23:45,240 --> 00:23:47,599
de hecho es que si la evaluamos da un nil puente de excepción

560
00:23:47,599 --> 00:23:49,039
entonces aquí

561
00:23:49,039 --> 00:23:50,980
aquí es mandatorio

562
00:23:50,980 --> 00:23:53,359
completamente hacerlo con doble bar

563
00:23:53,359 --> 00:23:55,759
con doble barra

564
00:23:55,759 --> 00:23:57,200
¿vale?

565
00:23:59,039 --> 00:24:00,319
entonces si alumnos es null

566
00:24:00,319 --> 00:24:02,279
esto ya es true, con lo cual la máquina

567
00:24:02,279 --> 00:24:03,160
virtual ya

568
00:24:03,160 --> 00:24:05,440
pasa del resto, pasa

569
00:24:05,440 --> 00:24:08,319
entonces no va a haber null.jit ni va a haber nada, pasa del resto

570
00:24:08,319 --> 00:24:10,380
y entonces ya saldría

571
00:24:10,380 --> 00:24:12,220
¿qué es diferente de null?

572
00:24:12,299 --> 00:24:14,000
y además el tamaño es diferente de 0

573
00:24:14,000 --> 00:24:16,200
porque si es diferente de null, aquí sí que se va a meter

574
00:24:16,200 --> 00:24:18,119
porque si es diferente de null, esto es falso

575
00:24:18,119 --> 00:24:20,019
entonces si esto es falso, falso

576
00:24:20,019 --> 00:24:22,019
or lo que sea, el resultado

577
00:24:22,019 --> 00:24:23,259
final depende de lo que sea

578
00:24:23,259 --> 00:24:25,220
entonces tiene que entrar aquí sí o sí

579
00:24:25,220 --> 00:24:27,660
que el tamaño es cero, no hay alumnos

580
00:24:27,660 --> 00:24:29,920
que no es cero, ahora ya es cuando entra aquí

581
00:24:29,920 --> 00:24:32,440
inicializa

582
00:24:32,440 --> 00:24:34,259
al primer alumno

583
00:24:34,259 --> 00:24:36,279
que tiene unas asignaturas

584
00:24:36,279 --> 00:24:37,099
diferentes de null

585
00:24:37,099 --> 00:24:39,200
y una vez que lo ha inicializado

586
00:24:39,200 --> 00:24:41,859
recorre el resto del array

587
00:24:41,859 --> 00:24:42,640
lo va recorriendo

588
00:24:42,640 --> 00:24:46,160
y para cada alumno que encuentre un alumno cuyas asignaturas

589
00:24:46,160 --> 00:24:48,059
su tamaño es superal

590
00:24:48,059 --> 00:24:49,839
de este otro, pues tiene un nuevo máximo

591
00:24:49,839 --> 00:24:51,859
y ya está, cuando hemos terminado

592
00:24:51,859 --> 00:24:53,079
ya tenemos el máximo aquí

593
00:24:53,079 --> 00:25:20,250
bueno, aún así

594
00:25:20,250 --> 00:25:22,930
hay otra situación, otro caso de prueba

595
00:25:22,930 --> 00:25:24,950
que si uno hace bien el testing

596
00:25:24,950 --> 00:25:27,150
le va a salir otro buf ahí

597
00:25:27,150 --> 00:25:29,509
hay otro buf ahí

598
00:25:29,509 --> 00:25:37,440
y es que todos los alumnos

599
00:25:37,440 --> 00:25:38,700
tengan

600
00:25:38,700 --> 00:25:41,119
asignaturas null, todos ellos

601
00:25:41,119 --> 00:25:45,700
porque entonces alumno max va a quedar inicializado a cero

602
00:25:45,700 --> 00:25:47,339
con lo cual

603
00:25:47,339 --> 00:25:48,839
el null puente va a salir aquí

604
00:25:48,839 --> 00:25:52,190
entonces

605
00:25:52,190 --> 00:26:13,750
Entonces de un código simple y sencillo que uno cree bien hecho lo que tenía que hacer, lo paso al equipo de pruebas. El equipo de pruebas se lo va a tirar porque en cuanto haga pruebas con casos de pruebas extraños, que no haya alumnos, que todos los alumnos no tengan asignaturas, que todo no sé qué, en cuanto haga pruebas con casos extraños le van a empezar a salir fallos.

606
00:26:13,750 --> 00:26:32,890
Por eso son tan importantes los equipos de prueba y se trabaja tanto en testing, porque uno siempre cree que lo que ha hecho está bien y está bien para los casos, para el funcionamiento normal, pero para los casos de pruebas extraños no está bien y arreglar esos bugs implica añadir muchas cosas, ¿vale?

607
00:26:32,890 --> 00:26:49,990
Pero bueno, nosotros en el examen no, repito, no vamos a pedir que comprobéis que para todos los casos funciona, para todos los casos, sino para el caso general, pues unos alumnos que existen con asignaturas y ya está, ¿vale?

608
00:26:49,990 --> 00:26:53,289
vale

609
00:26:53,289 --> 00:26:57,170
esto

610
00:26:57,170 --> 00:26:59,549
por si esto del máximo

611
00:26:59,549 --> 00:27:01,390
os angustia

612
00:27:01,390 --> 00:27:03,230
si fuera el alumno de más edad

613
00:27:03,230 --> 00:27:04,750
pues sería lo mismo

614
00:27:04,750 --> 00:27:07,609
vamos a hacer por ejemplo

615
00:27:07,609 --> 00:27:08,650
el alumno de más edad

616
00:27:08,650 --> 00:27:14,660
en este caso devolviendo el alumno enterito

617
00:27:14,660 --> 00:27:16,740
no solo el nombre

618
00:27:16,740 --> 00:27:25,599
vale, vamos a hacerlo sin

619
00:27:25,599 --> 00:27:27,960
proteger los casos raros para que no quede muy largo

620
00:27:27,960 --> 00:27:29,599
pues aquí

621
00:27:29,599 --> 00:27:30,859
lo mismo que hemos dicho antes

622
00:27:30,859 --> 00:27:33,599
vale, pues el alumno máximo

623
00:27:33,599 --> 00:27:34,859
el primero de todos

624
00:27:34,859 --> 00:27:41,380
venga, alumnos punto

625
00:27:41,380 --> 00:27:43,579
que es cero, este es el máximo

626
00:27:43,579 --> 00:27:45,680
el primero de todos, ya recorro los demás

627
00:27:45,680 --> 00:27:49,180
desde igual a

628
00:27:49,180 --> 00:27:51,359
cero, mientras si sea menor que alumnos

629
00:27:51,359 --> 00:27:52,880
punto

630
00:27:52,880 --> 00:27:54,480
seis, bla bla bla

631
00:27:54,480 --> 00:27:57,900
igual a uno

632
00:27:57,900 --> 00:28:02,690
pues ahora que hay que comparar

633
00:28:02,690 --> 00:28:05,829
hay que comparar si el alumno

634
00:28:05,829 --> 00:28:09,940
yésimo

635
00:28:09,940 --> 00:28:12,220
supera al alumno máximo

636
00:28:12,220 --> 00:28:13,880
pero en este caso lo supera en qué

637
00:28:13,880 --> 00:28:16,180
no en tamaño

638
00:28:16,180 --> 00:28:17,500
de su array de asignaturas

639
00:28:17,500 --> 00:28:18,880
sino lo supera en edad

640
00:28:18,880 --> 00:28:21,500
pues aquí será tan fácil como

641
00:28:21,500 --> 00:28:23,460
vale, pues comparo la edad

642
00:28:23,460 --> 00:28:25,480
si la edad de este

643
00:28:25,480 --> 00:28:26,759
resulta que es mayor

644
00:28:26,759 --> 00:28:29,880
que

645
00:28:29,880 --> 00:28:36,329
la edad de este

646
00:28:36,329 --> 00:28:38,369
pues ya tengo

647
00:28:38,369 --> 00:28:40,410
nuevo máximo, en este caso es el mismo

648
00:28:40,410 --> 00:28:42,170
algoritmo, el mismo

649
00:28:42,170 --> 00:28:53,799
y aquí devuelvo

650
00:28:53,799 --> 00:28:59,380
alumno max

651
00:28:59,380 --> 00:29:03,619
es el mismo

652
00:29:03,619 --> 00:29:04,559
el mismo algoritmo

653
00:29:04,559 --> 00:29:06,700
es el algoritmo de máximo de toda la vida

654
00:29:06,700 --> 00:29:09,720
pero aquí el criterio

655
00:29:09,720 --> 00:29:11,700
de maximizar, el criterio es

656
00:29:11,700 --> 00:29:13,599
que la edad sea mayor

657
00:29:13,599 --> 00:29:15,460
en el otro caso que el tamaño de las

658
00:29:15,460 --> 00:29:16,460
miniaturas, pues depende

659
00:29:16,460 --> 00:29:19,200
lo que cambia en el algoritmo de máximo es lo que

660
00:29:19,200 --> 00:29:20,900
comparamos entre ellos

661
00:29:20,900 --> 00:29:22,500
lo que les hace máximo

662
00:29:22,500 --> 00:29:25,079
en este les hace máximo la edad, pues por eso

663
00:29:25,079 --> 00:29:26,000
comparamos la edad

664
00:29:26,000 --> 00:29:28,539
en el de arriba les hacía máximo

665
00:29:28,539 --> 00:29:30,960
el número de asignaturas

666
00:29:30,960 --> 00:29:32,880
por eso comparábamos

667
00:29:32,880 --> 00:29:34,579
el size de asignaturas

668
00:29:34,579 --> 00:29:36,880
es lo único que cambia, que les hace máximo

669
00:29:36,880 --> 00:29:38,819
pero

670
00:29:38,819 --> 00:29:40,960
el algoritmo es el mismo siempre

671
00:29:40,960 --> 00:29:45,720
¿vale?

672
00:30:03,019 --> 00:30:04,720
vale, nos vamos a inventar otro método

673
00:30:04,720 --> 00:30:08,349
más, a ver

674
00:30:08,349 --> 00:30:10,630
que hagáis vosotros ahora, por ejemplo

675
00:30:10,630 --> 00:30:14,250
este, un método

676
00:30:14,250 --> 00:30:16,529
que dado un nombre de asignatura

677
00:30:16,529 --> 00:30:17,970
te diga

678
00:30:17,970 --> 00:30:19,690
cuantos alumnos hay matriculados

679
00:30:19,690 --> 00:30:22,529
puede ser un requisito

680
00:30:22,529 --> 00:30:24,789
que quiera satisfacer el tío que está en secretaría

681
00:30:24,789 --> 00:30:26,170
porque te dicen

682
00:30:26,170 --> 00:30:27,950
oye, ¿cuantos tengo matriculados en mates?

683
00:30:28,529 --> 00:30:30,089
para sacar copias de exámenes

684
00:30:30,089 --> 00:30:32,049
meto la asignatura, 15

685
00:30:32,049 --> 00:30:33,910
tienes 15, pues hago 15 copias

686
00:30:33,910 --> 00:30:35,769
15 copias, pues venga

687
00:30:35,769 --> 00:30:43,079
número de alumnos, matricula

688
00:30:43,079 --> 00:30:46,500
vamos a llamarlo

689
00:30:46,500 --> 00:30:47,700
matriculado para que sea más claro

690
00:30:47,700 --> 00:30:50,019
entonces, el parámetro de entrada

691
00:30:50,019 --> 00:30:52,500
el nombre

692
00:30:52,500 --> 00:30:53,180
de la asignatura

693
00:30:53,180 --> 00:30:59,420
y ahora tendrá que devolver un numerito entero

694
00:30:59,420 --> 00:31:02,799
que sea la cantidad de alumnos que hay matriculados

695
00:31:02,799 --> 00:31:05,140
de esa asignatura que yo le paso