Saltar navegación

20241024 ProgrEstruct-Bucles-ejercicios_9 - 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 24 de octubre de 2024 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues vamos a hacer este 14, que no es que sea difícil, es lo mismo, pero bueno, como vamos a tener que anidar bucles, perdón, sí, vamos a hacer el 14 por el tema de que es la primera vez que nos vamos a encontrar un bucle dentro de otro, no nos queda más remedio que hacerlo así. 00:00:00
entonces vamos a 00:00:15
a empezar esto 00:00:18
a ver 00:00:20
aquí 00:00:24
venga 00:00:28
14 hemos dicho 00:00:30
vale, pues a ver, 14 00:00:32
programa que lees 00:00:46
varias veces 00:00:50
es un numerito, bueno, ya eso es un bucle 00:00:52
seguro 00:00:54
¿vale? entonces 00:00:55
aunque siempre 00:00:58
hay que leer el ejercicio entero, entender en conjunto 00:01:00
qué tiene que hacer 00:01:02
etcétera, pero bueno 00:01:04
con esta primera línea nosotros ya sabemos 00:01:06
que este ejercicio va a ser un bucle 00:01:08
que lea un montón de veces un número 00:01:10
entonces vamos a 00:01:12
tenemos prisa, me van a quitar el examen de las manos 00:01:13
etcétera, pues venga, vamos allá 00:01:17
pues yo ya sé que esto 00:01:18
va a ser algo así 00:01:20
¿no? algo así 00:01:22
donde aquí tendré una variable 00:01:32
int n y aquí 00:01:34
el objeto para leer 00:01:38
por lo pronto hemos leído 00:01:40
la primera línea 00:01:50
que es 00:01:50
de sumar 00:01:52
esa es la conclusión a la que llegaremos 00:01:54
vale, entonces me dice 00:01:59
programa que lee un montón de veces un número n 00:02:02
Bueno, pues hasta ahí llegamos 00:02:04
Pues ya está, leer de forma repetida 00:02:06
Un número n, pues tengo mi variable n 00:02:07
Que voy todo el rato, una, otra, otra 00:02:10
Un bucle, que leo un montón de veces n 00:02:12
Pues un bucle 00:02:14
La condición, todavía no sabemos cuál es 00:02:14
Nos falta la condición 00:02:17
Tenemos que seguir leyendo el ejercicio 00:02:19
Porque nos falta, ¿qué hacemos con n? 00:02:21
Nos falta eso, ni idea 00:02:24
Nos falta eso, saber qué hacemos con ese n 00:02:25
Y nos falta 00:02:35
¿Y hasta cuándo la estoy leyendo? 00:02:37
Pues no sé, vamos a seguir leyendo 00:02:39
venga 00:02:40
a ver, ¿has venido ahí 00:02:42
a hacerlas, a alterarlas? 00:02:45
¿o qué? 00:02:47
hombre 00:02:50
que estaban muy tranquilas 00:02:50
antiguamente existía 00:02:53
la mili 00:02:59
no, es verdad, existía 00:03:00
la mili y en la mili 00:03:03
les daban bromuro a los chicos 00:03:05
¿eso no lo habéis oído nunca? 00:03:07
Pues les daban bromuro, el bromuro pues te deja que ya se te quitan las ganas de irte a la cama de tu compañero por la noche. 00:03:10
Pues eso, les vamos a dar bromuro, porque aquí tenemos una panda adolescente que no podemos gestionar. 00:03:23
Venga, a ver, ¿qué hacemos con N y hasta qué? Pues seguimos leyendo. 00:03:29
Dice, pues lo que vamos a hacer con N nos lo dice. 00:03:35
Para cada número leído 00:03:37
Ah, vale, aquí nos resuelve el misterio 00:03:39
Para cada número leído, ¿qué vamos a hacer? 00:03:41
Mostrar esta suma 00:03:43
Luego, anda 00:03:44
Pues ya sabemos lo que hay que hacer con n 00:03:46
Ya sabemos lo que hay que hacer con n 00:03:49
Para ese n 00:03:52
Hay que calcular 00:03:55
Y mostrar 00:04:01
1 más 2 00:04:03
más 00:04:11
así hasta n 00:04:12
eso para sn 00:04:14
ah vale, pero es que esto ya lo hemos hecho 00:04:17
esto ya sabemos hacerlo 00:04:19
eso teníamos que hacer una variable sumadora 00:04:20
un bucle que iba sumando los sumandos 00:04:23
pues todo eso 00:04:25
es un ladrillo de construcción que involucraba 00:04:26
un bucle que ya sabemos hacer 00:04:29
pues nada, lo calzamos ahí dentro 00:04:30
y me queda dentro del otro bucle 00:04:33
pero no pasa nada, es que es lo que 00:04:35
tengo que hacer dentro de ese bucle 00:04:37
¿vale? entonces yo 00:04:38
voy componiendo mi programa con las cosas 00:04:41
que tengo que hacer y dentro de bucles 00:04:43
pues habrá veces que necesite otro bucle, lo que sea 00:04:45
aquí en particular lo necesitaré 00:04:47
porque ahora 00:04:49
¿qué hacemos para calcular esta suma? 00:04:50
ya lo sabemos, ya lo tenemos 00:04:53
en la cabeza, lo hemos aprendido, lo hemos 00:04:55
estudiado, pues es una suma 00:04:57
acumulativa, ya lo sabemos, pues tendré que 00:04:59
hacerme una variable que empiece 00:05:01
variando cero, vale 00:05:02
para cada 00:05:04
Vale, como estoy en un bucle 00:05:07
No puedo estar 00:05:13
Bueno, sí, puedo declararlo aquí dentro 00:05:13
Porque fuera no lo voy a usar para nada 00:05:17
Porque aquí dentro ya muestro, calculo y muestro 00:05:18
Pues como hacemos 00:05:20
Pues ya hemos dicho, pues hacíamos esto 00:05:22
Esta versión la hicimos de muchas maneras 00:05:24
Pues podríamos hacerlo así 00:05:26
Vamos a hacerla con un for 00:05:27
Por ejemplo 00:05:31
Para practicar 00:05:31
Esta 00:05:33
Venga, no, vamos a 00:05:35
¿Cómo hacíamos este? 00:05:38
Tenéis que tener capacidad de reacción 00:05:42
Venga 00:05:44
¿Cómo hacíamos esto? Pues lo habíamos hecho de muchas maneras 00:05:45
Mientras n sea 00:05:48
Mayor o igual que 1 00:05:49
Y vamos decrementando el propio n 00:05:51
Y ya está 00:05:53
Suma más igual n 00:05:54
Por ejemplo 00:05:57
Y a n lo dejamos decrementado 00:05:59
Pues mira, esto 00:06:01
Esto ya todos lo entendemos 00:06:03
Es una suma acumulativa 00:06:06
Donde a suma que le vamos sumando 00:06:07
No me hace falta una variable adicional 00:06:09
El propio n 00:06:11
Primero sumo n 00:06:12
Y lo dejo decrementado 00:06:15
Que he llegado ya a ser 1 00:06:17
Mayor o igual que 0 00:06:20
Porque si no 00:06:23
El 1 no me lo sumaría 00:06:25
No, no, no, si perdón 00:06:26
Que estoy tonta 00:06:28
Entonces 00:06:28
Entro la siguiente vez 00:06:31
Incorporo el siguiente sumando 00:06:33
Que es una unidad menos de la anterior 00:06:35
Lo incorporo 00:06:36
Ya es 1 00:06:37
Pues ya no hago más sumas 00:06:39
Esta es una suma acumulativa 00:06:42
En la que ya no lo he hecho ahí 00:06:44
En plan robótico 00:06:45
Poniendo una variable adicional x 00:06:47
Sumándole aquí el x 00:06:49
Haciendo que x cada vez sea 00:06:50
El valor que toque 00:06:53
Que es n-1 00:06:55
Es esto mismo 00:06:56
¿Vale? Todo el mundo entiende este programa 00:06:58
No puede ser, que no lo entiendas 00:07:01
A ver, claro 00:07:05
Esto es post, para empezar 00:07:07
Esto es post decremento, con lo cual este menos menos 00:07:09
Se va a hacer después de haber 00:07:11
Sumado n a suma, ¿verdad? 00:07:13
Porque es post decremento, luego olvídate 00:07:15
De él, vale, entonces ¿qué hacemos? 00:07:17
A suma, a lo que tenga suma 00:07:20
Que inicialmente es 0 00:07:21
Le sumas el valor n 00:07:23
Vale, muy bien 00:07:25
Y ahora ya coges n y lo decrementas 00:07:26
Vale, y vuelves a entrar 00:07:29
Es decir, que me da igual 00:07:30
Ponerlo aquí 00:07:32
Que ponerlo aquí 00:07:34
Es lo mismo 00:07:36
Hombre, salvo que si lo pongo ahí 00:07:38
Tengo que poner unas llaves en el while, obviamente 00:07:40
¿A qué quieres hacer una cosa tan extraña? 00:07:42
No, o sea, suma es la 00:07:51
¿Qué necesidad tienes de hacer algo que no tiene nada que ver con esto? 00:07:52
Suma es la variable 00:07:55
Que incorpora los sumandos 00:07:57
Y n son los sumandos 00:07:58
¿Vale? 00:07:59
Entonces 00:08:01
Vale 00:08:02
Podríamos hacerlo así, pero como ya 00:08:04
Vamos cogiendo un poco más de soltura 00:08:07
Pues tampoco hace falta que lo vayamos haciendo todo 00:08:09
Tan, tan, tan, tan mascado 00:08:11
Me da igual hacer primero la suma y luego 00:08:12
Decrementar n 00:08:15
Que decirle, oye, post decrementum 00:08:16
Coge n 00:08:20
Opera con él para hacer lo que toque 00:08:21
Y ahora ya decrementalo 00:08:24
Me da igual, vale 00:08:25
Ventajilla 00:08:27
Si lo hago así, que como solo hay una insentencia 00:08:30
Dentro del while 00:08:33
Pues podríamos quitar la llave, podríamos 00:08:33
¿Vale? 00:08:36
Bueno, pues entonces 00:08:38
Cuando esto ya ha terminado 00:08:39
Ya tenemos en suma 00:08:43
Todo esto, 1 más 2 más n 00:08:45
Pues lo mostramos 00:08:46
La suma es 00:08:48
Y ponemos aquí suma 00:08:53
Vale 00:08:55
entonces ya tenemos un bucle 00:08:57
ya tenemos un bucle 00:08:59
que está todo el rato 00:09:02
lee número 00:09:05
para ese número hace la suma 00:09:07
para lo cual he tenido que usar otro bucle 00:09:09
pero da igual, pues uso lo que haga falta 00:09:11
y una vez que he calculado la suma 00:09:13
la muestro, siguiente iteración 00:09:15
leme otro número 00:09:17
calculame la suma, para lo cual 00:09:19
he tenido que usar otro bucle, pues da igual 00:09:21
y muéstramela, vale, solamente 00:09:23
me falta, y que me estoy así hasta el 00:09:25
infinito, pues no 00:09:27
tendremos que nos dice, no, espérate 00:09:29
cada vez que lo hagas 00:09:31
pregúntale si quiere continuar o no 00:09:32
vale 00:09:35
bueno, pues entonces 00:09:37
esta condición va a depender 00:09:39
de un carácter sí o no que te doy yo 00:09:41
que pedir por teclado, va a depender 00:09:43
pues entonces vamos a decirle aquí 00:09:45
la pregunta 00:09:47
desea continuar 00:09:48
y le decimos pues que nos 00:09:54
ponga S o N 00:10:00
ahora, aquí 00:10:01
leemos 00:10:08
esa opción, esa respuesta 00:10:10
ese lo que sea 00:10:12
que la podemos leer 00:10:13
con next line 00:10:16
perdón, perdón 00:10:18
perdón, que es que sois muy rápidos 00:10:24
a ver 00:10:26
y nos quedamos 00:10:27
con el characero 00:10:30
vale, y por si lo ha 00:10:32
metido en mayúsculas 00:10:34
le vamos a poner ya que como lo hicimos otras veces 00:10:36
pues que lo 00:10:39
bueno, perdón 00:10:39
como es un método de string 00:10:43
le vamos a poner 00:10:47
que lo pase a minúsculas 00:10:48
por si acaso lo ha metido en mayúsculas 00:10:50
que lo pase a minúsculas y ahora ya sí 00:10:53
nos quedamos con el carácter en la posición 0 00:10:54
vale, bueno 00:10:56
toda esta línea que he puesto aquí está clara 00:10:58
he leído una cadena 00:11:00
la he pasado a minúscula por si él ha metido la S 00:11:01
o la N mayúscula 00:11:04
y me he quedado con el primer carácter 00:11:05
Entonces, aquí tendré, si él lo ha hecho bien, una S o una N. 00:11:07
Y ahora esta condición sería, mientras la opción sea diferente, 00:11:11
y esto sí que no es igual, porque esto es un char, es un tipo primitivo, 00:11:18
sea diferente del carácter N, que es el carácter de no quiero seguir. 00:11:22
Mientras sea diferente de N, sigue. 00:11:28
No, mientras sea S. 00:11:31
O mientras sea S, vale. 00:11:32
Sí, mientras sea S. 00:11:35
Sí, lo que os guste más 00:11:36
Vale 00:11:38
Entonces, ahora ya 00:11:40
Esta es la estructura, vale, pues leo 00:11:43
Número, calculo la suma y le pregunto 00:11:44
Leo número, calculo la suma y le pregunto 00:11:46
Pero claro, el compilador nos dice, oye 00:11:48
Yo no puedo evaluar op, no conozco 00:11:50
Op no es visible para mí, no la conozco 00:11:52
Ah, claro, es que la he declarado dentro, ah no, pues entonces 00:11:54
No la puedo usar fuera 00:11:56
Luego la tengo que declarar 00:11:57
Aquí 00:12:00
Vale, ahora ya sí es visible 00:12:01
Para él, pero lo mismo 00:12:05
Me vuelve a decir lo mismo 00:12:06
Oye, pero la primera vez que entro 00:12:07
No tiene ningún valor 00:12:09
Entonces pensamos 00:12:12
¿Qué queremos? ¿Que entre una primera vez sí o sí? 00:12:14
Sí, pues venga, le vamos a poner 00:12:16
Como un primer valor 00:12:18
Ese, ya está 00:12:19
Entonces la primera vez entra 00:12:20
Me pide el número, me hace la suma 00:12:23
Y me dice 00:12:26
¿Desea continuar? 00:12:27
Y ya las siguientes va a depender de si yo le pongo sí o no 00:12:28
¿Vale? 00:12:31
Entonces los programas como veis son 00:12:34
Un mosaico de pequeñas cosas 00:12:36
Que vamos resolviendo 00:12:38
Ladrillos, pequeños agujeros negros 00:12:39
Venga, Leo, ahora tengo que resolver la suma 00:12:42
Pues en este agujero negro resuelvo la suma 00:12:45
Ahora tengo que resolverlo de la condición 00:12:47
Pues lo resuelvo 00:12:49
Es hacer una combinación 00:12:50
De cosas 00:12:52
Que ya sabemos hacer, que vamos resolviendo 00:12:54
Un poco por separado hasta combinar 00:12:56
Nuestro programa entero 00:12:58
Vale, entonces 00:13:00
Ejecutamos esto 00:13:11
La primera cadena 00:13:15
Me la dices, perdón, el primer número 00:13:18
Me lo dices sí o sí, seis 00:13:20
Ah, vale 00:13:22
¿Cómo no me habéis avisado? 00:13:23
Según lo escrito tenéis que haberme dicho 00:13:26
Ojo, que tienes un next line 00:13:28
Y cuando vuelvas arriba 00:13:30
Tienes un next in 00:13:32
Ah, acabáramos 00:13:34
Tú lo habías visto, pero no te has atrevido a decirlo 00:13:36
¿No? 00:13:38
Sí 00:13:40
Ah, claro 00:13:40
Tú lo habías visto y has dicho 00:13:43
Total, como no me va a escuchar porque soy invisible 00:13:44
¿Para qué se lo voy a decir? 00:13:46
Pues, te habría escuchado 00:13:48
Entonces 00:13:51
Ah, perdón, perdón, perdón 00:13:58
Sí, perdón, perdón 00:14:00
Después del número y antes de 00:14:01
O sea, la combinación peligrosa 00:14:04
Es leer número y luego cadena 00:14:07
Entonces, entre la lectura del número 00:14:09
Y la de cadena 00:14:10
Es donde lo tengo que hacer 00:14:11
¿Vale? Entonces como tengo leer número 00:14:13
Y luego cadena 00:14:20
Pues este salto de línea lo tengo que eliminar 00:14:21
Para que este next line 00:14:25
Porque el problema ha llegado antes 00:14:27
El problema ha llegado aquí 00:14:30
El problema llega cuando has leído un número 00:14:32
Y antes de leer esto 00:14:34
El problema ha llegado ahí 00:14:37
Cuando lees un número 00:14:39
El salto de línea no se ha procesado 00:14:41
Está ahí 00:14:43
cuando hagas luego un next line 00:14:44
va a coger ese salto de línea, cadena vacía 00:14:46
cuando yo haga el to lower case va a decir 00:14:48
string around this, o sea null pointer 00:14:49
exception, entonces el problema está 00:14:52
antes del next line, tengo que 00:14:53
quitar el 00:14:56
venga, pues ahora ya 00:14:56
ahora ya numerito 00:14:59
la suma es 28, deseamos 00:15:04
continuar, sí, numerito 00:15:06
la suma es 6 00:15:08
sí, numerito 00:15:09
la suma es 10, no 00:15:13
adiós, se acabó 00:15:14
hombre, siempre es buena idea 00:15:17
para saber que hemos salido 00:15:22
pues si ponemos fuera del while un mensajito 00:15:24
pues sabemos que hemos terminado 00:15:29
es más clara 00:15:30
la ejecución 00:15:33
cuando el bucle termine, porque ya le hemos dicho que no 00:15:33
cuando termine, pues por lo menos 00:15:37
muestra un mensaje, no se queda así callado 00:15:39
que muy feo eso 00:15:41
vale, pues esto es un ejemplo de que 00:15:43
tenéis que poneros en ese chip 00:15:49
un programa son 00:15:51
diferentes cosas que hay que resolver 00:15:53
de forma 00:15:55
independiente, soy de independiente 00:15:57
aquí hemos resuelto 00:16:00
la suma por un lado 00:16:01
que es una tarea independiente que sabemos resolver 00:16:03
el tema de la condición por otro 00:16:05
vamos resolviendo los temas 00:16:08
hasta ir tapando todos los agujeros 00:16:09
y tener el programa ya construido 00:16:12
¿vale? 00:16:14
Pues lo habrás hecho mal 00:16:16
No hay otra 00:16:23
¿Qué hay mal? 00:16:24
No toques nada 00:16:31
Déjalo 00:16:34
Mano sobre el teclado 00:16:35
Lo vas a subir aquí 00:16:36
Tus compañeros te lo van a decir en 3 segundos 00:16:38
Vamos a 00:16:40
O 4, no sé 00:16:42
Espérate 00:16:44
Espera un segundo, y no toques nada 00:16:46
No toques nada 00:16:49
Quieto, parado 00:16:51
No lo toques, aunque te hayas dado cuenta 00:16:52
Déjalo 00:16:55
Ahí, quieto 00:16:56
Venga 00:17:01
Que les vamos a hacer una prueba técnica a tus compañeros 00:17:10
A ver lo rápido que se dan cuenta del error 00:17:13
Espera, espera, no toques nada 00:17:15
Y tú no le digas nada, Pablo 00:17:19
Bueno, y dile a Pablo 00:17:20
Pablo 00:17:23
No le digo nada, solo quiero ver 00:17:24
Ni pongas cara de 00:17:26
Tampoco 00:17:27
No hagáis trampas 00:17:29
A ver 00:17:33
Venga, súbemelo aquí 00:17:33
A la zona esta 00:17:41
Súbemelo aquí 00:17:42
Sube tal cual el punto Java 00:17:43
No subas nada más 00:17:47
Sube tal cual el .java ese y ya está. 00:17:48
Ya está. 00:18:11
Vale, ya está. 00:18:18
Vamos a ver. 00:18:19
Vamos a ver 00:18:25
Pedro 00:18:27
¿Dónde estás? 00:18:29
Vale, a ver 00:18:39
Y ni eclipse ni nada 00:18:40
Esto es una prueba técnica de verdad 00:18:42
Lo voy a abrir en el blog de notas 00:18:43
Para que no 00:18:45
Para que no tengáis 00:18:48
Ayudas de, vamos a ver 00:18:50
Esto no te funciona, ese es tu problema 00:18:52
El problema es que no funciona 00:18:54
O es que te da un error de compilación 00:18:56
Yo le pongo un número 00:18:59
O sea que no te funciona 00:19:01
Vale, vale 00:19:03
No, si yo quería saber 00:19:03
Si era un error de ejecución 00:19:04
O de compilación 00:19:05
Es de ejecución 00:19:05
Vale 00:19:06
¿Ya lo has visto? 00:19:07
Vamos a ver 00:19:13
¿Qué tiene? 00:19:14
Numerito 00:19:15
Leemos el número 00:19:16
Ya está 00:19:17
Muy bien 00:19:23
Contratada 00:19:25
Vale, ya está 00:19:30
Muy bien, hay que ser muy rápida 00:19:31
Di que sí 00:19:38
Bueno, siempre está bien 00:19:38
Bueno, en la mayoría 00:19:41
De las cosas 00:19:44
Vale 00:19:45
Te sigue no sé qué 00:19:49
A ver, que te sigue funcionando mal 00:19:55
Vamos a ver si hay más errores 00:19:57
Venga 00:19:59
¿Te sigue sin funcionar? 00:20:01
No pasa nada 00:20:04
Te lo arreglamos 00:20:06
A ver, esto ya 00:20:07
Lo has cambiado y has puesto suma 00:20:08
Vale 00:20:12
Y te sigue sin 00:20:13
Funcionar 00:20:16
Vamos a ver 00:20:18
Tienes 00:20:18
N, dame tu número 00:20:21
Vaya orden 00:20:34
Sí, este contador no sabemos para qué está 00:20:35
Pero bueno, existe 00:20:38
Venga, lo quitamos 00:20:39
Y no te funciona correctamente 00:20:41
Vale 00:20:44
No, no, no, no le funciona correctamente 00:20:45
Ni a 00:20:52
Y ya 00:20:54
Vamos, yo sé por qué, pero quiero que me lo digáis alguno 00:20:56
Sí, sí, sí 00:20:58
A ver, este programa 00:21:00
no es igual que el mío, pero no 00:21:02
os fijéis en el mío, no, no, no, no os fijéis 00:21:04
mirad este solo 00:21:06
y porque lo que no quiero es que digáis 00:21:07
ah, este no es igual, pues era aquí, no, no porque 00:21:10
desarrolla más 00:21:12
¿y eso qué implicaciones 00:21:17
tiene? 00:21:28
¿que suma siempre va a ser cero? 00:21:31
no, hombre, suma se va sumando 00:21:33
aquí 00:21:34
suma va a entrar como cero 00:21:35
estupendo. Es como queremos, gente. Es una suma 00:21:38
acumulativa. 00:21:40
Pero no te está funcionando. 00:21:42
Algo tiene que estar fallando. 00:21:44
No, no, no, no. 00:21:46
No, hombre. 00:21:49
Es que este tiene que estar fuera del wild 00:21:50
porque la suma ha terminado aquí. 00:21:52
No, no le falta ninguna llave. 00:21:55
A ver, os doy una pista. 00:22:02
No, no, no, no, no, no. 00:22:05
A ver, os doy una pista 00:22:05
Este bucle 00:22:10
Hace la suma 00:22:12
De entre 1 y n 00:22:15
Varias veces, primero la hace 00:22:16
Para el primer número que metes 00:22:18
Luego la hace para el siguiente 00:22:19
O sea, hace eso varias veces 00:22:21
Esa es una pista que os doy 00:22:24
No, no, no 00:22:26
Ay, vaya gilipollas 00:22:28
Dile 00:22:32
A ver, el bucle sí se está repitiendo 00:22:32
pero ha puesto el dame el número 00:22:37
fuera del bucle, entonces eso no se repite 00:22:39
No, no, no, no, no, da igual, da igual 00:22:41
A ver 00:22:43
A ver, oye, pero que hace muy bien 00:22:45
diciendo cosas 00:22:48
A ver 00:22:49
A ver, dame el número, se lo dice solo una vez 00:22:51
Pero bueno, da igual, el número se lo está pidiendo 00:22:55
O sea, lo que importa es que el netline 00:22:57
esté dentro, eso es lo importante 00:22:59
A ver, os doy una pista 00:23:00
A que la primera suma te la está haciendo bien 00:23:03
Pero la siguiente es mal 00:23:05
La segunda, la cuarta y la tercera se hace bien 00:23:06
Pues claro, siguiente pista 00:23:09
Este programa 00:23:11
La primera suma te la hace siempre bien 00:23:12
La segunda, tercera y cuarta 00:23:15
Eso sí 00:23:18
Efectivamente 00:23:21
Claro, o sea 00:23:22
Esto es la suma acumulativa 00:23:24
Y la suma acumulativa 00:23:26
Tiene que empezar siempre a cero 00:23:27
Es decir, esta suma 00:23:29
es válida para el primero que metes 00:23:35
pero el siguiente que metes 00:23:37
inicias una suma de nuevas 00:23:39
estás reiniciando la suma otra vez 00:23:40
lo estáis reiniciando 00:23:42
entonces te falta 00:23:44
volver a reiniciar la suma cero 00:23:47
para las siguientes veces 00:23:49
el problema que tenía 00:23:50
es que pensaba que al meterle 00:23:53
la S no le volvía a hacer 00:23:56
bueno, pero el bucle 00:23:58
se le volvía a hacer 00:24:00
claro, pero el número 00:24:01
sí que lo estaba esperando 00:24:04
claro, pero es tontito 00:24:05
tontito no es 00:24:08
vale 00:24:09
a ver, si está bien que esté 00:24:11
inicializada aquí fuera, pero es que 00:24:16
solo vale para la primera vez que entras 00:24:18
una vez que has hecho la primera suma 00:24:20
por ejemplo, tú metes un 3 00:24:22
él te hace 1 más 2 más 3 00:24:23
y suma se queda valiendo 3 00:24:25
ahora vuelves arriba 00:24:27
metes el 7, pero como suma ya se ha quedado 00:24:29
valiendo 3 00:24:32
ahora te haría el 3 de antes 00:24:32
más 1 más 2 más 3 hasta 7 00:24:35
no, es que cada suma es independiente de la anterior 00:24:37
cada suma es independiente 00:24:39
entonces tú tienes que cada suma que haces 00:24:40
que se hace aquí, volverla a iniciar en 0 00:24:43
volverla a iniciar en 0 00:24:45
¿vale? 00:24:47
Entonces, esto es un buen ejemplo para ver 00:24:50
que tenéis que ver la programación 00:24:53
como ladrillos independientes. 00:24:55
Una suma acumulativa es todo esto. 00:24:57
Incluye inicializar a cero. 00:25:00
Incluye esto, inicializar a cero. 00:25:01
Entonces, si tú quieres hacer aquí una suma acumulativa, 00:25:03
pues tienes que poner todo el pack. 00:25:06
Inicializo a cero y hago la suma. 00:25:07
Siguiente vez que me toca hacer una suma acumulativa, 00:25:10
inicializo a cero, 00:25:13
porque si no voy a arrastrar la suma anterior y no quiero. 00:25:14
Inicializo a cero y hago la suma. 00:25:17
Entonces todo este pack al completo tiene que ir ahí, inicializar a cero y hacer la suma. Yo es que en el mío lo había puesto dentro directamente. Dentro la declaraba y la iniciaba cada vez. Entonces él lo había sacado fuera. Entonces pues arrastraba ese problema. 00:25:18
Claro, acabo de poner yo esto 00:25:41
Es lo que le faltaba 00:25:46
¿Vale? Es lo que le faltaba 00:25:47
Entonces cuando él no lo tenía 00:25:49
La primera vez que entraba muy bien 00:25:51
Porque suma venía cero desde arriba 00:25:53
Pero para los siguientes números 00:25:55
Suma tenía un valor de antes 00:25:57
Entonces se acumulaba sobre ese 00:25:59
¿Vale? 00:26:01
Entonces esto ya sí está bien 00:26:03
¿Vale? 00:26:05
vale, pues muy bien 00:26:11
vale, 16, 17 y 18 00:26:13
son la misma idea 00:26:28
ver si algo pasa o no pasa 00:26:30
esto sería 00:26:33
como otra estructura 00:26:35
como otro algoritmo 00:26:37
vale, como otro algoritmo 00:26:38
si veis ya 00:26:40
tenemos varios algoritmos en la cabeza 00:26:41
que ya sabemos aplicar 00:26:44
siempre que nos hagan falta 00:26:46
tenemos 00:26:47
las sumas y multiplicaciones acumulativas 00:26:49
cuando identificamos 00:26:52
que algo es la suma de muchos sumandos 00:26:54
o algo es la multiplicación de muchos 00:26:56
factores, ya sabemos 00:26:58
cómo plasmar eso, ya tenemos el algoritmo en la cabeza 00:27:00
lo tenemos entendido y sabemos plasmarlo 00:27:02
también sabemos contar 00:27:04
cuando identificamos que tengo 00:27:06
que contar cuantas veces pasa algo 00:27:08
también tenemos ese algoritmo 00:27:10
ya en nuestra cabeza elaborado 00:27:12
y sabemos plasmarlo, pues un contador que empieza abriendo 00:27:14
cero y yo cuento lo que pasa. 00:27:16
También sabemos hacer máximos 00:27:18
y mínimos. Cuando identificamos 00:27:20
en un programa que tengo que hacer el máximo 00:27:22
de algo o el mínimo de algo, ya ese algoritmo 00:27:24
lo hemos visto y ahora yo ya lo 00:27:26
plasmo. ¿Vale? 00:27:28
Cuarta idea. 00:27:30
La que me dicen esos tres ejercicios. 00:27:32
Estos tres ejercicios 00:27:35
no son ni contar, ni sumar, 00:27:36
ni nada. Son 00:27:38
dime si algo ocurre o si algo 00:27:39
no ocurre. Es otra idea. 00:27:42
más sencilla que las anteriores 00:27:44
es otra idea 00:27:46
pero importante que la plasmemos en un algoritmo 00:27:46
porque a veces 00:27:50
metéis la pata 00:27:50
entonces los tres son más o menos igual 00:27:53
vamos a hacer el 17, el del medio 00:27:55
vale, vamos a hacer el 17 00:27:57
venga, pues el ejercicio 17 00:28:04
dice 00:28:18
pedir 5 calificaciones 00:28:18
no da más detalles 00:28:21
habría que decirle al que nos ha puesto el ejercicio 00:28:23
Pero son en string, aprobado, notable, sobresaliente 00:28:25
Son en número 00:28:29
Vamos a decirle el número que es más fácil 00:28:30
De 1 a 10 00:28:33
Vale 00:28:33
Entonces 00:28:34
La primera parte, pedir 5 calificaciones 00:28:36
Ya vemos que es un bucle 00:28:40
Y encima sabemos que es un bucle que se ejecuta exactamente 5 veces 00:28:41
Pues hacemos un for 00:28:45
Es un bucle que se ejecuta 5 00:28:46
Pues ya podemos hacer esa primera parte 00:28:48
Y ya está, vamos a coger el escáner 00:28:50
y ahora un bucle que se hace 00:28:51
cinco veces y exactamente cinco 00:29:01
ya lo planto tal cual, ni pienso 00:29:03
ni lo pienso 00:29:06
este es un bucle que se hace exactamente cinco veces 00:29:10
no tengo nada que pensar, lo tengo ya grabado en mi cabeza 00:29:12
¿qué hacemos cinco veces? 00:29:14
pedir una nota, leemos la nota 00:29:18
yo por ahora las variables 00:29:29
las declaro como veis todo lo local 00:29:37
que puedo, si luego necesito 00:29:39
sacarlas fuera por lo que sea 00:29:41
pues ya las iré sacando fuera 00:29:43
vale, pues ya está, tengo un bucle que 5 00:29:44
notas me piden 00:29:57
vale, y ahora que tengo que hacer yo 00:29:58
con estas notas, no tengo ni que sumar 00:30:01
ni que hacer la media, ni que ver 00:30:03
el máximo de todas ellas, nada de lo que 00:30:05
he aprendido a hacer 00:30:07
me dicen, no, lo que me tienes que decir es 00:30:09
sí, alguna es 00:30:11
un suspenso, es decir 00:30:14
Este es un ejercicio, una aplicación en la que identifico que lo que tengo que hacer es ver si algo ocurre o no ocurre. 00:30:16
Ver si algo pasa o no pasa. 00:30:23
Entonces, esto normalmente se da en una situación en la que tú tienes un montón de valores y tienes que ver si al menos uno cumple algo. 00:30:26
Entonces, ¿cómo operamos así? 00:30:36
Pues hacemos un boolean, que de partida ese boolean es no ocurre. 00:30:38
Y empezamos a recorrer. 00:30:43
en cuanto encontremos uno que me hace cambiar de idea 00:30:44
porque cumple la propiedad, cambio el boolean a true 00:30:48
y ya está, y se acabó 00:30:51
entonces siempre es eso mismo 00:30:53
bueno, pues entonces, en este caso sería 00:30:55
el objetivo de mi programa es ver si algo pasa o no 00:30:57
en este caso es algún suspenso 00:31:00
pues me hago yo la condición 00:31:02
entonces, de partida voy a asumir que no hay ninguno 00:31:04
de partida, falso 00:31:11
y ahora ya me pongo a mirar 00:31:12
a ver si hay alguno que sea contraejemplo 00:31:15
de eso, si hay alguno 00:31:17
que me haga cambiar de idea 00:31:19
yo de partida asumo que ninguno 00:31:20
y ahora voy a ver si hay alguno que me haga cambiar de idea 00:31:22
pues lo tendré que ver en el bucle según me van llegando 00:31:25
no, no, no, este es 00:31:27
el resultado, el resultado es 00:31:33
algún suspenso, no, el resultado 00:31:35
ahora yo ya me pongo a recorrer 00:31:37
los valores y mi idea es 00:31:39
ver si alguno de ellos me hace 00:31:41
cambiar de idea, en este caso 00:31:43
cuando me hará cambiar de idea alguno de ellos 00:31:45
pues si alguna nota 00:31:47
es mayor o igual que 5 00:31:48
esta nota que he leído es mayor o igual que 5 00:31:51
perdón, perdón, perdón 00:31:54
porque estoy con suspenso, es menor 00:31:57
pues entonces 00:31:59
como he encontrado una que es menor que 5 00:32:01
ya automáticamente 00:32:04
cambio de idea 00:32:05
algún suspenso ha pasado a valer true 00:32:07
y se acabó el algoritmo 00:32:09
no tengo más que hacer 00:32:11
yo de partida asumo 00:32:12
que 00:32:16
esa condición no se da 00:32:18
y ahora empiezo a recorrer 00:32:20
que encuentro algún contraejemplo 00:32:22
alguno que me haga cambiar de idea 00:32:24
porque ahí sí que se da 00:32:27
lo cambio a true y se acabó 00:32:28
¿vale? entonces esta es la manera de plantear 00:32:30
una aplicación en la que tengo que ver 00:32:33
si algo ocurre o no 00:32:34
y ese si algo ocurre o no 00:32:35
normalmente se aplica que yo tengo un montón de valores 00:32:37
y tengo que ver si alguno 00:32:40
me hace cambiar de idea 00:32:42
vale, pues esto está clarísimo 00:32:43
Pues por alguna razón 00:32:46
Generalizando de nuevo 00:32:47
Os empeñáis en 00:32:50
Hacer esto 00:32:52
Lo cual no tiene ningún sentido 00:32:54
Y ha destrozado el programa 00:33:00
Completamente 00:33:03
El añadir esto 00:33:03
Esto ya deja de perder sentido 00:33:05
Claro 00:33:07
Entonces esto funciona 00:33:10
Uno tiene 00:33:12
Pues aquí 00:33:14
Esta nota 00:33:15
Esta nota, esta nota, esta nota 00:33:19
De partida asumimos que todas son aprobadas 00:33:20
Luego algún suspenso, falsa 00:33:24
Algún suspenso, falsa, vamos una por una 00:33:25
¿Esta es suspensa? 00:33:27
No, pues no pasa nada 00:33:29
¿Esta es suspensa? 00:33:31
No, no, no 00:33:33
No sé ya si es suspenso o aprobado 00:33:34
La condición 00:33:37
Si hay algún suspenso, ¿no? 00:33:40
De partida asumo que no hay ninguno 00:33:43
Vale, luego es 00:33:44
no, es que estoy sumiendo que 00:33:47
falso. Vale, sí. O sea, que 00:33:49
no hay ningún suspenso. Vale, que no hay ningún. 00:33:51
Voy uno por uno. 00:33:53
Este. 00:33:55
¿Este es suspenso? No. 00:33:57
Pues no me cambia nada. 00:34:00
Por ahora, mi 00:34:02
verdad universal sigue siendo algún suspenso 00:34:03
falso. Siguiente. 00:34:05
¿Este está suspenso? Sí. 00:34:08
Pues ya he encontrado uno, al menos. 00:34:10
Uno. Pues entonces algún suspenso ya 00:34:11
pasa truco. La cambio. 00:34:13
vale, ahora voy a este 00:34:14
ya da igual 00:34:17
pero claro, el problema 00:34:19
es que 00:34:20
seguimos, ahora, este está suspenso 00:34:21
sale que no 00:34:25
que este no está suspenso 00:34:27
entonces, si tenemos 00:34:28
aquí un if else 00:34:31
volveríamos 00:34:32
a cambiarlo, si habéis añadido este 00:34:35
else, volveríais 00:34:37
a cambiar esta false, no hay que cambiarlo 00:34:39
es que ya encontramos uno 00:34:41
antes, luego el true no hay que cambiarlo 00:34:43
desde el momento que hemos encontrado uno 00:34:45
ya se queda true, porque ya hemos encontrado 00:34:46
uno, y ya se queda true para siempre 00:34:49
que el siguiente es aprobado 00:34:51
vale, el siguiente es aprobado, pero eso 00:34:53
no significa que ya hubo un suspenso 00:34:55
antes, con lo cual este 00:34:57
si yo lo pongo 00:34:58
automáticamente estaría ignorando 00:35:00
el true del caso 00:35:03
anterior, entonces esto 00:35:05
jamás, claro 00:35:07
que lo hacéis ahí 00:35:08
continuamente 00:35:11
vale, pues quedaos entonces con esa idea 00:35:13
tengo que ver si algo ocurre o no ocurre 00:35:20
y para eso tengo un rango de valores 00:35:22
en los cuales tengo que ir recorriendo 00:35:24
para ver si alguno 00:35:27
me permite ver que eso ocurre 00:35:28
al menos una vez 00:35:30
de partida asumo que no, falso 00:35:31
de partida asumo que no 00:35:33
y me pongo a recorrerlos 00:35:34
que uno me hace cambiar de opinión 00:35:36
cambio de opinión 00:35:38
y ya está 00:35:39
Y luego ya 00:35:41
Sigo mirando los demás 00:35:44
Aquí ya no haría falta seguir mirando los demás 00:35:45
No haría falta seguir mirando los demás 00:35:48
Entonces, aquí una vez que ya hemos 00:35:49
Encontrado alguno que lo cumple 00:35:52
Nos gustaría salir del bucle, ¿verdad? 00:35:53
Nos gustaría, porque ya para qué mirar los demás 00:35:56
Pero aún hace falta 00:35:58
No hace falta, pero claro 00:35:59
Porque tengo cinco 00:36:01
Imaginaos que tengo estos 00:36:02
Entonces, he encontrado el primero 00:36:04
Suspenso, ya lo he cambiado a true 00:36:07
Ya lo he cambiado a true 00:36:09
Entonces voy a estar 00:36:12
499.000 iteraciones 00:36:13
Que ya no las necesito para nada 00:36:16
Porque ya encontré uno, lo puse a true 00:36:17
Y ya me da igual 00:36:19
Entonces 00:36:20
Cosa fea y mala 00:36:22
El famoso break que nos sale 00:36:24
Del bucle 00:36:27
Esta sentencia horrible 00:36:28
También 00:36:31
Break es una sentencia general 00:36:33
Que te saca del bucle donde estás metido 00:36:35
Entonces si yo pongo 00:36:38
break, en cuanto encuentro algún 00:36:39
suspenso, luego hace break y dice 00:36:41
el fort roto, roto a lo bestia 00:36:43
pero esta es muy fea, porque es una forma 00:36:45
de salir de los bucles 00:36:47
no es por código, es forzada 00:36:48
claro, entonces 00:36:51
esta muy fea 00:36:53
a ver, que se pone y aparece 00:36:56
por ahí y ya está, pero es feilla 00:36:58
¿por qué? porque 00:37:01
el que está llegando por aquí 00:37:02
él ve esto y dice 00:37:04
esto se va a hacer 500.000 veces, y queda con esa información 00:37:06
y le estás ocultando información 00:37:09
él no tiene por qué meterse aquí dentro 00:37:11
entonces aquí dentro 00:37:12
el break de repente altera 00:37:14
esto, lo está alterando 00:37:17
claro, por eso, que lo ideal, la otra forma 00:37:18
no lo hagas con break 00:37:25
sino incorporarlo en la condición 00:37:26
mientras yo no los haya mirado todos 00:37:28
pero no haya encontrado 00:37:31
ningún suspenso 00:37:33
es decir, mientras 00:37:34
yo no los haya mirado todos 00:37:36
vale, claro 00:37:38
Y, perdón 00:37:41
No, algún suspenso 00:37:43
Esto es mucho mejor 00:37:47
¿Vale? 00:37:51
Modifico aquí la condición 00:37:54
Porque desde el momento en que he encontrado ya 00:37:55
No, esto sería un or, ¿verdad? 00:37:58
Que ya es que con el timbre 00:38:00
Estáis recogiendo y me estáis poniendo nerviosa 00:38:02
¿Vale? 00:38:03
Sí 00:38:06
Entonces, desde el momento en que ya he encontrado alguno 00:38:07
Esta condición se hace 00:38:10
No, no era un año, estoy haciendo bien 00:38:11
Claro, porque sale cuando esto sea 00:38:13
False, vale, vale, vale 00:38:16
Vale, bueno, luego volvemos 00:38:18
Sobre ello, porque ya 00:38:20
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
24 de octubre de 2024 - 17:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 23″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
157.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid