Saltar navegación

20241021 ProgrEstruct-Bucles-ejercicios_4__BUCLE_FOR - 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 22 de octubre de 2024 por Raquel G.

18 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver, el ejercicio 9 dice, obtener a elevado a b, lo primero que hay que entender es que es a elevado a b, pero todos sabemos que a elevado a b es a por a por a b veces, entonces, todos sabemos que lo que tenemos que hacer es esto, que el resultado ya sabemos que va a ser igual a a por a y así, eso es lo que tenemos que hacer. 00:00:01
Entonces, esto es lo mismo que hacer una suma de muchos sumandos, 00:00:37
pero aquí es una multiplicación de muchos factores. 00:00:42
Es la única diferencia. 00:00:46
En lugar de ser una suma de muchos sumandos, es una multiplicación de muchos factores. 00:00:48
Entonces, si quisiéramos hacer esto, a más a más a esto b veces, 00:00:52
esto lo sabríamos hacer rápidamente. 00:01:04
Porque es una suma de muchos humanos 00:01:07
Entonces pediríamos primero los datos 00:01:09
Pues venga 00:01:12
Vamos a pedir 00:01:13
Los datos 00:01:14
Pediríamos primero los datos 00:01:18
Bueno, ni pongo el mensajito 00:01:23
A igual a 00:01:26
Y B igual a 00:01:29
Esto 00:01:36
Vale, ya están los datos 00:01:37
Entonces si el ejercicio fuera hacer esto 00:01:46
A más A más A más A 00:01:48
Ya sabríamos lo que tenemos que hacer 00:01:49
Tenemos que 00:01:52
Hacer una suma de muchos sumandos 00:01:53
Pues una variable suma 00:01:56
Para guardarlos todos 00:01:58
Ahora 00:02:02
Para poder hacer la suma de muchos sumandos 00:02:03
Es que no hay otra 00:02:09
Es esto 00:02:10
Vale, ahora, los sumandos 00:02:11
Los x, ¿cómo los generamos? 00:02:15
Pues los sumandos son todo el rato 00:02:19
A y A y A y A 00:02:21
Pues entonces x lo inicializo valiendo A 00:02:23
Y A no lo cambio 00:02:25
A no lo cambio 00:02:26
a no se cambia 00:02:27
con lo cual este bucle está haciendo 00:02:30
a más a más a más a más a 00:02:31
así hasta el infinito 00:02:34
claro, no queremos que sea hasta el infinito 00:02:36
queremos que haga 00:02:38
esta iteración 00:02:40
b veces, que este bucle 00:02:42
se ejecute solo b veces 00:02:44
solamente b, entonces nos falta 00:02:45
poner una condición 00:02:48
para que forzara que este bucle 00:02:49
se ejecute solo b veces 00:02:52
vale, pues entonces 00:02:53
Como ya sabemos contar 00:02:56
Lo que tenemos es que contar aquí 00:02:59
Para averiguar cuando hemos llegado 00:03:01
A la iteración número B 00:03:04
Ah, pero ya sabemos contar 00:03:06
Pues, ¿y cómo contamos? 00:03:07
Nos hacemos un contador 00:03:10
¿Vale? 00:03:11
¿Cómo funciona el contador? 00:03:15
El contador lo incrementamos de uno en uno 00:03:17
En cada iteración 00:03:20
De forma que este contador lo va contando 00:03:20
La primera suma que se hace, uno 00:03:23
La siguiente suma que se hace, dos 00:03:25
la siguiente suma 3 00:03:28
es un contador de las sumas que voy haciendo 00:03:29
pues entonces ahora ya sí 00:03:32
podemos hacer 00:03:34
mientras cont sea menor que b 00:03:35
porque la primera iteración 00:03:37
será la 0 00:03:40
y se quedará valiendo 1 00:03:41
la siguiente iteración será la 1 00:03:44
y se quedará valiendo 2 00:03:46
en la iteración b 00:03:47
se quedará valiendo b más 1 00:03:49
ahí ya quiero que salga 00:03:51
pues si el ejercicio fuera 00:03:52
a más a más a más a 00:03:57
sería este 00:03:58
Ya está. ¿Está claro? Vale. Pero resulta que no es a más a más a. Es casi lo mismo. Es a por a por a por a. Pues no pasa nada. Cambio la operación. La cambio de más a por y entonces se convierte en a por a por a por a por a por a. 00:04:00
pero claro, ¿qué cambia? 00:04:26
el valor inicial de suma 00:04:28
porque cuando yo voy acumulando una suma 00:04:30
el inicial sobre el que acumulo, la caja tiene que estar vacía 00:04:32
cero, ahora sumo esto 00:04:34
ahora sumo esto, pero cuando voy multiplicando 00:04:36
claro, la primera 00:04:39
multiplicación se tiene que hacer por uno 00:04:40
que es el elemento neutro de la multiplicación 00:04:42
para que no se afecte 00:04:44
entonces lo único que cambia ahora sea esto 00:04:45
hombre, y así cambio el nombre de la variable mejor 00:04:47
porque llamarse suma es muy feo 00:04:50
mult 00:04:55
si la cambio ya, mucho mejor 00:04:56
Vale, pues ya hemos conseguido el efecto de hacer b multiplicaciones 00:04:58
Gracias a que hemos puesto un contador 00:05:08
Que empieza valiendo 0, lo voy incrementando 00:05:10
Y cuando ya ha rebasado el b, salgo 00:05:14
¿Y qué voy haciendo estas multiplicaciones? 00:05:18
Porque lo he empezado en 0 00:05:28
Haz las cuentas y veas cómo salen 00:05:30
Es decir, entra valiendo 0 para la multiplicación número 1 00:05:32
con lo cual entrará valiendo 00:05:36
b menos 1 para la multiplicación b 00:05:39
que es la última 00:05:41
entonces quieres entrar para b menos 1 00:05:42
para b ya no quieres entrar 00:05:45
porque si entrabas para b estaría haciendo una multiplicación de más 00:05:47
a ver, si yo cambio contador 00:05:50
empiezo mi cuenta en 1 00:05:52
entonces aquí ya pongo menor o igual 00:05:53
pero normalmente las cuentas 00:05:55
se empiezan en 0 00:05:57
entonces este bucle se va a hacer 00:05:59
exactamente b veces 00:06:02
empezando en 0 00:06:04
con la condición estrictamente menor 00:06:06
¿vale? 00:06:08
con la condición estrictamente menor 00:06:09
entonces es importante entender 00:06:11
un segundinín, Adrián, que este bucle 00:06:13
se va a 00:06:16
ejecutar 00:06:17
b veces, porque el contador 00:06:19
ha empezado a cero 00:06:21
y la condición es mientras sea menor que b 00:06:22
se ejecutará para cero 00:06:25
para uno, para dos, para tres 00:06:27
y así hasta para b menos uno 00:06:29
un total de b veces 00:06:31
para la vez b no 00:06:32
Adrián, ¿qué querías tú preguntar? 00:06:34
Claro, esta es mi versión que yo he hecho 00:06:41
la versión robótica, llamémosle así 00:06:44
ahora ya podemos decir, bueno, pues efectivamente la variable x 00:06:46
la estoy usando solamente para guardar el valor de a 00:06:49
y la uso tal cual, luego no la modifico 00:06:53
no hago nada con ella, pues efectivamente 00:06:56
esta variable adicional x no me haría falta 00:06:59
multiplico por ahí y se acabó 00:07:02
vale, es decir, ahora podríamos simplificar y decir, hombre 00:07:04
voy a simplificar y esto mismo de aquí 00:07:12
pues sería, si yo multiplico directamente por A y quito esto 00:07:17
verdad, sería lo mismo, quito esto y multiplico por A y ya está 00:07:20
vale, si lo dejo aquí comentado, entonces 00:07:27
en lugar de esta versión, pues esta me ahorra una variable 00:07:33
mult 00:07:36
igual a mult 00:07:38
por a 00:07:43
y ya está 00:07:46
y ya me ahorro la variable x 00:07:48
pero estoy haciendo lo mismo 00:07:51
vale, de aquí lo interesante 00:07:52
es que 00:07:56
que nos va a permitir 00:07:58
esta estructura introducir 00:08:05
una sintaxis del bucle while 00:08:07
de los bucles que va a ser más cómoda 00:08:09
para situaciones como estas 00:08:11
Lo que pasa es que voy a necesitar un rotulador 00:08:12
El ejemplo que acabamos de hacer 00:08:15
Era para hacer la multiplicación 00:08:20
La potencia de A elevado a B 00:08:22
Y para eso hemos hecho 00:08:25
Nuestra variable multiplicadora 00:08:26
Que empezaba valiendo 1 00:08:33
Luego hemos hecho un contador 00:08:36
Para contar la cantidad de veces 00:08:40
Que se ejecuta el bucle 00:08:42
Y ahora hemos hecho 00:08:43
mientras ese contador sea menor que b 00:08:45
hemos incorporado en multiplicación esta operación 00:08:51
lo hemos multiplicado por a y el resultado lo hemos vuelto a guardar en multiplicación 00:09:02
es la operación que hemos hecho 00:09:06
y hemos incrementado contador 00:09:08
hemos incrementado contador para contar una iteración más 00:09:10
Entonces, esta variable contadora está solo, su único uso es contar la cantidad de veces que se ejecuta esto, nada más. 00:09:16
Ni forma parte del resultado, ni hace nada. 00:09:25
El resultado se va construyendo solamente con la a y la propia mult, claro. 00:09:28
Esta está solo para contar. 00:09:33
Vale, pues hay una situación que se nos puede dar muchas veces, que es exactamente esta, 00:09:35
que es un bucle que yo sé 00:09:41
de partida la cantidad 00:09:43
de veces que quiero que se ejecute. 00:09:44
Como es este caso, ¿no? En este caso 00:09:47
nosotros sabíamos de partida 00:09:48
que el bucle se tiene que ejecutar 00:09:50
B veces. 00:10:00
Vale, entonces, esto no ocurre siempre 00:10:16
que nosotros sepamos de partida la cantidad 00:10:18
de veces que se va a ejecutar un bucle. 00:10:20
Por ejemplo, en el programa en el que 00:10:22
hacíamos un bucle, en el que le estábamos 00:10:24
pidiendo al usuario números 00:10:26
todo el rato hasta que introduciera 00:10:28
no positivo. Era imposible 00:10:30
saber cuántas veces se iba a ejecutar. 00:10:32
Las que tarden meten 00:10:35
el positivo. Si tarda 20 veces, pues 00:10:36
20 se va a ejecutar. Si mete el 00:10:38
positivo a la primera, pues una se va a ejecutar. 00:10:40
Entonces hay situaciones en las cuales 00:10:43
de partida no se puede saber cuántas veces 00:10:44
se va a ejecutar. Depende de la ejecución. 00:10:46
Bueno, pero hay otras situaciones en las que 00:10:48
si se sabe, era esta. 00:10:50
Esta era uno de esos ejemplos. 00:10:52
Nosotros sabemos que este bucle, sí o sí, 00:10:54
se va a ejecutar 00:10:57
estas veces. 00:10:58
Y eso lo sabemos sí o sí, independientemente de la ejecución, se va a ejecutar B, ¿vale? Para eso hemos tenido que hacernos este mecanismo, un contador que se va incrementando y mientras sea menor que B se ejecuta. 00:11:00
Vale, pues como eso es algo que ocurre a menudo, 00:11:15
que uno identifique que tiene que hacer un bucle de sentencias, 00:11:18
que sabe de partida cuántas veces va a ejecutar, 00:11:20
pues hay una sintaxis para expresar eso 00:11:24
que me simplifica las líneas de código, sin más, 00:11:26
porque me incorpora dentro el contador. 00:11:29
Y como me lo incorpora dentro, 00:11:31
no tenemos que ponerlo fuera nosotros, 00:11:33
que es la sintaxis for, ¿vale? 00:11:36
Entonces, el bucle for es otra forma de expresar el way, 00:11:42
es otra forma. 00:11:46
¿Vale? Es otra manera, pero me facilita la escritura de código en bucles en los que yo sé de partida cuántas veces se va a ejecutar. 00:11:47
¿Vale? Entonces, ¿cuál es la sintaxis del bucle for? 00:11:58
Vale, pues la sintaxis del bucle for, vamos a ponerlo aquí más cerquita, la sintaxis del bucle for es esta. 00:12:02
Empezamos con for 00:12:17
Paréntesis que se abren y se cierran 00:12:21
Y aquí tres campitos 00:12:24
Que ahora vemos lo que significa 00:12:27
Separados por punto y coma 00:12:28
Sí 00:12:29
Que uno se queda vacío 00:12:32
Porque no tiene nada que poner 00:12:35
Se queda vacío 00:12:36
Pero los dos puntos y comas se quedan ahí 00:12:37
Separando los tres campos 00:12:39
Y aquí entre llaves 00:12:41
Las sentencias que se repiten 00:12:44
Igual que el while 00:12:45
Aquí las mismas sentencias 00:12:46
no, no se puede 00:12:47
no se puede, tiene tres 00:12:51
porque cada una tiene un uso concreto 00:12:54
vale, pues que se ponen 00:12:56
estas casillitas, si es que quieres poner algo 00:12:58
vale 00:13:00
la casilla del medio es la más 00:13:02
fácil de entender 00:13:04
en la casilla del medio se pone la condición 00:13:05
que mientras se repita 00:13:08
entras en el bucle 00:13:11
es decir, la que en el while poníamos aquí 00:13:12
vale 00:13:14
entonces aquí se pone la condición 00:13:15
luego un for 00:13:18
con estas dos cosas vacías 00:13:22
y ahí la condición 00:13:24
es lo mismo que un while 00:13:25
entonces si yo hago un bucle for 00:13:28
hago este bucle for así 00:13:29
vaya rotuz que me ha dado 00:13:30
vale 00:13:34
mi programa 00:13:35
este 00:13:37
int mult 00:13:38
igual a 1 00:13:43
int cont 00:13:45
igual a 0 00:13:48
y aquí 00:13:50
mult for igual a 00:13:52
y cont más más 00:13:58
este código 00:14:00
y el código de al lado son idénticos 00:14:03
son idénticos 00:14:08
porque esto es un bucle que se va a ejecutar 00:14:09
mientras esta condición se acierta 00:14:13
luego es igual 00:14:14
¿qué ocurre? que el for me permite 00:14:16
si yo quiero utilizar 00:14:18
estos dos campos para meter dos cosas adicionales 00:14:20
¿vale? 00:14:23
A ver, lo que se mete aquí, ¿qué tiene que ser? 00:14:26
Lo que se mete aquí es lo que a mí me dé la gana, 00:14:30
pero tienen que ser sentencias de Java, válidas. 00:14:34
Una o muchas. 00:14:37
Yo ahí meto sentencias que se van a ejecutar 00:14:39
solo una vez cuando el bucle arranca. 00:14:43
Es decir, que se ejecutan al arrancar el bucle. 00:14:51
Y solo una vez, solo la primera vez que entras, 00:14:55
no las siguientes, las siguientes no. 00:14:58
O sea, por ejemplo, una suma se ejecuta cada vez que pasa esto. 00:14:59
No, que se ejecuta solo una vez. 00:15:06
La primera vez que entra. 00:15:08
Las siete instalaciones ya no. 00:15:09
Como si fuera una inicialización. 00:15:11
¿Lo primero es para que solo se hace una vez? 00:15:13
¿Solo se hace una vez? 00:15:16
O sea, tú vienes por aquí. 00:15:18
Empieza el for. 00:15:20
Lo primero que se hace es ejecutar lo que hay aquí. 00:15:21
Una única vez. 00:15:23
Ahora ya se mira condición. 00:15:25
Que se cumple entras. 00:15:26
El bucle vuelve arriba, pero eso ya no se ejecuta más. 00:15:27
Es solo la primera vez. 00:15:30
¿Vale? 00:15:31
Solo la primera vez. 00:15:32
¿Vale? 00:15:33
¿Que aquí se quiere poner algo? 00:15:34
Se puede poner algo. 00:15:36
Y lo que se pone aquí, ¿qué tiene que ser? 00:15:38
Lo mismo, sentencias, 00:15:40
pero que éstas se ejecutan 00:15:41
al final de cada iteración 00:15:43
y en todas las iteraciones. 00:15:46
Efectivamente. 00:15:51
Entonces, por eso se adapta. 00:15:52
La idea no es meter aquí 00:15:54
millas de código y aquí mil, 00:15:55
porque entonces te queda un for que no entiendes, 00:15:57
sino que lo puedes usar, sobre todo, 00:15:59
para situaciones como esa. 00:16:01
Sentencias que se ejecutan 00:16:04
al final 00:16:06
de cada iteración. 00:16:09
Luego, 00:16:16
aquí que ponemos 00:16:18
lo que nos interese 00:16:20
para que nos quede un código 00:16:21
claro y legible. 00:16:22
Entonces, situación típica 00:16:24
para la que se usa siempre el for 00:16:25
y prácticamente para la única 00:16:27
que se utiliza. 00:16:28
Prácticamente para la única. 00:16:29
Cuando tenemos que contar 00:16:32
la cantidad de veces 00:16:33
que se ejecuta un bucle. 00:16:35
Porque para eso 00:16:37
siempre hay que hacer 00:16:38
esto al principio. 00:16:39
Esto al principio. 00:16:41
y solo una vez 00:16:41
y luego al final de cada iteración está 00:16:42
al final de cada iteración está 00:16:45
pues justo clavado 00:16:47
entonces pongo aquí 00:16:48
int cont igual a cero 00:16:50
con lo cual ya de aquí 00:16:53
la quito 00:16:55
y aquí pongo con más más 00:16:56
lo voy a dejar ya 00:16:59
puesto entero 00:17:02
este es el uso habitual del for 00:17:04
uno puede poner aquí lo que le dé la gana 00:17:20
y le interese 00:17:23
pero es el uso habitual 00:17:24
Porque esto uno lo ve rápidamente y dice, ah, vale, esto es un bucle que se va a ejecutar desde un contador valiendo cero, incrementándose una vez en cada iteración y mientras el contador no haya llegado a ser B. 00:17:26
Con lo cual uno ve esto y dice, ah, vale, esto es un bucle que se ejecuta B veces y ya está. 00:17:38
Y se olvida de poner esta variable fuera porque no hace falta, ya está aquí. 00:17:43
Con lo cual esto en cuanto entremos en el for es lo primero que se va a hacer, declarar el cont y inicializarlo a cero, lo primero. 00:17:48
y después de caer, este ya no sobraría 00:17:55
claro, este ya no sobraría 00:17:58
entonces ahora 00:18:00
este código 00:18:02
y este son iguales 00:18:04
pero este está como más compactado 00:18:05
más claro y más bonito 00:18:07
vale, venimos por aquí, esto es lo primero que se hace 00:18:08
cae el contador 00:18:12
se evalúa condiciones, se entran 00:18:13
y esto se hace después de que hay iteración 00:18:16
esto es como si estuviera aquí abajo 00:18:18
yo podría dejar esto en blanco 00:18:19
y poner esto aquí, sería el mismo 00:18:22
efecto, pero para eso no uso un for, pues había un 00:18:24
no hay, si uso un for es para en lugar 00:18:26
de ponerlo aquí abajo 00:18:28
ponerlo ahí, vale, pero acordémonos 00:18:29
que se ejecuta al final, siempre 00:18:32
al final de las sentencias 00:18:34
entonces suele ser 00:18:35
el uso habitual, yo tengo un bucle que quiero 00:18:38
que se ejecute x veces 00:18:40
pues me lo planto con un contador desde 00:18:41
cero, incrementándose 00:18:44
de uno en uno, mientras 00:18:46
sea menor que el 00:18:48
valor final de veces que tiene que hacer 00:18:50
es el uso habitual 00:18:51
de hecho la variable 00:18:53
la ventaja que tiene es que 00:18:56
aquí esta variable contadora 00:18:58
como la hemos declarado fuera del bucle 00:18:59
porque era necesario declararla fuera del bucle 00:19:02
para evaluarla aquí 00:19:04
esta variable contadora ya se va a quedar 00:19:05
visible para el resto del programa toda la vida 00:19:08
sin embargo esta 00:19:10
al estar declarada aquí 00:19:12
es local al bucle 00:19:14
y cuando ya hemos terminado la variable 00:19:15
cont ya no existe, entonces ya no molesta 00:19:18
esa es la ventaja 00:19:19
entre esta versión y esta 00:19:22
que este contador ya es una variable 00:19:24
que ya se va a quedar visible para toda la vida 00:19:26
y ya no puede declarar nada más 00:19:28
que se llame cont 00:19:30
sin embargo en esta variante como int está declarada aquí dentro 00:19:31
es local al for 00:19:34
y aquí ya no existe 00:19:36
podría volver a declararla 00:19:37
como pauta general 00:19:38
de programación 00:19:43
a esta variable que cuenta 00:19:44
que sirve para contar las veces que se va a ejecutar 00:19:47
el for 00:19:50
se la suele llamar i 00:19:50
que así queda más bonito y más claro 00:19:52
se la suele llamar i 00:19:57
pero vamos 00:19:59
como le dé la gana a 1 00:20:01
y se le suele llamar 00:20:02
la variable índice del bucle 00:20:05
porque es la variable que te va 00:20:06
marcando en qué iteración estás 00:20:09
la primera vez estarás en i igual a 0 00:20:10
la siguiente vez ya estarás en i igual a 1 00:20:12
la siguiente en i igual a 2 00:20:15
y cuando hayas llegado a i igual a b 00:20:17
ya no entras más 00:20:19
porque ya no te cambias 00:20:20
¿vale? luego ese es el aspecto 00:20:22
que nos encontramos siempre en el bucle for 00:20:28
pero uno 00:20:30
puede poner aquí lo que le dé la gana 00:20:32
y aquí lo de que siempre que sean sentencias 00:20:34
separadas por comas 00:20:36
aquí cualquier condición 00:20:38
y aquí sentencias separadas por comas 00:20:40
todas las que quiera 00:20:42
pero bueno, se trata de hacer códigos que sean claros 00:20:43
no hay que meter ahí todo el programa 00:20:46
aquí metido 00:20:48
si yo me enchuco aquí un programa entero, pues lo va a hacer 00:20:49
cuando acabe la interacción 00:20:52
Pero vaya follón de código que dejo 00:20:53
Vale, ya con esto uno puede jugar 00:20:56
Y hacer lo que quiera 00:21:03
Que queremos mostrar pues todos los números pares 00:21:03
Pues podríamos hacerlo con este mismo bucle for 00:21:07
Por ejemplo 00:21:09
Si hacemos esto 00:21:11
Por ejemplo 00:21:12
¿Qué estaría haciendo con este for? 00:21:18
Pues mostrar todos los pares 00:21:28
Entre 0 y 100 00:21:30
Porque aquí el salto que estoy dando es de 2 en 2 00:21:31
Por ejemplo 00:21:34
Lo que me refiero es que uno ya hace las modificaciones que quiere 00:21:34
y le interesa, está viendo cómo funciona el pot 00:21:37
este bucle 00:21:39
partiría de cero 00:21:41
en este caso, i se iría 00:21:43
incrementando de dos en dos, porque me da 00:21:45
a mí la gana ponerlo así 00:21:47
y ahora 00:21:48
mientras i sea menor que cien 00:21:50
me va mostrando el valor de i, lo mostraría cero 00:21:53
lo mostraría dos, luego cuatro 00:21:55
luego seis, que cada uno lo usa 00:21:57
como quiera 00:21:59
claro, tú ya 00:22:00
lo usas como quieras 00:22:03
sabiendo que 00:22:05
normalmente su uso es este 00:22:06
poner una variable 00:22:09
aquí inicializada 00:22:11
tocar aquí esa variable 00:22:13
y esa variable te suele servir como contadora 00:22:14
de las veces que se está haciendo 00:22:17
y aquí ya en función del 00:22:19
límite final, pues sabes cuando terminas, cuando no 00:22:21
¿y si lo que quieras poner en impares? 00:22:24
bueno, pues podrías empezar 00:22:28
desde 1, por ejemplo 00:22:29
este mismo programa 00:22:30
empiezas desde 1 y ya tienes los impares 00:22:32
desde el 1, 3, 5 00:22:35
pero vamos, el uso habitual del for es 00:22:36
pues eso, cuando yo tengo un bucle que sé 00:22:42
que se va a ejecutar exactamente un número 00:22:44
de veces las que sea, pues igual 00:22:46
hacer un contador, incrementarlo 00:22:48
y poner la condición, pues lo pongo aquí 00:22:50
pongo aquí el contador empezado a cero 00:22:52
aquí marco que lo vaya incrementando 00:22:54
y aquí la condición final y ya está 00:22:56
y es más cómodo poner todo eso 00:22:58
que hacerse todo igual con el conti 00:23:00
¿vale? y a partir de ahí uno usa 00:23:02
el for como quiera y como siempre y cuando 00:23:04
le sea más cómodo, ¿vale? 00:23:06
Entonces, en los ejercicios que vienen a partir de ahora 00:23:09
Pues si uno ve que le pega más un for 00:23:29
Pues puede hacer un for 00:23:32
¿Vale? En este caso 00:23:34
Pues con bucle for 00:23:37
Vale 00:23:44
Con bucle for, ¿cómo quedaría la cosa? 00:23:51
Vamos a volver a poner 00:23:55
la multiplicadora 1 00:23:56
pues con bucle for 00:23:59
quedaría así 00:24:05
vale, pues entonces 00:24:06
esto de a elevado a b 00:24:29
Con el for se queda así 00:24:30
Que queda más bonito 00:24:32
¿Verdad? 00:24:33
Mult empieza valiendo 1 00:24:35
Y ahora voy sobre mult 00:24:36
Multiplicando a por a por a por a 00:24:38
B veces 00:24:40
Desde igual a 0 00:24:40
Incrementando i 00:24:42
Mientras i sea menor que b 00:24:43
¿Vale? 00:24:44
Vale, pues ¿qué es el factorial? 00:25:01
Es lo mismo 00:25:03
Lo vais a hacer vosotros ahora antes de iros 00:25:03
¿Qué es el factorial? 00:25:05
A ver, ejercicio 11 00:25:08
Eso era multiplicar el número de 00:25:09
1, 2, 3 00:25:17
Hasta que llegue al número que tenéis 00:25:18
Eso, justo. Vale. Vale, el factorial de un número n, pues hay que multiplicar efectivamente 1 por 2 por 3, así hasta que llegas al propio n. Así. 00:25:20
luego de nuevo es una multiplicación 00:25:46
de muchos factores 00:25:50
luego habrá que hacer muchas 00:25:51
multiplicaciones, ya sabemos cómo 00:25:53
una variable multiplicadora que empieza 00:25:55
valiendo 1, ahora ya sí 00:25:58
ahora ya la variable sí que cambia 00:26:00
la variable por la que multiplico no es a 00:26:02
todo el rato, será una 00:26:04
variable x que la voy a ir 00:26:06
cambiando, ahora ya no es por a todo el rato 00:26:07
no es por a, por a, por a, es por la 00:26:10
que toque, luego ahora ya sí que la tendré que generar 00:26:12
vale, entonces 00:26:14
vale 00:26:17
me ha ocupado dos líneas 00:26:20
claro, este programa 00:26:24
se queda, tú lees n 00:26:27
leemos n 00:26:29
de nuevo 00:26:56
hecho así en plan robótico 00:26:57
pues sería, oye vamos a 00:26:58
una variable 00:27:01
factorial, que es la que va a tener el resultado 00:27:03
inicializada 1 00:27:05
porque sé que son muchas multiplicaciones 00:27:07
pues venga, esto será 00:27:09
fat por 00:27:13
igual 00:27:15
el factor que va multiplicando 00:27:18
este factor que va multiplicando 00:27:21
venga, inicialmente que sea el 00:27:24
1, aunque bueno, podría empezar del 2 00:27:25
porque 00:27:27
me da igual, esta multiplicación no afecta 00:27:28
Pero bueno, para que sea la definición matemática bonita. 00:27:31
Y ahora ya, x más más. 00:27:35
Claro. 00:27:41
Mientras que, mientras x sea menor que n, ¿verdad? 00:27:42
Menor o igual que n. 00:27:49
Porque para n queremos entrar también, ya n más 1 no. 00:27:52
Vale. 00:27:58
Y ahora ya mostramos FAD. 00:27:58
Esta sería la versión hecha, pues, de principio a fin. 00:28:00
Pero efectivamente, pues nos sobra, hay variables que podemos, la x nos sobra, podemos sobre factorial ir acumulando la propia n a la que vamos decrementando. 00:28:02
Claro, yo he hecho resultado igual a resultado por menos menos n. 00:28:16
Claro, entonces. 00:28:22
N es ya mayor que 1. 00:28:24
Claro, entonces aquí hemos usado una variable adicional que nos podemos quitar, porque la propia n mayúscula la podemos a ella ir decrementando. 00:28:26
E ir multiplicando primero por ella 00:28:34
Luego por ella menos uno, luego por ella menos dos 00:28:36
De que llegues a uno 00:28:38
¿Vale? Entonces ya, nos vamos quitando variables 00:28:39
Porque ya somos muy 00:28:42
Apañados y 00:28:43
¿Vale? Pues entonces 00:28:45
¿Cómo se da uno cuenta de que esta variable le sobra? 00:28:48
Se da uno cuenta 00:28:52
De que esta variable le sobra cuando dice 00:28:52
A ver, es que esta variable 00:28:54
N mayúscula no la estoy usando para nada más 00:28:56
Que para esto de aquí 00:28:59
No la estoy usando para nada más 00:29:00
¿Vale? Entonces otra versión 00:29:02
que es la que habréis hecho vosotros, pues sería 00:29:04
pues mira, más recogidita 00:29:06
mientras n 00:29:08
sea mayor 00:29:10
o igual que 1 00:29:11
pues 00:29:14
fact por 00:29:18
igual n 00:29:19
y la dejas decrementada 00:29:22
vale, la versión súper 00:29:23
comprimida de lo de arriba 00:29:26
no lo podemos comprimir ya más 00:29:27
esta ya es 00:29:29
para profesionales 00:29:32
sobre factorial vamos multiplicando algo 00:29:33
que lo dejamos decrementado 00:29:37
para la próxima 00:29:39
cuando se quede en 1 00:29:39
me va a entrar, multiplica por 1 00:29:47
luego cuando se me queda en 0 00:29:49
como no es mayor 00:29:51
no, está bien 00:29:53
está bien, está bien 00:29:54
está bien 00:29:56
mayor o igual que 1 00:29:58
está bien, o estrictamente mayor que 0 00:30:00
da lo mismo, me da igual poder mayor o igual que 1 00:30:02
o mayor que 0 00:30:04
vale, bueno, esta versión es 00:30:05
lo mismo, pero quitando la variable x 00:30:08
porque no la necesitamos 00:30:10
pero iría cada uno a su 00:30:12
a su gusto 00:30:13
vale, bueno 00:30:15
este 00:30:20
el que no lo haya hecho, que lo haga 00:30:23
el 10, el que no lo haya hecho 00:30:26
que lo haga, pensando pues en 00:30:28
estas últimas, pensando en como muchas 00:30:30
anteriores 00:30:32
el 12 00:30:33
la media, la media es una suma 00:30:35
sumar sabemos 00:30:39
claro 00:30:41
lo que pasa es que la media es 00:30:43
no solo la suma, sino dividida entre el total 00:30:45
de los que hemos leído 00:30:47
pues habrá que incorporar contadores 00:30:48
para positivos, negativos y ceros 00:30:50
vale 00:30:53
bueno 00:30:55
si, vamos a 00:30:57
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
18
Fecha:
22 de octubre de 2024 - 18:09
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 01″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
603.96 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid