Saltar navegación

Estructuras de control iterativo - 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 18 de octubre de 2023 por Stefano C.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar, por lo tanto, todo lo que digáis puede estar grabado y me autorizáis a grabarlo, ¿vale? 00:00:00
Entonces, las otras veces estuvimos mirando las estructuras condicionales, ¿vale? 00:00:08
Entonces hemos visto dos tipos de estructuras condicionales, que son por un lado el IF y por otro lado el SWITCH. 00:00:14
Esto me permite hacer una cosa u otra en función de una condición, ¿vale? 00:00:19
El concepto de condición o de expresión booleana a este punto debería ser relativamente claro, ¿vale? 00:00:27
En el sentido que hemos hecho ya muchos ejemplos de condiciones desde muy sencillas a menor que 3 00:00:34
a cosas más complejas que involucran también el AND, el OR y combinaciones de varios AND, OR, NOT, etc. 00:00:39
La idea es que con esto tenéis que familiarizaros porque casi todo en la informática 00:00:47
está basado sobre el concepto de encontrar la condición que quiero comprobar 00:00:52
y si la condición que quiero comprobar es verdadera, pasará una cosa y si no, pasará otra. 00:00:57
Además de las estructuras condicionales, necesitamos otra herramienta para poder hacer nuestros programas, 00:01:04
que es una herramienta muy potente, es la que nos abrirá la vía a poder hacer un mogollón de ejercicios 00:01:10
y un mogollón de prácticas, porque es lo que nos faltaba hasta ahora, 00:01:16
¿Vale? Que son las estructuras iterativas 00:01:21
¿Qué nos faltaba hasta ahora? 00:01:23
Vosotros habéis visto ejercicios que empiezan, hacen una cosa y acaban 00:01:25
¿Vale? Son los ejercicios más sencillitos 00:01:31
Lo que nos falta es poder decir, vale, pero cuando llegas al final, por ejemplo 00:01:33
Vuelves al principio y pídeme otra vez lo mismo 00:01:38
Sin que yo tenga que arrancar otra vez el programa 00:01:43
Estoy haciendo un programa que mira si los triángulos son isósceles, escalenos o equiláteros 00:01:46
Vale, fenomenal 00:01:52
Te doy tres números 00:01:53
Me dices, esto sería isócele 00:01:55
En vez de acabar y que tú tengas que lanzarlo otra vez 00:01:57
Vuelve arriba y te pregunte 00:01:59
Oye, mira, ¿quieres darme otro triángulo? 00:02:01
Y yo te digo, ¿cómo es? 00:02:04
O ya has acabado 00:02:06
Y tú puedes decir, no, he acabado 00:02:07
Entonces se acaba el programa 00:02:09
O que si tú le dices, sí, otro triángulo 00:02:10
Pues él te vuelve a decir, venga, dame otra vez tres números 00:02:12
Y yo te digo si es como más excepcional 00:02:15
Para hacer esto necesitamos una herramienta 00:02:18
Que me diga que un bloque de código 00:02:22
Se repita varias veces 00:02:25
Que el flujo de ejecución del programa 00:02:27
Reitere, haga varias iteraciones 00:02:31
Sobre ese trozo de código 00:02:36
Sobre ese bloque de código 00:02:39
Y esto se logra con las estructuras iterativas 00:02:40
Permite repetir un determinado bloque 00:02:44
Más de una vez 00:02:48
¿Cuántas veces? 00:02:49
Pues depende 00:02:51
Hay dos estructuras más conocidas 00:02:52
Que son el while y el for 00:02:57
El while se suele utilizar 00:02:59
Cuando tú tienes una condición 00:03:01
Que dices, mientras esta condición es verdadera 00:03:03
Yo quiero repetir y repetir 00:03:06
Y repetir este bloque 00:03:08
Cuando esta condición 00:03:09
se hará de repente falta 00:03:13
pues dejo de 00:03:15
gestionar, de repetir 00:03:16
este bloque y salgo de este bloque 00:03:19
¿vale? esto sería el while 00:03:21
ahora lo veremos más en detalle 00:03:23
el for es igual 00:03:24
todo lo que puedo hacer con el while lo puedo hacer con el for 00:03:27
y todo lo que hago con el for lo puedo hacer con el while 00:03:29
pero es más cómodo 00:03:31
cuando yo a priori sé ya 00:03:33
cuántas veces quiero repetir 00:03:35
este bloque 00:03:37
si yo sé que este bloque se tendrá que repetir 10 veces 00:03:38
Pues el for 00:03:41
Es más cómodo que el while 00:03:43
Eremos por aquí 00:03:45
¿Vale? Entonces 00:03:47
While y for son estructuras iterativas 00:03:48
Las dos son equivalentes, hacen lo mismo 00:03:51
¿Vale? Solo que si yo tengo 00:03:53
Que hacer este bloque, repetirlo 00:03:55
Mientras que una condición sea verdadera 00:03:57
Mejor el while, o sea, es más fácil utilizar el while 00:03:59
Si yo en vez quiero, tengo un bloque 00:04:01
Lo quiero repetir cuatro veces 00:04:03
Sé cuántas veces lo quiero repetir 00:04:05
Pues utilizo el for 00:04:06
Este es el while, ¿vale? 00:04:08
El comando while 00:04:12
Yo tengo el flujo de ejecución 00:04:13
Que viene desde aquí arriba 00:04:17
Llega a una condición 00:04:18
Por ejemplo, a menor que 3 00:04:19
Si esta condición es verdadera 00:04:22
Ejecuto un bloque de instrucciones 00:04:25
Y vuelvo antes de la comprobación de la condición 00:04:28
Si en vez de esta condición es falsa 00:04:33
Me salto el bloque de instrucciones 00:04:39
Y se sigue adelante 00:04:41
Entonces, una vez que yo entro en el while 00:04:42
Yo estaré aquí para siempre 00:04:47
Mientras que esta condición sea verdadera 00:04:49
Cuidado 00:04:51
Si yo pongo aquí una condición 00:04:53
Y esta condición no cambia 00:04:56
Dentro de este bloque 00:05:00
Estoy en un bucle infinito 00:05:01
Si yo digo 00:05:04
Mientras que a sea menor que cero 00:05:06
Haz esto 00:05:09
Y aquí dentro no cambio el valor de A 00:05:11
No lo toco el valor de A 00:05:14
Entonces si A es menor que 0 00:05:16
Cuando hará estas instrucciones 00:05:18
No cambiará el valor de A 00:05:20
Y cuando vuelva a comprobar la condición 00:05:22
Sigue siendo menor que 0 00:05:24
Porque nadie lo ha cambiado 00:05:26
Entonces entraría otra vez aquí 00:05:27
Y nadie lo cambia 00:05:29
Entonces volvería a la condición 00:05:30
Y sería siempre menor que 0 00:05:31
Y me quedaría aquí dentro para siempre 00:05:33
Los bucles infinitos 00:05:36
Si no quiero hacerlos 00:05:38
Mal 00:05:41
¿Vale? 00:05:42
Porque hay situaciones en que quiero un bucle infinito 00:05:44
¿Vale? 00:05:46
Un cajero automático 00:05:49
Tiene su programa 00:05:51
Viene un usuario 00:05:53
Mete la tarjeta 00:05:55
Pilla los dineros 00:05:56
Y vuelve arriba 00:05:58
No quiere decir, ah, he dado el dinero para hoy 00:05:59
Y he acabado hasta que me rearranque 00:06:02
No, es un bucle infinito 00:06:04
Que se puede parar 00:06:06
Solo en una situación 00:06:08
Absurda en el que va un 00:06:09
Técnico y lo para de alguna forma 00:06:12
¿Vale? 00:06:14
Pero técnicamente es como si fuera 00:06:15
Un bucle infinito, casi 00:06:17
¿Vale? Puede haber otros 00:06:19
Programas que por la naturaleza de ese programa 00:06:21
Tiene que ser activado, una vez activado 00:06:23
No cabe nunca, servidor 00:06:25
No sé, ¿vale? Siempre 00:06:27
Por debajo hay 00:06:29
Un acceso secundario en el que un 00:06:31
Un administrador de ese sistema 00:06:33
Puede decirle, oye, que sería 00:06:35
La condición de este Y 00:06:37
Mientras que el administrador nos ha dicho que pare 00:06:38
Y yo sigo adelante, aquí, aquí, aquí 00:06:41
Y aquí dentro a lo mejor no se modifica 00:06:43
Se modifica de otro lado 00:06:45
Que viene, se activa algo en otro lado 00:06:46
Y al activar algo en otro lado, esta condición cambia 00:06:49
Y entonces sale 00:06:51
¿Sí? 00:06:52
Estos son usos avanzados, lo veremos cuando haremos clases 00:06:54
Y cosas por el estilo 00:06:57
O el próximo año cuando haremos interrupciones, etc. 00:06:58
¿Sí? 00:07:02
Por ahora, la idea es esta 00:07:03
en todos nuestros ejercicios 00:07:05
al menos de esta evaluación 00:07:07
si dentro de este bloque 00:07:09
de instrucciones no actualizáis 00:07:11
la condición, mal 00:07:13
¿si? 00:07:15
porque quiere decir que se quedará ahí para siempre 00:07:17
y eso lo veréis porque encendéis 00:07:19
y veis, empieza a escribir cosas 00:07:21
un millón de cosas y no se para nunca 00:07:23
y, ¿os acordáis el cuadradito rojo? 00:07:25
eso que os hacía ver 00:07:28
si estaba encendido o no el programa 00:07:29
pues eso se os quedaba encendido 00:07:31
Pero el procesador está a tope 00:07:33
Porque está procesando esta condición 00:07:35
Millones de veces por segundo 00:07:37
Ahora lo hacemos 00:07:38
¿Vale? 00:07:40
Vemos que pasa 00:07:41
¿Sí? 00:07:41
Entonces 00:07:44
La idea, pero, es siempre esta 00:07:45
Yo llego con mi flujo de ejecución 00:07:48
Llego a la condición 00:07:51
Si la condición es falsa 00:07:52
Salgo ya 00:07:53
O sea, no necesariamente tengo que ejecutar 00:07:54
Estas instrucciones una vez 00:07:57
Si la condición cuando llega aquí es falsa 00:07:58
Pues me lo salto y sigo adelante 00:08:01
Si es verdadera, empiezo a girar en este bucle las veces que sean necesarias 00:08:02
En principio, dentro del bloque de instrucciones, esta condición podrá cambiar 00:08:10
Por ejemplo, si yo digo a es menor que 3, mientras que a es menor que 3, hace esto 00:08:16
Y aquí le digo a más más, a igual a a más 1 00:08:20
Entonces cada vez que pasa por las instrucciones, suma 1a 00:08:24
Y llegará un momento en que este a no será menor que 3 y por lo tanto sale 00:08:27
Pero habré hecho varias veces 00:08:31
Estas instrucciones, más de una 00:08:37
Dependiendo de cuánto valía 00:08:38
A al principio 00:08:40
Si A valía 0, habré hecho 0, 1, 2 00:08:42
Y a la 3 ha salido 00:08:45
Por lo tanto 3 veces 00:08:46
Si A cuando ha entrado la primera vez valía 2 00:08:47
Pues lo ha hecho una vez sola 00:08:50
¿Sí? 00:08:51
Más o menos 00:08:54
Segundo, cuando quiero repetir 00:08:55
Un cierto bloque de instrucciones 00:08:58
Me interesa ver la condición 00:09:00
Esta es un ejemplo de un while 00:09:01
Pregunta para vosotros 00:09:07
¿Qué hace este programa? 00:09:09
No lo sé 00:09:14
¿Qué hace este programa? 00:09:15
Tú dime qué sale de este programa 00:09:16
Por favor dejad de jugar también los demás niños 00:09:18
Pensadlo un momento 00:09:21
Y ahora luego 00:09:23
Que todos puedan pensar 00:09:23
Yo quiero saber, lanzo este programa 00:09:26
¿Qué veo en la consola? 00:09:28
Y si ya sabéis 00:09:41
¿Qué veo en la consola? 00:09:42
La pregunta es, ¿cuántas veces repito este bloque? 00:09:43
Diez. 00:09:48
Deja jugar los otros niños. 00:09:50
Mira que están grabados, ¿eh? 00:09:52
¿Quién sabe qué escribe este en pantalla? 00:09:54
Yo, yo, yo. 00:10:05
¿Qué escribe este en pantalla? 00:10:06
Uno. 00:10:11
Uno, dos, tres. 00:10:14
Desde cero, ¿vale? 00:10:17
La primera vez, int vale cero. 00:10:19
¿Cero es menor o igual que diez? 00:10:23
Sí, lo escribo en pantalla, cero, y sumo uno a este valor. 00:10:25
Por lo tanto, vuelvo al principio del while, y ahora ahí vale uno, 00:10:31
y me pregunto, ¿uno es menor o igual que diez? 00:10:35
Sí, por lo tanto, entro aquí, escribo uno, y sumo uno, y voy a dos. 00:10:38
Y vuelvo aquí, ¿dos es menor o igual que diez? 00:10:43
Y así, así, así, ¿hasta cuándo? 00:10:46
¿Hasta diez? 00:10:50
hasta 9 00:10:51
9 es menor o igual que 10 00:10:54
10 es menor o igual que 10 00:10:57
por lo tanto entraría, escribe 10 00:11:05
suma 1, va a 11 00:11:08
11 es menor o igual que 10 00:11:10
falso 00:11:12
si, o sea que este programa 00:11:14
de aquí escribe los números 00:11:18
desde el 0 hasta el 11 00:11:20
hasta el 10, perdón 00:11:22
y el 11 sale 00:11:23
Es decir, que aquí debajo 00:11:26
¿Cuánto vale i? 00:11:28
Cuando yo salgo de este while 00:11:32
i vale 11 00:11:36
Pero me ha escrito los números 00:11:37
De 0 a 10 00:11:40
¿Si? 00:11:43
Y si yo escribiera este system.auto.println 00:11:45
Debajo de este i++ 00:11:48
¿Y entonces que me escribe? 00:11:50
Desde el 1 00:11:55
Porque con el 10 entraría 00:11:58
Más un 11, lo escribo 00:12:04
Escribo 11 y luego salgo 00:12:06
Entonces la idea es esta 00:12:08
Tengo esta condición 00:12:16
Mientras que esta condición es verdadera 00:12:20
Estoy aquí haciendo esto una y otra vez 00:12:23
Y por algún lado dentro de este bloque 00:12:26
Actualizo la condición 00:12:29
¿Vale? Este I++ 00:12:31
Es el que me hace que sea posible 00:12:33
Que esta condición cambie 00:12:35
Si yo la quito 00:12:37
¿Qué haría este programa? 00:12:38
Sigue en esta línea de aquí 00:12:42
Escribiría por infinitas veces 00:12:43
¿Qué? Cero 00:12:47
Cero, cero, cero, cero 00:12:49
Y no para nunca 00:12:51
Porque como aquí esta condición 00:12:52
No se modifica, pues se quedaría 00:12:55
Siempre cero 00:12:57
¿Qué es esto? 00:12:58
Un bloque 00:13:03
¿Y qué puedo poner en un bloque? 00:13:04
If, declaración de variables 00:13:07
While, for 00:13:09
¿Puedo ir un while dentro de un while? 00:13:12
¡Claro! 00:13:14
¿Sí? 00:13:16
Y es lo que complica las cosas 00:13:17
Lo veremos dentro de un rato 00:13:18
¿Dudas sobre esto? 00:13:19
¿Se entiende la idea? 00:13:22
¿Para qué me puede servir? 00:13:23
Lo veremos 00:13:25
El ejemplo más básico que se puede dar 00:13:25
Es para que un ejercicio de todo lo que habéis hecho vosotros 00:13:28
En vez de hacerse una vez sola 00:13:32
Se puede repetir 00:13:34
Cuando haya acabado el ejercicio 00:13:35
Vuelvo arriba y digo 00:13:37
¿Quieres volver a hacer el ejercicio? 00:13:38
Y si tú le escribes uno 00:13:44
Pues te va arriba 00:13:45
Y te lo haces 00:13:46
Y escribes cualquier otro número 00:13:47
Pues no 00:13:48
Lo haremos ahora como 00:13:50
¿Cuándo? 00:13:51
¿Cómo? 00:13:55
Porque yo aquí debajo 00:13:59
Me haré una lectura 00:14:01
De un fichero 00:14:03
De un número 00:14:04
Y ese número lo guardo dentro de ahí 00:14:07
Y aquí pongo que mientras si es igual a cero 00:14:09
Sigue aquí delante 00:14:11
Aquí dentro, entonces aquí está todo mi programa 00:14:13
Y al final pediré al usuario 00:14:15
¿Quieres seguir? 00:14:17
Si pones un número que no es cero 00:14:18
Pues te paras y sales y vas adelante 00:14:20
O acabas 00:14:23
Y si en vez pones un número que es cero 00:14:24
Pues como la condición sigue siendo verdadera 00:14:26
Pues entro otra vez 00:14:28
lo haremos 00:14:29
¿cómo? 00:14:30
estos son boolean 00:14:34
normalmente leer un booleano 00:14:37
por teclado es una cosa que se hace 00:14:39
muy poco, ¿vale? 00:14:41
por teclado se suele leer un número 00:14:43
dando un menú de 1 sí, 2 no 00:14:45
y tú pones 1 y 2 00:14:48
o directamente la palabra 00:14:49
pero nosotros tenemos todavía un problemita 00:14:50
que a lo mejor ahora lo solucionamos 00:14:52
que es como comparamos string 00:14:54
porque hemos dicho que 2 string 00:14:57
no se comparan con igual igual 00:14:59
entonces 00:15:00
otro 00:15:05
otra 00:15:07
estructura iterativa 00:15:10
es el do while 00:15:11
¿vale? que es igual al while 00:15:13
solo que fijaos 00:15:15
el while 00:15:17
podría ser que esta instrucción 00:15:19
no se ejecute nunca 00:15:22
si cuando yo llego a la condición 00:15:24
la condición es falsa 00:15:26
Este bloque no se ejecutará nunca 00:15:27
Se salta 00:15:30
Y nada más 00:15:32
Y si yo quisiera hacer 00:15:32
Algo que me diga, oye mira 00:15:35
Una vez hace este bloque 00:15:37
Ejecuta 00:15:39
Y después de haberlo ejecutado una vez 00:15:41
A ese punto te vas a preguntar algo 00:15:44
Y si ese algo es verdadero 00:15:46
Sigues ejecutando este bloque 00:15:48
Una y otra vez, otra vez 00:15:50
Y si no, no 00:15:51
¿Entendéis la diferencia? 00:15:52
Aquí podría ser cero o más veces 00:15:54
En vez de la otra sería una vez 00:15:57
O más 00:16:00
¿Sí? ¿Cómo lo hago? 00:16:01
Pues en vez de utilizar el while 00:16:04
Uso la operación do while 00:16:06
¿Vale? 00:16:09
Sostancialmente entro en el do while 00:16:10
El bloque de instrucciones está antes 00:16:12
Este bloque de instrucciones se ejecutará una vez siempre 00:16:13
Y al final me llega la condición 00:16:16
Si la condición es verdadera 00:16:18
Vuelvo antes del bloque de instrucciones 00:16:20
Y lo ejecuto otra vez 00:16:23
Si en vez de esa condición es falsa 00:16:24
sigue adelante. ¿Se entiende la diferencia? Se suele utilizar más el while que el do while, ¿vale? 00:16:26
Pero a veces hay condiciones en que el do while puede ser cómodo. ¿Qué hace esto? Escribe en 00:16:33
pantalla contador, ¿cuántas veces? La primera vez escribe cero, suma uno, uno es menor que diez, 00:17:00
menor o igual que diez, sí, entonces vuelve al principio del do y escribe uno y suma dos, ¿vale? 00:17:07
Y me pregunta, ¿2 es menor o igual que 10? 00:17:15
Y así, así, así, así, así, ¿cuántas veces? 00:17:18
Hasta que esto sea 11, el contador sea 11, y entonces que he escrito 10. 00:17:25
O sea, que este es exactamente el ejercicio de antes. 00:17:30
Me escribe los números de 0 a 10. 00:17:32
La diferencia es que si yo pongo aquí 11, esto me escribe una vez 11, y luego sigue adelante. 00:17:36
Mientras que si yo pongo 00:17:46
Aquí 11 00:17:49
No me escribe nada en pantalla 00:17:50
¿Sí? 00:17:52
Vale 00:17:56
Claro el while 00:17:59
Tengo una condición, while ¿qué quiere decir en inglés? 00:18:01
Mientras 00:18:05
¿Vale? 00:18:06
Mientras esta condición es verdadera, hace esto 00:18:07
Este es el sentido del while 00:18:11
¿Sí? 00:18:13
Y luego está 00:18:14
Otra 00:18:16
Otra estructura 00:18:17
¿Vale? Un poquito distinta 00:18:20
Que hace más o menos lo mismo 00:18:23
¿Vale? Y que 00:18:24
Si tú cambias algunas 00:18:25
Cosas dentro, ¿eh? Puedes usar 00:18:28
Un for donde está un while 00:18:30
Y un while donde está un for, no cambia nada 00:18:32
¿Vale? Pero este es más práctico 00:18:34
Para otras cosas, hemos dicho, cuando yo ya sé 00:18:36
Que quiero ejecutar 00:18:38
Este bloque 10 veces, sé que son 00:18:40
10 de las veces que quiero ejecutar 00:18:42
Pues un for se hace más 00:18:44
Útil 00:18:46
Para quien sabe 00:18:48
Algo de programación 00:18:50
Cuando yo gestiono por ejemplo un array 00:18:51
Que sé cuantas posiciones tiene un array 00:18:54
Como sé que tengo que entrar en todas las posiciones 00:18:56
De array y son 25 posiciones 00:18:59
Pues puedo usar un for 00:19:01
Desde 0 hasta 24 00:19:02
Si no sabéis que es un array no importa 00:19:04
Lo veremos 00:19:06
Entonces que hace el for 00:19:08
El for pasa por 00:19:10
Tres fases 00:19:12
Hay una fase de inicialización 00:19:14
Inicializa algo 00:19:16
Inicializa como un contador 00:19:18
Normalmente, vale 00:19:20
Se pregunta una condición 00:19:21
Si esta condición es 00:19:24
Falsa, salgo fuera 00:19:26
Y he acabado, si esta condición 00:19:28
Es verdadera, como en el while 00:19:30
Voy a ejecutar un bloque de instrucciones 00:19:31
Pero al final 00:19:34
De este bloque de instrucción 00:19:36
Antes de volver a la condición 00:19:37
Hay una fase 00:19:40
De actualización, actualización de que? 00:19:42
De lo que he inicializado aquí 00:19:44
Vale, es como si 00:19:46
Dentro de este for 00:19:48
Hubiese un contador 00:19:50
¿Vale? Que al principio le digo 00:19:51
Oye mira, tú al principio vales 0 00:19:54
Y que cada vez que pasa 00:19:55
Por la fase de actualización 00:19:58
Le digo yo, oye mira 00:19:59
Incrementa este valor de 1 00:20:00
O incrementa este valor de 3 00:20:03
O resta este valor de 1 00:20:05
Lo que estamos haciendo es actualizar el valor 00:20:06
De lo que uso aquí en la condición 00:20:09
Así a lo mejor se entiende mejor 00:20:11
Este es el FOC 00:20:15
Inicialización 00:20:16
Me creo una variable i 00:20:18
¿Vale? Que está por índice normalmente 00:20:21
Que es igual a 0 00:20:23
Al principio, estoy aquí 00:20:24
He dicho que i vale 0 00:20:27
Punto y coma 00:20:29
¿Vale? 00:20:31
i menor que 10 00:20:33
La condición, ¿vale? 00:20:34
Mientras que esta condición sea verdadera 00:20:36
Tú vete ciclando de aquí 00:20:39
i más más 00:20:41
Esto es la actualización 00:20:43
Cada vez que vuelves aquí arriba 00:20:45
Y compruebas 00:20:48
Antes de comprobar 00:20:50
Ejecuta esta cosa de aquí 00:20:51
Entonces 00:20:53
Por cada ciclo que yo giro 00:20:55
Se incrementará de 1 00:20:59
Es parecido a lo que hacía aquí 00:21:01
Que sumaba 1 00:21:04
Pero lo tenía que poner explícitamente 00:21:07
Como instrucción dentro del bloque de instrucción 00:21:10
En vez ahora 00:21:12
Lo saco en la declaración 00:21:13
Del for diciendo que mi for 00:21:16
Tiene que ir desde 0 00:21:18
Cada ciclo incrementa de 1 00:21:19
Y que ciclaré 00:21:23
Estaré en el ciclo 00:21:25
Mientras que i sea menor que 10 00:21:26
Que yo vea las condiciones 00:21:28
Para que funcione 00:21:30
Y yo entro aquí dentro y escribo i 00:21:31
¿Qué hace este programa? 00:21:34
Escribe los números 00:21:43
Es 0 al 9 00:21:44
Un poquito distinto 00:21:46
Porque he puesto aquí menor estricto 00:21:48
Si pusiera menor igual 00:21:49
Haría exactamente lo mismo que los demás 00:21:52
Pero, ¿y dónde hay aquí que incrementa I? 00:21:54
Pues no lo incrementa en el bloque 00:21:58
Lo incrementa aquí en fase, digamos, de incrementación 00:21:59
Después de haber ejecutado el bloque 00:22:04
Ejecuta lo que yo he escrito aquí 00:22:06
Y vuelve a seguir 00:22:09
Cuando yo, por ejemplo, sé cuántas veces quiero hacer esta operación de aquí 00:22:10
Pues esto es muy práctico 00:22:17
Porque si pongo de 0 menor que 10 00:22:18
Pues esto se ejecutará 10 veces 00:22:21
¿Sí? 0, 1, 2, 3, 4, 5 00:22:23
Hasta 9, 10 veces 00:22:26
¿Dudas? 00:22:28
¿Es lo mismo que antes? Sí 00:22:32
¿Vale? Cambia un poco el formato 00:22:34
Y cambia un poco que aquí 00:22:36
Hay un 00:22:38
Aquí yo puedo declarar, mientras antes 00:22:39
Lo tenía que declarar 00:22:42
Fuera, luego utilizarlo 00:22:44
En cada ciclo 00:22:46
Y incrementarlo yo 00:22:48
Y estar yo pendiente 00:22:49
De estas cosas de aquí 00:22:52
Pues aquí dentro 00:22:53
El mismo for 00:22:55
Me da la posibilidad de declarar un contador 00:22:57
De declarar un índice 00:22:59
Que me dice en cuál iteración estoy 00:23:00
Si está en la tercera en 0, la tercera en 1, la tercera en 2 00:23:03
Y me dice 00:23:06
Este número de aquí, ¿cómo se actualiza? 00:23:07
Si aquí en vez de i más más 00:23:09
Hubiese puesto i igual a i más 2 00:23:10
Cada ciclo suma 2 00:23:13
No 1 00:23:16
¿Sí? 00:23:17
¿Dudas? 00:23:20
Vale 00:23:23
¿Qué hace esta cosa aquí? 00:23:24
Vale, perdonadme 00:23:38
Pasamos antes de aquí 00:23:39
Pregunta 00:23:41
Puedo usar i 00:23:41
Aquí fuera del while 00:23:47
Después del while 00:23:49
¿Existe i aquí? 00:23:51
¿Por qué existe i aquí? 00:23:55
Porque está declarada afuera 00:23:58
¿Vale? 00:24:00
Y si yo esta i la declaro aquí dentro 00:24:00
No funciona 00:24:03
¿Vale? 00:24:04
¿Puedo usar contador aquí fuera? 00:24:07
Mínima situación. 00:24:11
¿Puedo usar i fuera del for? 00:24:14
No. 00:24:17
¿Vale? 00:24:19
Esta variable de aquí está creada solo dentro de este for. 00:24:20
Cuando yo salga de este for, está ahí como si no existiera. 00:24:24
Es local a este for. 00:24:28
¿Y si quisiera ponerla fuera? 00:24:32
Imaginaos que yo después de haber hecho esto 00:24:39
Quiero utilizar i 00:24:42
¿Vale? 00:24:43
Entonces no la puedo declarar aquí 00:24:45
Entonces ¿Cómo lo hago? 00:24:47
Pues declaro que int i fuera 00:24:48
Luego entro en el for 00:24:52
Y inicialización de esta i 00:24:54
Condición 00:24:56
Y actualización de esta i 00:24:58
La uso aquí dentro 00:24:59
Esto me escribiría 0 00:25:01
Luego suma 1 va a 1 00:25:02
Entonces si 1 es menor que 3 me escribe 1 00:25:05
Luego va 2, me escribe 2 00:25:08
Luego va 3, 3 no es 00:25:11
Menor que 3, entonces saldría aquí fuera 00:25:13
En este punto de aquí 00:25:15
Fuera del bloque 00:25:17
Y valdría 3 00:25:18
¿Si? 00:25:20
Y luego la sobreescribo con Y 00:25:23
¿Vale? Entonces lo que me escribe por pantalla 00:25:25
Es 0, 1, 2 00:25:27
Esta cosa aquí no la puedo hacer 00:25:27
¿Vale? Esto me da error 00:25:38
Es lo mismo 00:25:40
Lógicamente 00:25:42
Pero a nivel de ámbito de la variable, este int i la declara solo dentro del for 00:25:43
Entonces si intento luego utilizarla fuera, pues no me vale 00:25:50
Y aquí os hace ver también una pequeña diferencia entre el for y el while 00:25:54
Imaginaos que yo tenga un while y este int i no la quiero declarar 00:26:02
Porque luego después no la uso nunca 00:26:11
¿Puedo yo no declararla afuera 00:26:13
Para hacer una cosa así? 00:26:16
¿Dónde la declaro? 00:26:21
Si aquí la estoy utilizando 00:26:22
Si la declaro aquí dentro 00:26:23
Aquí me va a dar un problema 00:26:30
Dice no existe 00:26:31
Si la declaro aquí afuera 00:26:32
Luego existe en todo el ámbito 00:26:35
Y a lo mejor no lo quería 00:26:36
Entonces en este caso sería un problema 00:26:38
Si no quisiera 00:26:40
Mientras el for te da esta posibilidad de aquí 00:26:41
La estoy declarando 00:26:45
En su fase de declaración 00:26:47
Y me vale local al forzo 00:26:49
Lo estás haciendo 00:26:51
Porque lo estás haciendo 00:26:59
Inicialización 00:27:02
Condición 00:27:04
Actualización 00:27:06
Aquí declararla 00:27:07
No le pronuncio 00:27:11
No se suele hacer 00:27:13
Vamos a partir de aquí 00:27:16
Vale 00:27:17
Está claro que la complejidad 00:27:21
De esta cosa 00:27:29
Surge 00:27:31
En el momento en que yo empiezo a poner 00:27:32
Números dentro de 00:27:35
O sea, for dentro de for 00:27:38
While dentro de while 00:27:40
¿Vale? 00:27:42
Si queréis un poco de cabraderos de cabeza 00:27:44
¿Vale? 00:27:47
Os ponéis aquí 00:27:49
Y veis que esta cosa aquí 00:27:50
Os escribe esta cosa aquí 00:27:53
¿Sí? 00:27:54
Y esto es pararse un momento 00:27:58
Razonar cuánto vale i 00:28:00
Cuánto vale j 00:28:02
Y entender por qué sale esta cosa aquí 00:28:03
¿Vale? 00:28:07
Tened en cuenta que por cada ciclo del for externo 00:28:08
Se hacen todos los ciclos del for interno 00:28:12
O sea, por i que vale 1 00:28:16
Haré 1 y 2 de j 00:28:19
Luego acaba j 00:28:23
Acaba i 00:28:25
Sumo 1 a i 00:28:26
Entonces i ahora vale 2 00:28:28
Y entro otra vez aquí dentro en este for 00:28:29
y hago otra vez dos ciclos de estos si os fijáis los primeros dos ciclos y vale 1 porque lo está 00:28:32
haciendo aquí dentro y no se está actualizando los segundos dos ciclos y vale 2 mientras aquí 00:28:42
si yo guardo el for cuando durante el primer ciclo del for externo el for interno el dj pasa 00:28:51
De 1 a 2 00:28:58
Luego acaba 00:28:59
Aumenta 1 el i 00:29:01
Vuelve arriba 00:29:04
1 y 2 00:29:05
Y esto no es sencillísimo 00:29:07
¿Vale? 00:29:11
Esto es pensarlo un poco 00:29:12
Y de vez en cuando 00:29:14
Tened en cuenta que 00:29:15
Poner for dentro de for 00:29:17
Y while dentro de while 00:29:20
Es peligroso 00:29:22
A veces es necesario 00:29:24
No es que no lo veremos nunca 00:29:25
Hay veces que algunos ejercicios necesitan una estructura de esto 00:29:27
Un for dentro de un for, un while dentro de un while 00:29:31
Un for dentro de un while 00:29:33
Para que puedan funcionar, para que se pueda hacer 00:29:34
Pero cuando meto while dentro de while 00:29:36
Me expongo a que la complejidad de mi programa 00:29:39
Sea demasiado grande 00:29:43
Sea exponencial 00:29:45
Cuando la complejidad es exponencial 00:29:46
Quiere decir que el tiempo que tarda el programa en hacer su trabajo 00:29:50
es exponencial con respecto 00:29:54
a los datos que le pongo 00:29:57
pongo pocos datos, va bastante rápido 00:29:58
pero cuanto aumente los datos 00:30:01
complejidad aumenta exponencialmente 00:30:05
entonces a lo mejor con 10 datos 00:30:07
ya me hace, se me hace lentísimo 00:30:09
y con 100 00:30:11
mogollón de veces más 00:30:12
lento, no 100 veces más lento 00:30:14
va exponencialmente más lento 00:30:17
así se me explica 00:30:19
entonces, hay que tener 00:30:21
cuidado a meter while dentro while 00:30:24
for dentro for, porque podrían causar 00:30:26
una explosión 00:30:28
exponencial de la complejidad 00:30:30
de mi programa, ¿vale? 00:30:32
es decir, que mi programa empieza a ir lentísimo 00:30:34
ya está, hacemos un ejemplo 00:30:36
pillamos 00:30:45
un ejercicio 00:30:50
cualquiera, ¿vale? de los sencillos 00:30:53
mejor 00:30:55
este es el ejemplo del libro 00:30:56
vale, este 00:31:00
te doy dos números 00:31:02
y me dices si son 00:31:04
divisibles, ¿os acordáis? este de aquí 00:31:06
¿vale? este de aquí 00:31:09
normalmente lo que hacía es hacerlo 00:31:11
una vez, ya está 00:31:13
pues vamos a intentar hacer, no, mira 00:31:14
yo quiero que cuando esto 00:31:17
haya acabado 00:31:19
vuelva a 00:31:20
te pregunte, oye mira, ¿has acabado 00:31:22
de verdad? o ¿quieres 00:31:25
comprobar otros dos 00:31:27
números? y si quieres comprobar 00:31:29
otros dos números, pues lo vuelves 00:31:31
a pedir, entonces 00:31:33
La primera pregunta que os hago es 00:31:34
¿Cuál es el bloque 00:31:36
De instrucciones 00:31:40
Que pensáis que se va a repetir 00:31:43
Una y otra vez y otra vez y otra vez 00:31:45
¿Desde dónde? 00:31:46
¿Cuál es el bloque de estas instrucciones 00:31:57
Que quiero repetir? ¿Esto? 00:31:59
¿Esto es lo que se repite mil veces? 00:32:01
Pregunto 00:32:04
No, ¿cuál? 00:32:04
Desde la línea 6 00:32:08
Hasta 00:32:10
La 9 00:32:11
Esto es lo que se repite mil veces 00:32:15
De la 6 hasta la 18 00:32:18
Este de aquí 00:32:23
Es el bloque que yo quiero hacer una y otra vez 00:32:25
Cada vez le diré 00:32:29
Dame dos números y te digo si son divisibles 00:32:30
Y luego te volveré a pedir dos números 00:32:33
Y te diré si son divisibles 00:32:35
Y te pediré dos números y te diré si son divisibles 00:32:36
¿Si? 00:32:38
Esto es lo que yo quiero repetir 00:32:42
fijaos, scanner teclado 00:32:44
lo quiero repetir 00:32:46
no, porque yo creo una vez 00:32:47
esta cosa que me permite 00:32:50
leer de teclado, y luego uso 00:32:52
el leerlo con el nextint 00:32:54
pero no tengo que crear 00:32:56
cada vez un nuevo teclado 00:32:58
el teclado ya lo tengo, vale 00:33:00
entonces, esto 00:33:02
hasta aquí 00:33:04
es lo que quiero que se repita 00:33:09
vale 00:33:14
¿Sí? 00:33:14
Ahora, ¿cuántas veces quiero que se repita? 00:33:19
Infinitas 00:33:22
Entonces, tendré que crearme una condición 00:33:23
¿Vale? 00:33:26
Por ejemplo, me puedo crear un booleano 00:33:27
Un int 00:33:29
¿Cómo queréis hacerlo? 00:33:31
Da igual 00:33:33
Un int 00:33:34
Int sigue 00:33:35
Es igual 00:33:38
Cero 00:33:40
¿Sí? 00:33:42
Mientras 00:33:44
Sigue 00:33:45
Es igual a cero 00:33:47
Hace esto 00:33:50
¿Cuántas veces lo hace? 00:33:53
Actualmente infinita 00:33:58
¿Por qué infinita? 00:34:00
Porque no estoy actualizando 00:34:01
Sigue aquí dentro 00:34:05
En ningún sitio 00:34:06
Aquí dentro estoy utilizando sigue 00:34:11
Por lo tanto sigue siempre 00:34:13
Valdrá cero para el resto de su vida 00:34:15
Y esta condición de aquí 00:34:17
Siempre será verdadera 00:34:19
Y por lo tanto me quedaré que aquí 00:34:21
Para siempre 00:34:22
Entonces vamos a solucionar esto 00:34:23
Al final del programa 00:34:26
Voy a preguntar al usuario 00:34:29
Si quiere seguir o no 00:34:31
¿Quieres 00:34:33
Hacer 00:34:38
Ejecutar 00:34:40
El programa 00:34:43
Otra vez 00:34:44
Barra n 00:34:47
Cero 00:34:51
Barra n 00:34:55
Otro número 00:34:57
¿Qué me hacen estas barra N? 00:35:03
Salto de línea 00:35:07
¿Vale? 00:35:08
Y ahora, después de haber escrito esta cosa 00:35:10
Me pregunto 00:35:13
O sea, leo un número 00:35:15
¿Qué número será? 00:35:17
Bueno, para leer un número sería 00:35:19
Scanna.nextint 00:35:20
¿Dónde lo guardo? 00:35:22
Sigue 00:35:28
De esta forma 00:35:29
Si el usuario me pone cero 00:35:33
Si el usuario me pone cero 00:35:35
Que corresponde a sí 00:35:42
Pues entonces 00:35:44
Sigue valdrá sí 00:35:46
Vuelvo aquí arriba 00:35:47
Sigue es igual a cero 00:35:48
Y lo hago otra vez 00:35:50
Si el usuario me pone otro número 00:35:51
Uno 00:35:55
Pues sigue valdrá uno 00:35:56
Vuelvo aquí arriba 00:35:58
Uno no es igual a cero 00:35:59
Y por lo tanto acabo 00:36:02
Y escribo aquí abajo 00:36:03
Programa terminado 00:36:04
Vamos a ver si funciona 00:36:12
Lanzo mi programa 00:36:19
Dame un int 00:36:21
Dos 00:36:27
Dame otro int 00:36:29
Cuatro 00:36:30
Son divisibles 00:36:31
¿Vale? 00:36:33
Y luego dice 00:36:34
¿Quieres ejecutar el programa otra vez? 00:36:35
Barra n 00:36:38
Cero dos puntos sí 00:36:38
Barra n 00:36:40
¿Otro número no? 00:36:41
¿Qué le doy? 00:36:43
Dame uno 00:36:47
Para ver que funciona 00:36:48
Ah no, perdón, cero 00:36:50
Tenía idea 00:36:51
Uno, uno, son divisibles 00:36:55
Le doy cero 00:36:58
Y veis que 00:36:59
No ha acabado, sigue funcionando 00:37:01
Y me vuelve a decir, vale, dame un int 00:37:04
Y que int le doy 00:37:06
Uno, dos 00:37:10
Y dice, son divisibles 00:37:12
¿Vale? 00:37:14
¿Quieres seguir? 00:37:16
Sí, cero 00:37:18
y 15 00:37:21
no es divisible, quiere seguir 00:37:23
se entiende 00:37:28
y esta es una forma básica 00:37:32
de como usar 00:37:36
el while 00:37:37
que no es 00:37:38
parte del 00:37:41
en este caso el while no lo estoy usando como parte 00:37:42
del algoritmo para solucionar el problema 00:37:46
sino que estoy mejorando 00:37:48
la calidad de mi programa 00:37:50
En el sentido que cuando el programa acaba 00:37:52
Si el usuario 00:37:53
Quiere hacer más operaciones 00:37:55
No necesita rearrancar el programa 00:37:58
Sino que directamente aquí dice 00:38:00
Sí, adelante 00:38:01
Y ahora nos voy a dar 00:38:02
Ejercicios del Wild 00:38:17
Os lo voy a dar el miércoles 00:38:18
Para ahora me interesa que entendáis la cosa 00:38:20
¿Queréis probarlo? 00:38:22
Pues lo que podéis intentar hacer es lo que he hecho yo 00:38:23
En otro programa 00:38:26
¿Vale? 00:38:27
También 00:38:30
Quiero que veáis 00:38:30
Otra cosa 00:38:33
Clash 00:38:34
Prueba 00:38:35
Wille 00:38:39
Ese es un programita, no hace nada 00:38:40
¿Vale? 00:38:49
Pongamos que yo pongo 00:38:52
Aquí int x 00:38:53
Es igual a 0 00:38:55
Wille 00:38:56
Menor 00:39:01
Que 100 00:39:02
Lo que hago es que x 00:39:04
¿Qué pasa si ejecuto esto? 00:39:10
¿Lo veis? ¿Cómo está mi pobre CPU? 00:39:32
¿Lo veis? ¿Quién está gastando 00:39:38
Un mogollón de 00:39:41
De CPU? 00:39:42
¿Por qué? 00:39:47
Porque este señor 00:39:51
Que es un procesador y es potente 00:39:52
Está todo el rato 00:39:55
Escribiendo un 0 y comprobando 00:39:57
Si es menor que 100 00:39:59
si, escribo un 0 00:40:02
y como lo puede hacer 00:40:03
millones de veces 00:40:06
al segundo, pues aquí 00:40:07
yo miro esto y digo, no sé qué hacer 00:40:10
lo lanzo otra vez, porque así funciona 00:40:11
mejor 00:40:14
ahora tengo dos procesos 00:40:14
que hacen esta cosa aquí 00:40:17
y este es útil 00:40:19
si, si, está aquí debajo 00:40:25
computándose también 00:40:30
y esto para qué es útil 00:40:31
Para en invierno 00:40:33
Cuando hace frío 00:40:37
¿Vale? 00:40:38
Te metes 5 o 6 de estos 00:40:39
Y te acercas a tu ordenador 00:40:41
¿Vale? 00:40:43
Por otra cosa no 00:40:44
¿Sí? 00:40:46
Entonces, ¿cómo lo paro ahora? 00:40:48
Aquí, ¿vale? 00:40:49
Esto lo para 00:40:51
Y si os fijáis, el otro sigue funcionando 00:40:52
Y ahora paro el segundo 00:40:55
Y cuando ha parado el segundo 00:40:56
Esto se baja 00:40:58
Y respira 00:41:00
Esto es en verano 00:41:01
¿Cómo soluciono esta cosa? 00:41:02
Pues tengo que aquí dentro 00:41:09
Dentro de este bloque 00:41:11
Actualizar de alguna forma 00:41:13
Y otra cosa que es importante 00:41:17
Es que tengo que aprender 00:41:20
A mirar este cuadrado de aquí 00:41:22
Si yo lanzo 00:41:24
Imaginaos esto 00:41:25
Lanzo 00:41:27
Oye, no funciona 00:41:31
No hace nada 00:41:34
¿Si? 00:41:35
¿A que si? 00:41:38
Pues nada 00:41:39
Ah si 00:41:39
Se me ha olvidado el system 00:41:40
Ahora lo pongo 00:41:41
Ah si si 00:41:43
Perfecto 00:41:44
Pongo X 00:41:45
Ah se me ha olvidado 00:41:46
X más más 00:41:47
Vale perfecto 00:41:48
Ahora si 00:41:49
Ahora lo he arreglado 00:41:50
Venga lo ejecuto 00:41:51
Aquí mira 00:41:52
Me ha funcionado 00:41:55
Hasta se ha parado 00:41:56
Perfecto 00:41:57
Aquí eh 00:41:59
Detrás 00:42:04
Trabajando 00:42:04
Saca hasta menos 00:42:06
Pero hasta allí no es normal 00:42:08
Que mi CPU esté a 38% siempre 00:42:10
¿Y quién es el malvado que hace esto? 00:42:12
No lo está ejecutando 00:42:15
Porque aquí detrás 00:42:19
Está 00:42:22
¿Veis que está? 00:42:23
¿Sí? 00:42:31
Solo que como este programa aquí 00:42:32
El que había escrito antes 00:42:34
Era esto, que no hace nada 00:42:36
Solo está dando vueltas inútiles 00:42:38
Para aquí, pero sigue 00:42:40
Si esto hace algo 00:42:41
o por ejemplo, x más más 00:42:43
no, x menos menos 00:42:46
vale, lo paro 00:42:47
este programa aquí, escribe algo 00:42:52
lo lanzo 00:42:54
ah, no escribe nada, no escribe nada 00:42:56
ah, pues sí, lo cambio 00:42:58
ah, no, porque era menos menos, era más más 00:43:00
vale, ok, ahora lo ejecuto 00:43:02
venga, aquí, ahora funciona 00:43:04
ha acabado, sí, ha perfecto 00:43:06
ha acabado porque con más más 00:43:08
llegará un momento en que esta 00:43:10
será falsa, pero por debajo 00:43:12
El x++ sigue por allí 00:43:14
¿Hasta cuándo? 00:43:16
¿Por qué ahora ha 00:43:20
Probablemente acabado, no lo sé 00:43:21
Vamos a ver si acaba 00:43:24
Bueno, el menos menos podría dar 00:43:25
Que a un cierto momento pase de los int 00:43:30
Entonces explota 00:43:32
Me explico lo que quiero decir 00:43:34
O sea, tened siempre cuidado con los while 00:43:40
Tengo que hacer algo 00:43:43
No solo que aquí actualice la x 00:43:46
Sino que el objetivo de actualizar 00:43:48
La X es que antes o después 00:43:51
Esto se quede falso 00:43:53
Si yo pongo esto 00:43:54
Se quedará 00:43:56
Esto falso alguna vez 00:43:59
No puede 00:44:01
A lo mejor 00:44:05
A lo mejor ha hecho eso 00:44:09
Pero en principio mal 00:44:13
Si, entonces tened cuidado con eso 00:44:15
Ahora, a veces os pasará 00:44:17
Lanzáis un programa 00:44:19
Y se os pone en un bucle infinito 00:44:21
Y se queda allí mil veces 00:44:22
Entonces lo que hacéis, pues lo paráis 00:44:24
Aquí, con el rojo 00:44:26
Vale, entonces, no, esto está bien 00:44:27
Entonces, para que veáis este programita 00:44:32
Aquí, vale 00:44:34
Luego escribimos 00:44:35
Y lo que hace 00:44:40
Funciona, hace sus cosas 00:44:41
Y veis que ha escrito los números 00:44:44
De 1 a 100 00:44:46
Y yo le puedo poner aquí 00:44:50
Mil 00:44:55
Y él lo hace 00:44:55
Y puedo disfrutar 00:44:57
A ver, cuando 00:45:06
¿Cuánto tiempo tardan en escribir 00:45:07
Todos estos números? 00:45:10
Que ahora ya se ve algo 00:45:11
Que antes lo hacía instantáneo 00:45:12
Ahora ya se ve que escribe algo 00:45:15
¿Veis? 00:45:16
Esto es computacionalmente 00:45:27
Linear 00:45:30
¿Vale? 00:45:31
Es decir, si tarda un tiempo en escribir un número, tarda cien veces más en escribir cien números. Mil veces más en escribir mil números. Es lineal la complejidad. 00:45:32
Ahora, si fuera exponencial 00:45:50
Para escribir un número no tarda nada 00:45:53
Para escribir 10 números tarda un segundo 00:45:55
Para escribir 100 números 00:45:57
Pues a lo mejor tarda 6 minutos 00:45:59
No el doble 00:46:01
O 100 veces más 00:46:03
¿Entiendes? 00:46:04
Y ya está, más o menos 00:46:09
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
14
Fecha:
18 de octubre de 2023 - 10:54
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 12″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
163.13 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid