20261023 Bucles_ejerc1 | Mediateca de EducaMadrid

Ya automáticamente pienso, ah, datos de entrada, vale, hay datos de entrada, 00:00:00

tengo que leer del teclado, vale, muy bien, hay datos de entrada, pues, 00:00:04

planto esto, tengo que leer dos valores y ahora sumar todos los valores 00:00:08

comprendidos entre esos dos que cumplan no sé qué. 00:00:20

Entonces, ah, vale, tengo que sumar un montón de cosas, 00:00:24

tengo que sumar un montón de cosas, pues entonces automáticamente 00:00:27

ya hago el chip, vaya, tengo que hacer una suma acumulativa, ¿vale? 00:00:30

¿Vale? Como ya identificamos ayer, ese patrón algorítmico ya lo identificamos. 00:00:34

Anda, una suma acumulativa, ¿vale? Pues es una variable acumuladora que la inicializo a cero 00:00:39

y luego asociada a un bucle, siempre asociada a un bucle, exactamente igual que el contador, 00:00:44

el contador siempre asociado a un bucle, pues asociado a un bucle en esa variable acumuladora 00:00:50

se va sumando en cada iteración un sumandito nuevo, ¿vale? 00:00:56

Pues como identificamos que vamos a tener que hacer una suma acumulativa, pues nuestro programa va a tener que ser algo como esto, es una suma de enteros, pues una variable acumuladora o suma que empieza valiendo cero asociada a un bucle, asociada a un bucle y ahora dentro de ese bucle pues tendremos que hacer algo como esto, ¿vale? 00:01:01

Y este será mi resultado, vale, pues a ver, ¿qué tengo yo que ir sumando? Pues números que parten de un valor inicial A que me dan y cada vez es uno mayor, cada vez es uno mayor, cada vez es uno mayor, hasta llegar a uno final que me dan B, pues justo lo que hicimos. 00:01:26

Pues estos sumandos serán números que inicialmente sea el numerito primero A que me han dado, 00:01:53

ese numerito A primero que me han dado, todavía no he hecho la lectura, porque ese es el primer sumando, 00:02:04

y ahora, una vez que he incorporado cada sumando, el siguiente sumando, ¿cómo lo obtengo? 00:02:09

Pues incrementándolo de uno en uno. 00:02:18

vale, el primer sumando será 00:02:20

cada iteración 00:02:23

me incrementa sumando de uno en uno 00:02:25

me lo va incrementando y lo voy acumulando 00:02:27

a suma, vale 00:02:29

ya me voy aproximando 00:02:31

pero, releyendo 00:02:32

esto y dejándolo bien entendido 00:02:35

cuidado, a esa 00:02:37

suma, solo 00:02:39

incorpora los que 00:02:41

sean múltiplos de 5, cuidado 00:02:43

no los sumes todos 00:02:45

no todos los sumandos 00:02:47

se van a ir incorporando a la suma, solo los que sean múltiplos de 5, ah vale, pues no pasa nada, entonces cuidado, esto estará condicionado a que sumando sea múltiplo de 5, 00:02:49

que ya sabemos como calcular si un número es múltiplo de otro, si el resto de dividirlo entre otro es 0, vale, pues ya se va aproximando, 00:03:03

A esta suma acumulativa voy sumando un número, otro número, otro número, que voy obteniendo, incrementándolos de uno en uno, de uno en uno, pero ¿lo sumo todos? No, cuidado, solo sumo estos, vale, muy bien. 00:03:12

me siguen faltando cosas 00:03:28

por supuesto inicializar A 00:03:34

ese es un dato que tendré que leer por teclado 00:03:37

pero vamos a acabar con el bucle 00:03:40

condición de finalización del bucle 00:03:46

sumo todos partiendo desde el A 00:03:50

hasta el fin de los tiempos 00:03:52

sigo incrementando sumando hasta el fin de los tiempos 00:03:54

de forma que se vayan sumando 00:03:57

todos los múltiplos de 5 00:03:59

partiendo desde la A hasta el final de los tiempos 00:04:01

no, no tiene sentido 00:04:03

que sea hasta el final de los tiempos 00:04:05

ningún bucle debería ser infinito 00:04:06

¿qué dice aquí? 00:04:08

ah, vale, sólo los comprendidos entre A y B 00:04:10

cuando hayas llegado a B 00:04:13

no sumes más 00:04:14

vale, pues entonces, ¿qué condición de finalización podemos poner? 00:04:15

lo mismo clavado que hacíamos ayer 00:04:21

lo mismo 00:04:23

¿qué condición de finalización pondríamos? 00:04:23

Yo sumo primero el a, luego el a más 1, el a más 2, el a más 3, el a más 4, ¿no? 00:04:34

El a más 5 lo vuelvo a sumar, el a más 6, el a más 7, el a más 8, ¿no? 00:04:40

El a más 10 lo vuelvo a sumar, ¿vale? 00:04:45

Pero esto ya sí suman todos los múltiplos de 5 partiendo desde el a, ¿no? 00:04:48

En algún momento paro de sumar. 00:04:52

Entonces, esa parada la tengo que reflejar con esta condición. 00:04:55

Entonces, ¿qué condición podría Isabel? 00:05:00

Recordad que la condición de ahí tiene que ser la negada de la que me hace parar. 00:05:02

¿Cuándo querremos parar de sumar? 00:05:08

¿Cuándo querremos parar? 00:05:11

Decidme esa condición en función de las variables que tengo aquí. 00:05:13

Suma, sumando, que son las únicas que tengo. 00:05:16

¿Cuándo querremos parar de sumar? 00:05:18

En un enunciado que me dice sumar todos los comprendidos entre A y B, patatín. 00:05:21

¿Cuándo querremos parar de sumar? 00:05:26

Vale, pero decídmelo directamente en sentencia Java. 00:05:29

¿Cuándo qué variable 00:05:32

sea igual a qué variable? 00:05:35

¿O cómo? 00:05:37

Cuando A sea igual a B. 00:05:37

Cuando A sea igual a B. 00:05:40

Pero aquí en ningún momento 00:05:41

se toca A y B, con lo cual... 00:05:43

Cuando sumando sea igual a B. 00:05:44

Vale, cuando sumando sea igual a B. 00:05:46

¿Vale? 00:05:49

El B entonces no lo vas a sumar. 00:05:51

Vamos a suponer que lo queremos incluir. 00:05:53

¿Vale? 00:05:56

Entonces, ¿cómo modificamos esa sentencia? 00:05:57

Es lo mismo que nos pasó en el ejercicio de ayer. 00:05:59

mientras sea diferente de n 00:06:01

si tú quieres parar 00:06:03

cuando sumando sea igual a b 00:06:05

entonces la que tienes que poner ahí 00:06:07

sería la negada 00:06:09

mientras sumando sea diferente de b 00:06:10

la negada 00:06:13

y si ponemos mientras sumando sea 00:06:15

diferente de b 00:06:17

si pones aquí 00:06:18

mientras sumando sea 00:06:22

diferente de b 00:06:25

dato que tendremos que haber leído por ahí 00:06:27

claro, aquí nos falta esa parte 00:06:29

pero esa parte es la más fácil 00:06:31

leer A y B 00:06:32

si lo pones así 00:06:34

el B no se llegaría a sumar 00:06:36

es lo que nos pasaba ayer 00:06:39

si poníamos mientras sumándose 00:06:41

diferente de N 00:06:43

entonces ¿cómo modificamos la sentencia? 00:06:44

para que fuera más general 00:06:47

claro, literalmente 00:06:48

¿qué pusimos? 00:06:53

¿qué tendríamos que poner? dictármelo tal cual 00:06:54

vale 00:06:56

Eso, algo mejor, ¿no? 00:06:59

Mientras sumando sea menor o igual que B. 00:07:02

Mientras sumando sea menor o igual que B, entro. 00:07:09

Entonces, el primero que ya no me suma es el B más 1. 00:07:12

Ese es el primero que ya no me suma. 00:07:16

Bueno, pues esa condición, vale, ya la tenemos. 00:07:21

Vale, pues este bucle está. 00:07:32

Mientras sumando sea menor o igual que B, 00:07:35

Voy incorporándolos a la suma acumulativa, pero solo los incorporo si son múltiplos de 5, ¿qué nos falta? Leer los datos de entrada A y B, mis datos de entrada A y B no los he leído, ¿vale? Pues vamos a leerlos, ¿vale? 00:07:37

Leemos A y leemos B. Esto ya estaría, pero me han dicho, ojo, cuidado, si el usuario introduce una más grande que B, entonces intercámbialo, porque si no los intercambiamos y el usuario introduce una que es mayor que B, el resultado final del programa, la suma final, ¿cuánto me saldría? 00:08:12

¿Vale? Este es mi programa. Imaginaos que el usuario introduce una A igual a 7 y un B igual a 1, que es la situación en la que queremos hacer el intercambio. 00:08:57

Si no hiciéramos el intercambio, este programa, ¿qué valor me daría para suma? 00:09:11

Una vez que ya he terminado, que termina con esta línea que aquí no ha cabido, 00:09:18

¿qué valor me mostraría para suma en el caso de que yo introduzca una más grande que B? 00:09:22

Venga, valor final del programa 00:09:37

O sea, resultado final, suma 00:09:44

Si yo le introdujera un A mayor que B 00:09:46

¿Qué valor da? 00:09:48

¿O si da error de ejecución? 00:09:51

¿Qué pasaría? 00:09:54

¿Error? ¿En qué momento daría error? 00:10:03

No, ¿en qué línea? 00:10:08

¿Cuándo daría un error? 00:10:09

¿Pero por qué? ¿Debido a qué? 00:10:15

Porque no puede sumar 00:10:17

¿Por qué no puede ser? 00:10:18

Si sumando es mayor que B 00:10:23

No tiene que hacer nada 00:10:24

vale, pero eso no es un error 00:10:25

simplemente este while 00:10:27

¿cuántas veces ejecutaría? 00:10:30

claro, pero eso no es un error 00:10:32

el programa no daría error 00:10:35

un while ya hemos dicho muchas veces 00:10:36

si la primera vez que llegamos 00:10:39

por allí, en la primera iteración 00:10:42

la condición es falsa 00:10:44

el while no se ejecuta nunca 00:10:45

y ya está, y eso no produce error 00:10:47

en la ejecución, simplemente en este programa 00:10:49

el while nunca llega a ejecutarse 00:10:51

con lo cual si el while 00:10:54

nunca llega a ejecutarse, el resultado final 00:10:56

del programa será 00:10:58

cero, ¿verdad? 00:10:59

¿Vale? Entonces, si A es mayor 00:11:01

que B, 00:11:04

esto es falso 00:11:06

de partida, es falso, 00:11:08

nunca entramos en el 00:11:10

while, la suma no se incrementa 00:11:12

en nada, y da cero. 00:11:14

Otra cosa es que con el usuario 00:11:16

que nos ha pedido el programa, le digamos, 00:11:18

¿es eso lo que quieres? Si A es 00:11:20

mayor que B, ¿quieres que te dé cero? 00:11:22

Entonces, él nos dice, no, no, 00:11:24

Lo que te he dicho en el enunciado, si A es mayor que B, entonces intercámbiame A por B, porque sí que quiero sumar todos los comprendidos entre A y B, pero a lo mejor yo te los estoy dando en orden cambiado, yo lo que quiero es que me hagas la suma igualmente, aunque yo te dé A y B en orden correcto, en orden cambiado. 00:11:26

entonces una vez que él nos dice eso 00:11:44

ya es cuando nosotros decimos 00:11:46

vale, pues entonces voy a tener que incorporar a mi programa 00:11:48

una sentencia 00:11:51

que intercambie los valores de A y B 00:11:52

solo si 00:11:55

A es mayor que B 00:11:56

vale, pues una vez que hemos identificado 00:11:58

que eso es lo que tenemos que hacer 00:12:00

pues ya sabemos programar esto 00:12:02

solo en el caso de que A sea mayor que B 00:12:03

tengo que hacer algo, solo en ese caso 00:12:07

¿eso qué es? pues unir, lógicamente 00:12:09

pero nosotros con lo que sabemos, sabemos programar cualquier cosa que nos pidan, cualquiera, vale, pues entonces aquí, ojo, que si, y solo en ese caso, si a es mayor que b, ojo, porque en ese caso, tengo que intercambiar, aquí, si a es mayor que b, ojo, porque solo en ese caso, solo en ese caso, 00:12:11

tengo que intercambiar los valores 00:12:38

de las variables 00:12:41

y eso ya hemos resuelto como hacerlo 00:12:41

voy a guardar 00:12:47

en una variable que me invento 00:12:51

solo como variable temporal 00:12:53

voy a guardar lo que tiene A 00:12:55

para no perderlo, lo guardo ahí 00:12:56

ahora 00:12:59

a mi variable A 00:13:00

que ya tengo guardado 00:13:04

lo que tiene, con lo cual me da igual pisarla 00:13:05

sobre escribirla con lo que sea 00:13:07

le voy a asignar lo que tiene B 00:13:09

vale, y a B 00:13:11

¿qué le asigno? lo que tenía 00:13:16

A, ¿y qué era lo que tenía 00:13:17

A? esto 00:13:20

vale, eso es lo que acabamos 00:13:21

de explicar hace 00:13:26

un ratín 00:13:28

vale, me invento 00:13:29

yo una variable auxiliar 00:13:32

aquí 00:13:34

tengo yo mis A y mis B 00:13:36

a mi variable 00:13:38

auxiliar le asigno 00:13:42

lo que tenía 00:13:44

A, imaginaos que A tiene 7 00:13:46

y B 1, le asigno 00:13:48

lo que tiene A, el 7, vale, pues el 7 00:13:50

se queda ahí guardadito temporal 00:13:52

ahora mi variable A 00:13:53

ya la puedo pisar y asignar 00:13:56

lo que tenía B, se queda con el 1 00:13:58

y ahora ya 00:14:00

mi variable B 00:14:02

le asigno lo que tenía A 00:14:03

de antes, que lo he conservado aquí 00:14:06

para no perderlo 00:14:07

en la sobrescritura anterior 00:14:09

pues le asigno el 7, el 1 desaparece 00:14:11

entonces estas 3 00:14:14

sentencias de código consiguen como resultado final el intercambio y efectivamente aquí me ha 00:14:16

aparecido una variable que he necesitado usar como valor temporal es grave pues no es grave porque 00:14:22

qué le pasa a esta variable pues lo que explicamos ayer donde la he declarado yo esta variable la 00:14:29

he declarado dentro de este bloque un bloque es un código entre llaves la he declarado aquí luego 00:14:35

cuando este código termina de ejecutarse 00:14:41

que es aquí fuera 00:14:44

cuando ese bloque ha terminado 00:14:46

todas las variables declaradas 00:14:47

aquí dentro desaparecen 00:14:50

pues aux fuera 00:14:52

ya deja de molestar 00:14:53

tuvo 00:14:56

su función aquí dentro 00:14:57

pero una vez que ya cumplió 00:14:59

su función no la quiero para nada 00:15:02

pues la declaro aquí dentro 00:15:03

y cuando este bloque termina de ejecutarse 00:15:05

esta variable aux 00:15:08

ha desaparecido 00:15:10

A y B por supuesto no han desaparecido 00:15:10

porque A y B están declaradas aquí arriba 00:15:13

solo desaparecen 00:15:15

las que estén declaradas dentro 00:15:18

de este bloque 00:15:19

yo podía haber declarado aux fuera 00:15:20

también 00:15:25

pero entonces aux va a estar existiendo 00:15:25

ahí esa cajita toda la vida del programa 00:15:29

si yo aux 00:15:31

la hubiera declarado aquí fuera 00:15:33

int aux 00:15:35

y aquí me hubiera limitado a usarla 00:15:37

pues sí, el efecto del programa 00:15:39

es el mismo 00:15:41

es idéntico el efecto del programa 00:15:42

pero 00:15:44

a cambio 00:15:46

mi variable aux 00:15:48

con este 7 00:15:50

se queda ya para siempre 00:15:53

todo el programa ahí en memoria 00:15:56

esa variable 00:15:57

y que necesidad de tener una variable ahí en memoria 00:15:58

ocupando 4 bytes de memoria 00:16:01

que necesidad 00:16:03

si solamente la voy a usar 00:16:04

en este bloque, solo aquí 00:16:07

pues si solo la voy a usar en este bloque 00:16:08

la declaro local a este bloque 00:16:11

vale 00:16:14

la declaro local a este bloque 00:16:15

y mucho mejor 00:16:19

me garantizo que desaparece 00:16:21

se acabó este espacio 00:16:23

y se acabó todo cuando el bloque termina 00:16:25

y esto ya no es solo 00:16:28

por un tema de ahorrar memoria 00:16:31

porque 4 bytes de RAM que ocupa un int 00:16:33

4 bytes de RAM no van a ningún lado 00:16:35

esto sobre todo 00:16:37

es por 00:16:39

evitar posibles 00:16:40

errores derivados de que haya 00:16:43

demasiadas variables en un momento dado 00:16:45

si yo estoy en un punto del programa 00:16:47

en el que tengo mil variables 00:16:50

declaradas, de las cuales solo estoy 00:16:51

usando tres, pues hay 00:16:53

un montón de variables de las que yo no soy consciente 00:16:55

que están ahí declaradas porque las 00:16:58

usé en un momento dado, con sus nombres 00:16:59

y a lo mejor 00:17:02

las uso sin querer 00:17:03

creyendo que estoy haciendo otra cosa 00:17:05

y porque me confundo 00:17:07

escribiendo el nombre 00:17:09

entonces abono el terreno para errores 00:17:10

porque tengo un montón de variables 00:17:13

con sus nombres, ahí y a lo mejor 00:17:15

me confundo, pongo el nombre de otra 00:17:17

y estoy usando esa otra 00:17:19

entonces lo ideal es que en cada 00:17:21

punto del código solo existan 00:17:23

las variables que estoy usando 00:17:25

¿qué necesidad de que la variable 00:17:26

aux exista todo el programa? 00:17:29

¿para molestar hay una variable aux y que yo 00:17:31

escriba aux sin querer y la lié? 00:17:33

¿creyendo que 00:17:36

hago una cosa y no estoy haciendo otra? 00:17:37

pues a declararla localmente 00:17:39

luego todas las variables 00:17:41

se declaran lo más local que se pueda 00:17:44

en el bloque más interno en el que se van a usar 00:17:46

en el bloque más interno 00:17:48

y esto es importante 00:17:49

entender lo de las variables locales 00:17:52

y su ámbito, lo que vimos ayer 00:17:54

bueno pues entonces 00:17:56

gran parte del programa 00:18:00

está hecho 00:18:02

ya está hecho lo de 00:18:02

leer los valores de entrada 00:18:05

intercambiarlos 00:18:07

si A es mayor que B 00:18:08

y ahora ya 00:18:11

hacer la suma 00:18:13

¿vale? 00:18:15

entonces, antes de 00:18:17

bueno, nada 00:18:19

sí 00:18:21

venga, vamos a 00:18:22

a incorporar esto que hemos dicho 00:18:27

ignoremoslo 00:18:29

pero vamos ahora ya a incorporarlo 00:18:30

una pequeñita validación de datos 00:18:33

vamos a incorporar, oye tú 00:18:35

no le dejes al usuario 00:18:39

introducir valores negativos 00:18:41

para A o B, no le dejes 00:18:44

entonces, ¿qué significa no dejarle? 00:18:46

tú no puedes salir del ordenador 00:18:50

y agarrarle la mano para que no le dé 00:18:51

al menos, lógicamente 00:18:54

entonces, no dejarle 00:18:55

significa 00:18:58

meterle ahí en un bucle 00:18:59

del que no salga 00:19:01

hasta que no introduzca un valor positivo 00:19:03

es decir, eso es validar un dato 00:19:06

este 00:19:12

next in de aquí 00:19:14

que yo he hecho 00:19:16

él ahí puede meter 00:19:17

cualquier número entero que le den la gana 00:19:20

menos 12, 13, cualquiera 00:19:22

puede meter, y yo no tengo forma 00:19:24

de evitarlo, no voy a salir del ordenador 00:19:26

a agarrarle la mano 00:19:28

lo único que puedo hacer 00:19:29

es meter esto en un bucle 00:19:32

de tal forma que 00:19:34

mientras este número sea negativo 00:19:36

lo vuelva a pedir, y si es negativo 00:19:38

lo vuelva a pedir, y si es negativo 00:19:40

lo vuelva a pedir, es lo único que puede hacer 00:19:42

es mi única manera de obligarle 00:19:44

no dejarle salir de un bucle 00:19:46

de recogida de datos 00:19:48

hasta que el dato que me da 00:19:49

no cumpla exactamente lo que 00:19:51

yo necesito que cumpla 00:19:54

entonces 00:19:56

pues ya está, vamos a meter 00:19:58

esto en un bucle 00:20:00

y ahora 00:20:01

aquí que bucle pondríais, un while o un do while 00:20:03

¿Qué bucle pega ahí de las dos estructuras que tenemos? 00:20:08

While o do while. 00:20:14

¿Recordáis la diferencia entre while y do? 00:20:19

Pues según esa diferencia, teniendo en cuenta que yo ya he concluido que tengo que meter esto en un bucle, 00:20:22

para que esté todo el rato leyendo mientras sea negativo. 00:20:29

¿Lo meteríais en un bucle while o lo meteríais en un bucle do while? 00:20:32

Venga, que alguien diga algo. 00:20:39

cuando procedía 00:20:40

cuando se adaptaba más 00:20:50

poner un bucle do-while 00:20:52

¿Perdón? 00:20:53

¿Tenía que revisar algo primero? 00:21:00

Más o menos 00:21:06

o sea, cuando 00:21:07

la primera ejecución del código 00:21:08

tenía que hacerse sí o sí 00:21:11

cuando lo que había dentro del bucle 00:21:13

una primera vez 00:21:15

queríamos que se hiciera sí o sí 00:21:17

y ya las siguientes condicionadas 00:21:19

¿Vale? 00:21:21

Entonces, en este caso 00:21:23

¿Necesitamos que se haga una primera vez sí o sí? 00:21:25

Sí, porque es un bucle de lectura de datos. 00:21:30

Entonces, la primera hay que hacerla. 00:21:32

La primera hay que hacerla. 00:21:34

Y las siguientes se harán o no dependiendo de la condición que sea. 00:21:36

En este caso, si ya es negativo. 00:21:40

Con lo cual, aquí, lógicamente, pega mucho mejor un do while. 00:21:42

pega mejor un do while 00:21:48

donde la condición será 00:21:52

¿cuál? 00:21:54

¿qué condición pongo ahí? 00:21:56

bueno, ahora estoy solamente leyendo el a 00:22:05

luego el b lo hago por libre 00:22:06

¿a mayor que 0? 00:22:08

piensa que esta es la condición 00:22:19

que mientras se cumpla 00:22:21

vuelvo otra vez arriba 00:22:23

y vuelvo otra vez arriba 00:22:25

cuando deja de cumplirse es cuando salgo 00:22:26

¿qué condición tendría que poner ahí? 00:22:28

Mientras esa condición se cumpla, 00:22:38

tengo que volver a pedirlo. 00:22:41

Tengo que volver a pedirlo. 00:22:42

Pues, ¿qué condición pondría? 00:22:43

Mientras a A le pase algo, 00:22:55

tengo que volver a pedir. 00:22:58

¿El qué? 00:22:59

Claro. 00:23:04

Me han dicho que yo no permita negativos. 00:23:05

Lo que acabo de decir es, 00:23:09

mientras el usuario meta negativos, 00:23:11

se vuelve a pedir, y se vuelve a pedir, y se vuelve a pedir. 00:23:13

¿Vale? 00:23:16

Es mi única forma de asegurarme 00:23:16

que lo que introduce sea positivo 00:23:19

entonces 00:23:21

mientras a sea 00:23:23

menor que cero, ahí le tengo 00:23:25

¿vale? 00:23:27

me falta aquí la llave 00:23:32

vale, mientras a sea 00:23:33

negativo, otra vez arriba 00:23:38

y otra vez arriba, entonces la primera 00:23:40

vez es incondicional, me pide el primero 00:23:42

y ya las siguientes 00:23:44

las pide o no 00:23:46

en función de si ese es negativo o no 00:23:48

Luego este es un bucle que está validando el primer dato y ahí se queda atascado, pues lo mismo con el B, exactamente lo mismo con el B, porque el B tampoco puede ser negativo, pues esto igual y ya está, mientras B sea negativo vuelve a pedir B y vuelve a pedir B y vuelve a pedir B y así todo el rato. 00:23:50

entonces no salimos de este bucle 00:24:34

hasta que el dato introducido sea mayor o igual que cero 00:24:39

vale 00:24:44

ahora ya parece que está todo 00:24:53

leemos los datos 00:24:58

pero le tenemos al usuario metido en un bucle 00:24:59

metido en un bucle 00:25:03

mientras lo que introduzca no sea como queremos 00:25:04

mientras no cumpla nuestro patrón 00:25:07

cuando ya hemos salido de los dos bucles 00:25:09

a y b son mayores o iguales que 0 00:25:13

si a es mayor 00:25:15

que 20, cambiamos, vale 00:25:18

y ahora ya sí, pues hacemos 00:25:19

la suma 00:25:21

vale 00:25:23

entonces 00:25:28

esto ya en principio, pues nos tendría que 00:25:31

funcionar 00:25:34

introduzca la 00:25:35

que le pongo el menos 3, pues ahí se está 00:25:37

ahí se está, hasta que yo no 00:25:40

introduzca un número positivo 00:25:42

pues el 8 00:25:43

muy bien 00:25:45

Ah, vale, es que he hecho copia y pega 00:25:46

En el de abajo 00:25:51

Y no he puesto introduzca B 00:25:52

Vale, entonces 00:25:54

Parece que me está pidiendo A otra vez 00:25:56

Pero no 00:25:59

Vale, pues lo paro, introduzca B 00:25:59

Pues venga 00:26:02

Ahora ya sí 00:26:06

Lógicamente el menos 4 no 00:26:12

Pues venga, le doy el 9 00:26:14

Ahora ya me ha dejado el B 00:26:16

Si al B le diera menos 1, pues tampoco 00:26:18

Dame el b 00:26:21

El 1 00:26:22

Se los he dado cambiados, con lo cual él va a intercambiarlos 00:26:24

A por b y me va a sumar 00:26:27

Todos los múltiplos de 5 entre 1 y 9 00:26:29

Que solo hay 1, 5, con lo cual me tendrá que sacar 5 00:26:31

Vamos a ver 00:26:33

Efectivamente 00:26:35

La suma de todos los múltiplos de 5 00:26:36

Comprendidos entre 1 y 9 00:26:38

Es 5 00:26:41

Porque solo hay 1 00:26:43

Vale, pues ya está 00:26:46

Vamos a parar aquí un momentín 00:26:49

Vale 00:26:52

20261023 Bucles_ejerc1 - Contenido educativo

Del mismo autor…

Clase 05-04-24 - 2

Clase 05-04-24 - 1

Clase 02-04-24 - 2

Clase 02-04-24 - 1

Clase 19-03-24 - 2

Clase 19-03-24 - 1

Clase 18-03-24 - 2