Saltar navegación

20241017 ProgrEstruct-Bucles-ejercicios_2 - 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.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

así, vale, pues entonces 00:00:00
el 5 es el 4 00:00:02
pero cambiando 00:00:03
este dato por un dato que me dan por 00:00:05
teclado, este por otro que me dan por 00:00:08
teclado y este por otro que me dan por teclado 00:00:10
nada más, entonces podemos 00:00:12
hacer un copia y pega 00:00:13
del código del 4 para el 5 00:00:15
ejercicios 00:00:18
de aquí 00:00:22
venga, pues me voy a hacer un 00:00:23
copia y pega 00:00:26
me hago un nuevo 00:00:28
ejercicio 5 00:00:30
y ahora me doy cuenta 00:00:34
pues bueno, es la misma idea que la anterior 00:00:40
entre un valor inicial y un valor 00:00:42
final, mostrar todos 00:00:44
los números que son múltiplos de 1 00:00:46
que he pedido por teclado 00:00:48
no de 1, sino de 1 que he pedido por teclado 00:00:50
vale 00:00:52
pues reutilizo código, o sea, reutilizar 00:00:53
código 00:00:56
nos viene muy bien, siempre que se puede 00:00:57
reutilizar código con criterio 00:01:00
claro, con criterio y con sentido 00:01:02
va a 1 y lo reutiliza 00:01:04
pero esta modificación 00:01:06
repito, exige que 00:01:08
el valor inicial 00:01:10
no es 1 00:01:11
el valor final no es 100 00:01:13
y el numerito del que yo 00:01:16
miro si son múltiplos o no, no es 7 00:01:18
todos van a depender 00:01:20
de un valor 00:01:22
que yo pido previamente 00:01:24
por teclado 00:01:26
pues entonces como en este caso si que pido los datos 00:01:27
por teclado 00:01:30
Pues hago esto 00:01:31
Número inicial 00:01:34
Y lo leo 00:01:42
Número 00:01:44
Final 00:01:54
Y lo leo 00:01:55
Y ahora 00:02:02
Valor del cual tengo que comprobar 00:02:04
Si es múltiplo o no 00:02:07
Pues yo que sé 00:02:08
Da igual como lo llame 00:02:11
Pues llamémosle 00:02:12
n, por ejemplo 00:02:17
nombres muy feos pero cortitos 00:02:19
vale, pues entonces ahora ya 00:02:21
ahora ya 00:02:23
bueno, le voy a llamar num 00:02:25
para no tener que cambiar la variable de abajo 00:02:27
vale, entonces ahora, el problema es el mismo 00:02:29
yo tengo que contar 00:02:31
luego un bucle con un contador que empieza valiendo 00:02:33
cero y se va incrementando 00:02:35
¿qué cuento? numeritos 00:02:37
pues una variable n para esos numeritos 00:02:39
esos numeritos 00:02:41
¿por dónde se van desplazando para que yo los vaya 00:02:43
contando, se van desplazando 00:02:45
desde n1 00:02:47
luego lo inicializo 00:02:49
con n1 y se va 00:02:52
desplazando con n++ 00:02:54
se va desplazando con n++ 00:02:55
mientras sea menor 00:02:57
o igual que n2 00:02:59
pues ahora ya tengo estos numeritos 00:03:00
n que empieza siendo n1 00:03:04
se va desplazando de 1 en 1 hasta llegar 00:03:05
a n2 y con cada uno 00:03:08
de ellos ¿qué hago? mirar a ver si es múltiplo 00:03:09
del que me han dado y si es múltiplo 00:03:11
del que me han dado lo cuento 00:03:14
y ya está, el mismo ejercicio de antes 00:03:15
pero cambiando el valor inicial 00:03:18
y el valor final 00:03:20
de mi recorrido de números 00:03:21
y variando 00:03:23
el valor del cual compruebo 00:03:26
si es múltiplo 00:03:28
bueno, pues el 5 es el 00:03:28
ya está, es el mismo 00:03:32
¿entendido? 00:03:33
¿si o no? 00:03:42
pues 00:03:45
el anterior si está entendido 00:03:46
n1 es el valor 00:03:51
si a ti te dicen 00:03:55
cuéntame todos los múltiplos de 3 00:03:57
entre 5 y 12 00:03:59
n1 es 5, que es del que empiezas 00:04:00
n2 es 12, que es en el que acabas 00:04:03
el 5 00:04:07
es el múltiplo 00:04:10
el valor del que ves si es múltiplo 00:04:10
n1 es un valor fijo, es el que te han dado 00:04:13
del que empiezas, yo empiezo en 7 00:04:15
n2 es otro valor fijo 00:04:17
el que te han dado que es en el que acabas 00:04:19
acabo en 20 00:04:21
n1 y n2 son fijos, te los han dado 00:04:23
empiezo en n1 y acabo en n2 00:04:25
n es el que va variando desde n1 hasta n2 00:04:27
y para cada n que va variando 00:04:31
desde n1 hasta n2 00:04:36
porque lo voy incrementando aquí 00:04:37
pues para cada uno de ellos 00:04:39
compruebo la condición 00:04:41
si se cumple, cuento, incremento mi cuenta 00:04:42
toca contar ese, toca contar 00:04:45
vale, vamos a hacer algo más de 00:04:46
contar para que 00:04:56
Claro, a ver, si siento esto 00:05:00
no es que no funcione 00:05:09
habría que ver qué hace 00:05:12
lo que hace es, si n1 es mayor que n2 00:05:13
no entra en el bucle nunca 00:05:16
con lo cual la cuenta 00:05:18
al no entrar nunca en el bucle 00:05:19
cont 00:05:22
no cambia nunca de valor, acaba siendo 0 00:05:23
y podría estar bien 00:05:25
porque entre 7 y 2 00:05:27
no hay múltiplos porque es que ya te has pasado 00:05:29
¿vale? otra cosa es que te dijeran 00:05:32
si el n1 es mayor que n2 00:05:34
intercambia los de valor 00:05:36
pero eso lo dejamos para otro ejercicio 00:05:37
que hay por ahí más abajo ¿vale? 00:05:40
si el número, si n es mayor que n2 00:05:46
bueno 00:05:48
n1 es mayor que n2 00:05:49
entonces lo que harías 00:05:54
es iniciar n con n2 00:05:56
y ahora que el 00:05:58
límite superior fuera n1 00:06:00
¿vale? 00:06:01
Claro, le das la vuelta 00:06:03
Y el valor que le das a n 00:06:05
Al principio que fuera n2 00:06:07
Porque es el más pequeño 00:06:09
Y luego ya este bucle 00:06:10
Se incrementa hasta n1 00:06:12
Pero bueno, ahora mismo 00:06:14
Puedes darle otro valor 00:06:15
Puedo darle 00:06:19
A ver, vamos a suponer que yo le doy 00:06:20
El número inicial 3 00:06:23
El número final 10 00:06:25
¿Cuántos múltiplos de 5 hay? 00:06:27
Que me tiene que dar 2 00:06:30
2, el 5 y el 10 00:06:31
Vale, vamos a hacer otro 00:06:33
Aunque no está en el listado 00:06:43
Para que esto de las cuentas y todo esto quede claro 00:06:44
Lo voy a llamar 00:06:46
Ejercicio 5 y medio 00:06:49
Porque me lo acabo de inventar 00:06:51
Y está entre el 5 y el 6 00:06:59
Ejercicio que me acabo de inventar ahora mismo 00:07:00
Para antes de pasar a lo de las sumas, pues asegurarnos, como os veo a lo mejor un poco dudosos, de que esto lo habéis entendido. 00:07:08
Por ejemplo, vamos a hacer ahora otra versión. Programa que recibe un valor, el total de esos comprendidos entre 1 y ese valor, cuya decena es 4. 00:07:15
Por ejemplo, el programa que solicita un número tiene que mostrar cuántos números comprendidos entre 1 y ese número tienen como decena la cifra 4. 00:08:04
Venga, pues haced esto en 2-3 minutillos y ahora lo corregimos. 00:08:20
¿Por qué os reís? 00:08:27
Si es lo mismo de siempre, pero cambiando la condición. 00:08:29
Es para asegurarnos que lo de la... 00:08:32
Vale, pues otra vez estamos en las mismas. 00:08:35
Ya está 00:08:37
Vale, pues otra vez estamos en las mismas 00:08:41
Estamos contando 00:08:44
Pues un contador que empieza valiendo cero y se irá incrementando 00:08:45
En las mismas, vale, espera, bueno 00:08:48
Voy a borrar esto 00:08:49
Muestra el total 00:08:50
De los números comprendidos entre uno y ese número 00:08:57
Muestra el total 00:09:00
Vale 00:09:01
Bueno, da igual, sí, da lo mismo 00:09:03
Vale, entonces 00:09:05
bueno, pues al final vuelve a ser esto 00:09:07
vuelve a ser esto 00:09:13
yo leo un numerito 00:09:16
y ahora partiendo desde 1 00:09:19
mientras n sea menor o igual que n1 00:09:22
y este numerito se irá incrementando 00:09:25
pues partiendo desde 1 00:09:27
hasta el final tendré que ver 00:09:29
este número n 00:09:30
si me cumple la condición 00:09:31
de decenas igual a 4 o no me la cumple 00:09:33
porque si me cumple esa condición 00:09:36
le cuento y si no, no 00:09:38
Luego vuelve a ser el mismo rollo de siempre 00:09:39
¿No? El mismo rollo 00:09:41
Ahora el tema es la condición 00:09:42
La condición aquí será 00:09:44
Que la decena de n 00:09:46
Sea igual a 4 00:09:48
Entonces la decena 00:09:51
La podéis haber sacado así ¿Verdad? 00:09:53
In decenas 00:09:56
Es decir, si dividís el numerito 00:09:56
Entre 10 00:09:59
Pues te va a quedar 00:10:01
Toda la parte que no es las unidades 00:10:03
315 te queda 31 00:10:05
2312 00:10:07
te queda 00:10:09
231, vale 00:10:10
pero queremos quedarnos con las unidades 00:10:13
de esa otra parte, entonces nos queda 00:10:15
todavía hacer esto 00:10:17
entonces esto sí que serían las decenas 00:10:18
entonces ahora 00:10:21
si uno hace esto 00:10:23
vale 00:10:24
vale 00:10:26
entonces 00:10:31
ya está, vale 00:10:33
ya está, entonces 00:10:36
si el número es menor de 10 00:10:38
ya sabemos que es imposible 00:10:40
que tenga las decenas cuatro. Entonces, 00:10:42
podríamos haber sido listo, habernos adelantado 00:10:44
y haber dicho, hombre, ¿para qué voy a partir 00:10:46
desde el uno? Si desde el uno hasta 00:10:48
el cuarenta no va a contar 00:10:50
ninguno, ¿no? 00:10:52
¿Vale? Entonces, ¿para 00:10:55
qué voy a empezar desde el uno? Entonces, 00:10:56
uno podría haber dicho, hombre, voy a 00:10:59
empezar ya en el cuarenta directamente, voy a empezar 00:11:00
en el cuarenta porque ese va a ser el primero que 00:11:02
cuente, los demás no. Eso por un lado, 00:11:04
¿verdad? Vale, pero a ver, 00:11:06
imaginaos 00:11:09
que habéis sacado 00:11:10
La decena de otra manera 00:11:12
A lo mejor 00:11:14
Nos han pedido otra cosa 00:11:16
No las decenas, sino otro numerito 00:11:18
Bueno, pues nosotros con los char y string 00:11:20
Esos que tanto gustan 00:11:22
Podríamos haber dicho, voy a sacarlo 00:11:24
Como la cifra de decenas, lo paso a string 00:11:26
Y me quedo con el char que está en la posición 00:11:28
De las decenas 00:11:31
Sí, por favor 00:11:31
Vale, pues entonces 00:11:34
Este numerito 00:11:35
Número en string 00:11:38
No, lo que quiero es que 00:11:43
Que sepáis 00:11:45
Que no, lo que quiero es que 00:11:49
Que no 00:11:51
Que ya me dijisteis el otro día 00:11:53
Que había sido todo cadenas 00:11:55
Y ya dije que es verdad 00:11:57
Que lo tenía en cuenta, pero hombre 00:11:59
Lo que estoy haciendo es 00:12:00
Miles de posibilidades 00:12:02
Vale, pues entonces vamos a imaginar que queremos sacar la cifra de la decena 00:12:03
De otra manera 00:12:07
Entonces, ya sabemos que esto siempre es una forma fácil 00:12:07
¿Verdad? De convertir un número entero a su versión stream 00:12:13
Vale, entonces, si yo me quiero quedar con la cifra de las decenas 00:12:17
Ese será una posición, ¿verdad? 00:12:24
Será ncadena.charat 00:12:29
Y ahora, mi pregunta 00:12:31
¿Qué posición son las de las decenas? 00:12:34
A ver, si tú tienes escrito 00:12:39
327 00:12:53
la 0 es el 3 00:12:56
la 1 es el 2 00:12:57
la 2 es el 7 00:12:59
Si tienes 1512 00:13:01
la 0 es la 1 00:13:03
la 1 es el 5 00:13:05
no hay ninguna forma de leer desde la derecha 00:13:06
entonces 00:13:09
la posición depende 00:13:11
pero hombre, no recordáis 00:13:12
el método 00:13:15
LENZ 00:13:16
voy a ponerlo aparte, no metido dentro 00:13:18
para que se vea 00:13:21
este método te devolvía 00:13:22
la cantidad de caracteres que tiene 00:13:36
nosotros sabemos que es el penúltimo 00:13:37
siempre, ¿va a ser el penúltimo? 00:13:40
pues entonces 00:13:42
¿cuál va a ser la última? 00:13:43
tan menos uno, porque si tiene 00:13:45
tan de tamaño, os tiran 00:13:47
entre 0 y tan menos 1. 00:13:49
¿Verdad? Es decir, si tiene 00:13:52
4, las posiciones van 00:13:53
de 0 a 3. Si tiene 00:13:55
7 caracteres, las posiciones van 00:13:57
de 0 a 6. 00:13:59
Si tiene 12 caracteres, las posiciones 00:14:01
van de 0 a 11. 00:14:03
Luego, si 00:14:06
tiene tan, o como 00:14:07
lo queramos llamar, las posiciones 00:14:09
van de 0 a tan menos 1. 00:14:11
Y como me quiero quedar no con la última, 00:14:13
que la última es tan menos 1, sino con la penúltima, 00:14:15
Pues entonces era esta. 00:14:17
¿Vale? 00:14:23
Entonces esta es la cifra de las decenas en char. 00:14:23
Y ahora yo ya la puedo comparar con el carácter 4. 00:14:28
Y es lo mismo. 00:14:33
¿Vale? 00:14:36
La diferencia es que aquí me vale tanto para si el número es negativo o positivo. 00:14:36
Me vale igual. 00:14:41
Me vale exactamente igual si el número es negativo o positivo. 00:14:43
claro, porque si me han dicho 00:14:46
el menos 320 00:14:49
pues la penúltima 00:14:51
es esta, si me han dicho 00:14:53
el 712, la penúltima es esta 00:14:55
yo me estoy quedando con la penúltima 00:14:57
la última es la del tamaño menos 1 00:15:00
porque la primera es 0 00:15:01
y el total es el tamaño 00:15:03
la penúltima será la del tamaño menos 2 00:15:04
independientemente de que empiece por menos o no 00:15:08
sin embargo, en la otra versión 00:15:10
si el número es negativo, la cifra de versiones 00:15:12
me da negativa, entonces tengo que 00:15:14
preocuparme de multiplicarla 00:15:15
por menos uno o sacar el valor 00:15:17
absoluto con alguna función 00:15:19
matemática o lo que sea. 00:15:21
¿Vale? Sin embargo, así, pues me preocupo 00:15:23
de si es negativo. Sí, pero 00:15:25
como todavía no usamos funciones. 00:15:27
Si le vas sumando uno, 00:15:30
nos diría, por ejemplo, 00:15:31
decenas de lo que se echa más 00:15:33
para abajo. 00:15:35
¿Por qué? 00:15:36
A ver, le estoy sumando 00:15:37
uno al numerito, entonces desde uno 00:15:41
cada vez el numerito es uno el que sea. 00:15:43
Y sobre ese, ya busco las decenas. 00:15:45
Vale, pues esta versión os gusta 00:15:49
y está muy bien, ¿vale? 00:15:51
Porque como os gustan mucho los stream, 00:15:52
pues como os ha gustado tanto, 00:15:54
vamos a ejecutarla. 00:15:56
No, pero entendéis... 00:15:59
A ver, no os hagáis lío con lo de las longitudes. 00:16:01
Este es el tamaño de la cadena. 00:16:04
Las posiciones, por tanto, van de esta 00:16:06
hasta uno menos esa. 00:16:08
Y ya está, y no hay más historia aquí. 00:16:10
Vale, pues como os ha gustado tanto, 00:16:13
Vamos a ejecutar esto 00:16:14
Venga, vamos a ver cuántos hay entre 00:16:15
Este y 78 00:16:18
Terrible 00:16:20
Esto es lo peor que nos puede pasar 00:16:23
Cuando hacemos un programa 00:16:25
Los errores de compilación están estupendos 00:16:26
Porque salen cuando todavía yo no he entrado 00:16:29
A ejecutar nada 00:16:31
Entonces me aparecen aquí, los arreglo y se acabó 00:16:32
Esos aparecen cuando yo ya he entregado mi programa 00:16:34
Y ya me creo que está todo hecho 00:16:36
Lo peor que te puede pasar es un pantalla 00:16:38
Bueno, ya, claro 00:16:39
pero eso siempre puedes decir que no 00:16:42
estaba en tu mano, que no depende de ti, esto 00:16:44
lo has hecho tú, vale 00:16:45
o sea, mi programa está fatal 00:16:47
porque ha dado error de ejecución, que es lo peor del mundo 00:16:50
vale, bueno, pues vamos 00:16:52
a ver donde ha dado el error de ejecución 00:16:54
me dice 00:16:56
string index out of 00:16:56
bound exception 00:17:00
ya lo tenías tú claro 00:17:01
vale, esto tiene mucho significado 00:17:04
de hecho, ya sabemos lo que significa 00:17:06
¿qué nos está diciendo? 00:17:08
cuidado que te has salido de las fronteras 00:17:09
del string, eso es lo que nos dice 00:17:12
¿no? bound es 00:17:14
límite, frontera, te has salido de la 00:17:15
frontera, pero ¿cómo me puedo haber salido? 00:17:18
si yo estoy yéndome a la penúltima 00:17:20
claro, pero es que cuando 00:17:21
las cifras, los numeritos tienen una cifra 00:17:23
solo hay penúltima, pues no hay 00:17:26
entonces ese ha sido 00:17:28
mi problema, que yo aquí 00:17:30
en mi programa 00:17:31
cada vez que se ejecute esto 00:17:33
cuando mi numerito está entre 00:17:36
1 y 9 00:17:37
me va a dar un pum, te ha salido 00:17:39
porque ahí no hay cifra penúltima 00:17:42
pero claro 00:17:43
entonces aquí 00:17:46
esto ideal para el caso 00:17:47
más general, pues lo meteríamos 00:17:49
en un if, si la longitud 00:17:51
es mayor o igual que 2 00:17:54
entonces esto tiene sentido 00:17:55
si no es mayor o igual que 2 00:17:56
pues en ese caso es que la cifra de las decenas 00:17:59
ni existe, no la contaría 00:18:02
entonces ni incremento contador ni nada 00:18:03
de hecho es casi más cómodo 00:18:05
que ya de hecho diga, oye, es que voy a 00:18:07
empezar ya con el 40 00:18:09
en lugar de empezar con el 1 00:18:10
como del 1 al 39 00:18:13
sé seguro que no los va a contar 00:18:14
no los va a contar, pues voy a empezar ya con el 40 00:18:17
empiezas con el 40 00:18:20
y ya sí que con total 00:18:21
seguridad 00:18:23
el tamaño va 00:18:24
o sea, esto no se va a salir 00:18:27
porque a partir del 40 siempre hay una penúltima 00:18:28
¿vale? entonces ahora 00:18:31
con la misma ejecución 00:18:33
pues hay 10, claro 00:18:34
del 40 al 49 00:18:39
lógicamente, es que no hacía falta 00:18:42
hacer un programa para esto 00:18:43
otra cosa 00:18:44
vale, pero bueno 00:18:48
lo que yo quería con esto es 00:18:54
seguir haciendo cuentas 00:18:55
y hombre, que le perdierais el miedo 00:18:57
a los stream, los métodos de las cadenas 00:18:59
y lo echaríais 00:19:02
¿bajaréis para acá? 00:19:02
Vale. Entonces, cuidado por lo de siempre. Si uno le quita aquí las comillas simples, el compilador no se entera. Pero entonces no estáis comparando decenas con el numerito 4. Estáis comparando decenas con el carácter que en la tabla ASTI corresponde al 4 y es a saber cuál es. 00:19:12
¿Entendéis, no? 00:19:32
La diferencia tan gigante, enorme 00:19:34
Que hay entre ponerlo así y así 00:19:35
También podrías poner el numerito del 4 00:19:38
Eso sí 00:19:40
Podría irme a la tabla ASCII y ver el 4 00:19:42
A qué número entero corresponde 00:19:44
Sí, exactamente igual 00:19:45
¿Vale? Pero aquí 00:19:47
Si yo quito las comillas 00:19:51
Estás diciendo 00:19:53
El char ASCII colocado en la tabla 00:19:54
En la posición 4, que a saber cuál será 00:19:57
Pues creo que es una estrellita 00:19:58
Pues me estará contando cuántas estrellitas hay 00:20:00
Entre uno y no sé cuántos, ninguna 00:20:03
Así que esto, no, muy mal 00:20:04
Es un rombo 00:20:09
Que es un rombo 00:20:10
El cuatro 00:20:15
Vale, pues no hay rombos 00:20:17
Venga, pues ahora 00:20:20
Ahora ya sí que sí, hemos hecho el cinco y medio 00:20:22
Más o menos esto de contar 00:20:24
Y todo eso, bueno, es 00:20:26
No estamos aportando 00:20:28
Nada muy nuevo 00:20:31
Estamos basándonos, ya veis, en cosas que 00:20:32
Ya sabemos de antes, por eso digo que 00:20:34
el que se sienta un poco más 00:20:36
incómodo, pues que haga ahora 00:20:39
el sobresfuerzo de empezar 00:20:40
otra vez desde el principio a reforzarlo 00:20:42
a metérselo todo en la cabeza 00:20:44
otra vez 00:20:47
pues ala, el 6 00:20:47
6, venga, con el 6 ya sí que 00:20:50
saltamos algo más 00:20:55
ahora ya no estamos contando 00:20:57
ahora ya no hay que 00:20:59
contar en este ejercicio, en este ejercicio 00:21:01
hay que hacer una suma de sumandos 00:21:02
¿Vale? Que es una situación que se puede dar muchas veces 00:21:04
Hazme una suma 00:21:07
Una suma 00:21:09
Integra sumandos 00:21:10
Cuando el número de sumandos 00:21:12
Yo ya lo sé a priori de partida 00:21:14
Puedo calzar la suma tal cual 00:21:16
Este sumando más este, más este, más este 00:21:19
Como hemos hecho hasta ahora, por ejemplo 00:21:21
Decíamos, recibe dos números y haz la suma 00:21:22
Tengo los dos sumandos, n1 más n2 00:21:25
Muy bien, o recibe tres números 00:21:27
Y haz la suma, estupendo, tengo los tres sumandos 00:21:29
Pues hago la suma, n1 más n2 más n3 00:21:31
¿cuál es el problema de esta suma? 00:21:33
que en cada ejecución 00:21:36
el número de sumandos es distinto 00:21:38
si yo le meto 7 00:21:40
la suma que hará el programa 00:21:43
en ese caso será 1 más 2 más 3 00:21:45
hasta 7, o sea 7 sumandos 00:21:47
si le meto 5 son 5 sumandos 00:21:48
no, no, no 00:21:51
el programa te muestra este numerito 00:21:54
la suma, punto pelota 00:21:57
entonces nosotros nos damos cuenta 00:21:58
de que esto es una suma de sumandos 00:22:00
Vale, primera cosa a la que nos damos cuenta, esto no es contar, no es contar cuántas veces pasa algo, no es contar, esto es mostrar el resultado de una suma, vale, pues siguiente paso, ¿cuáles son los sumandos de la suma?, todas las sumas están integradas por sumandos, si yo de partida sé cuántos son y los tengo, pues planto la suma, ya está, no tengo nada más que hacer, pero ¿en qué estábamos?, 00:22:03
Estábamos dándonos cuenta de que aquí el número de sumandos es variable, depende. 00:22:30
En una ejecución el número de sumandos será 5, si me han dado 5. 00:22:35
Pero en otra ejecución el número de sumandos será 12, si me han dado 12. 00:22:39
Entonces el número de sumandos es variable. 00:22:43
Luego, ¿cuántas sumas tengo que hacer? 00:22:46
Pues depende. 00:22:49
En algunas ejecuciones tendré que hacer hasta 2 sumas, 1 más 2 más 3, si me han dado 3. 00:22:51
pero en otra ejecución tendré que hacer 00:22:55
hasta 7 sumas, si me anda del 8 00:22:57
1 más 2 más 3, luego 00:22:59
lo que yo identifico que se repite 00:23:01
varias veces es sumar 00:23:03
luego ahora ya sí que veo 00:23:05
voy a tener que usar un bucle 00:23:07
un bucle, que lo que hace dentro es sumar 00:23:08
¿cuántas veces suma? 00:23:11
no lo sé, depende 00:23:13
pero ya me he dado cuenta que no hay forma de hacer esto 00:23:14
si no es con un bucle 00:23:17
porque yo tengo que repetir varias veces 00:23:18
una operación, que es 00:23:21
una suma. ¿Cuántas veces? 00:23:23
No sé cuántas, no sé cuántas. 00:23:25
Pues entonces tendré que meter esa suma en un bucle 00:23:27
y que ya la condición 00:23:29
me diga cuántas veces la hago. 00:23:31
¿Vale? Entonces cuando identifico 00:23:34
que tengo que hacer algo varias veces 00:23:35
pero de partida no sé cuántas, 00:23:36
pues es imposible hacerlo sin bucles. 00:23:39
Porque si de partida 00:23:42
sé cuántas veces tengo que hacer algo, pongo una 00:23:43
tras otra. Pero si de partida 00:23:45
no lo sé, pues eso 00:23:47
que tengo que hacer varias veces, como en este caso 00:23:49
la suma irá dentro de un bucle 00:23:51
Y ya que la condición decida en cada momento cuántas veces, en este caso la condición tendrá que ver con el numerito n, ¿vale? Entonces con eso ya empieza a tener más o menos una imagen de cómo puede ir mi programa. 00:23:52
Pues venga, ejercicio 6 00:24:07
Ejercicio 6 00:24:10
Como de costumbre, datos de entrada 00:24:21
Datos de entrada 00:24:22
Eso ya, en este caso 00:24:23
Un valor 00:24:28
Dato de entrada, un valor 00:24:29
Dato de entrada, un valor 00:24:31
Llamémosle N mayúscula 00:24:35
Nombre muy feo y muy mal elegido 00:24:38
Sobre todo porque sea en mayúscula 00:24:39
Pero bueno, vale 00:24:42
Y ahora, nos hemos dado cuenta 00:24:44
De que hay que hacer varias veces 00:24:46
Una suma 00:24:48
¿Vale? Y repito otra vez, ¿cuántas? No lo sé, depende de una condición. 00:24:49
Luego entonces, varias veces voy a tener que hacer una suma, ya veremos cuál, 00:24:55
y como lo tengo que hacer varias veces, esa suma va a tener que ir en un bucle. 00:25:01
Este bucle va a fijar cuántas veces hago la suma. 00:25:08
De alguna manera ya intuyo que esta condición va a depender de n, 00:25:13
va a depender de n, porque 00:25:15
cuanto más alto sea n, más sumas 00:25:17
me toca por hacer, más sumas me toca 00:25:20
entonces de alguna manera esta condición va a depender de n 00:25:22
vale 00:25:24
bueno, ahora mismo está esbozado 00:25:24
muy por encima, hay que meterse más 00:25:27
vale, el resultado 00:25:29
final, ¿cuál va a ser? recordad que 00:25:32
muchas veces he dicho, para poder 00:25:33
hacer un diseño de un ejercicio, no 00:25:36
perdáis de vista, ¿cuál es 00:25:37
el resultado final? y de hecho nos hacíamos 00:25:40
una variable para meter el resultado y luego construíamos 00:25:41
eso. Mi resultado final 00:25:44
aquí va a ser un número. Va a ser un número. 00:25:46
Que es el resultado 00:25:48
de una suma. 00:25:50
De una suma de muchos sumandos. 00:25:51
Vale, pues entonces, este 00:25:54
va a ser mi resultado final. 00:25:56
Sea el que sea, lo voy a guardar ahí. 00:25:58
Una suma de muchas cosas. 00:25:59
Luego mi programa tiene que acabar así, de alguna 00:26:02
manera. La suma 00:26:03
suma. 00:26:09
Y ahora ya me falta aquí hacer 00:26:13
operaciones 00:26:15
vale, ¿qué sumas tengo que hacer? 00:26:16
bueno, pues yo esta suma 00:26:21
de 1, 2, 3 00:26:23
ahora ya sí que la puedo ir planteando 00:26:24
como una cosa 00:26:26
que llamamos 00:26:28
es una suma acumulativa 00:26:29
es decir 00:26:32
¿cómo puede funcionar este 00:26:34
a ver, ¿cómo puedo plantearme 00:26:36
esa suma de sumandos? 00:26:41
bueno, lo hago aquí en pizarra 00:26:49
aunque no haya cámara ni nada 00:26:50
¿Vale? Pues tenemos que hacer esta suma de aquí 00:26:51
Entonces, como vemos, en realidad esta suma 00:27:08
A cada valor 00:27:12
O sea, inicialmente 00:27:14
Esto lo podéis plantear como que es 0 más 1 00:27:16
Entonces, inicialmente yo podría partir de que tengo el 0 00:27:19
¿Vale? 00:27:22
Entonces, a este 0 le hago la primera suma 00:27:24
Y ya tengo un primer resultado 00:27:27
vale, a este nuevo 00:27:29
resultado le vuelvo 00:27:32
a hacer otra suma 00:27:34
le vuelvo a hacer otra suma 00:27:36
y ya tendría mi siguiente resultado 00:27:38
que es 2, entonces 00:27:40
esto lo puedo plantear 00:27:42
una variable 00:27:44
llamémosla como uno la quiera llamar 00:27:45
una variable que inicialmente empieza 00:27:47
haciendo 0 y sobre esta 00:27:49
misma variable la voy actualizando 00:27:51
sumándole cada vez algo 00:27:54
¿verdad? entonces esta es 00:27:55
la sentencia clave de lo que llamamos 00:27:58
la suma acumulativa. 00:28:00
N sería 00:28:05
el acumulador. N es lo que 00:28:06
llamamos el acumulador. 00:28:07
Entonces, N inicialmente 00:28:11
es cero. Es el 00:28:12
acumulador que parte de cero. 00:28:13
N es el acumulador. N inicialmente tiene 00:28:16
cero. Vale. 00:28:17
Y ahora, N va 00:28:22
recibiendo sobre él valores 00:28:24
y se va actualizando. 00:28:26
La primera vez 00:28:28
que recibe un valor 00:28:30
n tiene cero 00:28:31
recibe ese valor 00:28:33
y ya se actualiza 00:28:34
y tendrá un nuevo valor 00:28:35
ya ha acumulado 00:28:36
una primera suma 00:28:37
ya ha acumulado 00:28:38
una primera suma 00:28:38
vale 00:28:40
la siguiente vez 00:28:40
que se ejecute 00:28:42
esa instrucción 00:28:43
n tendrá el valor 00:28:43
acumulado de antes 00:28:45
y le metemos 00:28:46
otro nuevo 00:28:47
otro nuevo 00:28:48
vale 00:28:49
tiene un nuevo valor 00:28:50
la siguiente vez 00:28:51
que se ejecute esto 00:28:53
tiene el valor 00:28:54
que ya tenía de antes 00:28:56
con las dos sumas 00:28:57
anteriores 00:28:58
y acumula el nuevo 00:28:59
entonces si metemos esto en un bucle 00:29:00
si metemos esta sentencia en un bucle 00:29:02
n igual a 00:29:05
n más x 00:29:07
partiendo n de 0 00:29:08
estamos consiguiendo este efecto 00:29:10
que es que la variable 00:29:14
n le sumo x 00:29:16
y luego le sumo x otra vez, y luego x otra vez 00:29:17
y luego x otra vez, y luego x otra vez 00:29:20
así hasta que yo decida, hasta la condición 00:29:22
que yo decida, y estos x 00:29:24
los que yo decida 00:29:26
¿vale? entonces n funciona 00:29:27
con un acumulador 00:29:30
que voy metiendo sobre él 00:29:31
sucesivos valores. 00:29:34
La primera vez que entro, 00:29:36
sobre el cero que tenía le sumo x 00:29:38
y me quedaré con el valor que tengo. 00:29:39
La siguiente vez que entro, 00:29:43
sobre ese nuevo valor 00:29:44
que tengo de antes, 00:29:46
le meto otro nuevo 00:29:48
y actualizo el que tengo. 00:29:49
Y vuelvo arriba. 00:29:51
Sobre ese nuevo valor 00:29:54
que acabo de actualizar, 00:29:55
actualizo metiéndole otro nuevo 00:29:57
y lo vuelvo a actualizar. 00:29:58
¿Vale? Luego esta es una estructura en el cual de una variable acumuladora que empieza valiendo cero voy yo haciéndole sumas. 00:30:00
Primero sumo x, luego sumo x otra vez, luego sumo x otra vez. 00:30:08
Y ahora sobre esta estructura general yo ya decido cuando paro de sumar y los diferentes sumandos cuáles son. 00:30:11
x haría el papel de los sumandos. 00:30:18
En mi caso los sumandos cuáles son. 00:30:20
Pues 1, 2, 3, luego x tiene que ir variando entre 1, 2, 3. 00:30:23
porque x hace el papel de los diferentes sumandos 00:30:27
¿no? la primera vez quiero sumar 1 00:30:30
pero la siguiente vez 00:30:32
quiero sumar 2, la siguiente vez quiero sumar 3 00:30:34
luego x son los diferentes 00:30:36
sumandos ¿vale? 00:30:38
bueno pues ya me construyo los sumandos 00:30:40
pues entonces 00:30:42
si escribimos esto en código 00:30:44
sería 00:30:45
vale 00:30:48
suma es el acumulador 00:30:50
empieza valiendo 0 00:30:52
uy, sí 00:30:53
suma es el acumulador que empieza valiendo cero, está claro 00:30:56
ahora, la sentencia 00:31:02
para que suma vaya recibiendo sobre ella 00:31:04
los siguientes sumandos es esta 00:31:08
a suma, sumale un valor x 00:31:09
vamos a declararlo aquí abajo 00:31:15
vale, pues entonces, esta sentencia funciona 00:31:17
de esta manera 00:31:24
a suma le voy haciendo la suma 00:31:25
de estos sumandos de aquí 00:31:29
entonces en cada iteración 00:31:31
x tiene que ir siendo cada uno de los sumandos 00:31:33
en cada iteración x tiene que ir siendo 00:31:35
cada uno de los sumandos, entonces ahora yo ya pienso en mi problema 00:31:37
mi problema digo es 00:31:40
a ver, los sumandos cuáles son 00:31:41
pues los sumandos son 1, 2, 3 00:31:43
pues me las tengo que apañar 00:31:46
para que x vaya variando 00:31:47
por esos valores, 1, 2, 3 00:31:49
me las tengo que apañar, ah vale, pero eso ya sé hacerlo 00:31:52
si es que ya lo he hecho en ejercicios anteriores 00:31:54
pues que empiece 00:31:56
valiendo 1 y lo incremento 00:31:58
ya está, ya he conseguido que x 00:32:00
vaya teniendo los sucesivos sumandos 00:32:04
que quiero ir llevando a suma 00:32:07
empezando en 1 00:32:08
e incrementando 00:32:10
entonces la primera vez que entra en el while 00:32:12
al valor inicial de 0 le sumo el 1 00:32:13
primer sumando, ya está sumado 00:32:16
primer sumando 00:32:18
y dejo incrementando x a 2 00:32:19
en la siguiente vez al valor que tenía de antes 00:32:21
que era el 1 le sumo el siguiente sumando 00:32:24
que es 2, ya me he preocupado yo de que sea 2 00:32:27
porque he hecho las operaciones correspondientes 00:32:29
en x para que sea 2 00:32:31
y dejo incrementando x para que sea 00:32:32
el tercer sumando, que es 3 00:32:34
en la siguiente 00:32:36
iteración, suma ya tenía el 1 00:32:39
más 2 de antes, le meto 00:32:40
el sumando nuevo, que es 3 00:32:42
y dejo incrementado x 00:32:44
para que en la siguiente iteración 00:32:46
ya sea el siguiente sumando 4 00:32:48
y ya está, y con esta 00:32:51
suma, estaré consiguiendo 00:32:53
esto, 0 00:32:55
más 1, más 00:32:56
2, eso es lo que estoy consiguiendo 00:33:02
en cada iteración 00:33:05
la primera suma que he hecho era 00:33:05
0 más 1, que era esta 00:33:08
y suma se queda valiendo 0 más 1 00:33:09
la siguiente vez que he entrado, como x 00:33:12
ahora vale 2, suma 00:33:15
ya se va a quedar valiendo esto 00:33:16
el 0 más 1 de antes 00:33:18
más el 2 nuevo 00:33:20
suma se va a quedar valiendo esto ya 00:33:22
y x se queda valiendo 3 00:33:24
la siguiente vez que entre, suma 00:33:26
tiene 0 más 1 más 2, que es lo que he hecho 00:33:28
antes, pues le sumo el 3 nuevo 00:33:30
ahora ya suma tiene esto 00:33:32
y x se queda valiendo 4 00:33:34
la siguiente vez que entro 00:33:36
a suma, que ahora tiene 0 más 1 más 2 más 3 00:33:39
me toca sumarle el siguiente sumando 00:33:41
que es 4 00:33:43
y ahora ya suma se queda valiendo esto 00:33:43
x lo dejo incrementado 00:33:46
para que la valga 5 00:33:48
la siguiente vez que entro suma 00:33:49
que ahora tenía 0 más 1 más 2 más 3 más 4 00:33:52
le estoy sumando el siguiente sumando 00:33:54
que es 5 00:33:56
y así voy incorporando a mi suma 00:33:57
los diferentes sumandos x 00:34:00
Que ya me he preocupado yo de hacer con x lo que sea para asegurarme de que van siendo 1, 2, 3. 00:34:02
Porque en este caso es lo que me han pedido, que son 1, 2, 3. 00:34:09
Segundín, ¿vale? 00:34:13
Entonces, ¿qué me falta aquí? 00:34:17
¿Cuándo termino de sumar? 00:34:18
¿Cuándo termino yo de sumar? 00:34:20
¿Qué condición pondríais ahí? 00:34:21
Bueno, pero no te hace falta que haya una variable adicional. 00:34:31
La última suma termina cuando has sumado esta variable. 00:34:33
¿Cuándo has sumado este valor? 00:34:40
Es decir, cuando x ha llegado a ser n, 00:34:43
ya no quieres sumar más. 00:34:46
Entonces, mientras x sea menor o igual que n mayúscula. 00:34:47
Ya lo has terminado, ¿no? 00:34:51
Porque x se va incrementando. 00:34:53
Entonces, tú vas sumando el primer x, que es 1. 00:34:55
Luego vas sumando el siguiente, que es 2. 00:34:57
Luego vas sumando el siguiente, que es 3. 00:34:59
El valor inicial. 00:35:02
Entonces, vas sumando así. 00:35:07
Claro, entonces 00:35:08
Ya este bucle 00:35:12
Lo que va a estar haciendo es 00:35:14
Ir haciendo estas sumas 00:35:15
Pero cuando haya sumado ya n 00:35:16
Haya sumado ya el n 00:35:19
Ese se queda siendo n más 1 00:35:20
Volvemos a la condición 00:35:22
¿n más 1 es menor que n? 00:35:23
No, ya nos hemos pasado 00:35:25
Pues ya no sumamos más 00:35:27
¿Vale? 00:35:28
Bueno, pues acordaos entonces de esta estructura 00:35:35
Cuando hay que hacer una suma con muchos sumandos 00:35:37
y el número de sumandos es variable 00:35:39
pues no hay otra manera de hacerlo 00:35:41
esa suma final 00:35:44
irá en una variable acumuladora 00:35:46
que es la que va acumulando las sumas 00:35:47
inicialmente cero, un acumulador 00:35:49
primero pasa de parte de cero 00:35:51
y ahora dentro del bucle 00:35:52
tendrá que haber una sentencia como esta 00:35:55
de tal manera que según se vaya repitiendo 00:35:56
el bucle 00:36:00
este acumulador cada vez meta un sumando nuevo 00:36:01
cada vez que el bucle 00:36:04
salta mete un sumando nuevo 00:36:06
Y ahora ya lo que me falta es 00:36:07
Estos sumandos ver como los genero 00:36:10
En este caso generarlos era 00:36:13
A partir de uno ir incrementando 00:36:14
Pero podría ser que fueran sumandos 00:36:16
Que yo pido por teclado, lo que sea 00:36:18
¿Vale? 00:36:20
Claro, podría ser variable 00:36:22
O sea, programa que pida números por teclado 00:36:24
Y lo sume todos 00:36:26
Pues como cambiaría, este x 00:36:27
Lo leería yo por teclado 00:36:30
Y luego lo sumaría 00:36:32
¿Vale? La condición de finalización, la que me dijeran 00:36:33
Mientras el número leído sea positivo 00:36:36
Lo que sea 00:36:38
Entonces el sumando es el que depende 00:36:39
Depende de lo que te pidan 00:36:41
Depende, aquí es que me decían que el sumando tiene que ser 00:36:42
Partiendo de uno e irse incrementando de uno en uno 00:36:45
Pues me decían eso, pues ya está 00:36:48
El sumando lo construyo así 00:36:50
Pero podrían ser otros 00:36:51
Pues los construyo como sea 00:36:54
Y claro, tengo que dejar muy claro 00:36:55
En qué momento termino de sumar 00:36:58
Porque si no termino de sumar nunca, el bucle no acaba nunca 00:36:59
¿Vale? 00:37:01
Vale, entonces esto si lo hemos hecho bien 00:37:05
Y ponemos el 4 00:37:07
Pues 1 más 2 más 3 más 4 00:37:09
Se supone que es 10, ¿no? 00:37:11
Y tú, espera 00:37:12
Adrián iba a preguntar algo 00:37:15
Sí, o sea, tú lo has incrementado aquí 00:37:17
Y aquí arriba 00:37:32
O sea, en lugar de ponerlo aquí 00:37:39
Pero no tienes que hacer ninguna modificación 00:37:41
Así ya estaría, ¿no? 00:37:43
A ver, si tú haces X++ 00:37:44
Suma la X y la X la deja incrementada 00:37:51
Luego es igual 00:37:53
Lo tienes que hacer en un cambio, ¿no? 00:37:55
¿Eh? 00:37:57
Espera, espera, que no lo digo 00:37:59
Dime 00:38:01
Claro 00:38:01
A ver, Juanjo, que te has puesto justo en medio 00:38:07
No le veo 00:38:09
No, aquí empieza desde 1 00:38:10
¿Por qué? 00:38:13
entres por aquí 00:38:14
x es 1, 1 es ver igual que n, sí 00:38:17
como es post incremento 00:38:19
primero lo coges para la suma 00:38:21
y luego ya lo dejas incrementado 00:38:23
porque es post 00:38:25
el problema es si tú lo haces así 00:38:26
entonces sí, así sí, porque así sería 00:38:28
pre incremento 00:38:31
a ver, vamos a ver 00:38:33
yo creo 00:38:35
que este código 00:38:37
espera, quítate de en medio 00:38:39
a ver, este código y el que he hecho yo 00:38:40
Creo que son iguales, pero vamos a comprobarlo 00:38:43
A ver si algo se me ha escapado 00:38:45
Ya, vale 00:38:47
Si yo le vuelvo a poner el 4, habíamos dicho 00:38:49
1, 2, 3, 10, me sale igual 00:38:51
A ver, este 00:38:53
Son idénticos, se supone 00:38:58
Vale, venga, ahora ya sí que paramos aquí 00:39:01
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
22 de octubre de 2024 - 17:47
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
158.42 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid