Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 04-03-24 - 2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 6 de marzo de 2024 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues esto de nuevo, como ya desde hace varios meses, es un problema para el que ya tenemos un algoritmo que siempre usamos. 00:00:03
¿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. 00:00:17
Ese es el problema del máximo de algo 00:00:25
Tengo un conjunto de datos 00:00:28
Y tengo que recorrerlo 00:00:29
Para ver el que más hace patatín 00:00:31
Pues es justo esto 00:00:33
Eso lo resolvíamos 00:00:36
Con el algoritmo para calcular el máximo de algo 00:00:37
Igual que hemos hecho 00:00:40
Algoritmos de sumas acumulativas 00:00:42
De no sé qué, pues ese algoritmo también lo teníamos 00:00:43
Un conjunto de datos 00:00:45
El que más hace algo 00:00:47
¿Cómo era ese algoritmo en general? 00:00:48
Pues ese algoritmo en general era 00:00:53
aquí que queremos 00:00:55
el alumno que más 00:00:56
o sea el resultado máximo es un alumno 00:00:59
un alumno va a ser el que más 00:01:01
cumpla algo, lo que sea 00:01:03
en este caso tener más asignaturas 00:01:05
bueno pues aquí 00:01:07
el resultado final 00:01:08
lo podemos guardar 00:01:11
preparamos esta variable para guardar 00:01:14
el resultado final 00:01:17
el resultado final va a ser 00:01:17
el alumno que más cumpla una condición 00:01:19
la que sea 00:01:23
porque es el alumno con más asignaturas 00:01:24
luego mi resultado final 00:01:27
va a ser el alumno que más 00:01:29
cumpla algo, luego otra cosa es que el método 00:01:30
me devuelva solo el nombre, bueno luego en el método 00:01:33
yo hago el retun 00:01:35
luego en el método yo hago el retun 00:01:36
solo del nombre 00:01:41
y ya está, pero bueno podría ser que el método 00:01:42
me dijera que devolvía al alumno completo 00:01:45
da igual, bueno pues entonces 00:01:47
está claro, tengo que recorrer 00:01:49
una colección de alumnos para ver el que más 00:01:51
cumple algo, luego el resultado final 00:01:53
va a ser un alumno, el que más cumple algo, ¿vale? 00:01:55
Pues esta variable se queda aquí preparada para eso. 00:01:58
Ahora, ¿cómo hacíamos esto? 00:02:01
¿Cómo programamos el algoritmo de máximo de algo? 00:02:04
Pues primero, asumíamos que el máximo inicial 00:02:08
era el primero de todos. 00:02:12
El primero de todos es el máximo inicial. 00:02:14
Y ahora recorríamos todos los demás, uno por uno. 00:02:16
En cuanto encontrábamos uno que superaba a ese, 00:02:20
teníamos nuevo máximo. 00:02:23
Ese es el algoritmo. 00:02:25
¿vale? o sea el máximo inicial 00:02:26
es el primero de todos 00:02:28
y ahora recorro los demás 00:02:30
¿este supera el primero? tengo nuevo máximo 00:02:32
me voy al siguiente 00:02:35
¿este lo supera? no, pues nada 00:02:37
me voy al siguiente, ¿este lo supera? tengo nuevo máximo 00:02:38
así era el algoritmo 00:02:41
y cuando ya habíamos terminado de recorrer todo 00:02:42
en esa variable 00:02:45
se había quedado el máximo 00:02:46
esa era la idea ¿no? 00:02:48
repito 00:02:52
buscamos el objeto que más 00:02:52
cumple algo 00:02:54
una variable para él 00:02:55
porque es el resultado final 00:02:57
una variable para él 00:02:59
ahora, esa variable se inicializa al primero de todos 00:03:00
y ahora ya voy con los demás 00:03:03
este supera a este 00:03:05
nuevo, para aquí 00:03:07
sigo, este supera a este 00:03:09
nuevo, para aquí, sigo 00:03:11
ese es el algoritmo, pues vamos a programar eso 00:03:12
vale, pues entonces 00:03:15
inicialmente 00:03:18
el máximo inicial 00:03:19
es el primero de todos 00:03:22
vale, el primero de todos, ¿cuál es? 00:03:23
el primero de todos es 00:03:26
alumnos.getDeCero 00:03:27
¿verdad? 00:03:32
ups, vale 00:03:33
este es el primer alumno de todos 00:03:41
pues ese es el máximo inicial 00:03:43
el que más asignaturas tiene 00:03:46
y ahora vamos a recorrer el resto 00:03:48
a ver si alguno supera a ese 00:03:50
pues venga, recorremos el resto 00:03:52
¿cómo lo recorremos? 00:03:56
pues desde i igual a 1 00:03:58
porque el 0 00:04:00
ya lo tengo 00:04:01
desde igual a 1 00:04:03
mientras i sea menor que 00:04:04
alumnos.size 00:04:06
incrementando i 00:04:10
con esto recorro todos 00:04:12
y ahora 00:04:15
¿qué hago con cada uno de ellos? 00:04:16
pues si alumnos.get i 00:04:21
supera 00:04:22
si este 00:04:27
supera a este 00:04:29
tengo nuevo máximo 00:04:30
y ahora es cuando tenemos que pensar 00:04:32
¿qué significa que éste supere a éste? 00:04:34
¿Qué significa? 00:04:37
Pues en nuestro caso 00:04:38
que le supere el número de asignaturas. 00:04:39
Podría ser en otra cosa 00:04:43
que hubiera dicho el alumno 00:04:44
de mayor edad. 00:04:45
Pues entonces aquí tendría que compararlos por edad. 00:04:48
A éste con el máximo. 00:04:50
Pero me han dicho el de más asignaturas. 00:04:53
Luego tendría que comparar 00:04:55
el número de asignaturas de éste 00:04:56
con el número de asignaturas de éste. 00:04:57
Si lo supera, tengo nuevo máximo. 00:05:00
vale, el número de asignaturas de este 00:05:02
¿cómo es? pues facilísimo de encontrar 00:05:04
porque yo me saco 00:05:06
array de asignaturas 00:05:10
su list de asignaturas 00:05:14
y me saco su tamaño 00:05:15
luego este es el número de asignaturas de este 00:05:17
pues si el número 00:05:20
de asignaturas de este es mayor 00:05:22
que el número de asignaturas 00:05:24
de este, tengo un nuevo máximo 00:05:26
que es este de aquí, y a correr 00:05:28
sigo con el siguiente 00:05:29
y ya está, ya he programado ese algoritmo 00:05:31
pues entonces 00:05:33
es mayor 00:05:35
voy a poner el, aunque quede feo 00:05:36
el mayor 00:05:39
aquí debajo para que se vea 00:05:41
pues si es mayor que 00:05:43
alumno máximo 00:05:45
punto get asignaturas 00:05:49
punto size 00:05:51
pues si las asignaturas 00:05:53
del de posición y 00:05:57
son más que las asignaturas 00:05:59
del que es máximo hasta ese 00:06:02
momento, tengo nuevo máximo. 00:06:03
Pues venga, tengo nuevo máximo que sustituye 00:06:07
al anterior, que es este. 00:06:10
Y ala, programado el algoritmo, terminado. 00:06:16
Como lo hemos hecho siempre. 00:06:19
Es el objeto que más 00:06:21
cumple algo. 00:06:24
Que más cumple algo dentro de una colección de objetos. 00:06:25
No da igual que sea un array, lo que sea. 00:06:28
Resultado final irá 00:06:31
a una variable. 00:06:32
Esa variable inicialmente es la del primero de todos. 00:06:33
Y ahora recorro los demás. 00:06:35
En cuanto encuentre uno que supera al que es máximo, 00:06:38
tengo nuevo máximo. 00:06:42
Y sigo. 00:06:43
Entonces, cuando este bucle termine, 00:06:45
pues como ya vimos esto en la primera evaluación 00:06:47
y lo explicamos, cuando este bucle termine, 00:06:50
pues ¿qué habrá en alumno máximo? 00:06:52
Habrá de todos estos el que tenía más asignaturas. 00:06:54
Eso es lo que habrá. 00:06:58
Porque ese es el que se habrá quedado aquí. 00:06:59
Ese es el que se habrá quedado aquí. 00:07:01
De todos los que he recorrido, 00:07:02
el que tenga más, ese es el que se habrá quedado ahí 00:07:04
luego una vez terminado el for 00:07:07
el for termina aquí, no he puesto 00:07:08
llaves porque solo quiero la sentencia if 00:07:11
dentro 00:07:13
una vez llegados ahí, sé que en alumno máximo 00:07:13
tengo el alumno con más asignaturas 00:07:17
vale, como me han pedido que devuelva el nombre 00:07:18
solamente 00:07:21
bueno, pues devuelvo solamente el nombre 00:07:22
alumno máximo punto 00:07:25
getNombre, vale, ya tengo 00:07:29
el método hecho 00:07:32
vamos a ahorrarle una línea 00:07:33
así 00:07:36
para que se vea todo junto 00:07:38
vale, lo declaro, lo inicializo 00:07:40
al primero 00:07:43
recorro los demás 00:07:45
en cuanto alguno supera el número de asignaturas 00:07:47
y efectivamente 00:07:49
no necesita parámetros 00:07:57
así que 00:07:58
eso fuera 00:07:59
vale, entonces no olvidéis nada de todo lo que hemos visto 00:08:01
porque es necesario usarlo todo el rato 00:08:09
tenemos que saber hacer los máximos de algo 00:08:12
aquí otra vez lo de siempre 00:08:15
si uno mira esto y dice 00:08:21
uff, como el array de alumnos 00:08:22
este es inicializar, el que llame 00:08:25
al método lo lleva, claro, porque le va a salir 00:08:27
un null pointer de step y se va a parar la aplicación 00:08:29
entonces, hombre 00:08:31
efectivamente 00:08:32
pues 00:08:35
este método está un poquito 00:08:36
desprotegido 00:08:38
hombre, si lo queremos proteger un poquito 00:08:39
Pues estaría bien hacer esto 00:08:42
Si alumnos 00:08:46
Es igual a null 00:08:51
Pues entonces 00:08:52
Podríamos avisar 00:08:57
Así 00:09:00
No hay alumnos 00:09:01
Y en ese caso ya salir del método 00:09:04
¿Vale? 00:09:07
Pero aquí sí que tenemos que devolver algo 00:09:10
Porque el método devuelve un string si o si 00:09:12
Aquí no se puede poner de tu un punto pelota 00:09:14
Hay que devolver algo 00:09:17
Pero aquí lo natural sería devolver null 00:09:17
no hay nada que devolver, devuelvo null 00:09:20
devuelvo null 00:09:22
lo que pasa es que hombre, entonces 00:09:26
por favor 00:09:28
avisemos aquí 00:09:30
si el método no 00:09:31
o sea, si no hay alumnos, devolverá null 00:09:35
avisemos aquí, para que el que 00:09:38
use el método vea en la ayuda 00:09:40
que esto puede devolver null 00:09:41
no vaya a ser que al que le salga el null pointer 00:09:43
este es el que llama a ese 00:09:45
vale, entonces aquí 00:09:46
cuidadín 00:09:52
Haríamos una documentación 00:09:58
Donde pondríamos 00:10:01
Devuelve a uno con más asignaturas 00:10:01
El alumno, no el nombre 00:10:03
Y return, y aquí pondríamos 00:10:10
Null 00:10:17
Si no hay alumnos 00:10:18
Null si no hay alumnos 00:10:20
Entonces el que nos use 00:10:24
Dirá, uy, cuidado 00:10:26
Si yo llamo al método 00:10:27
Y no hay alumnos, no pasa nada 00:10:30
No hay un null pointer exception 00:10:32
Pero él me va a devolver null 00:10:33
Cuidado, no vaya yo a usar ese objeto 00:10:34
es la forma de comunicarse 00:10:38
avisar, decir, si no hay alumnos te devuelvo 00:10:42
porque es que no tengo nombre que devolverte 00:10:44
vale, pues bueno 00:10:47
digamos que son las dinámicas 00:10:55
de programación 00:10:58
estas son las diferentes dinámicas 00:10:59
a las que os tenéis que acostumbrar 00:11:01
vale, aún así 00:11:03
bueno, seguimos siendo el jefe 00:11:06
que vemos este método 00:11:11
¿le haríamos algún otro comentario? 00:11:12
¿Algún otro comentario le haríais sobre este método? 00:11:22
Este método, tampoco te creas que es muy, muy, muy... 00:11:26
¿Alguna cosa más se podría pulir? 00:11:29
¿No os ocurre algún comentario más que hacerle? 00:11:34
A ver, puede ocurrir que alumnos no sean NULL, 00:11:40
pero no haya ninguno dentro. 00:11:45
Es decir, una lista, 00:11:47
y una RAI, cualquier colección, 00:11:48
en realidad tiene tres situaciones distintas. 00:11:50
Una, ser NULL, o sea, no existir, ser NULL. 00:11:52
Otra, existir, pero no tener nada. 00:11:55
y otra 00:11:57
existir y tener elementos 00:11:58
¿verdad? son tres situaciones distintas 00:12:00
bueno, pues si la lista existe y no tiene 00:12:02
nada, porque la hemos inicializado, new linked list 00:12:05
y ya está, existe y no tiene nada 00:12:07
no va a ser null 00:12:09
no va a ser null, pero claro 00:12:10
al irse aquí y buscar el 00:12:13
primero, nos va 00:12:15
a una excepción, nos va a una 00:12:17
excepción de tipo index bound exception 00:12:18
me dice, oye, que en la 0 no hay nadie 00:12:21
la lista no es null 00:12:22
luego aquí llegamos 00:12:25
y esto no da null pointer exception 00:12:26
null pointer exception no da 00:12:28
porque alumnos no es null, no da null pointer exception 00:12:29
pero da index bound exception 00:12:32
me dice, eh, tratas de hacer 00:12:35
una posición en la que no hay nadie 00:12:36
lo que nos pasaba con un array 00:12:38
si tenía tres posiciones y empezamos a hacer a la cuatro 00:12:40
nos decían, a la cuatro no hay nada 00:12:42
pues si la lista existe, no es null 00:12:44
pero no tiene nada dentro 00:12:46
la posición get0 no existe 00:12:48
get0 es la primera 00:12:51
si no hay ni primera 00:12:52
pues aquí saldría un index bound exception 00:12:53
entonces esto 00:12:56
lo podríamos proteger 00:12:57
mucho mejor así 00:13:00
si alumnos es igual a null 00:13:01
vale, no es null 00:13:04
pero 00:13:07
alumnos.size es igual a 0 00:13:07
que son dos cosas distintas 00:13:11
una cosa es que alumnos sea null 00:13:14
y otra cosa es que no lo sea 00:13:17
pero que su tamaño sea 0 00:13:18
es distinto 00:13:21
si su tamaño es cero no queremos bajar aquí 00:13:22
no queremos bajar aquí porque esto nos dará 00:13:25
un index bound exceso, no queremos bajar ahí 00:13:27
vale, entonces ahora esto ya 00:13:29
ya sí que quedaría bonito 00:13:35
¿le seguiríais haciendo algún otro comentario 00:13:37
al que hizo este método? 00:14:02
claro 00:14:06
el array tiene alumnos 00:14:07
estupendo, y ahora empezamos 00:14:10
a comparar las asignaturas 00:14:12
el tamaño del array 00:14:14
si hay algún alumno que no tenga ninguna 00:14:15
porque no se le ha matriculado de ninguna 00:14:18
todavía y además es null 00:14:19
esa lista es null 00:14:22
el null pointer exception va a salir aquí 00:14:23
aquí no va a salir 00:14:26
el null pointer exception porque ya hemos visto 00:14:28
que alumno ni es null ni tiene tamaño 0 00:14:30
luego este for no me va a dar 00:14:33
aquí null pointer exception 00:14:34
pero aquí si me lo puede dar 00:14:35
entonces si ya lo queremos 00:14:38
dejar hiper mega arreglado 00:14:40
hiper mega arreglado 00:14:42
pues podríamos hacer 00:14:44
Si alumnos, etiquetas y naturas es diferente de null y entonces ya se quedaría hipermega arregladísimo. 00:14:47
Entonces aquí lo ideal sería comparar solo con los alumnos que realmente es diferente de null. 00:14:59
y siendo 00:15:18
diferente de null 00:15:24
siendo diferente de null 00:15:25
ahora ya no es null, luego puedo ver su tamaño 00:15:29
su tamaño, que puede ser cero 00:15:32
ahí no me importa que sea cero 00:15:34
el número de asignaturas es mayor 00:15:35
que las de este 00:15:37
¿vale? entonces esto es bueno 00:15:39
para que vayáis viendo un poco las cosas en el examen 00:15:46
lo indicaremos 00:15:49
de todas maneras, pero 00:15:51
la idea no es que tengáis que 00:15:52
protegeros de cualquier situación de null 00:15:55
no es la idea, no es necesario 00:15:58
que tengáis que hacer los códigos 00:16:02
de manera que os protejáis de cualquier caso especial 00:16:04
no, simplemente 00:16:06
el código que funcione, que esté bien hecho 00:16:08
que recorra, que haga lo que tenga que hacer 00:16:10
no hace falta verificar que para cualquier 00:16:11
caso especial no va a salir un pointer excepto 00:16:14
no va a salir, pero eso no significa 00:16:16
que no tengáis que ser conscientes de ello 00:16:18
porque una cosa es el examen 00:16:20
y otra cosa es aprender 00:16:22
y de hecho aquí este ni siquiera 00:16:23
estaría del todo protegido este código 00:16:33
porque puñetera mala suerte 00:16:35
si el primer alumno de la colección 00:16:37
ese, sus asignaturas es nul 00:16:39
si ese es nul 00:16:41
me va a salir por aquí, cuando comparo 00:16:43
con el primero de todos 00:16:45
entonces tendríamos que coger como alumno 00:16:46
máximo el primero 00:16:49
que sus asignaturas no es nul 00:16:50
entonces ya sí que se quedaría 00:16:52
protegido de cualquier inclemencia 00:16:55
este código 00:16:56
¿entendéis la problemática que os digo? 00:16:59
yo aquí he cogido el primero 00:17:01
es el máximo 00:17:03
me voy a comparar con todos los demás 00:17:04
si alguno, su número de asignaturas 00:17:07
cuando existe es mayor 00:17:09
que el número de asignaturas 00:17:11
del que es máximo hasta ese momento 00:17:12
pero claro, si el que he cogido de partida 00:17:15
ya ese tiene null 00:17:17
entonces aquí habría que sustituir 00:17:18
este por un for 00:17:21
que estuviera 00:17:22
avanzando hasta que encontrara 00:17:25
un alumno y diferente 00:17:27
de null 00:17:29
para practicar programación vamos a hacerlo 00:17:30
pero no es la idea del examen, insisto 00:17:34
¿qué queremos hacer aquí? 00:17:36
queremos inicializar alumnos 00:17:40
alumno máximo al primer alumno que tenga 00:17:43
una RAI de asignatura es diferente de null 00:17:46
inicializamos alumno max 00:17:48
al primer 00:17:54
alumno 00:17:57
de la lista 00:18:00
cuya 00:18:02
lista de asignaturas 00:18:10
sea 00:18:14
nul 00:18:15
eso es lo que queremos aquí 00:18:17
no inicializar al primero sin más 00:18:20
no al primero sin más 00:18:22
sino al primero cuya lista no sea nul 00:18:23
y a partir de ahí ya recorrer para hacerlo del máximo 00:18:26
los que eran nul pasamos de ellos 00:18:29
no van a ser del máximo en cualquier caso 00:18:30
inicializar al primero cuya lista de asignaturas no sea nul 00:18:32
bueno pues aquí podemos hacer 00:18:35
un for 00:18:36
vamos a quedarnos 00:18:38
inicialmente una posición 00:18:40
esta es la posición inicial 00:18:42
y le vamos a ir avanzando 00:18:44
mientras 00:18:46
y podemos hacer 00:18:48
por ejemplo así si lo veis más claro 00:18:51
mientras 00:18:54
alumnos.get 00:18:55
.get 00:19:00
asignaturas 00:19:04
get asignaturas 00:19:06
sea igual a nul 00:19:09
y más más. 00:19:12
¡Hala! 00:19:16
Este bucle 00:19:17
y me falta el punto y coma en el c. 00:19:18
Espera, no voy a llamarla i 00:19:23
para no confundir con la de abajo. 00:19:25
La voy a llamar pos, 00:19:27
pos y pos. 00:19:33
Vale. 00:19:34
Entonces, con el punto y coma. 00:19:37
Vale, este bucle 00:19:42
va avanzando posición 00:19:43
mientras 00:19:46
el alumno de la lista 00:19:47
sus asignaturas sean null 00:19:50
lo va avanzando 00:19:52
en cuanto ya se encuentre uno 00:19:53
que su array de asignaturas no es null 00:19:55
no es null, ahí ya pues se queda parado 00:19:58
vale 00:20:00
pues entonces 00:20:02
ahora ya si podemos hacer esto 00:20:04
alumno 00:20:06
max igual a 00:20:14
alumnos.get 00:20:19
de posición 00:20:23
ahí ya lo dejo 00:20:24
y ahora este for cambia 00:20:27
¿en qué cambio este for? que tengo que cambiar aquí 00:20:37
¿en qué línea cambio algo? 00:20:39
¿y qué cambio? 00:20:46
en esta línea ¿no? cambio algo 00:20:49
¿eh? 00:20:50
desde cero 00:20:53
¿desde cero? 00:20:54
desde pos más uno 00:20:57
me he colocado en el pos 00:20:59
y ahora desde él 00:21:01
empiezo a trabajar desde él 00:21:03
pues desde igual a 00:21:05
pos más 1 00:21:07
y ahora ya más protegido imposible 00:21:10
de null pointer exception, de index bound exception 00:21:15
de todo 00:21:18
¿vale? entonces 00:21:18
si hago el máximo sin más 00:21:28
pues bueno, me quedaba un método muy cortito 00:21:31
ya está, si luego intento protegerlo 00:21:33
de null pointer exception, de index bound, pues ya se va 00:21:35
alargando, pero a ver, no pasa 00:21:37
nada, se supone que todo esto lo sabemos 00:21:39
hacer, ya tenemos soltura con ello 00:21:41
entonces aquí simplemente hemos hecho 00:21:43
revisamos 00:21:46
pues que es null 00:21:49
o su tamaño es cero 00:21:52
no hay alumnos, devuelvo null 00:21:53
y aviso para que el que me use 00:21:56
vea la documentación 00:21:58
porque si hace bien las cosas, cuando uno usa un método 00:22:00
mira la documentación del método 00:22:02
porque si no la mira, pues está usando la mal 00:22:04
mira la documentación 00:22:05
y dice 00:22:07
ah, cuidado, este método me va a devolver null 00:22:10
si no hay alumnos, téngalo yo en cuenta 00:22:13
no vaya a ser que 00:22:15
ahora el resultado de ese método 00:22:16
llame a otra cosa y me diga 00:22:18
no es point of exception, verifique yo que no es 00:22:20
vale, pues esa parte 00:22:22
primero ya la tendríamos 00:22:24
a ver, ¿cómo os gusta más? 00:22:25
¿con dos rayas o con una? 00:22:28
pronunciados, con criterio 00:22:38
es que con una es 00:22:39
horroroso, os tendría que hacer daño a la vista 00:22:45
porque con una sola 00:22:47
¿qué ocurría? 00:22:49
que la máquina virtual evalúa 00:22:50
las dos sí o sí, da igual que le 00:22:53
haga falta o no 00:22:55
entonces, situación en la cual alumnos es null 00:22:55
esto ya le da true 00:22:59
como ya le da true, el or va a ser true 00:23:00
no le haría falta entrar 00:23:03
pero como solo hemos puesto una barrita 00:23:04
voy a quitar el cursor de ahí 00:23:07
como solo hemos puesto una barrita 00:23:08
la máquina virtual se metía 00:23:11
al segundo igual 00:23:13
y entonces aquí ya le viene el null pointer escéptico 00:23:14
y eso, entonces no hemos arreglado nada 00:23:17
entonces ese or 00:23:19
no nos gusta 00:23:21
el or con una sola barrita 00:23:22
nos gustaba, si nos interesa 00:23:24
por alguna razón, que se hagan 00:23:27
las dos cláusulas siempre 00:23:29
siempre 00:23:31
porque aquí además de esto se haga 00:23:32
una lectura por teclado, lo que sea 00:23:35
pero no es el caso, aquí si esta ya es true 00:23:36
esta no queremos ni evaluarla 00:23:39
porque ya el or true con cualquier cosa 00:23:41
es true, no hace falta, no queremos evaluarla 00:23:43
de hecho es que si la evaluamos da un nil puente de excepción 00:23:45
entonces aquí 00:23:47
aquí es mandatorio 00:23:49
completamente hacerlo con doble bar 00:23:50
con doble barra 00:23:53
¿vale? 00:23:55
entonces si alumnos es null 00:23:59
esto ya es true, con lo cual la máquina 00:24:00
virtual ya 00:24:02
pasa del resto, pasa 00:24:03
entonces no va a haber null.jit ni va a haber nada, pasa del resto 00:24:05
y entonces ya saldría 00:24:08
¿qué es diferente de null? 00:24:10
y además el tamaño es diferente de 0 00:24:12
porque si es diferente de null, aquí sí que se va a meter 00:24:14
porque si es diferente de null, esto es falso 00:24:16
entonces si esto es falso, falso 00:24:18
or lo que sea, el resultado 00:24:20
final depende de lo que sea 00:24:22
entonces tiene que entrar aquí sí o sí 00:24:23
que el tamaño es cero, no hay alumnos 00:24:25
que no es cero, ahora ya es cuando entra aquí 00:24:27
inicializa 00:24:29
al primer alumno 00:24:32
que tiene unas asignaturas 00:24:34
diferentes de null 00:24:36
y una vez que lo ha inicializado 00:24:37
recorre el resto del array 00:24:39
lo va recorriendo 00:24:41
y para cada alumno que encuentre un alumno cuyas asignaturas 00:24:42
su tamaño es superal 00:24:46
de este otro, pues tiene un nuevo máximo 00:24:48
y ya está, cuando hemos terminado 00:24:49
ya tenemos el máximo aquí 00:24:51
bueno, aún así 00:24:53
hay otra situación, otro caso de prueba 00:25:20
que si uno hace bien el testing 00:25:22
le va a salir otro buf ahí 00:25:24
hay otro buf ahí 00:25:27
y es que todos los alumnos 00:25:29
tengan 00:25:37
asignaturas null, todos ellos 00:25:38
porque entonces alumno max va a quedar inicializado a cero 00:25:41
con lo cual 00:25:45
el null puente va a salir aquí 00:25:47
entonces 00:25:48
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. 00:25:52
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? 00:26:13
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? 00:26:32
vale 00:26:49
esto 00:26:53
por si esto del máximo 00:26:57
os angustia 00:26:59
si fuera el alumno de más edad 00:27:01
pues sería lo mismo 00:27:03
vamos a hacer por ejemplo 00:27:04
el alumno de más edad 00:27:07
en este caso devolviendo el alumno enterito 00:27:08
no solo el nombre 00:27:14
vale, vamos a hacerlo sin 00:27:16
proteger los casos raros para que no quede muy largo 00:27:25
pues aquí 00:27:27
lo mismo que hemos dicho antes 00:27:29
vale, pues el alumno máximo 00:27:30
el primero de todos 00:27:33
venga, alumnos punto 00:27:34
que es cero, este es el máximo 00:27:41
el primero de todos, ya recorro los demás 00:27:43
desde igual a 00:27:45
cero, mientras si sea menor que alumnos 00:27:49
punto 00:27:51
seis, bla bla bla 00:27:52
igual a uno 00:27:54
pues ahora que hay que comparar 00:27:57
hay que comparar si el alumno 00:28:02
yésimo 00:28:05
supera al alumno máximo 00:28:09
pero en este caso lo supera en qué 00:28:12
no en tamaño 00:28:13
de su array de asignaturas 00:28:16
sino lo supera en edad 00:28:17
pues aquí será tan fácil como 00:28:18
vale, pues comparo la edad 00:28:21
si la edad de este 00:28:23
resulta que es mayor 00:28:25
que 00:28:26
la edad de este 00:28:29
pues ya tengo 00:28:36
nuevo máximo, en este caso es el mismo 00:28:38
algoritmo, el mismo 00:28:40
y aquí devuelvo 00:28:42
alumno max 00:28:53
es el mismo 00:28:59
el mismo algoritmo 00:29:03
es el algoritmo de máximo de toda la vida 00:29:04
pero aquí el criterio 00:29:06
de maximizar, el criterio es 00:29:09
que la edad sea mayor 00:29:11
en el otro caso que el tamaño de las 00:29:13
miniaturas, pues depende 00:29:15
lo que cambia en el algoritmo de máximo es lo que 00:29:16
comparamos entre ellos 00:29:19
lo que les hace máximo 00:29:20
en este les hace máximo la edad, pues por eso 00:29:22
comparamos la edad 00:29:25
en el de arriba les hacía máximo 00:29:26
el número de asignaturas 00:29:28
por eso comparábamos 00:29:30
el size de asignaturas 00:29:32
es lo único que cambia, que les hace máximo 00:29:34
pero 00:29:36
el algoritmo es el mismo siempre 00:29:38
¿vale? 00:29:40
vale, nos vamos a inventar otro método 00:30:03
más, a ver 00:30:04
que hagáis vosotros ahora, por ejemplo 00:30:08
este, un método 00:30:10
que dado un nombre de asignatura 00:30:14
te diga 00:30:16
cuantos alumnos hay matriculados 00:30:17
puede ser un requisito 00:30:19
que quiera satisfacer el tío que está en secretaría 00:30:22
porque te dicen 00:30:24
oye, ¿cuantos tengo matriculados en mates? 00:30:26
para sacar copias de exámenes 00:30:28
meto la asignatura, 15 00:30:30
tienes 15, pues hago 15 copias 00:30:32
15 copias, pues venga 00:30:33
número de alumnos, matricula 00:30:35
vamos a llamarlo 00:30:43
matriculado para que sea más claro 00:30:46
entonces, el parámetro de entrada 00:30:47
el nombre 00:30:50
de la asignatura 00:30:52
y ahora tendrá que devolver un numerito entero 00:30:53
que sea la cantidad de alumnos que hay matriculados 00:30:59
de esa asignatura que yo le paso 00:31:02
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
6 de marzo de 2024 - 12:19
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
31′ 11″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
130.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid