Saltar navegación

iterativos - 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 13 de octubre de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me dais vuestro consentimiento a grabar esta voz. 00:00:00
Vale, entonces, nosotros estamos viendo los distintos tipos de sentencias de control. 00:00:05
Los condicionales ya lo hemos visto y lo hemos repasado, si no miráis el vídeo anterior. 00:00:12
Hoy empezamos un poquito con los iterativos. 00:00:17
El iterativo es sustancialmente un programa que me permite iterar varias veces en un bloque. 00:00:19
es decir, repetir este bloque una y otra vez y otra vez y otra vez, en base a, veremos qué, ¿vale? 00:00:26
En teoría, como pasaba con los condicionales, que tanto el if, el if else y los switch son todos iguales, 00:00:35
porque tú puedes escribir las cosas de tal forma que valga en un lado o en el otro, 00:00:41
o sea, con el if es suficiente, no serviría nada más, pero es cómodo tener las otras cosas, 00:00:45
lo mismo pasa con el iterativo, tú puedes tener un while, ¿vale? 00:00:51
y con el while es suficiente, ya tienes 00:00:54
el iterativo, ya tienes toda la potencia 00:00:57
que necesitas. Ahora, en determinados 00:00:59
casos, el for 00:01:01
es más útil, más claro, 00:01:03
más interesante. En algunos 00:01:05
casos es más interesante el while. 00:01:07
Si puede, puedo reescribir 00:01:09
el código para que una cosa sea la otra 00:01:11
y la otra sea una cosa, y haremos un ejemplo. 00:01:12
A lo mejor ahora hacemos un ejercicio, 00:01:15
vemos cómo funciona, luego decimos si es lo que 00:01:17
se hace con un for, y lo hacemos con un for. 00:01:18
A lo mejor nos sale peor o mejor. 00:01:20
Y luego está el do while, que es otra alternativa del while, que está ahí por ahí también, ahora la veo. 00:01:22
Pero los tres hacen lo mismo, es darme un bloque de código y te lo repito unas cuantas veces. 00:01:29
¿Para qué me sirve esto? 00:01:36
Nosotros hemos hecho ejercicios de info, donde se decía, oye, mira, haz esta cosa tres veces, haz esta cosa cinco veces, ¿vale? 00:01:38
Mientras que yo tenga un número concreto y finito de cosas para hacer, ¿no? 00:01:46
El ejercicio que hemos hecho la otra vez de el ordenador se inventa un número 00:01:50
y luego lo esconde y me pregunta a mí, dame un número, 00:01:55
y si lo pilla me dice bien, y si no me dice si es mayor o menor, ¿vale? 00:01:59
Nosotros en el ejercicio con el IS le decimos tres veces, cinco veces, ¿vale? 00:02:03
Porque el IS no puede rehacer código anterior, 00:02:08
puede solo decirte si lo hace o no lo hace, ¿vale? 00:02:13
Entonces, el problema es que mientras tú tengas en mente cuántas vidas tiene que tener este juego, cuántas veces vas a hacer esto, te sale una cosa terrible, porque con el if viene un if dentro de un if, dentro de otro if, dentro de otro if, una cosa terrible, luego de mantener que si tiene que cambiar algo, has repetido muchas veces el mismo código, entonces si encuentras un error lo tendrás que resolver en 25 sitios donde lo has copiado, pero funciona. 00:02:16
Cuando no funciona y cuando no puedo utilizar un if, es cuando no sé cuántas veces tú repites esto. 00:02:46
Cuando a priori tú sabes que antes o después mi programa funcionará, acabará, pero no sabes si en una, dos o veinticinco iteraciones. 00:02:55
No lo sabes. Ahora, si no lo sabes, no puedes poner un cierto número de if. 00:03:06
el número de ILS. Yo voy a decir, ah, mira, hago un cajero automático, ¿vale? Cajero automático, tú vas allí, metes dinero, 00:03:12
solamente la carta, papapá, quiero 100 euros, pues te pillas 100 euros. ¿Cuántas ven? ¿Pongo 20 veces? Pues los primeros 20 00:03:20
que van allí a sacar dinero, sacan dinero, el 21esimo, ha acabado el programa, se acabó, tú nada. Tú apagas el ordenador, 00:03:30
lo enciendes otra vez, venga, otros veinte. 00:03:39
Eso, hay programas 00:03:43
que están pensados para no acabar nunca. 00:03:46
Que es, a la vez, una cosa buena 00:03:49
y una cosa mala. 00:03:52
Porque hasta ahora, 00:03:53
hasta los condicionales, 00:03:55
yo no puedo hacer 00:03:57
un programa infinito. 00:03:59
Es imposible. 00:04:02
Mi programa antes o después acaba. 00:04:03
A partir de la introducción 00:04:06
de los wild, 00:04:07
yo puedo hacer programas que no terminan nunca. 00:04:09
Y si yo quiero que el programa no termine nunca, muy bien. 00:04:13
Si yo me he equivocado y quería que el programa no terminara nunca, 00:04:18
o sea, terminara, perdón, y en vez de terminar, no terminara nunca, 00:04:22
es un problema grave. 00:04:26
¿Vale? 00:04:27
Vosotros podéis hacer while infinitos y os pasará, sobre todo al principio. 00:04:28
¿Vale? 00:04:33
Cuidado, porque si os dais cuenta que vuestro programa está allí, 00:04:34
pensando y haciendo algo, pues lo lanzáis otra vez, lo lanzáis otra vez, lo lanzáis otra vez y luego tenéis ocho procesos que están yendo a tope, 00:04:39
haciendo siempre el mismo cálculo miles y miles de veces y llega un momento que vuestro pobre ordenador sufre, ¿vale? 00:04:47
Esas cosas allí son útiles solo por una cosa, en invierno, cuando hace frío, ¿vale? 00:04:55
Entonces ponéis unos 7, 8, while a trabajar mucho, vuestro ordenador calienta mucho y os ponéis detrás, el ventilador detrás, calentando vuestras manos. 00:05:01
Única cosa para que sirve while, this, that, ¿vale? 00:05:13
Entonces, vamos a verlo. 00:05:17
Estructuras iterativas, ¿vale? 00:05:26
Las estructuras iterativas permiten repetir un determinado bloque más de una vez. 00:05:28
mientras una condición sea verdadera, 00:05:33
o sea, el while me dice que tengo una condición 00:05:37
y mientras esta condición sigue verdadera, 00:05:40
pues repito el código. 00:05:45
Llego al final y la evalúo otra vez. 00:05:47
¿Sigue verdadera? Sí, repito el código. 00:05:49
Hago todo el código y al final vuelvo arriba y digo 00:05:51
¿sigue verdadera? Sí, sí. 00:05:53
Y así, así, así, hasta que esta condición se volverá falsa. 00:05:55
Cuando la condición es falsa, salto el bloque 00:06:02
y sigo por desde el bajo. Este es el while. Ahora, yo como programador tengo que cerciorarme 00:06:05
que la condición antes o después cambia. Si la condición que yo he puesto no cambia 00:06:16
nunca dentro del bloque de mi while, entonces eso será o siempre true o siempre false, 00:06:27
Si es false, no lo ejecutaré nunca. 00:06:34
Si es true, entraré dentro y nunca saldré de este núcleo. 00:06:36
Entonces, si mi condición se basa sobre la variable x, 00:06:41
hago para decir, 00:06:45
debería en algún lado de mi código dentro del bloque del while 00:06:46
modificar esa x. 00:06:52
Si yo hago una condición que se basa sobre una variable x 00:06:55
y no la toco nunca, no hago nada dentro del cuerpo del while, 00:06:59
eso quiere decir que el valor que tendrá al principio no cambiará nunca. 00:07:05
Y por lo tanto es un poco. 00:07:09
¿Sí? 00:07:12
Otra opción que yo quiero para utilizar los bucles 00:07:13
es que sepa que esta cosa de aquí la tengo que hacer 25 veces. 00:07:17
Esta cosa de aquí la tengo que hacer 77 veces. 00:07:22
Sé el número de veces que quiero repetir esta cosa. 00:07:25
En ese caso, hablamos más de un for. Un for me permite hacer una cosa por un determinado número de veces. 00:07:28
Cuidado, no es que tú tengas que saberla a priori. Yo hago mi programa y digo, este programa siempre se ejecutará cien veces. Pues un for. 00:07:37
a lo mejor me lo dice el usuario 00:07:52
a lo mejor al principio del programa 00:07:55
dice, usuario, ¿cuántas veces 00:07:58
los quieres hacer? 37 00:07:59
y este 37 se guarda 00:08:01
en la variable final 00:08:04
no, final no, variable 00:08:05
sí 00:08:07
y ahora 00:08:08
antes cuando he programado no sabía 00:08:10
que era 37 veces, pero ahora sé 00:08:14
que son 37 veces, por lo tanto es un 00:08:16
foco 00:08:18
ahora lanzo otra vez el programa 00:08:18
el siguiente usuario me pone 56 00:08:22
en vez de 37, pues voy a repetir 00:08:25
esta cosa 57 veces 00:08:27
en vez de 36. Pues pero sé 00:08:28
cuántas veces van a ser. 00:08:30
¿Qué se me explica? O sea, no lo sé 00:08:32
a priori, pero llegará un momento 00:08:35
en los ejemplos más lógicos. 00:08:36
Yo quiero pillar una palabra 00:08:39
y hacer algo 00:08:40
por cada carácter de esa palabra. 00:08:43
¿Es un for o un why? 00:08:46
Por. Porque yo pillo 00:08:49
la palabra, independientemente de la palabra 00:08:50
que tú me hayas dado yo sé cuántas letras tiene me has dado gato son cuatro letras entonces sé 00:08:52
que no tendré que hacer cuatro veces me has dado supercalifragilisticexpialidox son más vale pero 00:09:01
yo sé que es cada uno de ellos si entendéis lo que quiero decir que es un while vale el comando while se usa 00:09:11
cuando quiere repetir un cierto bucle 00:09:23
mientras una condición sea verdadera. 00:09:24
Entro de aquí y me pregunto 00:09:27
¿la condición es verdadera? 00:09:28
Sí, entonces hace unas instrucciones 00:09:29
y vuelve atrás, antes de la condición. 00:09:32
¿Es verdadera? Otra vez. 00:09:35
¿Es verdadera? Otra vez. 00:09:36
Cuando será falsa, te saltas estas instrucciones 00:09:38
y sigues adelante. 00:09:41
Esto es un while. 00:09:43
Esto es como se escribe un while. 00:09:49
Y si es igual a cero, 00:09:52
mientras y sea menor o igual a diez, 00:09:53
y más más que hace este magnífico programa 00:09:55
más que hace este programa 00:10:07
50 de 1 a 10 00:10:11
¿Qué sentido? 00:10:15
No cuento 00:10:16
Vamos con 1, 2, 3, 4, 5 00:10:17
Bueno, quizá por el cero 00:10:19
0, 1, 2, 3, 4 00:10:29
¿Hasta cuándo? 00:10:32
Hasta el día 00:10:34
¿Esto de qué escribo? 00:10:34
Los números de 0 a 10 00:10:39
Ya, yo te entiendo 00:10:41
Pero es que informar 00:10:42
es eso también 00:10:44
Ser informado quiere decir ser muy 00:10:45
rígido en estas cosas, ¿vale? 00:10:48
No es lo mismo hacer de 1 a 10 00:10:50
que hacer de 0 a 10 si es 00:10:53
una multiplicación. Si yo estoy multiplicando 00:10:54
todos los números entre ellos, antes lo multiplico por 1 00:10:56
luego por 2, si meto el 0 00:10:58
el resultado es 0. Y si no lo meto 00:11:00
el resultado será distinto de 0. 00:11:02
Entonces, cuidado con lo que hace. 00:11:04
¿Sí? Este de aquí es un 00:11:06
programa que empieza desde 0, 00:11:08
entra aquí dentro, me queda de 0, es menor que o igual 00:11:10
a 10, sí. Entonces, escríbelo 00:11:12
y suma 1. 00:11:14
Ahora ahí vale 1. 00:11:16
Vuelvo aquí, 1 es menor que 10, igual a 10, sí, escríbelo y le da suma 1, 2, 3, 4, 5, 6, llega al 10 y dice, 10 es menor o igual que 10, sí, la condición sigue la verdadera. 00:11:18
Entro aquí, escribo 10, entonces 10 lo escribe, va a 11, llega aquí y dice, es fácil, aquí abajo, ¿cuánto vale? 11, porque en la última vez cuando escribe 10, suma 1 y va a 11, 00:11:30
vuelve aquí, 11 no es 00:11:52
menor o igual a E, y sale. 00:11:54
Pero dentro de esta variable ahora tengo 11. 00:11:55
Hasta así 00:11:59
no lo he escrito nunca. 00:12:00
¿Entiendes? 00:12:03
¿Cómo podría 00:12:05
escribir los números 00:12:06
de 1 00:12:07
a 10? 00:12:09
De 1... 00:12:16
De 1 a 10. 00:12:16
¿Cómo lo he dicho? 00:12:21
Pones 1 aquí, ¿no? 00:12:30
A 10. 00:12:31
Sí, ya está. ¿Cómo pondríais los números de 1 al 11? 00:12:32
¿Cómo? 00:12:37
Arriba el 1 y abajo el 10. 00:12:44
1 y 10. Y 11. 00:12:46
¿Y otra forma? 00:12:49
Quitas el igual y pon el 12. 00:12:51
1 y 12 es igual. Vale, ¿otra forma? 00:12:53
Números de 1 a 11. Los dejas así, pero invertes estos dos. 00:13:00
antes haces la suma y lo escribes 00:13:11
entonces la primera vez, esto valdría 0 00:13:16
entra, pero suma 1, 1 00:13:18
y lo imprime, entonces el primero que imprime 00:13:20
es el 1 00:13:22
y la última vez, cuando esto sea 10 que es igual a 10 00:13:22
entra, lo suma 1, es 11 00:13:26
entra allí, lo escribe 00:13:28
y luego saldrá 12 00:13:30
cambiando estas pequeñezas 00:13:31
así, pues, fijaos 00:13:34
que mi condición 00:13:36
sobre que se vaya 00:13:37
sobre comprobar y 00:13:39
y fijaos que dentro del cuerpo 00:13:43
de la cosa, pues por algún lado 00:13:46
y cambia 00:13:48
¿qué pasa si pongo y menos menos? 00:13:49
ahora está, y entonces 00:13:56
¿hasta cuándo? 00:13:57
¿escribe de cero hasta el número? 00:13:59
hasta el infinito 00:14:04
no acaba nunca 00:14:05
es posible que o una cosa 00:14:06
de ese estilo o 00:14:14
cuando llega un momento en que no puedes 00:14:16
más calcular o 00:14:18
llegará un momento en que 00:14:20
me estás pidiendo demasiado explotó pero técnicamente estoy aquí como es un entero 00:14:21
es el cliente cuando llega a menos dos mil millones posiblemente te dirá el siguiente 00:14:29
número no es un entonces se enfadará por lo cual 00:14:33
dubai es lo mismo que un wild pero asumiendo que tú quieres al menos una vez hacer el cuerpo del 00:14:41
programa, del while. El while podría no hacer nunca el cuerpo, ¿vale? El cuerpo, esas son las instrucciones. 00:14:50
He hecho ahí. Si yo pongo aquí 100, el while llega aquí y dice, 100 es menor o igual que 10, falso. Salto y esto 00:14:59
no lo ha ejecutado nunca. 00:15:16
Un while 00:15:19
ejecuta el cuerpo 00:15:19
cero o más veces. 00:15:21
Cero o más. 00:15:25
¿Esto se lo recordará 00:15:26
la base de datos? 00:15:27
¿De uno a uno, de uno a muchos? 00:15:29
Esto es de cero 00:15:32
a muchos. 00:15:34
Sin embargo, si yo no quisiera 00:15:38
de cero a muchos, me diría, oye, esto 00:15:39
una vez lo ejecutas, siempre 00:15:41
lo haces, y luego 00:15:44
ya veremos si lo haces varias veces. Pues en vez de utilizar el while, puede hacer un do while. 00:15:46
Haz esto mientras esta condición. Esto, la primera vez que entra aquí, 00:15:53
esto lo hace una vez de segura. Esto se ejecuta. Cuando llega aquí, 00:16:01
decide si volver al do y hacerlo otra vez o, si esto es falso, salir. 00:16:07
Cuidado con esta cosa. Hay punto y coma. No. Hay punto y coma. Sí. Cuidado, que luego 00:16:16
os equivocáis. ¿Qué pasa si yo hago y, y, punto y coma, y luego escribo esto? 00:16:30
Y, y, menos 10, punto y coma, es para calentarse las manos. 00:16:49
Porque él dice, y el menor que 10, sí, ¿qué hago? Nada, punto y coma, vacío. 00:17:02
Era como el for, o sea, el if. 00:17:15
¿Os acordáis que el if podía no ponerle el bloque? 00:17:19
Si no le pongo el bloque, se aplica a una sola instrucción, a la instrucción que viene después del if. 00:17:22
Esto es lo mismo, si yo pongo punto y coma, me está diciendo que si esto es verdadero, lo que tienes que hacer es punto y coma. 00:17:30
nada 00:17:36
pero entonces ¿qué hará? volverá aquí 00:17:38
y me preguntará otra vez, pero este es verdadero 00:17:40
claro, como no he cambiado nada, seguirá siendo 00:17:43
verdadero, entonces entra otra vez 00:17:45
y hace nada, punto y coma 00:17:47
y como no ha cambiado nada, me preguntará 00:17:48
y es verdadero 00:17:50
y así, así, así, así, para siempre 00:17:52
es un ciclo infinito 00:17:55
¿sí? 00:17:57
¿entienden? 00:18:00
entonces cuidado, que el while no entiende 00:18:01
punto y coma, el do while 00:18:04
para decidir al final he acabado la cosa por si tiene un punto también para diferenciarlo del 00:18:05
baile aquí la diferencia es simplemente esto si yo quiero al menos una vez las instrucciones 00:18:11
ejecutarla como pongo todo ejecutó ese centro y aquí si es verdadero vuelvo a hacerlo una y otra 00:18:18
vez y otra vez y si no menos se puede hacer exactamente lo mismo con wine o dubai yo puedo 00:18:24
hacer un bloque arriba, luego poner un while y el mismo bloque 00:18:32
abajo, entonces lo estoy ejecutando una vez, luego empiezo el 00:18:36
while y aquí ciclo cuántas veces me da la gana, o ponerlo en un 00:18:39
do while y hacerlo una vez y tengo que pensar, este bloque de 00:18:42
código lo voy a ejecutar al menos una vez o no, en base a eso 00:18:47
elijo while o do while. 00:18:52
Yo no soy un gran fan del do while. 00:18:55
Y luego está el for. El for pasa por varias fases. Hace una inicialización. Te dice al 00:18:58
principio algo. Te dice, oye mira, empezamos con una variable que vale esto. Va. Luego 00:19:08
mira una condición. Y te dice, vale, ahora en este momento, ¿esta condición es verdadera 00:19:18
falso. Si es falsa, he acabado, me voy. Si es verdadera, entro aquí dentro, hago unas 00:19:24
instrucciones y antes de volver a hacer las condiciones, que en un while volvía directamente, 00:19:34
hago una fase de actualización, cambio algo, modifico algo y luego vuelvo a hacer la condición. 00:19:40
Entonces, inicializo a un valor, miro la condición, instrucciones, actualizo. 00:19:48
Miro si la condición después de estas actualizaciones ha cambiado o no. 00:19:55
¿Sigue verdadera? Pues lo rehago. 00:19:59
¿Sigue verdadera? Lo rehago. 00:20:01
¿Sigue verdadera? Cuando yo lo he hecho, cuando ya no es verdadera, salgo. 00:20:02
Parecido, ¿vale? 00:20:06
Y se hace así. 00:20:08
Por int igual a cero. 00:20:10
Esta es la inicialización. 00:20:13
Piensa una variable i que empiece a cero. 00:20:15
Esto es como se inicializa. 00:20:19
Esto se hace al principio. 00:20:21
Punto y coma. 00:20:23
Y menor que 10. 00:20:24
Me está diciendo. 00:20:26
Esta es la condición. 00:20:27
Mientras que Y se mayor que 0. 00:20:31
Y antes de volver aquí. 00:20:33
Después de haber hecho el bloque. 00:20:35
Siempre ejecuta este incremento actualización. 00:20:37
O sea, que Y le das más más. 00:20:41
Entonces, el que hace es entrar aquí. 00:20:44
Dice 0. 00:20:46
0 es menor que 10. 00:20:47
Sí, entra aquí dentro. Lo escribo y luego después vuelvo aquí. Pero al volver aquí, incremento y de 1. ¿Se entiende? Hago esta cosa aquí. Podría incrementar de 1, podría incrementar de 7, podría hacer otras cosas, ¿vale? 00:20:48
Pero esto se ejecuta cada vez que yo he acabado el bloque y vuelvo arriba. Lo ejecuto y luego 00:21:08
vuelvo a comprobar si este es verdadero o falso. ¿Que esto se ha vuelto falso? He acabado. ¿Que esto se ha vuelto verdadero? 00:21:18
Esta cosa aquí, por ejemplo, es un FOR que usaréis mil millones de veces porque esta cosa de 00:21:23
aquí se repite cuántas veces? Diez veces. Exactamente diez veces. Por int i igual a cero punto y coma i 00:21:33
menor que n punto y coma i más más, te está diciendo, esta cosa de aquí, repítela n veces. 00:21:46
Pues si yo sé que tengo que hacer una cosa n veces, por ejemplo, tengo cinco vidas, pues esta cosa aquí 00:21:55
ya me da cinco veces. Tengo una palabra con diez letras, pues esta cosa aquí ya me da 00:22:02
diez veces. Pues sustituyo esto con el número de veces que quiero hacer esta cosa. La otra 00:22:07
ventaja de tener esto es que tengo un índice, y está por índex, ¿vale? ¿Qué me está 00:22:17
diciendo? Que en el primer giro esto vale cero, en el segundo vale uno, en el tercero 00:22:23
vale dos, en el tercero vale cuatro, cinco... Me está diciendo en qué ciclo, en qué ronda 00:22:28
estoy. ¿Se puede hacer con un while? Sí. De hecho, esto y el otro tienen que hacer lo mismo. Si yo le pongo aquí un mayor igual en vez que un menor igual, en vez que un menor estricto, hacen lo mismo con lo que hemos visto worldwide antes. Solo que cuando tengo situaciones como esta de un índice que tiene que recorrer todos los valores desde cero hasta otro valor o desde un a otro valor, pues este de aquí es mucho más práctico que el otro. 00:22:33
Ejemplo, intifor igual a 0 y menor que 3 y más más, igual a 10. 00:23:06
¿Funciona? Sí. 00:23:20
Int lo he declarado fuera del for, por lo tanto esto vive hasta después del for, lo puedo reutilizar, ningún problema. 00:23:22
me escribe 0, 1 y 2, porque empieza por 0 y es menor, estrictamente menor que 3, 00:23:31
entonces entrará aquí con 0, entrará aquí con 1, entraré con 2, 00:23:38
cuando entra aquí con 3, irá 2, y saldrá, entonces no me lo escribe. 00:23:42
¿Dudas? Esto explota, porque si yo lo declaro aquí, esto es parte del for, 00:23:50
Y solo existirá dentro del for. 00:24:05
Cuando salgo fuera del for, esta variable aquí era local a este bloque y por lo tanto ya no existe. 00:24:08
Cuando intento utilizarlo me va a decir no. 00:24:17
¿La quiero utilizar fuera? 00:24:20
Entonces la sí. 00:24:22
La declaro antes y luego voy for. 00:24:24
¿La quiero utilizar, no la quiero utilizar después? 00:24:26
Pues toquemos lo que hice. 00:24:29
¿Sí? 00:24:32
Este i, normalmente se usa i, j y k, ¿vale? 00:24:33
Pero podéis utilizar lo que os da la gana. 00:24:38
Esta es una variable. 00:24:41
Yo estoy declarando una variable que existe en este for. 00:24:42
Que será mi contador. 00:24:45
Si hago int contador es igual a hacer contador menor que 3, contador más más, funciona perfectamente. 00:24:47
Fijaos un momento que si no es una i, no funciona. 00:24:54
For anidados. 00:25:04
Una maravilla. 00:25:06
dentro de un ford lo que os molará mogollón que os hará explotar el cerebro vale entonces esto 00:25:07
requiere un poquito de tranquilidad, no, si lo pago aquí, no lo deis, va, entonces estos son un for dentro de un for, vale, antes tengo un for externo y como ejecución dentro de este bloque tengo el for entero, entonces empiezo desde arriba 00:25:16
Y me dice, oye, crea un i que vale 1, ¿vale? 00:25:56
Entonces yo tengo i que vale 1, ¿sí? 00:26:00
i es menor o igual que 2, sí. 00:26:07
Por lo tanto, entro dentro. 00:26:11
Y dentro me encuentro este for, el for interno, 00:26:13
que me dice, oye, existe un j que vale 1, ¿vale? 00:26:15
j vale 1. 00:26:19
Y me dice, j es menor o igual que 2, sí, es 1. 00:26:27
Perfecto. Entra aquí dentro. Entonces me dice, escribe i, un espacio, j, un espacio, i por j. 00:26:32
Entonces esto me escribe i, ¿cuánto vale i? Uno. Un espacio, j, ¿cuánto vale j? Uno. 00:26:44
1 por 1 00:26:54
¿Están de acuerdo? 00:26:58
Ahora, he acabado el foro interno. 00:27:02
¿Dónde voy? 00:27:05
Entonces, 00:27:10
hemos acabado el foro interno. 00:27:11
¿Vale? 00:27:14
Desde aquí, he acabado esta cosa ahí. 00:27:15
¿Dónde voy? 00:27:17
¿Dónde salto? 00:27:21
Ahí. 00:27:26
¿Qué me oyes? 00:27:27
¿Incremento de cuál? 00:27:29
¿Quién incrementa? 00:27:30
¿Y o J? 00:27:32
Porque he acabado el for interno. 00:27:38
Entonces vuelvo a saltar al for interno, porque todavía este comando no ha acabado. 00:27:41
Y lo que haré es ejecutar el incremento del J. 00:27:48
Por lo tanto, J ahora vale 2. 00:27:52
J ahora vale 2. 00:28:01
Pero estoy aquí dentro. 00:28:04
he saltado a este foro de aquí 00:28:05
y me pregunto, ¿2 es menor o igual que 2? 00:28:06
Sí. 00:28:10
Por lo tanto, vuelvo a entrar 00:28:11
en este foro interno 00:28:12
y escribo, y ahora, ¿cuánto vale i? 00:28:14
Uno. 00:28:17
¿Cuánto vale j? 00:28:18
Y un por dos? 00:28:20
Y llego al final del foro interno. 00:28:25
¿Dónde salto? 00:28:27
No. 00:28:30
Al interior. 00:28:31
No lo he acabado todavía. 00:28:34
Bien. Hago el incremento y j se vuelve 3. 00:28:36
Y me pregunto, ¿3 es menor o igual que 2? 00:28:42
No. 00:28:46
Entonces salgo del for. 00:28:48
Y al salir del for, j desaparece. 00:28:51
Ya no existe. 00:28:56
¿De acuerdo con esto? 00:28:59
Llego a estas paréntesis de aquí porque he acabado el for interno 00:29:00
y vuelvo aquí arriba, haciendo el incremento del i. 00:29:05
Es decir, que ahora i vale 2. 00:29:10
Y me pregunto, ¿2 es menor o igual que 2? 00:29:13
Sí, por lo tanto entro aquí dentro. 00:29:17
Y aquí dentro me dice, ¡uy, hay un for! 00:29:20
Créame una variable j. 00:29:23
Creo una nueva variable j. 00:29:24
¿Cuánto vale j? 00:29:27
1 es menor que 2. 00:29:34
Sí, por lo tanto entro aquí dentro 00:29:37
Y escribo 00:29:40
¿Cuánto vale I? 00:29:41
¿Cuánto vale J? 00:29:44
¿Dos por uno? 00:29:46
Sí 00:29:49
Y voy aquí 00:29:50
¿Y desde aquí dónde salto? 00:29:52
Al sol interior 00:29:57
Y aumento J 00:29:58
Va a dos 00:30:03
¿Dos es menor o igual que dos? 00:30:05
Sí 00:30:08
Por lo tanto, entro. ¿Cuánto vale i? ¿Cuánto vale j? ¿2 por 2? Y llego aquí. Y vuelvo aquí, aumentando j. ¿Ahora j vale 3? ¿3 es menor o igual que 2? No. 00:30:09
Por lo tanto, salto esto y llego aquí. 00:30:28
Cuidado que ahora, opa, ya no existe. 00:30:32
Porque he salido de este for de ahí. 00:30:35
Voy aquí, vuelvo aquí arriba y hago el incremento. 00:30:39
Por lo tanto, i se transforma en 3. 00:30:42
Y me pregunto, ¿3 es menor o igual que 2? 00:30:45
No. 00:30:49
Por lo tanto, salgo de este for e desaparece. 00:30:50
Esto es lo que escribo. 00:30:57
Si en vez de 2 le pongo 10 y menor, pues me hace la tabla del, sí, me haría todas las tablas de 1x1, 1x2, 1x3, 1x4, 1x5, por ejemplo, 2x1, 2x2, 2x3, 3x1, 2x3, ¿entendéis? 00:30:58
Pues, sinceramente, ¿cómo funciona esto? 00:31:23
Por cada ciclo del exterior se hacen todos los ciclos internos. 00:31:25
Entonces, ciclo 1, IE1, J1, 2, 3, 4, 5, 6, 7, hasta que salga. 00:31:32
Ahora IBA2, J1, 2, 3, 4, 5, 6, 7, hasta que salga. 00:31:37
J3, I3, J1, ¿sí? 00:31:41
O sea, por cada ciclo exterior se hace todo lo interior. 00:31:45
FOR dentro de FOR o WHILE dentro de WHILE, 00:31:52
o WHILE dentro de FOR o FOR dentro de WHILE, 00:31:55
hacen que mis programas exploten a nivel de complejidad, a nivel de necesidades computacionales. 00:31:58
Mientras que tengo un solo while o cosa por estilo bien, pero while dentro de while o for dentro de for, 00:32:12
tengo que estar, tener mucho cuidado en cómo lo hago. Porque puede que pocos datos para 00:32:18
procesar se vuelvan una cosa muy lenta de procesar. Normalmente tienen una... Si un 00:32:29
programa. La complejidad de un programa se calcula en base al input. Si yo tengo n datos, 00:32:40
me dan n elementos para procesar y mi programa tarda n operaciones en programarla, en resolverla, 00:32:58
dice que está del orden de n. Entonces, ¿me das mil palabras para procesar? Tardo mil 00:33:08
segundos. ¿Me das cien mil palabras para procesar? Pues tardo cien mil segundos. Es lineal. Si 00:33:16
hago esto, cuántas palabras me das, o cuántos datos me das, cuántos segundos tardo, es 00:33:23
lineal. Esto puede ser un poquito más, un poquito menos, pero es lineal. Cuántos más 00:33:31
más datos me das, peor será mi rendimiento, más tarde, pero de una forma lineal. 00:33:39
Si yo tengo for dentro de for, normalmente con n datos estamos hablando de un orden de 00:33:46
n al cuadrado. Entonces ya no tengo esta cosa aquí, tengo esta cosa aquí. Cuanto más 00:33:55
aumente los datos 00:34:08
que proceso, el tiempo 00:34:10
que se necesita 00:34:12
no es lineal. 00:34:14
No es una parábola. Entonces, cuanto 00:34:16
más me alejo, más esto 00:34:18
va para arriba. ¿Rápidamente? 00:34:20
Bueno, bastante rápidamente. 00:34:24
¿Sí? 00:34:26
No tan rápidamente como si 00:34:27
la n fuera el exponente. Si yo tengo 00:34:29
una cosa que es 2 a la n, 00:34:31
exponencial, esto es 00:34:34
parecido, pero mucho más lípido. 00:34:35
¿Sí? 00:34:42
Lo que yo quiero es tener O de log de bien. 00:34:43
Si yo consigo hacer un algoritmo que tiene esta complejidad, 00:34:57
quiere decir que la información, o sea, por cuánto aumente la cosa, 00:35:02
pues esa es la función del log. 00:35:08
Entonces la cosa interesante es que aumento los datos, 00:35:14
pero el tiempo que tardo en procesar estos datos 00:35:18
crece, va creciendo, pero va creciendo lentamente 00:35:22
tengo 100 datos, tardo 100 segundos 00:35:25
tengo 1000 datos, pues a lo mejor tardo 900 segundos 00:35:29
tengo 10.000 datos, a lo mejor 9.000 segundos 00:35:33
voy tardando más, pero menos que se fuera el día 00:35:41
Ahora, estas son cosas avanzadas. Si algún día de estos vais a la universidad, estudiaréis cómo, dado un algoritmo, pueda saber cuál es su coste computacional, ¿vale? Su complejidad. 00:35:46
Y lo que tenéis que hacer es evitar esto, al ser posible evitar esto, bueno, aceptable, bien, hasta mejor. 00:36:07
Hay cosas que son ODC, constantes. 00:36:20
Eso es lo mejor. 00:36:25
¿Has dado un millón de datos? Pues tardo tres segundos. 00:36:26
¿Diez millones de datos? Tardo tres segundos. 00:36:29
¿Siete millones de datos? Pues tres segundos. 00:36:31
Fenomenal. 00:36:35
Hay problemas que no se pueden hacer así. 00:36:37
Problemas que tienes que ir aquí o aquí. 00:36:40
Por lo tanto, todo esto, que es una cosa compleja, que dejáis allí, 00:36:58
si lo habéis entendido bien, si no lo habéis entendido, no pasa nada, 00:37:05
nunca os pediré estas cosas, ni en exámenes, ni en clase, ni nada. 00:37:08
A lo mejor de vez en cuando hablaremos o lo volveré a explicar. 00:37:12
Pues cuando vosotros empezáis a utilizar while dentro de while 00:37:16
O for dentro de for, iterativos dentro de iterativos 00:37:21
Os estáis exponiendo a que estáis entrando en este mundo 00:37:24
¿Vale? 00:37:27
Esto quiere decir que si tú metes 00:37:30
Hagamos una tabla rápida 00:37:33
Pensamos en aquí 00:37:35
Aquí está o de n 00:37:48
Y aquí está o de n al cuadrado 00:37:53
si yo tengo 00:37:56
y aquí está en 00:37:59
si yo tengo 10 datos 00:38:00
asumiendo una cosa mágica 00:38:02
que estos son segundos 00:38:06
¿cuántos tardo aquí? 00:38:07
10 segundos 00:38:09
¿cuánto tardo aquí? 00:38:10
bien, 10 elevado a 2 00:38:15
ahora aumento el doble 00:38:16
si yo tengo 20 00:38:22
datos 00:38:25
¿cuánto tardo aquí? 00:38:26
20 segundos 00:38:29
el doble 00:38:30
¿Cuánto tarda aquí? 00:38:31
400 00:38:34
20 por 100 00:38:35
No es doble 00:38:37
4 veces tanto 00:38:40
Si yo tengo 100 datos 00:38:42
¿Cuántos segundos tarda aquí? 00:38:46
¿Y aquí? 00:38:50
100 por 100 00:38:54
¿Bien? 00:38:55
1, 2, 0 00:38:57
¿Entendéis el problema 00:38:58
de esta cosa aquí. 00:39:02
Y aquí sería hasta peor. 00:39:05
¿Vale? 00:39:08
Aquí tendría 12 a la 10. 00:39:09
Y 24. 00:39:14
Y crece. 00:39:16
Crece más bajo, 00:39:17
pero luego, en un momento que va mucho más a la red. 00:39:20
¿Vale? 00:39:22
Pero la idea de esta aquí es que si yo hago un algoritmo 00:39:23
que va linealmente con el número 00:39:26
de datos, pasa esto. 00:39:28
Doblo los datos, este va al doble de lento. 00:39:29
O sea, tarda más el doble. 00:39:32
triplico los datos 00:39:33
está bien, si en vez de lo hago 00:39:34
con esto, que cuando hago un 00:39:37
iterativo dentro de un iterativo, es posible 00:39:39
que me salga esta cosa aquí 00:39:41
pues me está pasando esto 00:39:43
si hago el doble de datos 00:39:45
hago el doble del tiempo 00:39:47
cuatro veces 00:39:50
si hago diez veces los 00:39:51
datos, pues a lo mejor lo que estoy haciendo es 00:39:53
cien veces más 00:39:55
¿se entiende? 00:39:57
¿dudas? 00:40:00
Vale 00:40:01
Bueno 00:40:05
Esto era 00:40:09
Nuestro 00:40:12
For dentro del for 00:40:13
Y aquí vamos a hacer ejemplos 00:40:14
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
13 de octubre de 2026 - 14:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
93.11 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid