Saltar navegación

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

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

6 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, aquí está el numerito, pedir un número 00:00:00
y ahora ya uno se plantea 00:00:03
pues venga 00:00:06
eliminar ese 00:00:06
número 00:00:09
y todos sus 00:00:10
divisores 00:00:13
vale, pues entonces 00:00:14
uno puede 00:00:22
funcionar así en plan 00:00:24
puede funcionar así en plan 00:00:26
piloto automático 00:00:28
y hacerlo mal, claro 00:00:32
entonces en plan piloto automático 00:00:35
pues uno funciona diciendo 00:00:36
recorro las listas, el que cumple la condición 00:00:38
me lo ventilo 00:00:41
eso ya funciona en modo automático 00:00:42
entonces, pues eso es lo que he hecho aquí 00:00:44
bueno, el contains 00:00:46
te sirve para ver si un número 00:00:50
está 00:00:52
claro 00:00:52
sí, pero 00:00:57
para los divisores 00:00:59
para los divisores no te vale 00:01:00
para borrar, pides un número 00:01:05
y dices, if contains, remove 00:01:09
vale, entonces 00:01:11
en modo piloto automático 00:01:15
los de atrás 00:01:17
en modo piloto automático 00:01:19
recorremos 00:01:22
si el número cumple la condición 00:01:23
que en este caso el tema es que la condición 00:01:25
es más compleja, si fuera a ser 00:01:27
igual, efectivamente 00:01:29
el contains ya nos dice eso 00:01:30
vale, entonces voy número por 00:01:32
número, si es igual 00:01:35
lo divide 00:01:39
¿vale? si el numerito n 00:01:40
es igual que el que me han dado 00:01:43
o es un divisor suyo 00:01:44
una de estas dos cosas 00:01:46
pues fuera 00:01:48
¿vale? este es el modo piloto automático 00:01:50
que ya vimos el otro día que esto 00:01:53
¿por qué no? 00:01:55
porque el for each como va 00:01:59
a recorrer esta lista 00:02:01
la bloquea y el remove 00:02:02
entra en ella también para recorrerla 00:02:05
porque ya sabemos que el remove lo que hace es 00:02:08
le damos un objeto 00:02:10
se hace dentro su for 00:02:11
para recorrer la lista 00:02:14
y cuando encuentra 00:02:16
un objeto con este valor 00:02:18
lo borra 00:02:20
entonces, ¿qué ocurre? que cuando este remove 00:02:21
se va adentro a coger 00:02:24
esa lista para recorrerla 00:02:26
el for each la tiene bloqueada 00:02:27
¿vale? entonces esto parece que está muy bien 00:02:29
pero luego 00:02:32
Por eso tenemos que entender que esta situación concreta no funciona, 00:02:34
que es lo que hicimos el otro día y que a veces le deja a uno desconcertado. 00:02:38
Por ejemplo, vamos a poner el 6, el 3, y el 7. 00:02:44
Vale, entonces 00:02:55
Pues tengo ordenada de forma ascendente 00:03:00
Recorrida al revés 00:03:13
Ordenada de forma descendente 00:03:15
Vale, ahora vamos a introducir un número 00:03:17
Para que borre ese número y todos los divisores 00:03:19
Pues por ejemplo le ponemos el 6 00:03:22
Entonces debería borrar el 6 00:03:24
Y también luego el 3 que es divisor 00:03:27
Vamos a ver 00:03:30
A ver, es que no he buscado un buen ejemplo 00:03:31
Porque lo que yo quiero es que me salga el error 00:03:37
Que sale a veces y a veces no 00:03:40
Que explicamos el otro día 00:03:42
Vamos a 00:03:43
A ver 00:03:45
6, 3 y 2 00:03:50
Vale, venga, introduzca número 00:03:58
Pues venga, el 6 00:04:01
Vale, aquí está 00:04:03
Entonces, esto es lo que dijimos el otro día 00:04:05
Que de repente uno hace una prueba 00:04:08
Y dice, ah, me ha funcionado 00:04:10
Vale, pero una prueba te puede haber funcionado 00:04:12
De casualidad 00:04:14
Luego sigues haciendo pruebas y te das cuenta de que no funciona 00:04:15
Bueno, pues 00:04:18
De repente nos puede aparecer este error 00:04:20
Que uno no entiende lo que significa 00:04:22
Ahora ya sí que lo entendemos 00:04:23
Significa, hay un recurso al que intentan acceder 00:04:24
Dos a la vez 00:04:28
Pues es justo lo que está ocurriendo aquí 00:04:29
Dos a la vez 00:04:32
a números 00:04:34
lo está recorriendo el for each 00:04:37
luego lo tiene bloqueado y ahora el remove 00:04:40
entra dentro para recorrerlo 00:04:42
y eliminar n 00:04:44
entonces nos sale este error 00:04:45
cuando no nos salía 00:04:48
cuando coincidía 00:04:50
cuando coincidía 00:04:52
que este remove solo 00:04:53
se ejecutaba para el último 00:04:56
valor, para el último 00:04:58
porque entonces este for each ya ha soltado 00:04:59
el recurso, porque ya ha terminado y lo ha soltado 00:05:02
porque ya es su última iteración 00:05:04
entonces cuando este remove entra 00:05:06
como es la última iteración este ya lo soltó 00:05:08
pues si en ese caso en concreto hemos hecho la prueba 00:05:10
no nos ha dado error y nos creemos que funciona 00:05:13
y no 00:05:15
entonces esta combinación es la peligrosa 00:05:16
entonces un for each 00:05:19
bloquea este recurso 00:05:21
si yo aquí hago cosas 00:05:22
que de nuevo iteran sobre él 00:05:24
como el remove que itera por dentro aunque yo no lo vea 00:05:26
pues 00:05:28
me va a salir esto 00:05:29
por eso decimos 00:05:31
que por sistema y para evitar ese tipo 00:05:34
de problemas, usemos los for each 00:05:36
solo para consultar, no usemos 00:05:38
los for each con cosas dentro aquí 00:05:40
que quieran modificar el recurso 00:05:41
que lo quieran modificar 00:05:44
remove lo va a modificar porque va a eliminar 00:05:45
entonces cuando recorremos 00:05:48
con un for each una colección 00:05:50
no hagamos nada dentro 00:05:51
que modifique la colección, que la 00:05:53
cambie de estado 00:05:56
no hagamos nada dentro que la cambie de estado 00:05:56
porque pueden estar los dos 00:05:59
concurriendo el mismo recurso 00:06:02
Luego esta opción, muy mala, ¿vale? Aunque de casualidad alguna vez funcione. 00:06:03
Entonces, para recorrer y borrar de forma segura, dijimos el iterador, el iterador, pues nos hacemos un iterador, nos hacemos un iterador y ahora ya sí recorríamos con el iterador, como con un for normal. 00:06:15
Claro, porque el remove 00:06:43
El remove tiene dentro a su vez 00:06:48
Otro for 00:06:52
El problema es ese 00:06:52
A ver, con un for de índice 00:06:54
Tienes que tener cuidado 00:06:58
Lo que puedes hacer es entonces borrar por índice 00:06:59
Puedes llamar al remove de ahí 00:07:01
Porque el remove tiene dos versiones 00:07:02
Remove y el objeto 00:07:05
Y ese sí que tiene que hacer un for dentro 00:07:06
Hasta que encuentre un igual 00:07:08
Y luego hay un remove de posición 00:07:10
entonces si tú estás recorriendo con el índice 00:07:12
le puedes pasar 00:07:16
de esta manera 00:07:17
que no sé qué manera es 00:07:19
de esta manera 00:07:21
sí pero ten cuidado 00:07:34
porque al borrar una posición 00:07:36
la lista se acorta luego 00:07:38
entonces cambia 00:07:40
entonces luego aquí se vuelve a evaluar 00:07:41
el número de puntos altos 00:07:44
entonces habría que controlar bien 00:07:45
si hay algún caso de prueba 00:07:47
en el cual estés borrando la última 00:07:50
pero todavía quiere entrar y le salga un loop interception 00:07:52
conclusión, cuando tú quieres 00:07:54
modificar cosas de una lista 00:07:56
evita iterar por ellas en for 00:07:57
¿vale? en general, cuando tú quieres 00:08:00
hacer acciones de modificación 00:08:02
que esas acciones de modificación 00:08:03
no estén dentro de for 00:08:06
porque te van a complicar un poco la vida 00:08:07
¿vale? entonces 00:08:09
pero no modificábamos 00:08:11
no hacíamos remove dentro, hacíamos otras cosas 00:08:16
o sea, la primera vez 00:08:18
Que iteramos para borrar dentro 00:08:20
Fue el otro día, el viernes 00:08:22
Que fue cuando contamos todo esto 00:08:23
Recorríamos con for 00:08:24
Pero para mostrar 00:08:29
Simplemente, para mostrar valores 00:08:30
No hacíamos remove dentro 00:08:32
Vale, entonces 00:08:34
La forma más segura de iterar 00:08:35
Es el iterador 00:08:38
Y cuando iteramos con iterador 00:08:39
Pues iteramos así 00:08:43
Nos quedamos con el numerito 00:08:46
y .next 00:08:49
nos quedamos con el numerito 00:08:55
y ahora ya sí, si este numerito 00:08:56
cumple la condición 00:08:59
si este numerito 00:09:00
cumple la condición, entonces 00:09:08
quiero borrar ese numerito 00:09:10
pero lo puedo borrar 00:09:12
a través del iterador 00:09:14
con iterador.remove y esta es la combinación 00:09:15
buena 00:09:18
eso es lo que vimos el otro día, ¿vale? 00:09:19
entonces, ¿cuándo? 00:09:22
entonces, recordad, tenemos 00:09:27
para borrar de una lista 00:09:28
tenemos varias situaciones distintas 00:09:29
yo quiero borrar 00:09:32
un objeto en concreto, ahí no tengo ningún problema 00:09:33
llamo al método remove 00:09:37
remove este objeto y ya está 00:09:38
y me borra ese objeto y ya acabó 00:09:40
¿vale? pero si yo quiero borrar 00:09:42
un conjunto de objetos que cumplen 00:09:44
una condición 00:09:46
ahí ya sí que tengo que iterar 00:09:47
para ver los que la cumplen e ir borrando 00:09:50
cada uno de ellos, ¿vale? luego son dos cosas 00:09:52
diferentes, borrar un 00:09:54
objeto, remove le paso el objeto, borrado 00:09:56
o borrar una serie de objetos 00:09:58
que cumplen una condición, como es esta, ser igual 00:10:00
o divisor 00:10:02
bueno, pues en este caso tenemos que iterar 00:10:03
para ir borrando los que la cumplen 00:10:07
y entonces, si nos ponemos 00:10:08
a iterar, cuidado, porque la combinación 00:10:10
de un for y dentro 00:10:13
modificar la colección es peligrosa 00:10:15
para algunos casos 00:10:17
de prueba en función de si tocan los extremos o no los tocan 00:10:18
pues si yo quiero iterar 00:10:21
porque lo necesito, para ver 00:10:23
los valores que cumplen una condición 00:10:25
iterar y a la vez ir 00:10:26
borrando, pues esta es la 00:10:29
combinación que cogemos 00:10:31
iteramos con iterador, mientras el 00:10:32
activador tenga siguiente, me cojo 00:10:34
ese siguiente, cumple la condición 00:10:36
cumple la condición 00:10:38
borro, pero borro a través 00:10:40
del iterador, porque esto ya hace 00:10:43
toda la protección de 00:10:45
sincronización que le haga falta a todo 00:10:46
borro a través del iterador, no haría aquí otra vez 00:10:48
número remove.n 00:10:51
porque estarían las mismas, no haría 00:10:52
un error, un punto de emborro a través del iterador. 00:10:54
¿Vale? Entonces se trata de una situación 00:10:57
muy concreta. Son situaciones concretas. 00:10:58
Yo os trato de acotar para que 00:11:01
no os liéis. Situaciones concretas. 00:11:02
¿Vale? O sea, lo peligroso en las colecciones es 00:11:04
cuando uno las modifica para eliminar. 00:11:06
Cuando las modifica 00:11:10
para agregar, bueno, te puede 00:11:11
dar un efecto secundario, pero bueno, ahí estás 00:11:12
añadiendo. Cuando las 00:11:14
modifica para eliminar. Son situaciones peligrosas. 00:11:16
Y ahí de nuevo hay dos situaciones. 00:11:19
Repito. Eliminar un objeto 00:11:20
en concreto, facilísimo, remove y fuera 00:11:22
elimino ese objeto 00:11:24
o eliminar varios que cumplen la condición 00:11:25
tengo que iterar, no hay otro 00:11:28
vale, pues entonces cuidado con esta situación 00:11:29
concreta, vale 00:11:32
y luego a uno se le puede haber ocurrido 00:11:33
otra combinación muy inteligente 00:11:36
como la de Miguel, por ejemplo, que es decir 00:11:38
hombre, pues me voy a hacer una lista 00:11:40
primero con todos los 00:11:42
que cumplen la condición y luego le paso 00:11:44
un remove all, por ejemplo 00:11:46
pues yo que sé, la escribimos, por si a alguien le gusta 00:11:47
yo creo que esta es la más fácil 00:11:50
la más rápida y la más corta, pero a uno se le puede haber ocurrido esta otra cosa y no está mal 00:11:52
y así practica con ese método, vamos a hacernos una lista 00:11:56
de elementos para borrar 00:12:00
para borrar, estos van a ser los que quiero yo borrar 00:12:03
y esta lista, vale, pues ahora recorremos la otra 00:12:11
aquí sí que puedo recorrerla cómodamente, porque como no voy a tocarla 00:12:21
voy simplemente a consultarla para copiar en otra 00:12:28
pues entonces aquí podríamos hacer 00:12:31
pues venga, para cada numerito 00:12:34
n en mi lista de números 00:12:37
si n 00:12:38
cumple la condición famosa 00:12:42
que es toda esta 00:12:45
si n cumple la condición famosa 00:12:46
pues n es un candidato 00:12:50
a borrar, pues lo meto en esta lista 00:12:52
ala 00:12:54
entonces la lista de números no la estoy tocando 00:12:59
entonces yo itero con este 00:13:02
porque no la estoy modificando 00:13:04
no estoy borrando nada de ello, no hay problema 00:13:05
la estoy usando para consultar los numeritos 00:13:07
y los que cumplen cierta condición 00:13:10
se van aquí 00:13:11
y ahora ya puedo aprovecharme 00:13:12
del método removeAll 00:13:16
y decir, oye, bórrame a mogollón 00:13:17
bórrame a mogollón 00:13:19
todos esos 00:13:21
todos los que yo te pase aquí 00:13:22
todos estos que yo te pase aquí 00:13:25
todos a mogollón, que hay unos cuantos 00:13:28
un montón, el 7, el 12 00:13:30
todos los que cumplen la condición 00:13:32
los borra todos 00:13:33
y borra todos esos números 00:13:36
y además si alguno de ellos aparece más de una vez 00:13:40
lo borra todas las veces que aparece 00:13:42
que fue lo que comprobamos el otro día 00:13:44
a raíz de la duda esa que surgió 00:13:45
¿vale? pues bueno, pues otra forma de hacerlo 00:13:48
lo hacéis una lista adicional 00:13:51
aquí lo único es que 00:13:52
se me queda esta lista 00:13:56
ahí para toda la vida 00:13:57
entonces hombre, esto es poco eficiente 00:13:59
imagínate que me toca borrar 00:14:01
15.000 números 00:14:03
me quedo yo aquí con una lista de 15.000 números 00:14:05
durante todo el tiempo en el que el método 00:14:08
esté vivo 00:14:09
no, hasta que no se pierda 00:14:10
la referencia, solo se 00:14:13
borraría si tú haces esto 00:14:15
vale 00:14:17
claro, o sea, si tú haces esto 00:14:25
a borrar igual a null, entonces 00:14:28
toda la lista 00:14:30
que estaba colgando de aquí 00:14:31
se ha quedado sin referencia, sin nadie que le apunte 00:14:33
sin nadie que le apunte 00:14:36
si lo hubieras copiado en otro sitio, no, claro 00:14:38
se ha quedado sin nadie que le apunte 00:14:40
entonces el recorrector de basura 00:14:41
cuando se despierte dirá 00:14:43
uy aquí tengo un montón de datos inaccesibles 00:14:44
el recorrector de basura 00:14:47
borra todo lo que sea inaccesible 00:14:49
o sea poner esto a null no significa 00:14:51
que esa lista que estaba apuntada 00:14:53
desde aquí desaparezca 00:14:55
esa lista se queda ahí 00:14:56
lo que significa es que su referencia 00:14:58
de repente se va a otro lado 00:15:01
y se nos ha quedado ahí una bolsa de números 00:15:02
que no están apuntados por nadie 00:15:04
porque quien les apuntaba se ha ido para allá 00:15:06
entonces, ¿quién se encarga de borrar eso? 00:15:09
pues el demonio que hay ahí rondando 00:15:12
que es el recolector de basura 00:15:14
que de vez en cuando se despierta y dice 00:15:15
uy, aquí tengo datos inaccesibles 00:15:17
con ellos a punta, pues fuera 00:15:19
pero claro, tienes que preocupar 00:15:21
tú de ir dejando 00:15:23
sin referencia 00:15:25
a todos esos datos 00:15:27
de nuevo es una tarea molesta 00:15:28
para el desarrollador, es una tarea molesta 00:15:30
y no solo eso, sino que previamente 00:15:32
has tenido que llenar una lista entera 00:15:36
Entonces, hombre, pues siempre va a ser más cómodo 00:15:38
Y más fácil esto, ¿vale? 00:15:40
Pero esto también, pues tiene su sentido 00:15:42
¿Vale? 00:15:45
Entonces vamos a ponerlo aquí 00:15:48
¿Vale? Pues vamos a probarlo 00:15:50
Porque podemos haber escrito alguna tontería 00:16:04
Venga, pues metemos 00:16:06
Introducimos número 00:16:10
Venga, pues el 2 00:16:20
Vale 00:16:21
Pues se ha eliminado el 2 y sus divisores 00:16:23
Que en realidad solamente es el 1 00:16:26
Ha eliminado el 2 y el 1 00:16:28
Vale 00:16:30
Esto hecho de la otra manera 00:16:31
Habría dado un concurren modification exception 00:16:34
Entonces si uno aquí fuera 00:16:36
Un programador serio 00:16:39
Haría más pruebas 00:16:41
Obviamente 00:16:44
Haría más pruebas 00:16:46
Porque con solo una prueba 00:16:49
Pues hombre 00:16:51
Vale, introducimos un número 00:16:51
venga, el 4, a ver si me elimina los dos 4 00:16:55
y el 1 00:16:57
como ha sido un programador serio 00:16:57
y ha hecho otra prueba 00:17:01
pues ha encontrado 00:17:02
otro bug de su aplicación 00:17:05
que era esperable 00:17:07
¿de dónde viene? 00:17:09
¿de dónde intuís que puede venir 00:17:14
este error de aquí? 00:17:15
vamos a mirar el código 00:17:21
¿cómo hago para bajar eso? 00:17:22
para que no lo veáis 00:17:25
mirad vosotros vuestro código 00:17:25
lo tenéis arriba 00:17:29
¿cómo? 00:17:30
hay un cero, pero un cero es un número 00:17:34
no me debería dar un error, ¿qué es lo que he hecho mal? 00:17:36
el problema es mi programa 00:17:38
claro 00:17:39
yo no he metido el cero hasta ahora 00:17:41
para obviar eso 00:17:44
que mirad mi programa 00:17:45
cuando comprueba estas condiciones 00:17:48
si el numerito n 00:17:50
de la lista es igual que el que quiero borrar 00:17:52
o lo divide 00:17:54
de forma exacta, es divisor 00:17:56
y para ver si lo divide de forma exacta 00:17:58
él tiene que hacer la división 00:18:00
anda, pues en cuanto un elemento de la lista 00:18:02
sea n y le toque 00:18:04
comprobar, perdón, sea cero 00:18:06
y le toque comprobar si es divisor de otro 00:18:08
esto 00:18:10
me va a dar división por cero 00:18:11
¿verdad? si yo me voy aquí, justo 00:18:14
se ha ido a esta línea 00:18:16
entonces aquí tengo un bug 00:18:17
como le meta ceros 00:18:20
me va a saltar, porque el cero no es 00:18:22
divisor de nadie 00:18:24
entonces hombre, aquí la modificación sería 00:18:25
si números, y además 00:18:30
tendría que incorporar 00:18:32
y siendo n diferente de 0 00:18:34
o sea, si n es igual a número 00:18:36
n, aquí ya entramos en 00:18:38
la famosa tarea del programador 00:18:42
de poner parches 00:18:44
que está muy bien, me refiero que siempre 00:18:45
hay que poner parches en una aplicación 00:18:48
pero cuidado, porque cuando ya los parches son muchos 00:18:50
hay veces que es mejor 00:18:52
tirarla a la basura y rediseñarla 00:18:54
de nuevo 00:18:56
eso es lo que pasa con la mayoría de las aplicaciones 00:18:57
uno las empieza 00:19:00
con su equipo de trabajo 00:19:02
ya está, está con ella unos meses 00:19:04
la saca a producción, la aplicación estupenda 00:19:06
a partir de ahí entra ya la fase de mantenimiento 00:19:08
en la fase de mantenimiento 00:19:10
pues se van incorporando, de repente se detecta un error 00:19:12
vale, de repente el cliente te pide otra cosa 00:19:14
pues bueno 00:19:17
empiezan los meses 00:19:18
se le van a dar un parche, otro parche, otro parche 00:19:20
hasta que llega alguien y diga 00:19:22
a ver, esto no, y al final 00:19:24
la aplicación a la basura 00:19:26
y vamos a rediseñarla desde el principio 00:19:28
porque ya tanto parche ha perdido 00:19:29
su... bueno vamos a poner 00:19:32
aquí este parchecito que es 00:19:34
si n es diferente de 0 00:19:35
siendo diferente de 0 00:19:39
no ha sido 00:19:42
un parche tan grande 00:19:44
entonces aquí la condición la hemos puesto 00:19:44
y aquí que pasa que me falta algún 00:19:47
ah si que me falta un paréntesis 00:19:50
este 00:19:52
la condición para ver si n 00:19:53
es igual que el numerito 00:19:56
Que yo he leído por teclado 00:19:58
O divisores 00:20:00
Si n es igual que el número, está claro 00:20:01
O si siendo n diferente de 0 00:20:03
Siendo n diferente de 0 00:20:06
Además divide a n 00:20:07
Ahora ya sí 00:20:09
Ahora ya con este parchecillo 00:20:11
Ya no debería 00:20:14
Salirme 00:20:18
Este error 00:20:20
Vale, entonces 00:20:25
Si introduzca número 00:20:27
Pues el 3 00:20:28
Uh, que he hecho mal 00:20:30
¿Dónde sigo dividiendo por cero? 00:20:33
Ah, es que he hecho lo mismo dos veces 00:20:35
Claro, porque como lo he hecho lo mismo de las dos maneras 00:20:36
De esta y de la otra 00:20:39
Tengo que poner el parche en los dos sitios 00:20:40
¿Vale? 00:20:42
Entonces este parchecillo 00:20:44
Como lo he hecho de dos formas 00:20:46
Otra forma 00:20:50
Pues este parchecillo tiene que ir aquí también 00:20:51
Vale, y ya está, ¿no? 00:20:54
Ya está 00:20:57
5, 0, 4, 1 00:20:58
G, vale, vamos a 00:21:07
ahora ya sí, ha eliminado el 4 y el 1 00:21:11
el 0 lo ignora 00:21:14
no es divisor de nadie 00:21:16
vale 00:21:17
bueno, pues de cualquier ejercicio 00:21:24
aunque sea pequeñito 00:21:29
porque este no involucra ni otras clases 00:21:30
ni involucra nada de cualquiera 00:21:33
se sacan un montón de cosas 00:21:34
de cualquiera se sacan un montón de cosas 00:21:37
de matices, entonces cualquier cosa 00:21:39
que uno haga, está estudiando 00:21:41
Le voy a pedir a chat.gpt cualquier enunciado 00:21:43
Ponme un ejercicio chorra de programación 00:21:47
Un enunciado chorrita 00:21:48
Que pues de cualquier cosa 00:21:50
Uno ya saca un montón de 00:21:52
De matices, de cosas 00:21:56
Que repasar, etc 00:21:58
¿Vale? 00:22:01
Vamos a ver que enunciado nos propone 00:22:07
El Menda este 00:22:10
Ay, que Menda 00:22:13
Ay, tengo que ir donde está 00:22:35
el chico que está en el examen. 00:22:42
Bueno, da igual, era solamente para ver 00:22:44
si nos daba algún enunciado interesante. 00:22:45
Venga, pues vamos a ver. 00:22:49
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
3 de abril de 2024 - 18:32
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
22′ 50″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
107.38 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid