Saltar navegación

20250217 SolucionExamenCursoPasado - 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 17 de febrero de 2025 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos, venga, examen año pasado. 00:00:00
Vale, entonces, por supuesto, será importante entender el enunciado. 00:00:08
Escuchadme, porque los enunciados son largos, claro, porque tienen que describir una situación que ahora es un poquito más compleja. 00:00:18
A ver, ¿me está escuchando alguien o me pongo a gritaros? 00:00:26
Vale, entonces como ahora son varias clases, la situación es un poquito más compleja de describir o más larga de describir, entonces los enunciados son más largos. 00:00:32
Pero enunciados largos, resoluciones cortas, se trata de seleccionar lo que haya que seleccionar, la estructura que hay que seleccionar, recorrer lo que haya que recorrer, poco más. 00:00:41
¿vale? entonces, al principio 00:00:49
os leeré el enunciado 00:00:52
para que quede claro y lo hayáis entendido bien 00:00:54
porque lo que no tenéis que hacer es poneros a 00:00:56
programar y hacer cosas sin entender lo que 00:00:58
hay que hacer, porque si habéis entendido 00:01:00
bien lo que hay que hacer, se hace en nada 00:01:02
si no lo habéis entendido y os ponéis 00:01:04
a dar vueltas, pues sí, os estáis 00:01:06
efectivamente las dos horas, ¿vale? entonces 00:01:08
lo leeremos al principio para que todo el mundo tenga claro 00:01:10
lo que tiene que hacer, bueno, pues esto es igual 00:01:12
uno ve este enunciado y dice, uy, que enunciado más largo 00:01:14
estos son cuatro tonterías 00:01:16
vale, pues venga, enunciado 00:01:17
un mundo mágico de color 00:01:19
existen criaturas místicas, vale 00:01:22
pues vamos a modelar esas criaturas 00:01:23
vale, pues 00:01:26
habrá una interfaz poder místico 00:01:28
que todos los que la implementen podrán activar poder 00:01:29
bueno, entonces 00:01:32
una clase abstracta 00:01:33
criatura mística que además 00:01:35
podrá activar el poder 00:01:37
o lo que es lo mismo, implementa la interfaz 00:01:39
poder místico, vale 00:01:41
la clase abstracta además 00:01:43
sabéis que puede tener atributos, pues tiene nombre, edad 00:01:45
y un método abstracto 00:01:47
que se queda implementado con estos de aquí. 00:01:48
Vale, es que fijaos, o sea, ya con 00:01:52
esto que os he dicho, ya son cuatro 00:01:53
puntos de este ejercicio. 00:01:55
¿Cuatro puntos sobre 00:01:56
diez del ejercicio? Pero este 00:01:59
es la mitad. 00:02:01
Claro, aún así, es como si... 00:02:02
Vale, entonces, bueno, pues 00:02:05
entonces 00:02:07
vosotros veis y decís 00:02:08
¡qué fácil! Pues lo de mañana 00:02:11
será similar. Y sin embargo, lo de mañana 00:02:13
me montaréis un pollo 00:02:15
y diréis, vaya saber horroroso 00:02:16
cuando será lo mismo 00:02:19
¿vale? 00:02:20
claro 00:02:24
claro, pues por eso 00:02:25
haz que el programa 00:02:27
traduzca este texto en arameo 00:02:29
claro 00:02:31
arameo 00:02:34
venga, pues ala 00:02:35
vamos a hacer 00:02:43
Interfaz examen 00:02:43
Interfaz poder místico 00:02:47
New 00:02:48
Interfaz 00:02:50
Poder místico 00:02:52
Poder místico 00:02:54
Los que implementen 00:02:57
Poder místico 00:03:01
¿Qué tienen que implementar? 00:03:02
Activar poder 00:03:04
No hay ni que poner 00:03:05
El public porque ya sabéis que una interfaz 00:03:08
A ver, bueno, en realidad es porque 00:03:12
Por defecto son todos públicos 00:03:20
O sea, si tú pones public 00:03:22
Es como si no 00:03:23
Ponerlo y no ponerlo es lo mismo 00:03:28
Por defecto son públicos 00:03:30
Porque están pensados para que gente del exterior los implemente 00:03:31
Por defecto son publicos 00:03:34
No, en las interfaces 00:03:36
En las interfaces no 00:03:37
En las interfaces son públicos todos 00:03:39
no hay alternativas, son públicos 00:03:41
con lo cual da igual que lo pongas o que no lo pongas 00:03:43
¿por qué? porque están pensados en realidad 00:03:44
las interfaces para que los implementen 00:03:47
ajenos, de otros paquetes 00:03:49
bueno, el ajeno lo va a sobrescribir 00:03:51
con lo cual no puede cambiarlo, para el ajeno será public 00:03:55
porque es ese, dime 00:03:57
hombre, si no pones void es un método muy mal hecho 00:03:58
pero ¿cómo vas a poder no ponerlo? 00:04:02
cualquier método 00:04:08
o devuelve algo o devuelve Void. 00:04:09
Vale. 00:04:12
Con lo cual es que... 00:04:13
A ver, como aquí no especificamos nada... 00:04:16
Vale, criatura mística. 00:04:23
Pues venga. 00:04:26
La criatura mística es una clase. 00:04:27
Vale, la criatura mística... 00:04:38
implementa 00:04:41
no, la interfaz que se llama 00:04:43
poder místico, perdón 00:04:47
implementa poder místico 00:04:48
con lo cual al implementar poder místico 00:04:53
tienes que hacer el método 00:04:55
entonces como estamos así en plan rápido 00:04:58
luego según vayamos avanzando en el enunciado 00:05:00
vamos a ver que pongo ahí dentro 00:05:02
pero que lo tengo que implementar, eso está claro 00:05:04
vale, entonces 00:05:06
la clase abstracta 00:05:08
además tiene nombre y edad 00:05:11
y describir catura 00:05:13
con la información básica. Pues venga. 00:05:15
La clase abstracta 00:05:17
pues le vamos a poner nombre y edad. 00:05:19
Justo eso iba a decir. Que como ya 00:05:28
una clase abstracta 00:05:30
siempre está pensada para edad de ella, 00:05:31
siempre, pues efectivamente ya de partida 00:05:34
le pongamos 00:05:36
protector. ¿Vale? 00:05:37
nadie jamás ha dicho eso 00:05:42
tonto no 00:05:46
charlatán un rato 00:05:47
venga 00:05:49
vale pues ya está 00:05:53
dígame 00:05:54
a ver 00:05:59
mucho mucho más no 00:06:00
pero lo puedo intentar 00:06:02
se me va el ordenador 00:06:06
vale 00:06:09
como una clase abstracta 00:06:10
tracta. Por definición, está 00:06:11
pensada para heredar de ella, porque no está 00:06:13
pensada para instanciar objetos. 00:06:15
Entonces, si ya va a tener herederos, 00:06:17
pues este 00:06:19
modificador 00:06:19
se adapta, porque este modificador permite 00:06:24
usar la propiedad desde la subclase. 00:06:27
Entonces, se adapta mejor. 00:06:29
Y luego, además, dice 00:06:31
como es protected, 00:06:32
pues tiene sentido poner los 00:06:35
get y set, claro. 00:06:37
Para los dos. 00:06:39
y luego podríamos ponerle un constructor 00:06:41
pero bueno, si estamos en modo examen 00:06:45
vamos a ir poniendo las cosas según las necesitemos 00:06:46
pues podemos ir aparcando 00:06:48
bueno, una cosa es el modo examen 00:06:51
que yo voy resolviendo, primero entiendo 00:06:55
lo que tengo que hacer, y luego voy resolviendo 00:06:56
y voy poniendo las cosas según voy necesitando 00:06:58
y decir, no me relajo 00:07:00
y digo, voy a poner 200 constructores 00:07:02
y si lo necesito o no, voy a poner 00:07:04
no sé qué, no es el momento de relajarse 00:07:06
¿vale? 00:07:08
Venga, pues a ver 00:07:09
La clase abstracta tiene describir criatura 00:07:11
Que imprima la información básica 00:07:14
De la criatura 00:07:16
Pues hombre, describir criatura 00:07:16
Este es como si fuera un tuestrín 00:07:19
En realidad, es un tuestrín 00:07:25
Describir criatura 00:07:27
Pues nada, vamos a hacerlo muy rápido 00:07:29
Nombre 00:07:31
No, porque las propiedades ya están ahí 00:07:36
¿Ya puedo darle ahí 00:07:40
una implementación? 00:07:43
Vale, a ver. 00:07:48
Luego yo puedo 00:07:50
en una subclase cambiarla. 00:07:51
Vale, pero... 00:07:53
Vale, vale, vale. 00:07:56
Vamos a ver. Y un método abstracto. 00:07:57
Perdón, perdón. 00:07:59
Perdón, perdón, que es que estoy leyendo muy rápido. 00:08:01
Ya dice que es abstracto. 00:08:04
Vale. 00:08:05
De todas maneras, 00:08:07
al poner un método abstracto 00:08:08
ya automáticamente hay que poner aquí el abstract 00:08:12
y ya está 00:08:14
vale 00:08:16
también 00:08:17
public voy a describir criatura 00:08:18
te voy a poner el abstract también aquí 00:08:22
vale 00:08:24
entonces aquí 00:08:26
en este pues lógicamente está muy masticado 00:08:28
que esto tiene que ser 00:08:31
interfaz, que esto clase abstracta 00:08:32
que esto método abstracto no tiene por qué ser así 00:08:34
por el propio contexto del problema 00:08:36
se puede deducir 00:08:39
si va a ser abstracta no puede ser abstracta también 00:08:40
¿vale? 00:08:43
ha sonado tal cual 00:08:45
en el examen no te va a salir así 00:08:46
la verdad es que para algunas cosas sois muy tontos 00:08:48
y para otras sois muy listos 00:08:50
¿eso qué significa? 00:08:52
pues no 00:08:54
que así no lo ponían en el examen 00:08:56
bueno, venga, seguimos 00:08:59
o sea que para el año pasado se lo ponían 00:09:01
para tontos, pero para nosotros no 00:09:02
es que no somos tontos 00:09:04
No, de los del año pasado 00:09:05
No, los del año pasado 00:09:11
Los que éramos tontos 00:09:16
El año pasado éramos nosotros 00:09:19
Igual que preguntábamos chorradas 00:09:21
Ya está 00:09:23
Bueno, a ver 00:09:24
Tenemos que hacer el otro también antes de irnos 00:09:26
Que es el más complicado 00:09:28
Venga, pues ya está 00:09:29
Método abstracto 00:09:32
Que queda hora y media, pero que como nos enrollemos 00:09:33
tanto en cada cosa. 00:09:36
Eh, no me hables así, ¿eh? 00:09:37
Venga. 00:09:43
Dragón, unicornio, elfo. Venga. 00:09:47
Que heredan 00:09:50
de criatura mística y añaden 00:09:51
cada uno una característica. Pues venga. 00:09:53
Hacemos dragón, unicornio 00:09:56
solo, ¿vale? Pues a ver. 00:09:58
Dragón. 00:10:06
dragón, hereda de criatura mística 00:10:07
vale 00:10:11
entonces al heredar de criatura mística 00:10:17
tiene que implementar este método 00:10:20
y aparte añade, dice que añade una propiedad 00:10:23
la que nos dé la gana 00:10:26
pues va a añadir la propiedad 00:10:27
temperatura del fuego, por ejemplo 00:10:28
porque es un dragón 00:10:30
y temperatura del fuego 00:10:33
vale 00:10:37
Entonces, describir criatura 00:10:39
Ahora ya la podemos 00:10:42
La podemos definir 00:10:43
Como nombre 00:10:51
Nombre 00:10:52
El otro era la edad de la criaturita 00:11:00
La temperatura del fuego 00:11:05
Bueno, es que me han dicho 00:11:08
Que lo llame describir criatura 00:11:16
Pues yo lo llamo, a ver, puedo hacer un twist 00:11:17
Y luego cambiar el método y me ahorro escribir un montón 00:11:19
así que veis como sois muy listos 00:11:21
yo no sé como luego a veces 00:11:24
parecéis no serlo 00:11:25
yo soy como tonto pero sin el como 00:11:27
no, no, no, es verdad 00:11:33
os vendéis fatal 00:11:36
venga, a ver 00:11:36
dragón, cada uno 00:11:39
venga, y el unicornio 00:11:40
el unicornio lo que le mide el cuerno 00:11:42
ya está comprando 00:11:46
A ver, es lo que se nos ocurrió 00:11:50
A ver, ¿tú has visto unicornios con muchas patas? 00:11:55
¿Con más de cuatro o menos? 00:12:04
Hombre, sueños 00:12:06
Si consideras a un narval 00:12:08
Un narval, ¿qué es eso? 00:12:10
¿Qué es un unicornio? 00:12:12
Es un 00:12:13
Un mamífero marino 00:12:16
Que tiene un colmillo que más de un cuerno 00:12:18
¿Tú también eres muy aficionado a videojuegos? 00:12:20
Sí, a literatura fantástica 00:12:23
Narval, con V 00:12:26
Ah, pues luego lo busco 00:12:29
Venga 00:12:34
El tamaño del cuerno 00:12:38
Ala 00:12:41
Tiene este método 00:12:41
Tenía que haber hecho delto string 00:12:46
Bueno 00:12:49
Nombre 00:12:49
Edad 00:12:55
Sí 00:12:59
Longitud del cuerno 00:13:02
Vale 00:13:05
A este le falta el getty set del cuerno 00:13:06
Constructores estoy pasando 00:13:10
Sin parámetros todo el rato y listo 00:13:11
¿Para qué? 00:13:13
¿Para qué qué? 00:13:15
Por eso que los estoy dejando todos sin parámetros 00:13:17
al no poner ninguno, todos tienen uno sin parámetros 00:13:19
y en caso de necesidad uso ese y ya está. 00:13:21
Por ahorrar tiempo, no porque sea 00:13:23
recomendable. Y el dragón 00:13:25
tampoco le he puesto el get y set del que falta. 00:13:27
¡Hala! 00:13:33
¡Amogollón! 00:13:35
Vale, pues ya tenemos, el elfo pasa muy bien. 00:13:37
No, ¿por qué? 00:13:40
Porque los elfos 00:13:42
son muñoños todos. 00:13:43
¡Venga! 00:13:45
Ah, y hay que implementar, activar poder de la interfaz poder místico de manera única para cada clase. Vale, entonces, vale, pues hijo, cada uno, entonces tenemos poder místico, activar poder, criatura mística, implementa poder místico, vale. 00:13:46
Y ahora 00:14:12
Vale, pues el dragón 00:14:15
Activa poder 00:14:24
Vale 00:14:29
Aquí sí que tengo que poner el public, obviamente 00:14:30
Vale 00:14:35
Tengo que activar el poder 00:14:36
Por ejemplo 00:14:39
¿Por qué? 00:14:42
Si criatura mítica 00:14:44
Implementa por el mítico a los otros dos 00:14:45
¿Por qué se abstracta? 00:14:47
A ver, ¿eh? 00:14:49
¿Por qué a los otros dos no se le ponen una vez el activo poder? 00:14:51
Claro, porque es abstracta y las abstractas las tienes que implementar tú por tu cuenta. 00:14:54
Vale, entonces, a ver, poder místico, activar poder, entonces criatura mística. 00:15:00
Si fuera un método normal, tú lo podrías llamar, pero si lo pones como abstracto, tienes que implementarlo. 00:15:07
A ver, a ver 00:15:14
Vamos a ver 00:15:32
Esta clase 00:15:33
La clase criatura mística 00:15:35
Como implementa, aunque sea abstracta 00:15:37
Como implementa poder místico 00:15:40
pues nos ha obligado a implementarla 00:15:42
y lo hemos puesto así, pero luego al darnos cuenta 00:15:44
de que era abstracta 00:15:46
podíamos haberla dejado sin cuerpo también 00:15:47
¿vale? y entonces haberla implementado 00:15:50
abajo, entonces al haberla implementado aquí vacía 00:15:52
¿vale? 00:15:54
al haberla implementado aquí vacía 00:15:56
no nos la pedía aquí 00:15:58
pero si nos damos cuenta de que 00:15:59
en el momento que la hemos convertido en abstracta 00:16:01
porque esta ya es abstracta, esta implementación 00:16:04
vacía que habíamos hecho la podemos quitar 00:16:06
porque esta clase ya puede tener todos los métodos vacíos que quiera 00:16:08
todo lo que quiera, entonces ese lo quito 00:16:10
porque yo no sé cómo activa el poder una criatura mística 00:16:12
genérica, entonces la ventaja 00:16:14
que tengo de quitarlo, la ventaja que tengo 00:16:16
es que ahora ya aquí me obliga 00:16:18
entonces yo me doy cuenta de que tengo que hacerlo 00:16:20
si no lo hubiera quitado 00:16:22
si no lo hubiera quitado 00:16:23
al decirme aquí implementa activar poder 00:16:25
yo lo habría implementado, pero 00:16:28
porque yo sé que tengo que implementarlo 00:16:29
y lo implemento, pero no me habría obligado 00:16:32
el compilador, porque ya tiene una versión vacía 00:16:34
arriba 00:16:36
entonces 00:16:36
pero bien visto 00:16:39
porque se me había olvidado quitarlo de aquí 00:16:41
quitarlo y al no 00:16:43
dejarlo ahí puesto 00:16:45
pues no me obligaba 00:16:46
claro, porque es abstracta, si le quitas el abstract 00:16:47
lo tienes que poner 00:16:51
porque lo implementa, aunque luego lo quieras 00:16:52
dejar vacío y las que hereden de ella 00:16:55
que pueden heredar de ella, aunque no sean abstractas 00:16:57
le den otro valor, le den otro 00:16:58
pero lo tienes que poner 00:17:00
pero si la pones como abstracta y lo puedes quitar 00:17:01
No, no, no, no, claro no 00:17:04
Solo te lo pido obligatoriamente si es abstracta 00:17:16
Si no, no, si no tú eliges 00:17:18
Sobrescribirlo o quedarte con la versión de arriba 00:17:20
Que ya está hecha, en este caso vacía 00:17:22
Vale, entonces ahora en esta 00:17:24
En unicornio 00:17:27
Implementamos 00:17:30
el método de activar 00:17:32
poder que va a ser 00:17:35
pues cualquier 00:17:36
cosa 00:17:39
eso 00:17:39
no sé, no sé cómo 00:17:42
activa un unicornio su poder 00:17:46
no sé qué poderes son 00:17:48
los de los unicornios 00:17:51
vale, pues las clases 00:17:51
ya están todas y aquí 00:17:56
hombre, a lo mejor 00:17:58
se podían haber hecho diferentes variantes 00:18:00
Pero la idea es que queda una cosa coherente 00:18:02
Y esto es coherente 00:18:06
Y uno se va dando cuenta de ciertas cosas cuando lo va haciendo 00:18:07
¿Vale? 00:18:10
Entonces ahora viene la parte interesante del ejercicio 00:18:11
Que es hacer un main con diferentes criaturas 00:18:14
Y ver si el uso del polimorfismo 00:18:18
Pues lo hacéis bien 00:18:20
Vale, un main 00:18:21
Pues venga, vamos a hacer un main 00:18:22
Un main 00:18:25
Pues en el main dice 00:18:34
A ver 00:18:37
haz cuatro 00:18:37
un array de cuatro criaturas 00:18:39
místicas 00:18:41
con un array 00:18:42
no, porque este ejercicio 00:18:45
no evaluaba el RA que 00:18:48
incorpora, entonces 00:18:49
perdona, se lo decís a los que hicieron el BOE 00:18:51
que nos vuelven locos con esto 00:18:54
por evaluar por separado 00:18:55
si yo te meto aquí 00:18:57
que en lugar de un array sea una lista 00:18:59
te tengo que evaluar un porcentaje 00:19:01
de la RA de no sé qué 00:19:04
y ya mi es celpeta, así que 00:19:05
ya estoy 00:19:07
vale 00:19:11
a ver, lo que no podéis es olvidaros de los 00:19:13
arrays, más que nada porque este examen recupera 00:19:21
todo lo anterior, entonces como puede recuperar 00:19:23
todo lo anterior 00:19:25
vale, entonces 00:19:26
pero vamos a ver 00:19:28
criatura mística 00:19:31
Criatura mística 00:19:37
Criaturas, esto es hacer un array 00:19:41
New 00:19:44
Criatura mística 00:19:48
Han dicho 4 00:19:50
Ya está, ya tenemos un array 00:19:53
Vale, y ahora dice 00:19:55
Poner una instancia diferente 00:19:56
Pues venga, vamos a poner 00:19:58
Vamos a hacer un dragón 00:19:59
Y un unicornio 00:20:01
O dos dragones 00:20:06
Y dos unicornios 00:20:07
Y los ponemos donde nos pete 00:20:09
vale 00:20:10
de 1. 00:20:11
¿por qué me deja? 00:20:18
no, fijar en la edad 00:20:22
pero porque me ofrece edad directamente 00:20:24
porque no has puesto private 00:20:26
¿no he puesto private? 00:20:28
sí, sí está puesto 00:20:29
de 1 00:20:30
criatura mística 00:20:35
de este dragón 00:20:36
Bueno, da igual 00:20:38
Vamos a hacerlo con el set que es más bonito 00:20:50
La edad del dragón 00:20:52
Cuatro años 00:20:55
Sí, hombre 00:20:56
¿Cuánto te crees que iba un dragón? 00:20:58
El nombre del dragón 00:21:00
Pues yo qué sé 00:21:02
Anita 00:21:04
Y no tiene más propiedades 00:21:08
Ah, sí, alta la temperatura del fuego 00:21:11
Pues venga, 100 00:21:13
¿Cómo allá? 00:21:18
¿Sabes que en el escudo antiguo del metro había un dragón? 00:21:19
¿Ah, sí? 00:21:22
Se lo inventaron porque se metieron con el escudo de Madrid 00:21:22
Añadimos un dragón 00:21:25
Es una dragón así con moño 00:21:27
¿Qué cosas? 00:21:29
¿Qué cosas? 00:21:32
Venga, ahí vamos a hacernos dos unicornios 00:21:32
Vale, uno punto 00:21:43
Uno punto 00:22:00
Claro, y sin embargo en el unicornio no me lo ofrece 00:22:03
Y en el dragón sí 00:22:07
Y en el unicornio 00:22:08
Qué raro 00:22:12
Bueno, da igual 00:22:13
Será una chorrada 00:22:18
Del entorno 00:22:19
Venga, unicornio tiene 100 años 00:22:21
Y el cuerno le mide mucho 00:22:24
50 centímetros 00:22:29
No es tan grande 00:22:32
Yo diría que está en la media 00:22:34
Vaya hombre 00:22:35
Y se llama 00:22:36
María 00:22:40
Venga, unicornio 2 00:22:42
El unicornio 2 tiene 2 00:22:56
Y el cuerno le mide un poco menos 00:22:59
Y se llama Carlos 00:23:01
Y ahora ya, pues ya está 00:23:05
Criaturas 0 00:23:07
Iguala de 1 00:23:14
Sí, sí, sí, perdón 00:23:16
Estoy pisando a uno con el otro 00:23:23
Y el dragón también con el copia y pega 00:23:25
Sí, sí, estáis muy espabilados 00:23:30
Sí, sí 00:23:38
Criaturas 00:23:39
Dos 00:23:45
Iguala 00:23:48
Unicornio 1 y criaturas 3 igual a el unicornio 2. 00:23:50
Vale, ya tenemos el array con cuatro instancias cualesquiera que se nos han ocurrido. 00:24:03
Y ahora, ¿qué tenemos que hacer? 00:24:08
Vamos a mostrar la descripción de todas y activar el poder solo de los elfos. 00:24:13
Pues lo cambiamos, solo de los unicornios. 00:24:18
vale, vamos a mostrar la descripción 00:24:22
de todas las criaturas, vale, pues entonces 00:24:24
vamos a recorrer el array 00:24:26
como tenemos que 00:24:27
criatura mística 00:24:38
perdón, vale 00:24:41
activar el poder de todas 00:24:44
no, activar 00:24:49
mostrar la descripción de todas 00:24:51
vale, pues aquí está claro 00:24:52
describir criatura 00:24:55
para todas y cada una me hará 00:24:57
el describir criatura suyo, cada una 00:24:59
el suyo, pero 00:25:01
activar poder solo de las que 00:25:02
sean 00:25:04
dragones, por ejemplo, hemos dicho 00:25:05
claro, entonces 00:25:08
esta es la forma buena de hacerlo 00:25:10
c instance 00:25:14
dragón 00:25:17
solo en ese caso 00:25:19
solo en ese caso 00:25:22
c punto 00:25:23
activar poder 00:25:24
y se acabó el ejercicio, vale, matiz 00:25:27
aquí uno podría haber 00:25:35
hecho. Hombre, como 00:25:37
las sello, porque las tengo aquí arriba, las he visto, 00:25:39
pues 00:25:43
paso del instance of 00:25:43
y decimos, bueno, pues 00:25:45
en las dos primeras iteraciones 00:25:48
o simplemente hago 00:25:50
el for para este y luego me hago aquí. 00:25:51
De uno punto activar poder y de dos 00:25:53
punto activar poder. Pero, hombre, 00:25:55
eso no lo valoramos. 00:25:57
Especificamos, porque esto no es polimorfismo. 00:26:00
O no lo valoramos del todo. Sabía yo que 00:26:03
William iba a levantar la mano. 00:26:05
Dime 00:26:06
Perdón, perdón, es que no te he oído 00:26:08
No te he entendido 00:26:23
Nada, ninguna 00:26:24
O sea, criar 00:26:37
Ninguna 00:26:38
Ninguna, o sea, yo puedo pasar de D1 00:26:40
Lo he hecho así para que esté más organizado 00:26:44
Puedo hacer criaturas de 0, New Unicorn 00:26:45
Y luego criaturas de 0 puntos en nombre, criaturas de 1 00:26:47
New Dragón, ninguna 00:26:49
¿Cómo se llama? 00:26:51
¿Perdón? 00:26:57
¿Cuál es el nombre técnico del dragón primero? 00:26:58
¿El nombre técnico del dragón primero? 00:27:01
No entiendo la pregunta. 00:27:07
¿Tú lo entiendes? 00:27:10
El nombre técnico del dragón primero. 00:27:11
El segundo dragón es la instancia. 00:27:14
El primer dragón quiere... 00:27:16
¿Qué? 00:27:17
El segundo dragón es la instancia. 00:27:20
El primer... 00:27:22
Todos son instancias. 00:27:23
No te entiendo. 00:27:24
O sea, yo estoy haciendo un dragón, 00:27:27
otro dragón, 00:27:30
un unicornio y otro unicornio. 00:27:31
No me refiero a esto. 00:27:32
¿A qué te refieres? 00:27:33
A la de la vuelta. 00:27:34
que tienes un dragón en la 00:27:37
ahora te agachas 00:27:39
esto que hace 00:27:40
referencia 00:27:53
esta es la clase 00:27:55
o sea esta es una referencia 00:27:57
de clase dragón que se instancia 00:27:59
como clase dragón 00:28:01
tu pregunta es podría poner aquí 00:28:02
criatura mística, si claro que puedes 00:28:05
cuando hago list 00:28:07
es que esto de list criaturas de cero 00:28:12
es lo que he perdido 00:28:14
¿qué es list criaturas de cero? 00:28:14
perdón, claro 00:28:16
criaturas 00:28:17
a mi arraigo he llamado criaturas 00:28:20
cuando hago criaturas de cero 00:28:22
igual a new dragon 00:28:23
sí 00:28:25
¿cómo se llama lo de izquierda? 00:28:26
tiene un nombre 00:28:30
instancia, no te entiendo 00:28:30
vale, o sea 00:28:32
Sí, a ver, pero 00:28:35
Claro, yo podría, si es lo que te acabo de decir 00:28:38
Yo podría, en lugar de haberlas 00:28:40
Hecho por separado 00:28:42
Pues haber hecho aquí 00:28:44
Criaturas de cero igual a New Dragon 00:28:45
¿Vale? 00:28:48
Y lo que pasa es que ahora tendría que haber ido 00:28:50
Poniendo las propiedades 00:28:52
Criaturas de cero, punto 00:28:54
No sé qué 00:28:56
¿Vale? 00:28:57
Pero habría tenido un problema 00:29:00
Y es que desde aquí, criaturas de cero 00:29:01
no me habría dejado acceder 00:29:04
al tamaño, al fuego 00:29:07
claro, por eso ponemos 00:29:09
la referencia 00:29:11
lo que está sucediendo es que criaturas de 0 00:29:12
igual a 1 dragón sería lo mismo 00:29:15
que decir criaturas 00:29:17
justo, justo 00:29:19
sería lo mismo que si tú aquí pones 00:29:21
criatura mística en vez de dragón 00:29:23
cuál es el problema, que a la hora de 00:29:25
esta propiedad no te dejaría fijarla 00:29:27
tendrías que hacer un casting 00:29:29
¿vale? pero sería lo mismo efectivamente 00:29:30
Pero esto no te dejaría hacerlo 00:29:33
Haces un casting 00:29:35
Para eso lo más cómodo es instanciar un dragón directamente 00:29:37
¿Vale? 00:29:39
Vale 00:29:42
Vale 00:29:42
Pues esto está entendido 00:29:49
¿Vale? 00:29:51
Entonces lo que decía 00:29:53
Uno podría decir 00:29:54
Hombre, hago lo que hace el ejercicio si hago 00:29:56
De uno punto de escribir 00:29:58
De dos punto de escribir 00:29:59
De tres punto de escribir 00:30:00
Y luego de uno punto activar 00:30:01
De dos punto activar 00:30:03
Pero el ejercicio 00:30:04
lo que valoramos es el uso del polimorfismo 00:30:05
no sé si aquí estaba 00:30:09
en la puntuación especificado 00:30:10
pero vamos, no se valoraba igual 00:30:12
lógicamente, porque si aquí 00:30:15
me cambia, me cambian de 00:30:17
orden estos de aquí 00:30:19
esto ya no me funcionaría 00:30:20
si lo habéis hecho 00:30:22
vale, pues ya está 00:30:22
vamos a por el otro 00:30:33
que esto es muy largo 00:30:34
venga, que tenemos una hora 00:30:36
¿eh? 00:30:39
bueno, a ver 00:30:43
esto es lo que dice 00:30:44
esto 00:30:49
la RA4 al completo 00:30:50
si este vídeo está hecho, la RA 00:30:52
si sacas un 10 en este ejercicio, tienes un 10 00:30:54
en la RA4 00:30:57
si sacas un 10 en este ejercicio, tienes un 10 en la RA7 00:30:58
como no encuentro el ejercicio de ese mañana 00:31:01
Pues a ver, lo que no podéis es ser 00:31:03
muy, tampoco 00:31:07
unos flojos, por Dios. 00:31:08
Venga. 00:31:11
Vamos a hacer el 00:31:13
ejercicio 1. 00:31:14
A ver, que nos tenemos que ir 00:31:17
puntuales, por favor. 00:31:18
Que tenemos sueño y hambre y de todo. 00:31:21
Dígame. 00:31:25
Es que no nos va a dar tiempo 00:31:28
hacer el ejercicio. 00:31:29
A ver, ¿por qué no descansáis en paralelo 00:31:31
Que lo vamos haciendo 00:31:32
O sea, a ver 00:31:34
Según hacemos los getter y setter 00:31:38
Que es automático, pues ahí 00:31:40
Hacéis un click y desconectáis un rato 00:31:41
A ver, es que no va a dar tiempo a hacerlo 00:31:44
No va a dar tiempo a hacerlo 00:31:47
Venga, vamos a hacerlo 00:31:48
Y el que necesita descansar, que desconecte un rato 00:31:50
Y luego ya se engancha 00:31:52
No, que soy muy listo 00:31:53
de que lo pusimos 00:31:56
en la virtual 00:32:05
ay Silvia 00:32:06
necesitas un poco más de magnesio 00:32:11
venga 00:32:15
pero si lo has preguntado tú 00:32:17
ah Andrea tú también 00:32:21
que mala uva 00:32:25
tú esto, pasa tú primero 00:32:25
no vaya a ser que 00:32:29
de verdad, venga 00:32:30
a ver 00:32:35
modelo de datos 00:32:37
silencio 00:32:39
en lugar de leerlo y recrearnos 00:32:41
en la lectura 00:32:43
vamos a ir tirando sobre la marcha 00:32:44
y vamos resolviendo 00:32:47
vale 00:32:48
esto va a ser un jueguito con cartas y barajas 00:32:49
pues venga, primero la clase carta 00:32:53
El palo y el número de carta 00:32:55
Venga 00:32:57
Clase carta 00:32:57
Mientras lo haces, la mano te va sola y tú desconectas 00:33:00
Palo, oros 00:33:03
Y el número de la carta 00:33:19
Venga 00:33:20
stream 00:33:22
palo 00:33:27
que generación 00:33:28
por dios 00:33:34
que está fatal 00:33:34
que le va a pasar 00:33:43
a ver 00:33:43
que he dicho 00:33:47
que si queréis descansar 00:33:48
como la mano va sola 00:33:49
dejad que la mano vaya sola 00:33:50
y mientras os relajáis 00:33:51
ya está 00:33:53
hombre, porque asumo 00:33:54
que son una generación evolucionada 00:34:07
de todas formas, ¿por qué vosotros asumís 00:34:10
que eso solo lo malinterpretan los hombres? 00:34:19
las mujeres que pasa 00:34:21
que no usan la mano 00:34:26
ni hacen nada tampoco 00:34:26
en fin, de verdad 00:34:28
vamos, carta ya está 00:34:32
palo y no un cartas 00:34:34
venga 00:34:37
baraja 00:34:39
un set de cartas 00:34:41
no, porque he dicho 00:34:44
que no haga falta 00:34:47
yo voy al mínimo esfuerzo 00:34:48
ahora mismo para que nos dé tiempo 00:34:50
venga, baraja 00:34:51
un conjunto de cartas 00:34:54
vale 00:34:55
vale, este 00:34:57
os reconozco que no era fácil 00:35:07
este no era fácil, a cambio el otro era muy fácil 00:35:09
vale 00:35:13
¿por qué se caracteriza? 00:35:15
por un set de cartas 00:35:17
Venga 00:35:22
Ponemos un haset 00:35:23
Si luego me hacen cambiar de idea ya cambio 00:35:27
Pero por ahora ponemos un haset 00:35:30
A ver, si ponemos un triset 00:35:31
Acordaos que la ventaja 00:35:33
Si pongo un triset, ¿qué va a ocurrir? 00:35:35
¿Qué carta tiene que implementar comparable? 00:35:37
¿Y qué ventaja tengo? Que cuando luego lo liste 00:35:39
Van a ser ordenados, esa es la ventaja 00:35:41
Lo listo y ordenados 00:35:43
En algún momento voy a tener que sacar cartas ordenadas por algo 00:35:44
Si las tuviera que sacar ordenadas me vendría muy bien un triset 00:35:47
Si no tengo que sacar las ordenadas dejo un haset 00:35:49
Vale 00:35:51
Vale. ¿Qué más me dice Baraja? Un constructor sin parámetros en el cual en la baraja se metan 40 cartas del 1 al 10 de cada palo. Uf, eso mismo digo yo. 00:35:52
public baraja 00:36:10
entonces 00:36:24
tenemos que hacer 00:36:25
un bucle 00:36:28
para ir metiendo en las cartas 00:36:30
entonces primero vámonos 00:36:33
como tienen que ir del 1 al 10 00:36:34
pues vamos a generar los numeritos 00:36:36
del 1 al 10 porque son del 1 al 10 hemos dicho 00:36:39
cartas del 1 al 10 00:36:41
Vale, como sabemos programar, afortunadamente 00:36:44
La parte de programar la tenemos superada 00:36:46
Mientras 00:36:47
Y sea menor o igual que 10 00:36:49
Incrementando 00:36:52
Pues le vamos metiendo aquí al amigo 00:36:54
Cartas.add 00:36:57
New 00:37:00
Aquí me va a venir muy bien un constructo con parámetros 00:37:01
Así que lo voy a hacer 00:37:03
New carta 00:37:04
Oros 00:37:07
Y con el numerito 00:37:12
y esto mismo lo hago 00:37:14
para copas 00:37:18
espadas y bastos 00:37:20
bueno, ¿para qué quiero hacer un array normalito? 00:37:22
porque pone 00:37:30
oro, espadas, bastos y copas 00:37:30
lo recorres 00:37:34
sí, a ver, que lo podemos hacer de muchas formas 00:37:34
yo esto es lo más sencillo 00:37:37
copas y bastos me falta 00:37:39
vale, entonces voy a estar 00:37:44
metiendo en el constructor sin parámetros 00:37:47
de cada palo 10 cartas 00:37:49
¿verdad? ¿qué es lo que quiero? de cada palo 10 cartas 00:37:51
pues voy a hacer el constructor 00:37:54
este con parámetros 00:37:56
crear constructor string int 00:37:57
que este constructor 00:38:00
string int 00:38:02
¿qué nombres más feos le ha puesto? 00:38:03
vamos a poner que le llame 00:38:05
palo 00:38:07
numcartas 00:38:08
y ahora este constructor 00:38:12
Pues dis.palo 00:38:15
Igual a palo 00:38:18
Y dis.numcartas 00:38:19
Ala 00:38:24
Vale 00:38:27
Pues ya hemos avanzado algo del ejercicio 00:38:28
Ya tenemos el constructor 00:38:31
Ya tenemos un punto y medio 00:38:32
Por esto, toma ya 00:38:34
Solo con esto un punto y medio 00:38:35
Clase jugador 00:38:38
Nombre, puntuación 00:38:40
y una lista con las cartas que tiene en cada momento. 00:38:44
Pues venga, vamos a ver. 00:38:48
Vale, entonces. 00:38:59
Nombre. 00:39:06
Puntuación. 00:39:13
Y aquí es que nos lo han especificado 00:39:14
Podrían no habernoslo especificado 00:39:17
Entonces nosotros decidir 00:39:18
En función de si 00:39:19
¿Va a ser necesario duplicados? 00:39:21
No, si no es necesario duplicado 00:39:23
Siempre un set 00:39:26
Pues 00:39:27
Podéis vosotros decidir 00:39:29
Y si en el caso de que no se especifique 00:39:31
Tomáis la decisión correcta 00:39:33
Pues se puntúa un poquito más 00:39:34
Vale, y entonces aquí nos han dicho que sea una lista 00:39:35
La mano entonces 00:39:38
Va a ser una lista 00:39:40
New, pues lo que os dé la gana 00:39:41
Venga, ArrayList, que siempre pongo LinkedList 00:39:46
No sé por qué les tengo manía 00:39:48
Tienes razón, vale, me has convencido 00:39:49
De verdad, no, tienes razón 00:39:54
Que lo he hecho así un poco a lo 00:39:56
Que no es tanto mostrar 00:39:59
Porque uno cuando juega a la jarda no está mostrando todo el rato 00:40:02
Sino que está más bien cogiendo y sacando 00:40:04
Efectivamente, cambiando 00:40:06
Vale, pues venga 00:40:08
Get y set 00:40:13
No, pues muy bien, muy bien 00:40:14
Todo eso son puntos 00:40:20
Estas 00:40:22
Vale 00:40:23
Jugador ya tiene 00:40:25
Eso 00:40:29
Jugador 00:40:30
Jugador además va a tener métodos 00:40:31
Que es 00:40:35
Recibir una carta 00:40:35
Se añade la carta 00:40:37
en su conjunto de cartas 00:40:41
y entonces se elimina 00:40:43
desde la baraja. 00:40:44
¿Vale? 00:40:47
Vale. Entonces. 00:40:48
Vale. Aquí lo que pasa es que hay que leerlo 00:40:51
entero para que, porque en el 00:40:56
main habrá 00:40:58
un objeto baraja nuevo. Entonces. 00:41:00
Elimina desde la baraja. Entonces. 00:41:04
Vale. 00:41:07
A ver. En el main 00:41:10
esto 00:41:12
que lo explicábamos 00:41:13
en el enunciado 00:41:16
cuando se leía entero y lo explicábamos 00:41:17
pues la clase main 00:41:19
¿vale? 00:41:23
pero lo que pasa es que entonces la baraja 00:41:36
tendríamos que hacerla como un linked list 00:41:38
y la baraja en este ejercicio 00:41:39
está puesto 00:41:41
que las cartas sean un set 00:41:44
vale, entonces no podemos usar push y pull 00:41:45
pero estaría bien pensado también 00:41:47
vamos a poner a hacer exámenes 00:41:49
vale, entonces 00:41:51
la baraja de cartas 00:41:53
no es tan fácil 00:41:55
vale 00:41:59
entonces la baraja de cartas 00:42:07
es, os indicábamos 00:42:10
una variable estática 00:42:12
de mi aplicación 00:42:14
entonces podéis ir avanzando el main 00:42:15
con una variable estática aquí de mi aplicación 00:42:16
y ahora ya 00:42:19
jugador añade una carta 00:42:21
y tendrá acceso a esta baraja 00:42:23
para eliminarla 00:42:25
porque si no habría que pasárselo por parámetro también 00:42:26
y aquí no está indicado que se le pase por parámetro 00:42:29
¿vale? 00:42:31
aún así 00:42:34
si uno, pues en un momento dado 00:42:35
en una situación como esta, dice 00:42:37
ostras, ¿cómo ha accedido a la baraja para eliminar las cartas de la baraja? 00:42:38
pues se la paso y lo agrega y se la pasa 00:42:41
contamos cosas 00:42:42
nosotros lo que evaluamos es que 00:42:44
sepáis programar y hagáis cosas con sentido 00:42:47
que resuelvan, no tanto 00:42:49
que hagáis 00:42:51
adapteis a 00:42:53
algo exactamente 00:42:55
pues venga, vamos a hacer el recibir carta de jugador 00:42:57
ala, venga 00:42:59
porque si es con peor lo disculpas 00:43:03
vale, recibir carta 00:43:15
añadir una carta 00:43:17
a la mano 00:43:19
vale 00:43:21
Pues entonces, vale, mano.ad, carta, vale, esto ya está, y se elimina de la baraja. 00:43:22
entonces aquí 00:43:44
la baraja que es esta 00:43:47
a la que yo puedo acceder 00:43:48
tiene el método 00:43:50
main.baraja 00:43:51
main.baraja 00:43:56
le podemos sacar 00:44:00
las cartas 00:44:04
ah es que tengo las cartas 00:44:07
Ah, es que no tengo el get 00:44:16
En Baraja no tengo el get 00:44:17
No tengo el get 00:44:19
Entonces necesito el get 00:44:21
Es que como estoy haciendo 00:44:23
Sobre la marcha 00:44:24
Según vamos necesitando 00:44:27
Pues entonces, aquí 00:44:29
Yo aquí saco las cartas 00:44:31
Y aquí tengo que borrar 00:44:36
Esta carta 00:44:38
Entonces ahora aquí es donde 00:44:39
Cuando ya estoy usando colecciones 00:44:41
Claro, aquí cuando ya estoy usando colecciones 00:44:43
es cuando me paro y digo, a ver, cuidadín 00:44:45
para que remove funcione 00:44:47
tiene que tener el método 00:44:49
hashCodeEquals en la clase 00:44:51
carta, para que él sepa 00:44:53
encontrar una igual a esta 00:44:55
¿vale? pues entonces 00:44:57
esto ya nos lleva a ver si 00:44:59
dado que cartas es un hashSet 00:45:01
porque cartas en baraja 00:45:03
es un hashSet 00:45:05
pues esto me lleva 00:45:06
a ver si hay un hashCodeEquals 00:45:09
en carta 00:45:11
¿hay un hashCodeEquals en carta? 00:45:12
no, tenemos que ponérselo 00:45:15
¿cuál es la igualdad entre cartas? mismo palo 00:45:17
mismo número, los dos 00:45:19
pues entonces aquí ponemos un 00:45:20
jasco de equals 00:45:23
de las dos 00:45:25
vale 00:45:26
esto ya está resuelto, este borrar carta 00:45:27
va a borrar la de la baraja 00:45:31
y ahora pensamos, añadir carta 00:45:32
vale 00:45:35
aquí 00:45:36
la mano es una lista 00:45:38
vale 00:45:43
entonces la mano es una lista 00:45:44
aquí todavía que exista el equals 00:45:46
o no, me da igual, porque añadir 00:45:48
carta no mira el equals ni mira nada, la añade 00:45:50
yo sé que por el funcionamiento 00:45:52
un jugador no va a tener en la mano dos cartas repetidas 00:45:54
porque se habrá 00:45:56
borrado de la baraja, entonces la aplicación 00:45:58
estará hecha para que se añada una carta 00:46:00
cogiendo la de la baraja, claro 00:46:02
entonces, ahora mismo en cualquier caso el equals 00:46:04
todavía no me hace falta, es que aunque lo pusiera 00:46:06
este add no lo mira 00:46:07
si mano fuera un set 00:46:09
si mano fuera un set 00:46:11
entonces, ese add 00:46:13
sí que miraría si hay un jasco de equals 00:46:15
o un comparetus es un tris, así que miraría 00:46:18
porque solo haría el add 00:46:20
si no hay uno igual, solo haría el add 00:46:21
entonces ahí sí que me interesaría 00:46:23
poner ya el jasco de equals, en este caso pues una lista 00:46:25
todavía puedo eludirlo 00:46:28
que luego quiero borrar yo de la lista 00:46:29
el remove de lista sí que usa el equals 00:46:31
entonces ahí sí que lo pondría, pero por ahora 00:46:33
lo imprescindible 00:46:35
recibir carta ya está, pues hala 00:46:37
vamos ya por dos puntos y medio 00:46:39
venga 00:46:42
jugar carta 00:46:43
selecciona la carta más alta 00:46:46
de ese palo 00:46:50
le elimina de la mano 00:46:51
de ese jugador, muestra el mensajito 00:46:54
y si no hay cartas de ese palo 00:46:56
pues no elimina nada 00:47:00
y muestra el mensaje 00:47:01
además devuelve la carta jugada 00:47:02
a la baraja 00:47:05
Vale, pues venga, vamos a ver jugar carta 00:47:07
Que es un poquito el más complicado 00:47:15
Porque mostrar mano es facilísimo 00:47:16
Es mostrar la mano, ya está, un puntito 00:47:18
Hacer un font para mostrar la lista 00:47:20
Este no hace falta hacerlo 00:47:22
Jugar carta, vamos a hacer jugar carta 00:47:24
Y luego ya es hacer un main que llame a las cosas 00:47:27
Y nada más 00:47:29
Venga 00:47:30
Jugar carta 00:47:31
Vamos a ver 00:47:34
jugar carta 00:47:35
la devuelve como valor de retorno 00:47:44
¿vale? 00:47:47
¿qué es lo que tiene que hacer? 00:47:58
lo que tiene que hacer es, ¡ay! se le pasa un palo 00:48:00
jugar carta de un palo 00:48:03
vale, pues tiene que seleccionar 00:48:04
la carta más alta 00:48:11
de ese palo, que esa es 00:48:12
la carta jugada, la que habrá que 00:48:14
devolver a la baraja, eliminar de la mano, etc 00:48:16
luego nuestro objetivo aquí 00:48:18
aquí es uno de los ejemplos en los cuales 00:48:20
uno tiene que organizar bien 00:48:23
en la cabeza los pasos de lo que va a hacer 00:48:24
¿vale? para luego no empezar a liarse 00:48:26
y que le salga aquí un código raro 00:48:29
¿su objetivo final cuál es? va a ser 00:48:30
hacer un remove de la lista 00:48:33
esta, hacer un remove porque es eliminar una 00:48:35
carta y luego hacer 00:48:36
un add a la baraja 00:48:39
ese es su objetivo final 00:48:40
pero claro, primero hay que encontrar la carta 00:48:41
luego tenemos un objetivo, un target 00:48:44
que es encontrar esta carta 00:48:46
esta, esa es la que tenemos 00:48:49
que encontrar, porque una vez que la hayamos 00:48:51
encontrado ya podemos hacer 00:48:53
mano remove carta 00:48:54
y luego main 00:48:56
punto baraja 00:49:00
punto get cartas 00:49:02
punto add carta 00:49:05
¿vale? 00:49:06
y listo, lo único es que aquí 00:49:08
cuando ya 00:49:10
para que se calle 00:49:11
vale 00:49:15
y luego devolveríamos la carta 00:49:16
aquí ya vemos que ya 00:49:19
vamos a borrar, vamos a usar remove 00:49:24
de esto que es una 00:49:26
bueno, porque dice el método 00:49:27
que la devuelva 00:49:30
devuelve la carta, luego el main a lo mejor la usa 00:49:31
luego para algo, lo que sea 00:49:34
luego además te decía aquí que muestres jugando 00:49:35
el número, pero todavía no lo has averiguado 00:49:38
vale 00:49:39
entonces, aquí nos paramos 00:49:39
cuidado que estoy haciendo un remove 00:49:43
en una colección 00:49:45
el remove usa 00:49:47
equal si es una lista 00:49:49
hasco de equal si es un haset 00:49:51
y compare tú si es un triset 00:49:53
vale, pues cuidado, están esos métodos 00:49:55
en la colección correspondiente 00:49:59
vamos a ver, mano que es 00:50:00
mano es una lista 00:50:02
luego tiene que haber un equals en carta 00:50:04
para que remove funcione 00:50:07
vale, entonces cuidado 00:50:09
cada vez que hagáis un remove, un contains 00:50:10
porque remove y contains exigen 00:50:12
que en la lista correspondiente 00:50:14
la clase 00:50:17
a la que pertenecen 00:50:18
los objetos de esa lista tenga el método 00:50:20
que toque, que en una lista cualquiera 00:50:22
es equals, en un hash set 00:50:25
o linked hash set es un hasco de equals 00:50:27
en un triset es 00:50:28
compare tú, vale 00:50:30
pues lista de carta, ¿carta tiene equals? 00:50:34
pues tiene equal 00:50:38
porque se lo hemos puesto antes 00:50:39
pues genial, vale 00:50:40
pues entonces 00:50:43
ahora que nos falta, nos falta 00:50:44
localizar esta carta, que es la más alta 00:50:46
de ese palo, pues venga 00:50:48
vamos a, ya sabemos que 00:50:50
inicialmente 00:50:52
tenemos la suerte de que está ordenada 00:50:55
luego vamos a 00:50:57
poner 00:50:59
como carta que sea 00:51:01
la primera de todas 00:51:03
mano punto get 00:51:06
cero, la primera, y ahora recorremos todas 00:51:07
las demás, a ver si encontramos alguna 00:51:09
cuya puntuación sea mayor 00:51:11
teniendo 00:51:13
ese palo 00:51:15
¿eh? 00:51:17
bueno, voy a hacer algoritmo de máximo 00:51:19
que es, asumo que 00:51:23
esto es como si fuera carta máxima 00:51:25
asumo que la máxima 00:51:26
es la primera y luego ya recorro el resto 00:51:29
a ver si alguna supera la máxima y ya está 00:51:31
bueno, a ver, llámala como quieres 00:51:32
si te quedas más tranquilo llamándola así 00:51:37
me da lo mismo 00:51:38
me da igual, si lo que importa 00:51:39
es que esa carta va a ser la carta 00:51:44
que tiene el máximo número 00:51:46
dentro de ese palo, inicialmente 00:51:48
la primera de todas. Y ahora vamos a ver 00:51:50
recorremos 00:51:52
para 00:51:54
ind igual a 00:51:56
1. Porque la 00:51:58
primera ya la hemos mirado. Mientras 00:52:02
i sea menor que mano.6 00:52:04
Incrementando i. 00:52:07
Nos preguntamos 00:52:11
¿la carta 00:52:12
esta de 00:52:14
aquí es de 00:52:16
Este palo es igual a palo y además de ser igual a palo, porque la primera ya la he encontrado con, justo eso iba a decir, que en cualquier caso esta podría no ser de ese palo. 00:52:18
Entonces, tendríamos que quedarnos con la primera carta que es igual de ese palo, ¿vale? 00:52:45
Sí, perdón, me ha faltado este. 00:52:53
Vale, entonces un momentito, vamos a completar 00:53:02
esto y vemos como esto podría dar un 00:53:04
y mano.get 00:53:06
.getNumCartas 00:53:12
es mayor 00:53:17
que 00:53:21
cartaMax.get 00:53:24
con cartas 00:53:26
entonces 00:53:28
pero hay que cambiar 00:53:32
carta máxima, entonces 00:53:34
máxima 00:53:36
igual a 00:53:39
mano.get 00:53:40
mano.get 00:53:43
mano.get 00:53:45
el objetivo de esto es ir 00:53:45
navegando por toda la mano y para todas 00:53:49
aquellas, solo aquellas cuyo palo sea 00:53:51
este, las que superen 00:53:53
número 00:53:54
la que tiene el máximo 00:53:56
pues ya estaría 00:53:59
pero cuidado que tenemos un problema 00:54:00
por ejemplo, imaginaos que 00:54:03
me han pasado oros 00:54:05
y la primera carta es 00:54:06
el doce de espadas 00:54:09
pues ninguna carta de oro 00:54:11
superaría el doce de espadas 00:54:15
es el número doce 00:54:16
claro 00:54:18
por eso esta inicialización está mal 00:54:19
entonces, lo que podríamos es 00:54:22
quitar la 00:54:25
sí, pero el tema es que 00:54:31
al comparar 00:54:33
yo no puedo poner aquí un null 00:54:35
o sea, puedo poner una carta porque entonces 00:54:36
aquí me saldría cuando hago el gendun cartas 00:54:38
pero puedo poner una nueva carta 00:54:41
de este mismo palo y con puntuación 0 00:54:42
new carta 00:54:44
new carta 00:54:47
Y ahora pongo 00:54:54
Carta max 00:54:59
Punto set 00:55:01
Palo 00:55:02
Igual al palo que me han pasado 00:55:03
Creo que no, porque como he ido al 00:55:05
Iset num cartas 00:55:07
Cero 00:55:11
Y luego abajo aquí pondría 00:55:13
Y ahora aquí el cero 00:55:16
Vale 00:55:17
Vale, new carta, el constructor sin parámetros está indefinido. 00:55:21
Debe ser que he hecho un constructor con parámetros en algún momento. 00:55:25
Claro, es que he hecho un constructor con parámetros. 00:55:28
Vale, pues entonces podríamos haber hecho esto más fácil. 00:55:31
New carta, palo, cero. 00:55:33
Y me ahorro esto. 00:55:36
¿Vale? 00:55:40
Entonces, hacemos algoritmo de máximo. 00:55:41
Ponemos una carta cualquiera que sea de este palo con puntuación cero. 00:55:44
Para que ya la primera de todas, la primera, sea la carta máxima. 00:55:48
Y ahora ya, para todas las cartas de la mano 00:55:52
Que sean de ese palo 00:55:54
Y su número de cartas supere 00:55:55
A la que es máxima hasta ese momento, actualiza 00:55:58
Y ya está 00:56:00
Ya tenemos la carta máxima 00:56:02
Yo pondría aparte un i 00:56:03
Por si acaso se sigue valiendo cero 00:56:05
Es decir, no ha encontrado la carta 00:56:07
Claro, es que lo vamos a tener que poner 00:56:08
Porque aquí me dice que nos falta añadir el mensajito 00:56:10
Entonces, ahora 00:56:13
Primero añadimos el mensajito 00:56:15
Que es 00:56:18
carta máxima 00:56:20
punto 00:56:22
getNumCartas 00:56:22
es mayor que cero 00:56:25
es porque ha encontrado carta 00:56:27
y en ese caso 00:56:28
jugando carta 00:56:30
jugando carta 00:56:31
y ahí se ponen los datos 00:56:36
ni lo pongo 00:56:38
y si no es porque sigue siendo cero 00:56:38
con lo cual no se actualizó 00:56:42
o lo que es lo mismo 00:56:43
no existe ninguna de ese palo 00:56:44
ninguna 00:56:45
pues entonces se pone 00:56:46
No tengo 00:56:48
Carta de ese palo 00:56:50
No tengo carta 00:56:54
De ese palo 00:56:55
Y aquí ya saldría 00:56:57
Return null para que no me haga el add y el remove 00:56:58
Claro 00:57:03
El mensajito que fuera 00:57:03
Y ya está 00:57:08
Me aseguro que salgo 00:57:12
Del método 00:57:14
Porque esto solamente lo quiero hacer 00:57:14
En el if 00:57:18
Lo podríais meter en el if como quisierais 00:57:19
vale, pues bueno, este era un poquito 00:57:21
el método más complicado 00:57:25
pero vamos, que en realidad es 00:57:26
hacer un algoritmo de máximo 00:57:28
para encontrar una carta 00:57:30
y luego borrarla de una lista 00:57:31
y añadirla a otro, a un set 00:57:34
y ya está, vale 00:57:36
y esto ya 00:57:38
la inicialización era lo más 00:57:41
que os podía complicar 00:57:44
vale, y esto ya es uno y medio 00:57:45
este en na 00:57:48
Vale, y ahora aquí 00:57:49
Vale, habría que hacer el main 00:57:56
¿Vale? 00:58:03
El main es 00:58:05
Venga, vamos a ver lo que nos da tiempo a hacer del main 00:58:06
Mostrar mano lo dejamos 00:58:09
Porque no es nada, recorrer un list 00:58:11
Vale 00:58:13
Venga, pues main 00:58:14
La baraja ya está creada 00:58:20
¿Vale? Es una variable estática del main 00:58:24
Y ahora 00:58:27
Dos objetos jugador 00:58:30
Con cualquier nombre y a puntuación 0 00:58:33
Pues venga 00:58:35
Vamos a crear 00:58:36
Jugador 1 00:58:38
Igual a new jugador 00:58:40
Que es el jugador Luis 00:58:42
Que tiene 0 puntos 00:58:45
Jugador 00:58:47
Y aquí sí que no tengo constructor con parámetros 00:58:53
Venga, se lo voy a poner 00:58:56
Ah, que estoy en 00:58:58
Ah, vaya 00:59:01
Bueno, hasta luego 00:59:05
Sí, pero me da unos parámetros que luego tengo que cambiar también 00:59:07
Son nombres muy raros 00:59:12
Entonces casi mejor así y así me pone los nombres buenos 00:59:13
Un constructor con puntuación 00:59:15
Y nombre y puntuación 00:59:19
Venga, ya está 00:59:21
Y ahora lo mismo otro jugador 00:59:23
¿Vale? Pues venga 00:59:25
Ya tenemos dos jugadores 00:59:37
Ahora 00:59:45
Cada jugador recibe 10 cartas 00:59:46
Al principio 00:59:49
Escogidas aleatoriamente 00:59:50
De la baraja 00:59:53
Esto de escogidas aleatoriamente de la baraja 00:59:54
¿Vale? Pues lo podíais hacer 00:59:57
De muchas maneras 00:59:59
Pero si uno pues 01:00:00
Da las 10 cartas que le den la gana ahí 01:00:02
no, vale, por ejemplo 01:00:05
vamos a hacer primero el jugador 1 01:00:08
bueno, vamos a hacer un bucle que se ejecute 10 veces 01:00:13
vale, pues aquí podríais jugar con 01:00:15
el random, ¿verdad? 01:00:26
claro, pero podemos hacerlo 01:00:30
más sencillo, si queréis 01:00:32
que es 01:00:34
punto 01:00:34
recibir carta 01:00:37
New carta 01:00:39
Oros 01:00:42
De I 01:00:47
Entonces aquí empiezo en 1 01:00:50
Y acabo en 10 01:00:52
Pues mira, al primero le he dado 01:00:54
Todos los oros 01:00:56
A ver, es que recibir carta ya la sacaba 01:00:57
Esa es la historia 01:01:07
El método recibir carta 01:01:09
de jugador 01:01:11
el método recibir carta 01:01:13
la carta que le pasas 01:01:15
ya la saca de la baraja 01:01:18
la añade a tu madre y le saca la baraja 01:01:19
entonces repartir 01:01:22
es hacer esto, recibir cartas sin más 01:01:23
y la baraja esta seguirá quedando vacía 01:01:25
pues yo lo estoy haciendo 01:01:27
ah ya 01:01:29
por no hacerlos aleatoriamente 01:01:33
ya bueno ya 01:01:35
pero me refiero que sea aleatorio 01:01:39
que también puede ser aleatorio 01:01:41
vuestro cerebro, me refiero que 01:01:43
cualquier, con aleatoriamente 01:01:45
estaba más elegido, podía ser al azar 01:01:47
queríamos decir al azar 01:01:49
que las que te dieran la gana 01:01:51
entonces a ver, si esto es añadir un random 01:01:52
y ya está entre cuatro y en función de eso seleccionar 01:01:55
si es oro, si luego añadir un random para aquí 01:01:57
¿vale? 01:01:59
y como las vas 01:02:02
sacando da igual que se repitan 01:02:03
pero 01:02:04
entonces 01:02:05
Venga, esto nos vale 01:02:08
Al primero le hemos dado todos los oros 01:02:20
De hecho, si miráramos el tamaño con el que se ha quedado la baraja 01:02:22
Saca una carta de la baraja 01:02:24
Y la mete en la mano del jugador 01:02:30
Entonces, por ejemplo, si nosotros aquí mostráramos 01:02:31
Lo que tiene la baraja 01:02:34
Antes y después, debería quedarse 01:02:36
Aquí tiene 40, la baraja tiene 01:02:37
Sí, pero ya he dicho 01:02:40
Para mí el azar es 01:02:48
Le doy los 10 oros al primero y las 10 copas al segundo 01:02:50
Queda igual, queda lo mismo 01:02:53
¿Cómo recibir carta por 10? 01:02:55
Porque recibir carta 01:03:04
Hay que pasar a una carta, recibir carta vacío no existe 01:03:05
Recibir carta y pasar a una carta 01:03:07
tienes que pasarle cartas 01:03:08
y además cartas que no estén en la baraja 01:03:13
porque ya se han sacado de antes 01:03:15
vale, la baraja tiene 01:03:17
y aquí si ponemos 01:03:19
baraja.size 01:03:21
baraja.getCartas 01:03:23
perdón 01:03:30
si lo probamos antes y después 01:03:30
primero me tendrá que decir 40 y luego 20 01:03:38
porque he repartido 10 a cada uno 01:03:40
vale 01:03:42
vamos a hacer, a probar solo este main 01:03:44
para ver si realmente 01:03:50
inicialmente la baraja tiene 20 01:03:51
o sea se ha inicializado bien con el, perdón 40 01:03:53
y luego después de haber 01:03:55
hecho esto, la baraja se ha quedado 01:03:57
con 20, con lo cual habrá 10 ya 01:03:59
en la mano de este y 10 en la mano de este otro 01:04:01
40 y 20 01:04:03
perfecto 01:04:10
hay 10 en la mano de este y si tuviéramos 01:04:11
el mostrar mano hecho veríamos que efectivamente 01:04:14
Vale, ¿y qué más hay que hacer aquí? 01:04:16
Ya con esto pues llevamos casi el 8 01:04:19
O el 8 y pico en el examen 01:04:21
Venga 01:04:23
Ya, sí 01:04:24
Venga, a ver 01:04:30
Cada jugador recibe 10 cartas 01:04:33
El sistema elige un palo aleatoriamente 01:04:34
Bueno, aquí sí que se puede hacer con un 01:04:37
Y ahora empieza el juego 01:04:40
Y ahora esto es un bucle que está todo el rato 01:04:41
Vale 01:04:44
Elige un palo aleatoriamente 01:04:45
A ver 01:04:56
Vale, a ver, aquí se podría hacer un random 01:04:56
Entre 1 y 4 01:05:02
Y luego ya en función de si es 1, 2, 3 y 4 01:05:03
Cogeré los espadas, bastos y no sé qué 01:05:06
Pero para mí, elegir un palo 01:05:07
Aleatoriamente es esto 01:05:10
Sí, pero lo especificaremos 01:05:11
A ver, este enunciado 01:05:16
Luego de palabra 01:05:18
Sí que dijimos ciertas cosas 01:05:19
Para facilitaros 01:05:21
La optimización del tiempo 01:05:24
Claro 01:05:25
Enunciado de mañana 01:05:26
Quedará más especificado 01:05:29
Claro, o sea que el juego 01:05:32
Va a acabar instantáneamente 01:05:38
Porque el juego finaliza 01:05:39
Es decir, más altos 01:05:41
No ha podido jugar 01:05:43
Y el otro sí, si no ha podido jugar 01:05:44
No, porque si no ha podido jugar, cada jugador recibe 01:05:46
Cartas para que vuelva a tener 10 01:05:49
Claro, pero como ya tiene 10 01:05:51
Pues se metería en un bucle infinito 01:05:53
Efectivamente 01:05:55
En este caso, venga, vamos a poner oro 01:05:56
Pero da igual, se metería en un bucle infinito y no pasa nada 01:05:58
Tu programa estaría bien 01:06:01
Lo que pasa es que qué mala suerte 01:06:02
Que todos tengan oro 01:06:05
O copas 01:06:06
Venga 01:06:08
Pues ala, el palo aleatorio es 01:06:09
Oros 01:06:13
Y ahora, ¿qué hace el programa? 01:06:14
Un bucle 01:06:17
Y ahora un bucle que está todo el rato haciendo esto 01:06:18
Pues venga, un bucle 01:06:21
¿Cuándo termina el juego? 01:06:22
Pues ya veremos cuándo termina 01:06:25
Es un bucle que está todo el rato 01:06:26
Haciendo lo que me digan 01:06:29
Pues venga, ¿qué hace todo el rato? 01:06:30
Cada jugador 01:06:36
Trata de jugar la carta más alta 01:06:37
de ese palo, para eso tenemos un método 01:06:39
afortunadamente 01:06:41
vale, entonces 01:06:42
la carta 01:06:44
que juega el jugador 1 01:06:47
la carta que juega el jugador 1 01:06:49
será 01:06:51
jugador1.jugarCarta 01:06:51
del palo que me han dado 01:06:55
vale 01:06:57
la carta 01:06:58
que juega el jugador 2 01:07:01
es esta 01:07:03
jugarCarta de ese mismo palo 01:07:05
ya tengo las dos cartas 01:07:07
jugadas que pueden ser nul 01:07:09
si alguno de los dos no ha podido jugar 01:07:10
o los dos, vale 01:07:13
si una 01:07:14
de las dos es nul y la otra 01:07:17
no, el que no sea nul 01:07:19
sube la puntuación 01:07:21
y si las dos son nul, recibimos 01:07:22
carta hasta 10 01:07:25
vale, vamos a 01:07:26
son tres casos, que ninguna 01:07:28
de las dos sea nul, pues el 01:07:31
de la carta más alta sube la puntuación 01:07:33
pues venga 01:07:35
Si C1 es 01:07:35
Diferente de nul 01:07:39
Vale, reconozco que era un poco complicado 01:07:40
El ejercicio, o largo más bien 01:07:45
Si C1 es diferente de nul 01:07:47
Sí, sí, sí 01:07:49
No estuvo muy bien logrado este ejercicio 01:07:52
El enunciado no estuvo bien 01:07:55
Vale 01:07:58
Tranquilo 01:08:00
Tato controlado 01:08:05
Si los dos han jugado cartas, vamos a ver cuál tiene mayor para subir la puntuación. 01:08:07
Pues venga, si c1.getnumCartas es mayor que c2.getnumCartas, 01:08:11
Pues entonces, jugador1.set.puntuación igual a jugador1.get.puntuación más 1. 01:08:23
Podéis hacer el jugador, sube punto, incrementar puntuación y ya está. 01:08:45
Y estupendo y muy bonito. 01:08:50
y si no, pues lo mismo 01:08:51
pero es jugador 2, no pueden tener 01:08:54
la misma puntuación porque es el mismo palo 01:08:56
o es uno o es el otro 01:08:57
no pueden ser que saquen la misma puntuación los dos 01:08:59
porque no pueden tener cartas repetidas 01:09:02
y si no es el jugador 2 01:09:04
ala, la primera parte está 01:09:07
pero que ocurre 01:09:12
si esto no se ha cumplido 01:09:14
que sean los dos diferentes de null 01:09:16
el save 01:09:18
Y lo que ocurre es que 01:09:19
C1 es igual a nul 01:09:23
Es diferente 01:09:30
De nul 01:09:32
¿Por qué no pones C1 o C2? 01:09:33
Sí, es que no 01:09:39
Porque no sé ni lo que hay que hacer 01:09:40
Vale, el que ha jugado 01:09:41
Cartas sube 1, bueno, porque tenemos que distinguir 01:09:44
Pero sí podría 01:09:46
si a ver, si c1 01:09:47
es, o sea tarde o temprano voy a tener 01:09:50
que, si c1 es 01:09:52
igual a nul o 01:09:54
c2 es igual a nul 01:09:55
pues ahora ya 01:09:58
tengo que ver 01:09:59
claro 01:10:01
pero tiene que ser excluyente 01:10:04
porque si los dos son nul no le subo la puntuación 01:10:06
tiene que ser excluyente 01:10:09
entonces 01:10:10
si c1 es igual a nul y 01:10:11
c2 es diferente de nul 01:10:14
Entonces 01:10:16
Efectivamente 01:10:17
Al jugador 2, este de aquí 01:10:20
Este código se puede hacer más bonito 01:10:22
Anidándolos, pues estamos repitiendo 01:10:24
Código a lo bestia, esto está muy feo 01:10:26
Pero bueno, estamos en un examen 01:10:28
Y ahora el otro, el save 01:10:30
En un examen, pues es que uno optimizar código 01:10:36
Para no tener tantos anidados 01:10:38
No estamos 01:10:40
Por la labor 01:10:42
C2, C1 01:10:43
pues entonces es el jugador 1 01:10:47
y ahora el else 01:10:49
es que ninguno haya jugado 01:10:52
vale, pues si ninguno 01:10:55
ha jugado carta 01:11:01
hay que dar hasta que vuelvan a tener 10 01:11:02
entonces 01:11:04
el jugador 1 tendrá que recibir 01:11:06
tantas cartas como 10 menos 01:11:09
tamaño de cartas tenga 01:11:10
y el jugador 2 pues entonces vamos a ver 01:11:12
¿cuántas cartas recibe el jugador 1? 01:11:15
Número de cartas del jugador 1 01:11:17
Pues el número de cartas que tiene que recibir el jugador 1 01:11:20
Va a ser 01:11:22
10 menos 01:11:23
Jugador1.getMano.size 01:11:25
Estas va a recibir el jugador 1 01:11:31
Vale 01:11:32
Y ahora ya que hacemos 01:11:34
Pues un bucle 01:11:36
Desde int igual a 0 01:11:38
Mientras 01:11:40
Y sea menor que 01:11:41
Las cartas que tiene que recibir el jugador 1 01:11:44
y más más 01:11:47
pues jugador 1 01:11:50
punto recibir carta 01:11:51
y ahora 01:11:53
lo mismo con el jugador 2 01:11:57
efectivamente 01:11:58
hay que ponerle 01:12:16
aquí una carta de 01:12:18
la baraja, si esto es un rollo patatero 01:12:19
Que no, que no, que esto fue una fumada 01:12:22
Pero bueno, nosotros también fumamos a veces 01:12:28
Por eso es que repetir cada vez 01:12:30
La carta a mano es imposible 01:12:36
Claro, entonces 01:12:37
Recibir carta 01:12:39
Y tiene que recibir una carta 01:12:45
Claro, entonces aquí 01:12:47
la carta que recibimos 01:12:54
pues tiene que ser una acogida 01:12:56
de la baraja 01:12:59
¿Dónde? 01:12:59
¿No hay un método que te haga una carta de la baraja? 01:13:03
¿Sería en el recibir 01:13:06
carta que editarlo? 01:13:09
Sí, pero 01:13:11
claro 01:13:12
Sí, pero 01:13:13
Sí, sería lo ideal 01:13:16
Vale, pero estoy viendo cómo sacar aquí 01:13:18
Cartas de la baraja 01:13:20
Hasta que 01:13:22
Ya, pero en el resto del juego 01:13:24
Pueden 01:13:29
Hasta que llegue a salir 01:13:30
Claro, pero esto para que fuera más o menos bonito 01:13:32
Claro, no, esto cómo lo podríamos dejar bonito 01:13:39
bueno, sí, pero luego nos faltaría la condición 01:13:45
y la condición de finalización sería 01:13:49
mientras la carta 01:13:50
el tamaño de la baraja 01:13:53
sea 01:13:55
mayor que cero 01:13:55
while baraja.get 01:13:58
cartas.size 01:14:01
mayor que cero 01:14:04
mientras haya cartas 01:14:06
en la baraja 01:14:07
intentamos jugar 01:14:08
se puede dar de todo 01:14:10
pero da igual 01:14:27
es el 10 igual 01:14:28
tú haces esto y tienes un 10 01:14:30
me hicieron oríficas 01:14:32
tienes menos 01:14:34
vale 01:14:36
Es que yo ya estoy bloqueada 01:14:41
sobre cómo... 01:14:43
Que no, que no, que... 01:14:45
No, más fácil, más fácil. 01:14:47
Esto era muy... 01:14:51
El main era muy complicado. 01:14:52
A ver, el de recibir carta, no. 01:14:53
El main era complicado. 01:14:56
A ver, aquí lo que pasa es que 01:15:00
lo que tendría sentido es hacer un... 01:15:05
Saca carta 01:15:11
Baraja 01:15:17
Y aquí 01:15:18
A ver 01:15:23
De todas formas es muy fácil 01:15:35
Escoger la primera carta de la baraja 01:15:37
Y ya está, le damos siempre la primera 01:15:39
No hace falta la zar 01:15:40
Claro, yo hago aquí un método 01:15:41
Sacar carta baraja 01:15:44
Y me hago lo siguiente 01:15:46
For 01:15:48
Carta 01:15:50
C en 01:15:52
Baraja.getCartas 01:15:53
La primera que me sale 01:15:57
La devuelvo y punto pelota 01:15:59
Y ya está 01:16:00
Retur C 01:16:02
Y ahora para que este se calle 01:16:04
Un retur 01:16:08
Y ahora ya aquí 01:16:10
Recibir carta, sacar, saca carta baraja 01:16:14
¿Qué? 01:16:16
Arriba, dentro del paréntesis 01:16:18
Puedes poner 01:16:20
Baraja.getcarta de cero 01:16:20
No, porque es un set 01:16:24
No es una lista, si fuera un set sería 01:16:26
Y podrían hacer lo del push y pop 01:16:30
Que decía él, que sería mucho más fácil 01:16:31
Sacar carta, pop 01:16:33
Devolver carta, push 01:16:34
Pero como es un set 01:16:37
Pues sacar carta baraja 01:16:38
No sea más remedio que iterar 01:16:40
Para coger la primera 01:16:42
No sea otra 01:16:43
Este es mi propio 01:16:45
Claro 01:16:47
La que salga 01:16:51
Vale, sacar carta baraja 01:16:52
Entonces 01:16:55
Recibir carta 01:16:56
Sacar carta baraja 01:17:00
¿Y qué me dice aquí? 01:17:01
Ah, que no lo he puesto estático 01:17:04
Vale, bueno, lo voy a subir a la hora virtual 01:17:05
A ver, lo que pasa es que en un examen 01:17:24
Uno se le va mal la pinza 01:17:32
Uy, que ni ha parado 01:17:37
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
17 de febrero de 2025 - 14:27
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 17′ 42″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
374.08 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid