Saltar navegación

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

Clase 11-03-24 - 1 - 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 3 de abril de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues venga, ordenar la lista de mayor a menor. 00:00:00
Ordenar, no nos hace falta programar un algoritmo de ordenación, que podríamos, 00:00:05
porque tenemos un método dentro de la interfaz list. 00:00:11
Entonces, números es una lista. 00:00:15
Entonces, como números es una lista, me ofrece un montón de métodos, 00:00:18
uno de ellos el sort. 00:00:22
Entonces, el problema del sort es que tenemos que, como hemos visto hasta ahora nosotros, 00:00:24
darle un criterio de ordenación 00:00:28
al menos tengo que dar un objeto 00:00:30
un objeto que se supone que es un objeto 00:00:32
que cumple la condición 00:00:34
de ser criterio de ordenación 00:00:36
¿vale? 00:00:38
aquí tendría que dar un objeto 00:00:40
¿pero qué ocurre? 00:00:41
que uno podría pensar, oye pero a ver 00:00:46
los números 00:00:48
los enteros 00:00:49
ya tienen un orden natural 00:00:51
o sea, hay cosas que ya en Java 00:00:54
tienen su orden natural 00:00:56
que son muy poquitas 00:00:58
son en las variables primitivas 00:00:59
los números 00:01:02
de cualquier tipo 00:01:04
byte, ind, double, todos tienen el orden 00:01:05
el orden algebraico de toda la vida, tienen su orden natural 00:01:08
y los char 00:01:10
que tienen el orden de la tabla 00:01:12
así, vale, entonces todas las variables 00:01:14
primitivas tienen un orden 00:01:16
natural que no hace falta 00:01:18
que yo lo programe 00:01:19
cuando queremos comparar un número n1 con un número n2 00:01:21
ponemos n1 menor que n2 00:01:24
y ya está, no nos complicamos la vida 00:01:26
luego aparte hay otros tipos 00:01:28
de variables que también tienen orden 00:01:30
porque se ha 00:01:32
programado en la clase a través del 00:01:34
compare to etc, como string 00:01:36
ya lo hemos visto otras veces, pero bueno 00:01:38
estamos hablando de enteros 00:01:40
entonces los enteros uno podría decir con todo el criterio del mundo 00:01:42
los enteros tienen ya un orden 00:01:45
natural, que es 3 es menor 00:01:46
que 5, o sea no el orden que conocemos 00:01:48
de toda la vida, tienen ya 00:01:50
entonces es necesario que yo 00:01:52
especifique criterio de ordenación 00:01:53
en este caso concreto sí, porque me han dicho 00:01:55
ordena de mayor a menor 00:01:58
ordena de mayor a menor 00:02:00
pero incluso 00:02:02
si hubiera una forma 00:02:04
de que sort usara 00:02:06
el orden natural de los enteros 00:02:08
pues yo podría ordenarlo 00:02:10
por el orden natural 00:02:12
y luego a la hora de mostrar, hacer el recorrido 00:02:13
al revés, mostrar de la última a la primera 00:02:16
y así lo mostraría en el orden de mayor a menor 00:02:18
¿entendéis lo que quiero decir? 00:02:20
en cualquier caso, el problema que estoy 00:02:22
planteando es, si los números 00:02:24
tienen un orden ellos, por naturaleza 00:02:26
matemática 00:02:28
realmente, si yo quiero ese 00:02:29
orden natural, es necesario 00:02:32
que yo especifique aquí un criterio de ordenación 00:02:34
pues la respuesta 00:02:36
es no, o sea 00:02:38
si yo aquí no especifico un criterio 00:02:40
de ordenación, si no lo especifico 00:02:42
entonces sort va a tirar 00:02:43
del orden que esté programado 00:02:46
en el tipo de objeto que yo le pase 00:02:47
entonces, ¿qué ocurre? que los 00:02:50
integre, que mi lista de números 00:02:52
los de integer tienen ya un orden programado, 00:02:53
que es el que conocemos nosotros. 00:02:56
Los string también lo tienen, 00:02:58
porque el string tiene dentro el método compareTo. 00:03:00
Es decir, ¿qué es lo que tiene un orden comparado? 00:03:03
Todo lo que sea comparable. 00:03:06
¿Os acordáis de la famosa interfaz comparable? 00:03:08
Pues vámonos un momento a la clase integer, 00:03:13
esta de aquí. 00:03:15
La clase integer está de aquí, 00:03:19
que no la hemos hecho nosotros, 00:03:21
porque ya está hecha, 00:03:23
y que sirve para guardar 00:03:24
un numerito entero 00:03:26
nada más que para eso y para ofrecerme 00:03:27
métodos para hacer cosas como el parseIn 00:03:30
pues esta clase resulta que implementa 00:03:31
comparable, vale 00:03:33
pues cuando una clase implementaba comparable 00:03:35
no os olvidéis de eso, ¿qué significa que 00:03:38
implementara comparable? 00:03:40
que automáticamente era obligatorio 00:03:41
que implementara el método 00:03:43
compareTu, ¿verdad? el compareTu 00:03:46
y al implementar el método 00:03:48
compareTu, damos un criterio 00:03:50
que define el orden de esos 00:03:52
objetos entre sí, luego 00:03:54
al implementar integer 00:03:56
comparable, los números 00:03:57
integer, los objetos integer 00:03:59
son ya ordenables, son 00:04:01
comparables, ya son ordenables 00:04:03
y cualquier clase que implemente 00:04:05
comparable, como tendrá que implementar el 00:04:07
método compareTo, pues ya es 00:04:09
ordenable, comparable, entonces 00:04:11
aquí, pues el método compareTo 00:04:14
pues estará por ahí abajo, en algún sitio 00:04:16
aquí como era que buscábamos 00:04:18
con control F 00:04:20
sí, ahí, vale 00:04:21
pues aquí lo tenemos, este es el método 00:04:32
compare tú, que implementa la clase integer, que a través de este método 00:04:35
que a su vez tendríamos que meternos en él, pero para qué arrastrar, pues te 00:04:40
fija el criterio de ordenación de los números enteros, que es el natural 00:04:43
el orden natural que te fija, el 3 es menor que 7, el 12 es menor que 15 00:04:47
bueno, pues qué quiero decir con esto, que todas las clases 00:04:51
que implementen comparable como esta 00:04:55
llevan ya ellas dentro 00:04:58
un criterio de ordenación, lo llevan ya dentro 00:05:00
que yo he hecho mi clase alumno 00:05:02
por ejemplo, que es el ejemplo que hicimos 00:05:05
mi clase dos objetos alumno 00:05:08
no son comparables por naturaleza 00:05:10
entonces si yo quiero 00:05:12
que dos objetos alumno sean 00:05:14
ordenables o comparables 00:05:16
en mi clase alumno tendría que hacer 00:05:17
el implement comparable y meter dentro 00:05:20
el compare to, lo que ya hicimos 00:05:22
entonces si yo he hecho eso, ya los objetivos 1 son comparables 00:05:24
bueno, pues si yo tengo una lista 00:05:27
yo tengo una lista de cosas 00:05:30
y la clase a la que pertenecen esas cosas 00:05:33
implementa comparable 00:05:37
ya llevan ellas dentro un criterio de orden 00:05:38
el que se haya decidido el comparator ya lo llevan dentro 00:05:42
bueno, pues entonces yo puedo en ese caso pasar 00:05:45
del comparator este y darle el 1 00:05:48
y entonces sort ¿qué hace? 00:05:51
como no le estás dando ningún criterio de ordenación 00:05:53
coge 00:05:55
el criterio de ordenación que tengan esas clases 00:05:57
programado dentro, en su compare tú 00:05:59
¿vale? bueno pues 00:06:01
en este caso, si yo ordeno 00:06:03
los números con sort y no le 00:06:05
pasó nada, los va a ordenar 00:06:07
con el criterio de ordenación que tenga 00:06:09
el compare tú de la clase 00:06:11
íntegre y el criterio de ordenación que tiene 00:06:13
el compare tú de la clase íntegre es el natural de los números 00:06:15
el ascendente 00:06:17
o sea de menor a mayor, el natural 00:06:19
¿vale? entonces, aquí me piden 00:06:21
de mayor a menor, entonces 00:06:24
no me valdría 00:06:26
este sort 00:06:29
tendría que hacer otro criterio de ordenación 00:06:29
a menos que se lo quiera mostrar 00:06:32
pues entonces ordeno así y luego muestro de abajo a arriba 00:06:34
pero si yo quiero tenerla 00:06:36
ordenada en orden descendente, este sort no me vale 00:06:38
vale, vamos a hacer primero esta prueba 00:06:40
porque como decís que el método no funciona bien 00:06:42
el que hemos hecho para probarlo 00:06:44
vamos a ordenar 00:06:46
ahora mismo 00:06:48
de menor a mayor 00:06:49
vamos a ordenarla 00:06:53
de menor a mayor 00:06:55
entonces 00:06:57
¿vale? entonces 00:07:00
repito, de menor a mayor 00:07:06
como es el orden natural de los números enteros 00:07:11
no le pasó nada 00:07:14
y sort va a coger el compare to 00:07:16
de integer, pero porque integer lo tiene 00:07:18
si yo a sort 00:07:20
no le pasó nada 00:07:22
y los objetos que forman parte de esta lista 00:07:24
no implementan compare, me tienen compare to 00:07:26
aquí sí que nos va a dar un error, nos va a decir 00:07:28
de compilación 00:07:30
no, pero en el momento de ejecutar me va a decir 00:07:33
oye, esto que me estás dando no implementa 00:07:34
comparable, no puedo, pero aquí 00:07:36
los íntegros que forman parte de números 00:07:39
se implementan comparables 00:07:40
luego cuando ejecutemos esto, va a decir 00:07:42
vale, te ordeno según ese criterio, que es el de menor a mayor 00:07:44
bueno, vamos a probarlo 00:07:47
a ver 00:07:49
qué ocurre, primero ordenamos de menor 00:07:50
a mayor y ahora mostramos la lista 00:07:53
entonces para mostrar la lista 00:07:54
Como solamente vamos a mostrar 00:07:56
Es muy cómodo hacer un for each 00:07:58
Y ahora vamos a mostrar n 00:08:01
Esto sería para mostrarla 00:08:08
Vale, vamos a ver 00:08:10
Donde nos salta esto 00:08:11
Ahí abajo 00:08:15
Bueno, como no he puesto introduzca número 00:08:20
En ningún momento, pues está ahí 00:08:27
Ah, vale, vale, vale 00:08:39
Ya sé lo que está pasando 00:08:42
45, claro, es que 00:08:43
El método leer cadena no captura la excepción 00:08:48
Vale, entonces yo le paso aquí una Y 00:08:51
Ah, es que debe ser que 00:08:53
Leer cadena sí que le puse capturar la excepción 00:08:59
Ah, lo miramos, vale, bueno 00:09:01
Pues cuando le he pasado algo que no cumple eso 00:09:03
No está 00:09:06
Funciona, claro, es que estaba bien todo 00:09:08
si se lo pusimos, claro, que la captura 00:09:11
la adentro, así no tenía que lanzarla afuera 00:09:13
vale, entonces 00:09:15
efectivamente ha ordenado de mayor a menor 00:09:17
bueno, pues todo ha funcionado, no sé 00:09:19
por qué te ha saltado la excepción 00:09:21
pero 00:09:22
¿te sale la excepción de number, formate, excepción? 00:09:26
¿y estás leyendo con el cadena o el entero? 00:09:31
porque el entero sí que te saltaría 00:09:33
pero el cadena 00:09:35
le cabe todo, sea la i, sea el 13 00:09:37
igual cuando haces el integer 00:09:39
parseIn estás metiendo otra cosa que no es lo que has 00:09:41
leído o algo, porque ahí también te saldría 00:09:43
si tú al integer parseIn le pasas 00:09:45
hola 00:09:47
el integer parseIn 00:09:49
al tratar de convertir hola a número 00:09:51
te va a salir el number forma exception también 00:09:53
pero en nuestro caso lo estamos haciendo bien 00:09:55
porque 00:09:57
estamos haciendo el parseIn 00:09:58
solo 00:10:01
si es número 00:10:02
solo si hemos verificado que es número 00:10:04
solo si hemos verificado que es número 00:10:07
le hacemos el integer parseIn 00:10:09
no sé, revísalo porque algo 00:10:10
vale, pues entonces 00:10:14
nos ha ordenado de manera 00:10:16
con el orden natural 00:10:18
de comparable, repito 00:10:19
si yo aquí en lugar de números 00:10:22
esa lista fuera de objeto cliente 00:10:23
y cliente no implementara 00:10:26
comparable ni tuviera por tanto 00:10:28
el compare tú, cuando yo 00:10:30
hubiera ejecutado esto, me habría dado el error 00:10:32
cliente no implementa 00:10:34
comparable, no puedo ordenar, me habría dado un error 00:10:38
de ejecución 00:10:40
pero integer si que lo implementa 00:10:41
entonces no nos da 00:10:44
bueno, pero ocurre que nosotros no queremos ordenar de menor a mayor 00:10:44
sino que queremos ordenar al revés 00:10:48
y además no solamente 00:10:50
que queramos mostrar al revés 00:10:52
porque si quisiéramos mostrar al revés 00:10:53
pues podríamos dejar esta ordenación 00:10:56
y luego recorrer la lista pero de la otra manera 00:10:58
entonces como es 00:11:00
una lista, puedo recorrer 00:11:02
por posición y entonces 00:11:04
si quiero mostrar la lista en el otro orden 00:11:05
podría hacer esto 00:11:08
mostrar la lista en orden inverso 00:11:08
pues podríamos hacer esto, ¿verdad? 00:11:13
desde i igual a la última posición de la lista 00:11:20
que es números 00:11:25
punto 6 menos 1 00:11:26
por ejemplo, mientras, perdón 00:11:30
claro, desde la última hasta la primera 00:11:33
mientras i sea mayor o igual que 0 00:11:37
decrementando i 00:11:40
mostramos 00:11:42
números.get i 00:11:46
vale 00:11:52
esto me mostraría la lista 00:11:54
en orden, o sea desde la última 00:11:56
posición a la primera 00:11:58
esta es la última posición 00:11:59
decrementando mientras si 00:12:02
sea mayor o igual que cero que es la primera 00:12:04
entonces esto 00:12:06
me la mostraría 00:12:08
en orden del mayor 00:12:10
al más pequeño, lo que pasa es que la lista 00:12:12
no es que estuve ordenada así, la lista estaría ordenada 00:12:14
en orden ascendente 00:12:16
lo que he cambiado es la forma de recorrerla 00:12:17
para mostrarla 00:12:20
vale, es lo único que he cambiado, la forma de recorrerla 00:12:21
para mostrarla 00:12:24
si ejecutamos esto 00:12:25
pues me pide 00:12:28
los números 00:12:30
vale 00:12:31
me dio dos 7 00:12:40
esta es 00:12:42
el primer recorrido con el for each 00:12:44
y el recorrido 00:12:47
de abajo es el segundo 00:12:49
que es al revés 00:12:52
es el espejo de este, obviamente 00:12:53
es el espejo del de arriba 00:12:55
vale, pero bueno 00:12:56
nosotros ahora lo que queremos es 00:12:59
que además esté ordenada la lista 00:13:01
que esté de hecho ordenada 00:13:03
en orden del mayor al menor 00:13:05
entonces ese no es 00:13:07
el orden natural de los integer 00:13:09
entonces como ese no es el orden natural 00:13:11
de los integer, no puedo ordenarla así 00:13:13
no puedo ordenarla así 00:13:15
porque si yo le paso null 00:13:18
me lo va a ordenar como diga 00:13:19
el comparable de la clase 00:13:21
y el comparable de la clase dice de menor a mayor 00:13:22
porque así está hecha la clase íntegra 00:13:25
así está hecha 00:13:26
bueno, pero entonces tenemos una alternativa 00:13:27
que es usar el sort como hemos usado otras veces 00:13:30
le voy a pasar yo mi propio criterio 00:13:32
y ese criterio va a 00:13:35
sobreescribir 00:13:37
va a pesar más que el de 00:13:37
la clase, que el comparable de la clase 00:13:40
le vamos a pasar nuestro propio criterio 00:13:43
pues venga, vamos ahora a ordenar 00:13:44
ahora ya sí 00:13:47
vamos a ordenar de mayor a menor 00:13:47
vale, pues vamos a ordenarla de mayor a menor 00:13:53
repito, hay que darle un criterio de ordenación 00:13:58
que sustituya al que tiene la clase íntegra dentro suya 00:14:02
que lo sustituya 00:14:06
para esta ordenación solo, no para siempre 00:14:07
claro, para esta ordenación 00:14:09
y eso lo hacíamos instanciando un objeto 00:14:10
que tendremos que crear 00:14:12
pues como es una clase que voy a crear yo 00:14:14
la llamo como me dé la gana 00:14:18
pues orden descendente 00:14:20
para que no sea tan larga 00:14:24
uy, vale, entonces 00:14:26
esta clase que nos tenemos 00:14:32
que crear es la que va a 00:14:36
programar el orden de mayor a menor 00:14:38
de dos números enteros 00:14:40
pues venga, vamos a crear la clase 00:14:43
me aprovecho del eclipse, que para algunas 00:14:47
cosas es útil, y cuando él me detecta 00:14:49
oye, que no existe ninguna clase así 00:14:51
dice, ¿quieres que te la cree? 00:14:53
venga, sí, créamela, me aprovecho de él 00:14:55
Le digo, venga, créamela. 00:14:57
Y es tan listo que ya él se da cuenta de que esta clase, 00:15:01
como la has metido dentro del sort, 00:15:05
tiene que implementar comparator. 00:15:06
Entonces, es tan listo que eso te lo pone. 00:15:08
Lo que ya no es tan listo es como para dejarte esto así. 00:15:10
¿Vale? 00:15:14
Venga, queremos una clase que implemente comparator. 00:15:15
¡Hala! 00:15:21
Entonces, implementa comparator, tiene que ir. 00:15:21
y ahora ya 00:15:24
este método tiene que devolver 00:15:27
negativo si este va antes que este 00:15:29
cero si van a la vez 00:15:33
y positivo si este va después, vale 00:15:35
ir antes 00:15:37
en el orden descendente, ir antes que significa 00:15:38
significa ser mayor 00:15:42
ser mayor, ir antes significa ser mayor 00:15:43
en ese caso 00:15:46
tiene que devolver negativo 00:15:47
o sea, si este es mayor que este 00:15:49
hay que devolver negativo 00:15:51
y si este es más pequeño que este 00:15:53
hay que devolver positivo 00:15:56
y si este es igual que este hay que devolver 0 00:15:58
pues lo más fácil es que esto devuelva 00:16:00
directamente O2 menos O1 00:16:02
y ya está 00:16:04
si este nos devuelve 00:16:05
O2 menos 00:16:10
O1 ya lo tenemos 00:16:12
si O1 00:16:14
es mayor que O2 00:16:16
esto es negativo 00:16:18
luego este va antes 00:16:19
que es lo que queremos indicar 00:16:20
queremos indicar que este va antes 00:16:23
si son el mismo, devuelve 0 00:16:24
que eso significa que están en la misma posición 00:16:26
en cuanto a orden 00:16:29
y si este es más pequeño 00:16:30
que este 00:16:33
devuelve positivo, que significa justo 00:16:33
que este va después 00:16:37
porque estamos en orden descendente 00:16:38
vale, pues ya tenemos 00:16:40
el criterio programado 00:16:42
vale, no confundáis 00:16:46
por tanto la interfaz 00:16:49
comparator con la interfaz 00:16:51
comparable, que son 00:16:53
para cosas distintas, no las confundáis 00:16:55
la comparable se asocia a una entidad 00:16:56
alumno, cliente, en la que 00:16:59
tú tienes la entidad con sus propiedades 00:17:01
y además le dices, y además 00:17:03
que implemente comparable 00:17:05
para que diferentes objetos alumnos 00:17:06
sean comparables entre sí 00:17:08
ese es comparable 00:17:10
la implementan las entidades, pues el alumno 00:17:12
el cliente, para fijar 00:17:14
un criterio de orden asociado a ellas 00:17:17
siempre, y esto 00:17:18
es un criterio de ordenación 00:17:20
un criterio de ordenación entre dos objetos 00:17:22
de un tipo 00:17:24
este es un criterio de ordenación 00:17:25
que va suelto 00:17:28
entonces comparable es una 00:17:30
característica más de una clase 00:17:37
sea alumno, sea cliente 00:17:39
sea factura, es una característica más 00:17:41
de una clase, eso es comparable 00:17:43
y comparator es un criterio de ordenación 00:17:44
que yo se lo doy a quien lo necesite 00:17:47
vale, pues quien necesita 00:17:49
el criterio de ordenación ahora en este 00:17:51
caso, pues lo necesitaba este 00:17:53
el sort, le pasamos este criterio 00:17:55
de ordenación 00:17:59
orden descendente 00:17:59
y ahora si volvemos 00:18:01
a mostrar la lista 00:18:04
la mostramos pues de 00:18:06
de arriba a abajo 00:18:10
vale, le vamos a poner 00:18:14
para distinguir 00:18:18
vale, pues esta es la primera 00:18:24
muestra que es 00:18:49
ordenado con la orden natural 00:18:50
1, 3, 7, 8 00:18:52
esta es ordenado, sigue ordenada 00:18:54
con su orden natural, pero la hemos recorrido 00:18:57
de abajo a arriba, la hemos recorrido 00:18:59
vale, y ahora 00:19:02
la hemos ordenado con nuestro 00:19:03
criterio de ordenación, y efectivamente 00:19:05
según nuestro 00:19:08
criterio de ordenación, la lista 00:19:09
se ha ordenado de 00:19:11
mayor a menor 00:19:13
vale, según nuestro 00:19:15
criterio de ordenación, y aquí en el 00:19:20
criterio de ordenación, uno pone lo que 00:19:28
le dé la gana, hombre claro, lo que tenga 00:19:30
que poner según lo que le estén pidiendo 00:19:32
el criterio de ordenación es para comparar 00:19:34
dos objetos sueltos, dos objetos 00:19:37
y decir cual va antes que el otro 00:19:39
vale 00:19:40
bueno pues ya tenemos entonces 00:19:45
la lista ordenada 00:19:48
y ahora solicitar un número 00:19:52
y eliminar de la lista tanto ese 00:19:55
número como todos sus divisores 00:19:57
eso es lo último que falta por hacer 00:19:59
ahora ya para eliminar de la lista 00:20:01
pues venga, hace de esta parte 00:20:03
Eliminar de la lista ese número de sus divisores 00:20:07
Y quien lo 00:20:09
Tenga hecho 00:20:11
Vale 00:20:13
Este no nos vamos a meter ahora 00:20:14
Porque el interés que tiene este 00:20:18
Es comparar HACET y TRISET 00:20:20
Y TRISET lo vamos a meter para el examen 00:20:22
¿Vale? 00:20:24
Pero sí que nos vamos a quedar con esta frase 00:20:25
Si cambiáramos 00:20:28
Si nosotros ahora cambiáramos 00:20:31
Nuestra aplicación 00:20:34
Y dijéramos, oye he cambiado de idea 00:20:35
He cambiado de idea, no quiero que los números estén en un list 00:20:37
No quiero 00:20:40
Quiero que estén en un set 00:20:41
Pues hala 00:20:43
¿En qué tipo de set? Pues en este que es muy rápido 00:20:45
Y muy eficiente, vale 00:20:50
Bueno, he cambiado 00:20:52
El contenedor, no pasa nada 00:20:54
Ahora mi contenedor es un conjunto 00:20:56
Vale, aquí va a haber algún problema 00:20:57
No va a haber ninguno 00:21:01
Simplemente que si meto 00:21:02
Un número por segunda vez 00:21:04
No entra, ya está 00:21:06
ni me va a dar error de ejecución 00:21:07
ni me va a dar nada, simplemente no lo va a meter 00:21:10
le digo 3, 5, 3 00:21:12
el siguiente 3 00:21:13
no lo va a meter, ya está, nada más 00:21:14
esa es la primera diferencia 00:21:18
¿y cuál es la siguiente diferencia? 00:21:20
ahora ya es error de compilación 00:21:23
que aquí ya no tiene sentido 00:21:24
plantearse ordenar 00:21:26
¿vale? en los set 00:21:27
no hay sort, porque aquí no hay posiciones 00:21:29
¿qué significa ordenar en un conjunto? 00:21:32
¿en un conjunto están todos ahí? 00:21:33
ordenar se ordena en las filas 00:21:36
Una fila se ordena 00:21:37
Y una fila es una lista 00:21:39
Pero un conjunto no 00:21:40
Entonces en un conjunto no tiene sentido 00:21:42
Plantearse ordenar 00:21:44
¿Vale? 00:21:46
Bueno, pero nosotros no estamos trabajando 00:21:51
Sino con esto ahora mismo 00:21:56
Venga 00:21:59
Pues 00:22:03
Haced lo de 00:22:03
Haced eso, los que hayáis acabado 00:22:05
Este 2 pasáis de él 00:22:08
Porque el tricet no lo tenemos 00:22:11
Y se supone 00:22:12
3, 4 y 5 es lo mismo 00:22:14
todo el rato, pues clases 00:22:19
unas contienen cosas de otras, etc 00:22:20
pues 3, 4 y 5 00:22:22
aquí hicimos el 3 00:22:25
en clase que lo tengo 00:22:27
en el proyecto ese en el que estoy incorporando 00:22:29
esto otro, hicimos el 3 00:22:31
pues 4 y 5 lo hacéis 00:22:32
para que sea otra vez lo mismo 00:22:35
y el 7 y el 8 00:22:38
no, porque ya son más 00:22:43
¿vale? 00:22:44
Pero ahora mismo, a corto plazo, pues esto. 00:22:46
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
3 de abril de 2024 - 18:30
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
22′ 54″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
116.10 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid