20261023 Bucles_ejerc3_for - Contenido educativo

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 25 de octubre de 2026 por Raquel G.

2 visualizaciones

Pues así calcado, porque estamos un poco todavía pensando muy detenidamente, con pinzas, dime, a ver, un momento, vale, pues entonces, si entendemos el ejercicio, después de haberlo leído, haber analizado un poquito lo que significa a elevado a b, pues ya llegamos a la conclusión de que es a por a por a por a b veces, 00:00:02

entonces es hacer una multiplicación acumulativa 00:00:37

muchas multiplicaciones 00:00:42

entonces ya identificamos que eso es lo que tenemos que hacer 00:00:43

y ya identificamos que es el patrón entonces de siempre 00:00:46

este para la suma acumulativa 00:00:49

y este para la multiplicación acumulativa 00:00:51

cambia el más por el por y el valor inicial 00:00:54

luego ya para cada ejemplo tenemos que ver 00:00:57

cómo ponemos la condición y de dónde sale este factor 00:01:01

Bueno, pues, bueno, vamos a leer a y b lo primero 00:01:04

Entonces, leemos a y b lo primero de todo 00:01:09

Introduzca base de la potencia 00:01:21

Introduzca la base, pues venga, la base igual 00:01:29

Uy, perdón 00:01:36

Pues venga, la base igual a scan.nextint 00:01:38

Vale, ahora introduzca el exponente 00:01:49

Introduzca el exponente de mi potencia 00:01:52

Pues, bueno, perdón, la base es A 00:02:02

Y el exponente es B 00:02:06

Vale, ya tenemos A elevado a B 00:02:08

Y ya sabemos que esto, por tanto, tiene que ser 00:02:10

A por A y por A 00:02:12

Y así un montón de veces 00:02:15

¿cuántas? b veces, vale, bueno, pues es una multiplicación acumulativa, pues nada, un acumulador, un acumulador, en este caso, como es multiplicación, inicializado a 1, 00:02:18

y ahora ya esto se va a ejecutar en un bucle 00:02:33

¿cuántas veces? pues no lo sé, tendremos que definirlo 00:02:37

y ahora en este bucle la operación que yo tengo que hacer es 00:02:41

acum igual a acum por 00:02:45

el factor que yo quiero multiplicar cada vez 00:02:51

esta sería la idea, ¿vale? y el resultado 00:02:55

sería pues esto, ¿vale? ahora ya esto 00:02:59

si entendemos lo que hay debajo de esto 00:03:03

que se supone que lo tenemos que entender 00:03:06

ahora ya se trata de que yo adapte 00:03:08

este factor que es lo que se va multiplicando cada vez 00:03:11

y que adapte esto 00:03:14

¿vale? ¿qué es lo que se va multiplicando? 00:03:16

A todo el rato 00:03:19

todas las multiplicaciones son por A 00:03:20

no son por nada variable 00:03:22

si fueran por algo variable 00:03:25

yo tendría que declarar aquí esto como una variable 00:03:26

porque es por algo variable 00:03:30

y ahora esta variable, darle aquí el valor que fuera, el valor que correspondiera, hasta construir en cada iteración el factor nuevo, pero esto es mucho más sencillo, este factor es a todo el rato, todo el rato es por a, por a, por a, pues mira, tan sencillo como era ya, no necesito una variable adicional para construir ese factor ni nada, por a todo el rato, 00:03:33

entonces la primera vez que entro aquí 00:03:58

hago 1 por A 00:04:01

y actualizo el acumulador 00:04:03

la siguiente vez que entre 00:04:04

ese 1 por A se multiplica por otro A 00:04:07

ya van 2, A por A 00:04:09

la siguiente vez que entre 00:04:11

ese A por A 00:04:13

se multiplica por un A adicional 00:04:14

ya van 3, A por A por A 00:04:17

y así todo el rato 00:04:18

cada iteración de este bucle 00:04:21

multiplico por un A adicional 00:04:23

pues esto ya está casi hecho 00:04:25

pero claro, me falta, oye 00:04:28

y cuan 00:04:30

ese bucle, cuantas veces 00:04:32

tengo que hacerlo, hasta cuando 00:04:35

bueno, pues aquí la condición 00:04:36

digo, lo tienes que hacer B veces 00:04:38

esa es una condición muy concreta 00:04:40

y es, tienes que asegurarte 00:04:43

de que este bucle se hace B veces 00:04:44

que se hace B veces 00:04:47

ahhh 00:04:49

pues automáticamente aquí me viene 00:04:50

anda, un contador 00:04:52

yo tengo que contar 00:04:54

las iteraciones del bucle 00:04:55

y cuando este bucle se haya hecho exactamente 00:04:58

B 00:05:00

ya termino 00:05:01

pues ahí ya me viene, bueno, tengo que contar 00:05:03

tengo que contar vueltas del bucle 00:05:06

contarlas 00:05:09

claro, ya tenemos la estructura 00:05:09

de contar en la cabeza, sabemos que yo puedo 00:05:12

contar las veces 00:05:14

que paso por un bucle 00:05:16

pues vamos a poner un contador 00:05:17

y las vamos a contar 00:05:20

y cuando ese contador llegue a B 00:05:22

adiós 00:05:24

pues venga, vamos a poner ahí un contador 00:05:26

para contar 00:05:28

todas las cuentas se inician a 0 00:05:29

y ahora este por ser un contador 00:05:32

en cada vuelta del bucle lo incremento 00:05:34

esta es mi estructura de contador 00:05:36

¿no? un contador 00:05:38

que empieza su cuenta a 0 00:05:40

y se incrementa en 1 00:05:42

cada vuelta del bucle 00:05:44

y así va contando 00:05:45

vale, pues este contador 00:05:47

me permite ahora fijar la condición 00:05:50

qué condición pongo aquí 00:05:52

para asegurarme que el bucle 00:05:55

se va a ejecutar exactamente 00:05:58

b veces 00:06:00

tengo la variable b que la acabo de leer 00:06:01

y tengo la variable cont 00:06:04

que se va incrementando de uno en uno 00:06:06

vale, pues decidme qué condición 00:06:08

pondríais ahí exactamente 00:06:10

para aseguraros 00:06:12

de que ese bucle se hace exactamente 00:06:14

b veces, en la vez b más 1 00:06:16

ya no entra 00:06:18

qué condición pondríais aquí 00:06:20

díctamela, cont menor o igual que b, casi, pero seguro, vamos a comprobarlo, a ver, tiene sentido, ¿no? 00:06:21

Entra para la vez 0, para la vez 1, para la vez 2, para la vez b, para la vez b más 1 ya no entra, para la vez b más 1 ya no entra, vamos a ejecutarlo, ¿vale? 00:06:46

Entendéis lo que hemos escrito, ¿no? 00:07:00

Y la idea de por qué lo hacemos, estamos contando para saber cuándo tenemos que salir, 00:07:01

que será cuando el opuesto a esto, cuando con ya sea mayor que b, cuando ya se haya salido. 00:07:07

Entonces, vamos a ejecutar esto. 00:07:13

Vamos a probar una operación fácil. 00:07:17

La base es 2 y el exponente es 3. 00:07:20

Nos debería dar 2 elevado a 3, que es 8, ¿no? 00:07:23

Nos debería dar 8 y nos da 16. 00:07:27

parece que lo ha hecho una de más 00:07:31

parece que lo ha hecho una de más 00:07:34

entonces esta prueba nos permite 00:07:36

uy, realmente es una de más 00:07:38

voy a volver a probarlo 00:07:40

porque yo tengo que tratar de aislar bien 00:07:41

mi fallo, caracterizarlo bien 00:07:44

para buscar donde puede venir 00:07:46

voy a hacer con otra prueba 00:07:47

por ejemplo, con 3 00:07:49

elevado a 3 00:07:52

3 elevado a 3 sería 3 por 3, 9 00:07:53

9 por 3, 27 00:07:55

a ver si me sale 27 00:07:57

pues me sale una vez más 00:07:58

27 por 3 00:08:02

con lo cual después de hacer varias pruebas 00:08:03

parece que entra al bucle 00:08:05

una vez más de las que debería 00:08:07

entra una vez más 00:08:09

luego entonces una vez que yo ya 00:08:10

he identificado el problema 00:08:12

y es que lo hace una vez más 00:08:14

porque no vale con que yo vea 00:08:16

uy, no lo hace bien 00:08:18

y ponerme aquí de buenas a primeras 00:08:19

a ver qué pasa, no 00:08:22

tengo que identificar bien exactamente 00:08:23

qué está pasando 00:08:26

Pues después de varias pruebas resulta que lo hace una vez de más. 00:08:27

Entonces me puedo ir a la zona peligrosa, que es esta, 00:08:31

que esta es la que me marca la cantidad de veces que se ejecuta. 00:08:34

Entonces me voy aquí y digo, vamos a pensar. 00:08:38

Me pongo yo cabeza CPU y digo, vamos a ver, 00:08:40

en el caso de prueba que yo le he dado, vamos a ver qué está pasando. 00:08:44

El primer caso de prueba que yo le he dado es A igual a 2 y B igual a 3. 00:08:47

Venga, conti igual a 0, primera vez que entra. 00:08:54

para cont igual a 0, la primera vez que entra me hace 1, porque acum es 1, por a, por 2, 00:08:56

luego para cont igual a 0 es la primera vez que entra en el bucle, 00:09:04

y la primera vez que entra en el bucle el acumulador se queda con a, vale, 00:09:08

y cont se queda con 1, cont se queda con 1, porque se ha incrementado, volvemos, 00:09:14

¿cont que es 1 es menor o igual que b que es 3? 00:09:22

sí, pues entramos una segunda vez 00:09:26

en esta segunda vez, cont es igual a 1 00:09:28

y la multiplicación que se hace es 00:09:31

lo que tenía en la acumula anterior, que era a 00:09:34

lo que tenía en la acumuladora anterior, que era a 00:09:36

se multiplica por a 00:09:40

luego ahora ya mi acumulador será 00:09:42

el a anterior que ya arrastraba por el nuevo a 00:09:45

a por a, vale 00:09:49

y cont se queda incrementado, se quedará a 2 00:09:50

¿2 es menor o igual que 3? Sí, pues entra una tercera vez 00:09:53

con cont igual a 2, esta es mi tercera vez, cont igual a 2 00:09:58

ahora, a mi acumulador anterior que tenía 00:10:03

a por a, a mi acumulador anterior que tenía a por a 00:10:06

le multiplico por el nuevo a, ya van 3 00:10:11

a por a por a, y eso al nuevo acumulador 00:10:14

A por A por A, vale, y cont se incrementa, se queda valiendo 3, ¿3 es menor o igual que 3? Sí, pues ahí está el error, está entrando una cuarta vez para cont igual a 3, y se está pasando, porque ahora nos hace A por A, por A, que tenía de antes los 3 A por el nuevo A, 00:10:18

luego el error está 00:10:39

que me ha entrado una vez de más 00:10:41

efectivamente me entra cuando contes igual a b 00:10:43

y yo no quiero que me entre cuando contes igual a b 00:10:46

esa última vez no la quiero 00:10:49

¿cómo puedo cambiar esta condición entonces? 00:10:51

¿cómo la transformo para que no me entre en la vez b? 00:10:55

esta sería una manera 00:11:05

cont menor o igual que b menos 1 00:11:06

vale, pero es más fea y más larga 00:11:08

que si ponemos directamente 00:11:12

cont menor que b 00:11:14

que es lo que habitualmente nos vamos a encontrar 00:11:15

uy, vale 00:11:18

si ponemos 00:11:23

cont menor que b, no es lo mismo 00:11:24

porque cont menor que b es 00:11:26

párate en la vez 00:11:29

b menos 1, párate en la b 00:11:30

menos 1, no te pares en la b 00:11:32

sino párate en la b menos 1 00:11:35

entonces acostumbraos 00:11:37

más a esta idea, cuando queréis 00:11:39

llegar a valores entre 0 y b 00:11:41

no pongáis menor o igual que b menos 1, que es más feo, poner menor que b, que es lo mismo, ¿verdad? 00:11:43

No es lo mismo poner menor o igual que b menos 1 que poner menor que b, no es lo mismo, es igual, ¿verdad? 00:11:52

Poner menor o igual que b menos 1 que poner menor que b, es la misma condición, es idéntica, si b es 0, ¿verdad que sí? 00:12:01

entonces 00:12:08

esta condición es más bonita 00:12:11

y más común ponerla así 00:12:13

que ponerla arriba 00:12:15

aunque son la misma 00:12:16

me da igual decir menor o igual que b menos 1 00:12:18

que decir menor que b 00:12:20

con menor o igual que b menos 1 00:12:21

llego hasta b menos 1 00:12:23

con menor que b llego hasta b menos 1 00:12:25

en ambas condiciones 00:12:28

llego hasta b menos 1 00:12:30

son la misma 00:12:31

pero esta de abajo es más bonita 00:12:32

vale pues este era nuestro único problema 00:12:34

de este ejercicio, que este menor o igual es un menor que b, ¿vale?, para que se quede en la b menos 1, 00:12:40

entonces si ahora ejecutamos esto, si ahora ejecutamos esto, pues seguramente ahora ya se lo haga, 00:12:51

base 3, exponente 3, 8, muy bien, base 3, exponente 3, 27, vale, ¿entendido?, bueno, pues resulta que así sin comerlo ni beberlo, 00:13:02

nos hemos encontrado en este ejercicio con una situación que se da muy a menudo, 00:13:26

un bucle 00:13:31

que yo quiero que se ejecute 00:13:33

un número de veces exacto tal cual 00:13:35

que yo ya sé de partida 00:13:38

¿vale? 00:13:40

en este caso yo quería que esto se ejecutara 00:13:41

B veces 00:13:44

¿vale? B veces 00:13:46

ya lo sabía de partida 00:13:50

no tengo ni que poner aquí una condición extraña 00:13:52

ni nada 00:13:55

he tenido que inventarme un contador 00:13:56

para poder poner ese hecho 00:13:59

que se ejecutara B veces 00:14:01

como si tenga otro programa 00:14:02

yo tengo 30 alumnos 00:14:04

y les voy a poner la nota 00:14:06

pues yo sé 00:14:08

que el trozo de código 00:14:10

poner nota lo tengo que hacer exactamente 00:14:12

30 veces 00:14:14

vale, hay una situación 00:14:15

de código que se puede dar a menudo 00:14:18

que es, tú tienes un bloque de código 00:14:20

que sabes exactamente 00:14:22

la cantidad de veces 00:14:24

que se tiene que ejecutar 00:14:26

en este caso era B, lo que tenga B 00:14:27

no sé lo que tendrá B, pero es exactamente B veces 00:14:29

bueno, pues cuando tenemos esa situación 00:14:32

tal cual 00:14:35

hay una tercera y última 00:14:36

sintaxis de bucle 00:14:39

que se adapta más, queda más bonita 00:14:40

que es el famoso 00:14:42

bucle for 00:14:45

¿vale? 00:14:45

entonces la sintaxis de bucle for 00:14:48

se adapta a la situación 00:14:50

de bucle 00:14:53

que se va a repetir exactamente 00:14:54

una cantidad de veces que yo sé de partida 00:14:56

la sé antes de entrar 00:14:59

entonces puedo hacerlo así 00:15:00

con un contador como hemos hecho aquí 00:15:03

empieza valiendo cero, lo incremento 00:15:04

y mientras sea menor que el número de veces 00:15:06

siempre podría hacerlo así 00:15:08

este bucle, sea lo que sea que hay aquí 00:15:09

se va a repetir exactamente 00:15:12

B veces, con esta estructura de contador 00:15:14

ya está, lo tengo 00:15:16

pero esta sintaxis 00:15:17

me permite 00:15:21

hacer esto mismo 00:15:23

sin poner el contador 00:15:24

porque la sintaxis se presta a eso 00:15:25

y vale para eso realmente 00:15:29

vale, pues vamos a ver cómo es la sintaxis del bucle for 00:15:30

entonces, a ver, vale, pues 00:15:34

vale, sintaxis del bucle for 00:15:45

bueno, pues en vez de while, aquí se pone for 00:16:07

vale, for, y entre paréntesis 00:16:14

las cositas que sean, ahora lo ponemos 00:16:20

y aquí el código que se repite, vale, ahora 00:16:23

La pregunta es, ¿qué se pone aquí dentro? 00:16:36

Dentro del while se ponía una condición, ¿verdad? 00:16:39

¿Aquí qué se pone? 00:16:42

Aquí se ponen hasta tres cosas, separadas por punto y coma. 00:16:43

Hay tres campitos aquí, separados por punto y coma. 00:16:50

¿Vale? 00:16:55

No tienen por qué estar los tres, ahora veremos lo que significa. 00:16:55

Pero lo que sí que tienen que estar es en los puntos y comas. 00:16:58

Si alguno de ellos no está, ahí se queda plantado el hueco. 00:17:01

Ahí se queda plantado. 00:17:04

¿Vale? Porque los separadores de punto y coma sí que tienen que estar. 00:17:06

¿Vale? ¿Qué se pone en cada huequito? Vamos a llamarlos huequito A, huequito B y huequito C. 00:17:10

¿Qué se pone en cada huequito? Pues a ver, en el huequito A se pone una sentencia, la que a mí me dé la gana, 00:17:17

que es la que se llama sentencia de inicialización, que se va a ejecutar cuando el bucle entre por primera vez. 00:17:29

y solo una vez, esa 00:17:36

la sentencia de inicio 00:17:38

podemos llamarla, vale 00:17:42

sentencia de inicio 00:17:44

vale, esa sentencia 00:17:47

se puede poner la que uno le dé la gana 00:17:48

ahora veremos cuál es su uso habitual 00:17:50

esa sentencia 00:17:52

la que yo ponga aquí, sea la que sea 00:17:55

cuando la máquina virtual llega por aquí 00:17:57

plaz, la ejecuta 00:17:59

y luego ya empieza con el bucle 00:18:00

ahora después de 00:18:03

ver esto 00:18:08

¿qué se pone en el huequito B? 00:18:09

se pone la condición equivalente, lo mismo que poníamos en el while, 00:18:14

condición que mientras se cumple tú entras. 00:18:19

Pues esa condición, con el mismo sentido que diría en el while, idéntico, 00:18:23

esa condición se mete ahí, en el hueco del medio. 00:18:28

Y eso funciona igual que el while. 00:18:33

Si esta condición se cumple, haces lo que tengas que hacer y vuelves arriba. 00:18:35

Que se sigue cumpliendo, haces lo que tienes que hacer y vuelves arriba. 00:18:41

que ya no se cumple, se acabó 00:18:44

es como si fuera la condición del while 00:18:46

vale, si la primera vez 00:18:49

que llegas ya no se cumple 00:18:52

ya no hay nada que hacer 00:18:54

se habrá ejecutado esta, eso sí 00:18:55

porque esa se ejecuta nada más llegar 00:18:58

una única vez, esta se habrá ejecutado 00:19:00

pero ya lo que hay dentro del bucle 00:19:02

no, porque lo que hay dentro del bucle 00:19:04

se ejecuta solo si B 00:19:06

es cierta 00:19:07

y por último 00:19:09

¿qué se pone en el hueco C? 00:19:11

si es que uno quiere ponerlo 00:19:14

se pone una sentencia, o incluso varias se podrían poner, que se van a ejecutar una por cada iteración. 00:19:15

Es decir, cuando este bucle esté lanzado, cada vez que entremos se ejecuta lo que hay debajo 00:19:25

y antes de volver arriba se ejecuta C. 00:19:31

Esto se ejecuta por iteración. 00:19:38

no es como la A 00:19:41

que la A se ejecutaba 00:19:44

según llegabas y ya nunca jamás 00:19:50

si tú has entrado en el bucle 00:19:52

cada vez que entres 00:19:56

se hace esto 00:19:57

y luego antes de volver arriba 00:19:59

se hace lo que hayas puesto en C 00:20:01

y se vuelve a evaluar condiciones 00:20:03

es cierta, entras 00:20:05

y se ejecuta C otra vez 00:20:07

es como si C estuviera escrito aquí al final 00:20:10

pero no está escrito aquí 00:20:12

está escrito ahí 00:20:13

que la condición sigue siendo cierta 00:20:14

y vuelves a entrar, se ejecuta esto 00:20:17

y la C también, y se vuelve 00:20:19

arriba, que la condición es cierta 00:20:21

se ejecuta esto 00:20:23

y se ejecuta esta otra vez 00:20:24

y vuelves arriba, que la condición es falsa 00:20:27

ya no entramos más 00:20:29

y se acabó 00:20:31

entonces A se ejecuta 00:20:33

cuando llegas 00:20:35

independientemente de la condición 00:20:36

y una única vez, por eso se llama 00:20:38

la sentencia de inicio 00:20:41

B es la condición del bucle que marca si entras o no entras 00:20:42

y C es una especie de sentencia de epílogo 00:20:47

que se pone aquí y se ejecuta una vez por iteración 00:20:51

ahora la pregunta sería 00:20:55

¿y qué utilidad tiene esta sintaxis de bucle tan extraña? 00:20:58

pues la utilidad natural para la que siempre se usa 00:21:02

aunque se puede usar poniendo aquí lo que te dé la gana 00:21:05

es justo el ejemplo que hemos visto aquí 00:21:08

cuando tienes un bucle que se ejecute exactamente 00:21:11

n veces 00:21:14

porque pones esto, aquí el contador 00:21:15

que se inicializa y aquí el incremento del contador 00:21:18

y ya lo tienes, no hace falta que lo hagas fuera 00:21:20

¿vale? pero bueno, paramos ahora 00:21:22

y lo 00:21:24

y lo ponemos después 00:21:25

Del mismo autor…

Clase 05-04-24 - 2
Contenido educativo. subido por Raquel G. 43′ 23″ - hace 2 años - 20 visualizaciones
Clase 05-04-24 - 1
Contenido educativo. subido por Raquel G. 28′ 45″ - hace 2 años - 15 visualizaciones
Clase 02-04-24 - 2
Contenido educativo. subido por Raquel G. 24′ 49″ - hace 2 años - 10 visualizaciones
Clase 02-04-24 - 1
Contenido educativo. subido por Raquel G. 43′ 05″ - hace 2 años - 14 visualizaciones
Clase 19-03-24 - 2
Contenido educativo. subido por Raquel G. 34′ 0″ - hace 2 años - 7 visualizaciones
Clase 19-03-24 - 1
Contenido educativo. subido por Raquel G. 29′ 32″ - hace 2 años - 10 visualizaciones
Clase 18-03-24 - 2
Contenido educativo. subido por Raquel G. 55′ 03″ - hace 2 años - 10 visualizaciones