Saltar navegación

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

Clase 04-03-24 - 3 - Contenido educativo

Ajuste de pantalla

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

Subido el 6 de marzo de 2024 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

venga, pues vamos a ver 00:00:00
lo que más o menos habéis hecho 00:00:04
aquí de nuevo el problema es otro 00:00:05
aquí el problema es 00:00:08
venga, ya, hemos parado 00:00:10
aquí el problema es otro, os tengo que contar 00:00:12
sobre un conjunto 00:00:15
de alumnos, sobre un conjunto 00:00:17
de datos, siempre se cuenta sobre una sucesión 00:00:18
de cosas, se cuenta en una sucesión 00:00:20
este, este, este 00:00:22
vale, pues aquí la sucesión de cosas en la que tengo 00:00:24
que contar son mis alumnos 00:00:26
Vale, pues tenemos que recorrer los alumnos para contar a aquellos que cumplen algo. 00:00:28
Bueno, pues lo que yo tengo que recorrer es mi array de alumnos para contar a aquellos que cumplen algo. 00:00:33
Luego esto es una cuenta. 00:00:39
Luego, como esto es una cuenta, siempre va a implicar un contador. 00:00:41
¿Vale? 00:00:45
Bueno, ¿qué tengo que contar? 00:00:46
Alumnos de mi lista. 00:00:49
Pues tendremos que recorrer la lista, porque yo voy a contar alumnos de mi lista. 00:00:51
Pues a recorrer la lista para contarlos. 00:00:55
vale, pues recorremos la lista 00:00:56
de esta manera 00:01:00
que es un poco la más sencilla 00:01:01
vale, pues con esto estamos recorriendo 00:01:03
la lista, y ahora 00:01:19
¿qué alumnos contamos? todos, no 00:01:21
incrementamos 00:01:23
cuenta, es decir, contamos 00:01:25
incrementamos la cuenta, contamos 00:01:27
solo 00:01:31
los alumnos get i que cumplen algo 00:01:32
solo eso 00:01:35
vale, incrementamos la cuenta, solo los alumnos 00:01:36
get i que cumplen algo, entonces este cont más más 00:01:39
en realidad es condicionado 00:01:42
a que el alumno get i cumpla algo 00:01:43
¿vale? vale, pues ahora hay que pensar 00:01:45
ya, pero ¿qué tiene que cumplir? 00:01:47
pues tiene que cumplir 00:01:49
que alguna de sus asignaturas 00:01:51
sea igual que esta 00:01:53
sus asignaturas a su vez son 00:01:55
un array, a su vez son un array 00:01:57
pues entonces tendremos que meternos 00:01:59
en el array de asignaturas 00:02:01
e ir uno por uno a ver si 00:02:03
encontramos alguna 00:02:05
que sea igual a la que me han dado 00:02:06
pero no nos queda más remedio que meternos 00:02:08
para ver si el alumno cumple esa condición 00:02:11
nos tenemos que meter en el array de asignaturas 00:02:13
porque su condición es que alguna de ellas 00:02:14
sea igual 00:02:17
bueno, pues no pasa nada, nos metemos en el array 00:02:18
de asignaturas del alumno 00:02:21
como es un for dentro de otro 00:02:22
porque ahora estoy en el alumno de posición y, estoy dentro 00:02:26
un for está dentro de otro 00:02:28
estoy en el de posición y, estoy dentro 00:02:30
pues será un for con otro índice, j o el que queramos 00:02:32
y ahora 00:02:35
¿qué colección estamos recorriendo? 00:02:36
Estamos recorriendo la colección de asignaturas del alumno GetI. 00:02:38
Esto es lo que estamos recorriendo. 00:02:45
Estamos recorriendo la colección de asignaturas del GetI. 00:02:50
Esta colección es la que recorremos. 00:02:54
Luego esto será mientras sea menor que el tamaño, incrementando J. 00:02:57
Y ahora aquí, ¿qué queremos hacer? 00:03:03
Pues si resulta que la asignatura de posición J 00:03:04
Estamos recorriendo este array 00:03:09
Estamos recorriendo este array, esta lista 00:03:11
Estamos recorriendo esta lista con índice J 00:03:15
Bueno, pues si esta lista, la posición J en la que estoy 00:03:17
Toda esta lista, la posición J 00:03:22
Es igual a la asignatura que me han dado 00:03:26
Pues ya puedo incrementar la cuenta 00:03:32
Entonces 00:03:34
Hola 00:03:35
¿Te ha enviado el correo que te envié? 00:03:39
Te he enviado 200.000 correos 00:03:41
Pues es que Rosa, a mí me envío correos y no me llegan 00:03:43
A ver 00:03:44
Venga, seguimos 00:03:46
Vale, pues entonces 00:03:49
Esta asignatura 00:03:51
La de posición J es un string 00:03:52
Y tenemos que compararla con esta que es un string 00:03:54
Luego comprar un string con otro 00:03:57
Tiene que ser el equals 00:03:58
Como ya sabéis, pues entonces aquí 00:03:59
Obviamente habrá que poner un equals 00:04:01
y cuál es así 00:04:04
entonces si es igual 00:04:06
pues la cuento 00:04:07
¿vale? 00:04:09
y cuando este for ya ha terminado 00:04:12
ya he contado 00:04:14
las apariciones de esa asignatura 00:04:15
en el array de asignaturas 00:04:18
de este alumno y además 00:04:20
lo habré contado para todos los alumnos 00:04:22
pero cuando este for 00:04:25
ha terminado ya tendría la cuenta 00:04:26
y la devuelvo 00:04:28
¿vale? esta sería 00:04:31
la primera versión 00:04:32
vale, aquí lo único 00:04:34
no vamos a empezar a retocarla para corregir mil cosas 00:04:37
porque eso es volver a hacer lo mismo 00:04:39
y otra vez, vale, verificarlo 00:04:40
de la RAI y todo eso 00:04:42
pero lo único aquí es el coste 00:04:43
de lo que ocurre, claro, si cuando 00:04:47
se hizo la matrícula, el método de matricular 00:04:49
no está bien hecho, bien pulido 00:04:51
y tú puedes matricular 00:04:53
a un alumno de lo mismo tres veces 00:04:55
le puedes matricular de lengua, luego de mates 00:04:56
luego de lengua otra vez, luego de mates 00:04:58
pues entonces te va a contar para un solo 00:05:00
alumno, te la va a contar tres veces 00:05:03
lengua, entonces te va a decir 00:05:05
tú le pasas lengua y hay dos alumnos 00:05:07
uno está matriculado dos veces de la misma 00:05:09
y otro tres veces, te va a decir cinco 00:05:11
te va a decir cinco 00:05:12
claro, pero esa situación de nuevo 00:05:14
¿cómo se resuelve? no es que esté bien o mal 00:05:16
es que esa situación se resuelve 00:05:18
en función de lo que el cliente quiera que ocurra 00:05:20
entonces aquí 00:05:23
lo normal sería 00:05:24
que cuando uno, lo que has dicho tú antes 00:05:26
que en el método de matrícula de alumno 00:05:30
de asignaturas se verifique si ya está 00:05:32
y si ya está no te matricula 00:05:34
y te diga uno ya está matriculado 00:05:37
entonces ya pues el resto de métodos 00:05:38
no arrastran ese problema 00:05:40
eso por un lado 00:05:41
vale 00:05:43
otra cosa que podemos hacer 00:05:45
bueno todo esto 00:05:48
de aquí, este for 00:05:50
que va asignatura por asignatura 00:05:52
para ver si encuentra una asignatura 00:05:54
que sea igual a esta 00:05:56
de así, este for de aquí 00:05:58
es un rollo, en realidad 00:06:00
la idea que recoge ese for es 00:06:02
que 00:06:04
este array de asignaturas 00:06:05
tenga dentro esa asignatura 00:06:08
que es una idea muy natural 00:06:09
una cosa muy natural que uno puede 00:06:11
querer necesitar hacer en una colección es 00:06:14
que esta colección 00:06:16
contenga esto 00:06:18
es algo muy normal que uno puede querer hacer 00:06:19
entonces lo podemos hacer a mano 00:06:22
como lo hemos hecho nosotros, recorriéndolo y viendo 00:06:24
si lo contiene 00:06:26
pero ya para eso hay un método 00:06:27
que es más cómodo 00:06:29
que ese método ya era el for el dentro. 00:06:32
El for no se ahorra, el for lo hace él. 00:06:34
Le llamamos al método y ya está. 00:06:36
¿Qué es el método? Pues contains. 00:06:37
Si uno busca los métodos de list que hemos visto, 00:06:39
pues rápidamente le llama a contains. 00:06:41
Tiene pinta de que este método, por su propio nombre, 00:06:43
me dice si una colección contiene un elemento concreto. 00:06:47
Entonces, por ejemplo, 00:06:53
si esto mismo lo quisiéramos hacer de otra manera. 00:06:56
voy a 00:06:59
se me ha vuelto a olvidar 00:07:01
como era lo de 00:07:04
ah no, así 00:07:05
vale, vamos a hacer esto mismo de otra manera 00:07:06
venga, pues vamos a recorrer 00:07:09
la colección de alumnos, otra vez 00:07:11
vale 00:07:13
pues ahora, ¿qué queremos hacer con cada alumno? 00:07:27
lo que queremos es ver 00:07:31
si el array de asignaturas de este alumno 00:07:32
si queremos 00:07:35
lo que queremos 00:07:37
lo que queremos es ver si el array de asignaturas 00:07:37
de este alumno 00:07:41
contiene la asignatura asig 00:07:42
si el array de asignaturas 00:07:45
la contiene 00:07:47
eso es lo que queremos hacer 00:07:48
bueno, pues buscando los métodos de lista 00:07:49
vemos que 00:07:52
get asignaturas 00:07:54
al ser una lista 00:08:03
vale, o sea, esto es 00:08:04
la lista de asignaturas 00:08:11
del alumno, es esta 00:08:14
pues si miramos a ver los métodos 00:08:15
que me ofrece la interfaz list 00:08:17
vemos que me ofrece 00:08:20
el método contains que me dice 00:08:22
pásame un objeto 00:08:24
concreto, uno, y yo te 00:08:26
digo si ese objeto está 00:08:28
en la lista, que es justo 00:08:29
lo que queremos hacer, pasarle un string 00:08:32
la asignatura y ver si 00:08:34
ese objeto string está 00:08:36
en la lista de string, está en la 00:08:38
lista, es justo, pues es justo lo que queríamos hacer 00:08:40
pues hala, llamo al método 00:08:42
y ya que se preocupe 00:08:44
él de hacer el for dentro 00:08:46
lo que sea, porque mi código va a quedar más claro 00:08:47
y así me queda 00:08:50
más bonito, no es que sea más eficiente 00:08:53
es más bonito 00:08:56
y me falta aquí cerrar 00:08:57
el if 00:09:00
pues este queda más claro 00:09:01
este código queda más claro que el de arriba 00:09:13
contains no lo tiene 00:09:15
vale 00:09:20
entonces 00:09:25
aquí queda más claro 00:09:26
vamos alumno por alumno, para cada alumno 00:09:29
su lista de asignaturas 00:09:31
si su lista de asignaturas que es de string 00:09:33
contiene este objeto string 00:09:36
entonces la lista tiene que ser 00:09:38
de un tipo de dato igual que el que yo le paso 00:09:40
porque lo tiene que contener 00:09:41
pues si lo contiene, cuento 00:09:43
ese alumno contiene la asignatura 00:09:45
y no solo es más claro 00:09:47
más el que ve el código 00:09:56
lo entiende mejor que arriba 00:09:58
el de arriba ve dos foranidades y ya se vuelve loco 00:10:00
el de abajo lo ve más claro 00:10:02
y dice, ah, si lo contiene 00:10:04
pues ya sé lo que estás contando 00:10:06
lo entiende mejor el código 00:10:07
podría ser lo que estás contando 00:10:09
no solo es más claro, más legible 00:10:11
uno entiende mejor lo que está haciendo esto 00:10:16
sino que nos ahorramos al problema ese que decíamos 00:10:18
el método contains te dice 00:10:20
si lo contiene, pero te le da igual 00:10:22
si lo contiene 1, 2, 3, 4 veces 00:10:25
te devuelve true si lo contiene 00:10:26
y false si no 00:10:29
con lo cual este 00:10:30
no te cuenta por duplicado 00:10:32
las asignaturas que aparezcan 2, 3 veces 00:10:34
en cada alumno, te las cuenta por duplicado 00:10:37
esa es la ventaja que tiene respecto al de arriba 00:10:38
si tienes asignatura 00:10:41
sea una, dos, tres, cuatro veces 00:10:43
te devuelve true 00:10:44
y en ese caso lo cuentas 00:10:48
pero claro, el contains 00:10:50
de nuevo, igual que el remove 00:10:57
utiliza el equals 00:11:00
porque contains despliega un for el dentro 00:11:01
despliega un for el dentro 00:11:04
y se pone a recordar asignatura por asignatura 00:11:06
a ver si encuentra alguna 00:11:08
que sea equals a esta 00:11:10
es decir, lo mismo que hemos hecho arriba 00:11:12
nosotros, y en cuanto encuentre alguna 00:11:14
dice true 00:11:17
entonces usa el equals 00:11:17
con lo cual tiene que estar el equals correctamente 00:11:20
implementado en la clase 00:11:23
a la que pertenezca este objeto 00:11:24
pero en este caso es string 00:11:26
en string ya está el equals, no hay problema 00:11:28
pero cuidado 00:11:30
si usamos el contains 00:11:33
con listas de clases nuestras 00:11:35
por ejemplo, como alumno 00:11:36
imaginaos, vamos a hacer un método 00:11:39
ahora, que es 00:11:42
decir si está matriculado o no, me dan un número 00:11:44
de matrícula y yo tengo que decir si está 00:11:46
un nombre, perdón, un nombre 00:11:48
no, un nombre no 00:11:50
porque el equals va por número de matrícula 00:11:52
tendríamos que hacer otro, me dan un número de matrícula 00:11:54
y yo tengo que ver 00:11:57
si ese número de matrícula está, está en mi lista de alumnos 00:11:58
o si no es, vale 00:12:00
pues entonces vamos a hacer este método 00:12:02
existe 00:12:06
matrícula, le vamos a llamar al método 00:12:16
y le pasamos 00:12:18
un número 00:12:20
de matrícula. Y hay que decir si ese número de matrícula 00:12:22
existe o no. 00:12:24
¿Vale? Este requisito 00:12:30
podría tener sentido porque es 00:12:31
una API que se llama, o sea, una 00:12:33
funcionalidad que yo ofrezco fuera 00:12:35
porque se puede, imaginaos que se pueden pedir 00:12:36
ayudas si tú estás matriculado en un centro. 00:12:39
Entonces tú das, sí, estoy 00:12:42
matriculado, este es mi número de matrícula. 00:12:43
Entonces, pues esta es una forma de verificar que no te has 00:12:45
inventado el número, que estás realmente 00:12:47
matriculado en un centro. Entonces el que 00:12:49
quiera verificarlo llama a este método y le dice 00:12:51
sí, el número de matrícula es válido. 00:12:53
¿Vale? Es una funcionalidad que tiene sentido. 00:12:55
El número de matrículas es válido. 00:12:57
Está en el... 00:12:59
¿Vale? Pues con el contains 00:13:01
ahora podríamos hacerlo 00:13:03
muy fácil. No tendremos que recorrer 00:13:05
el for 00:13:06
sin el contains lo haríamos así, ¿verdad? 00:13:08
Haríamos 00:13:11
un boolean 00:13:12
está, inicialmente 00:13:14
vimos que no está. Y ahora 00:13:16
recorremos todos los alumnos 00:13:22
y en cuanto encontremos 00:13:24
uno cuya matrícula es ese, cambiamos el boolean. 00:13:26
Pues aquí haríamos, si alumnos.getI.getNúmeroDeMatrícula es igual que el número de matrícula que me acaban de dar, la paso abajo, pues entonces ya sé que está. 00:13:29
Entonces lo cambio a true. 00:14:12
De partida, sumo que no está, recorro los alumnos, en cuanto encuentro uno cuyo número de matrícula coincide, está igual a true. 00:14:16
Y si no quiero que el for se esté hasta el infinito 00:14:24
Pues puedo añadirle esto 00:14:26
Mientras no lo haya encontrado 00:14:29
¿Verdad? 00:14:31
Y así nos sigue hasta el infinito el bucle 00:14:36
Así para que se vea más pegado 00:14:38
¿Vale? Recorro los alumnos 00:14:44
Mientras no haya llegado al final 00:14:47
Y no lo haya encontrado 00:14:49
¿Este alumno coincide? 00:14:51
Sí, ah pues ya está 00:14:54
Esta es igual a true 00:14:55
el for cuando vuelva arriba 00:14:57
ya va a salir 00:14:59
vale, y ahora ya 00:15:00
existe, bueno este 00:15:02
lo natural sería que volviera un boolean 00:15:06
este método 00:15:08
volvería un boolean y ahora aquí 00:15:10
devolveríamos así 00:15:12
por ejemplo 00:15:16
vale 00:15:17
esta sería una versión sin contains 00:15:20
y sin nada 00:15:25
vale 00:15:25
de nuevo aquí lo que estamos en realidad 00:15:27
conceptualmente lo que estamos 00:15:31
haciendo es ver si hay 00:15:33
si existe un alumno 00:15:35
tal en la colección 00:15:37
es lo que estamos viendo, si existe un alumno de 00:15:39
la colección, ver si está 00:15:40
si lo contiene 00:15:43
es lo que estamos haciendo, pues para eso es el método 00:15:44
contains, para ver si una colección contiene 00:15:46
algo, pues entonces 00:15:48
esto mismo 00:15:51
lo podríamos hacer 00:15:53
con el contains en una sola línea 00:15:59
más cómodo, si alumnos 00:16:01
la colección 00:16:05
alumnos contiene 00:16:06
¿qué contiene la conación alumno? 00:16:09
pues un alumno con 00:16:13
número de matrícula S 00:16:14
entonces 00:16:16
como no tengo un constructor solo con número de 00:16:18
matrícula 00:16:20
voy a hacerme el alumno auxiliar aquí arriba 00:16:21
aux.set 00:16:24
vale, pues aquí no he hecho 00:16:35
ningún for, el for ya lo hace dentro 00:16:59
con des, no es que nos lo evitemos, ya lo hará 00:17:00
dentro él, que hace este método 00:17:02
se pone a recorrer esta colección 00:17:05
y en cuanto 00:17:07
encuentra un objeto 00:17:09
en esta colección igual 00:17:11
que este, devuelve true 00:17:12
en cuanto encuentra uno igual que este 00:17:14
devuelve true, repito 00:17:17
el context es como el remove, que en cuanto 00:17:19
encontraba uno igual lo eliminaba 00:17:20
pues este en cuanto encuentra uno igual 00:17:22
devuelve true 00:17:24
y encontrar uno igual significa 00:17:25
hacer el equals todo el rato de este 00:17:28
con cada uno de los de la colección 00:17:30
hacer el equals 00:17:32
y como el equals está basado en el número de matrícula 00:17:33
en cuanto encuentre 00:17:36
uno con el número de matrícula igual que este 00:17:38
ya devuelve el proof 00:17:40
¿vale? pero esto solo tiene sentido 00:17:42
si en alumno 00:17:46
tenemos efectivamente un equal 00:17:47
hecho 00:17:50
con número de matrícula 00:17:50
porque si no lo tenemos hecho 00:17:53
la igualdad 00:17:55
para contains entre 00:17:57
aux y alumnos es que sea 00:17:59
idéntico el mismo, la misma referencia de memoria 00:18:01
y es imposible, este lo acabamos de crear 00:18:03
no tiene nada que ver con la lista 00:18:05
la igualdad que nos interesa 00:18:08
es que el número de matrícula de este sea igual que este 00:18:09
o que este o que este, luego eso hay que hacerlo en el equal 00:18:11
¿vale? 00:18:13
entonces hombre, aquí ya podríamos 00:18:21
directamente 00:18:23
es que todo esto de arriba 00:18:24
incluso va a ser 00:18:27
más cómodo si quitamos 00:18:29
todo esto, hasta nos sobrearía 00:18:31
y devolvemos 00:18:33
directamente, ¿verdad? 00:18:35
retun 00:18:39
alumnos.contains 00:18:39
y nos queda 00:18:40
más sencillo 00:18:42
devuelve 00:18:48
alumnos.contains este 00:18:49
devolverá true si lo contiene 00:18:51
devolverá false si no 00:18:54
por ejemplo 00:18:55
aquí ya sí que es una tontería 00:18:58
hacerse el boolean porque es que este ya 00:19:00
me devuelve true 00:19:02
si esta colección contiene uno igual a este 00:19:03
me devuelve false si no 00:19:06
bueno pues estos son un poco los 00:19:08
métodos 00:19:16
con los que se trabajan 00:19:17
con las listas, pues el añadir 00:19:19
obviamente para añadir 00:19:21
remove para borrar, ojo 00:19:22
con el equals, el remove 00:19:25
borra cuando encuentra uno igual 00:19:27
según lo que diga el equals 00:19:29
de la clase a la que pertenecen 00:19:31
entonces ese equals tienes tú que haberlo implementado 00:19:33
para que la igualdad sea la que te interesa 00:19:35
el contains 00:19:37
lo acabamos de decir, el get 00:19:38
para recuperar por posición 00:19:41
el index of, pues para ver en que 00:19:42
posición está un objeto, pues son 00:19:45
más o menos los métodos con los que trabajamos 00:19:47
y así podemos guardar objetos 00:19:49
de forma muy fácil y trabajar con ellos 00:19:51
de forma muy fácil. 00:19:53
Y ya la complejidad está envuelta dentro 00:19:55
de los métodos, dentro está ya envuelta la complejidad, 00:19:57
pero el uso es muy 00:19:59
sencillo. 00:20:01
¿Vale? 00:20:05
Vale, pues 00:20:09
vamos a dejar plantear un ejercicio para que 00:20:10
antes de empezar con otra 00:20:13
cosa, que no... 00:20:15
para que asentéis y poseéis un poco 00:20:17
de esto. A ver, 00:20:19
A ver. Vale, pues de esto de aquí, que tenéis ya la virtual. Vale, para que sea parecido a esto, ¿vale? Este en lugar de asignaturas, el 3, trabaja con profesores, ¿vale? 00:20:27
dos clases 00:23:20
el profesor tiene una lista de alumnos 00:23:22
entonces 00:23:24
aquí todo listas 00:23:26
aquí dice una lista y 00:23:28
en el main se guardarán los profesores en un set 00:23:30
no, todo listas 00:23:32
vale, todo listas 00:23:34
entonces, hace de esto 00:23:35
pero lo que 00:23:40
dice en la clase main se guardará el conjunto 00:23:43
de profesores en un set, no, se guardará 00:23:45
en una lista también, en otra lista 00:23:46
vale, pues venga, el 3 de esa hoja 00:23:48
que es muy similar a lo que hemos visto 00:23:54
pero con otros ejemplos para 00:23:57
para ver si queda claro 00:23:59
pues este 3, ahora, ¿vale? 00:24:02
Gracias. 00:26:26
Gracias. 00:27:07
Gracias. 00:27:43
Gracias. 00:28:13
Gracias. 00:29:37
Gracias. 00:30:22
Gracias. 00:34:09
Gracias. 00:36:01
Gracias. 00:36:31
Gracias. 00:37:01
Gracias. 00:37:31
Gracias. 00:38:01
No, no, no. 00:38:31
Gracias. 00:39:01
Gracias. 00:39:31
Gracias. 00:40:01
Gracias. 00:40:31
Gracias. 00:41:01
Gracias. 00:41:31
¡Gracias! 00:42:01
que pensaba yo que nos quedaba una hora entera 00:42:31
de clase a las dos y media 00:42:34
y ahora una y treinta y cinco 00:42:35
a ver, pues ya lo estaba hablando 00:42:38
con este chaval 00:42:55
pero a ver, el uso es el mismo 00:42:56
y no lo conozco por la marca 00:43:01
así que no incorpora 00:43:02
nada más que unos cuantos matices 00:43:05
nada más 00:43:06
pero es que ya veréis 00:43:12
que es lo mismo 00:43:39
da lo mismo 00:43:40
usar un set que usar un disc 00:43:41
da lo mismo 00:43:43
no sufras de verdad porque 00:43:44
uy no veo 00:44:03
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
6 de marzo de 2024 - 12:21
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
44′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
193.96 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid