Saltar navegación

20251029 EjerBucles_4 - 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 31 de octubre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues volvemos 00:00:00
ahora 00:00:02
nos encontramos con un ejercicio 00:00:04
como este, ¿vale? 00:00:06
este, primero entendemos lo que hay que hacer 00:00:10
me dan un número cualquiera 00:00:12
y yo tengo que sumar todos los números comprendidos 00:00:14
entre cero y ese 00:00:16
¿implica contar? 00:00:17
no, aquí no te voy a contar nada, el programa no me dice 00:00:20
que cuenta cuantas veces pasa no sé qué 00:00:22
o dime las veces 00:00:25
que ha ocurrido esto, dime 00:00:26
Joder, se me ha puesto un silencio 00:00:27
Perdón 00:00:31
Sí, sí, soy yo 00:00:32
Vale, a ver 00:00:52
Vale, pues 00:00:56
volvemos a donde estábamos, ¿vale? 00:01:00
Vamos. 00:01:05
Venga, volvemos a donde estábamos. 00:01:06
Entonces, ahora uno 00:01:08
me es denunciado 00:01:10
y esto no es contar, esto no es 00:01:11
cuántas veces pasa algo, esto no implica contar, 00:01:13
esto implica hacer sumas. 00:01:16
¿Vale? Pues sumas sabemos. Un operador 00:01:18
suma y otro operador 00:01:20
suma sabemos. Pero claro, 00:01:22
aquí el tema es que cuántas 00:01:24
sumas hay que hacer, porque las sumas se hacen de una en una 00:01:26
lógicamente, operador suma 00:01:28
operador 00:01:30
entonces esta es una suma, pero luego habrá que hacer otra 00:01:30
luego habrá que hacer otra, ¿cuántas sumas hay que hacer? 00:01:33
pues no sabemos, depende 00:01:36
cuando me den un numerito n que sea 00:01:37
20, habrá que hacer 00:01:40
19 sumas, un montón 00:01:41
cuando me den 12 00:01:43
habrá que hacer solo 12 sumas 00:01:45
entonces yo para hacer este programa 00:01:47
voy a necesitar un bucle 00:01:49
porque es hacer varias veces algo 00:01:51
¿qué algo? 00:01:54
sumar, es hacer muchas sumas 00:01:56
¿vale? este programa va a ser 00:01:58
hacer muchas sumas 00:02:00
¿cuántas? no lo sé 00:02:02
depende de n 00:02:04
luego algo que se hace muchas veces 00:02:06
un número de veces 00:02:09
indeterminado, depende 00:02:10
de una condición, en este caso dependerá 00:02:12
de cuánto sea n, pues es un bucle, lógicamente 00:02:14
entonces, esto lo vamos a tener que hacer 00:02:16
con un bucle, pero en ese bucle 00:02:18
ya no habrá que contar, ese bucle ya no será 00:02:20
un contador que se va incrementando según pasa algo 00:02:22
esto ahora ya es 00:02:24
una suma que llamamos 00:02:26
una suma acumulativa, que es 00:02:28
otra operación que puede, que necesitamos 00:02:30
hacer continuamente, sumar 00:02:32
muchas cosas 00:02:34
¿vale? es otra operación básica 00:02:35
y de todas las operaciones básicas 00:02:38
que vamos a ir ejemplificando 00:02:40
a lo largo de esta lista de ejercicios 00:02:42
pues contar, sumar, máximos y mínimos 00:02:44
patatín, todas las operaciones básicas 00:02:47
ya combinadas, se hace 00:02:49
cualquier cosa, ¿vale? pero tenemos 00:02:50
que entender un poquito cada una 00:02:52
por separado 00:02:54
Bueno, pues entonces, aquí, si nos vamos al código directamente, que se ve más claro que en la pizarra 00:02:55
Vamos a hacer este ejercicio, que es el ejercicio 6 00:03:05
Ejercicio 6, vale 00:03:12
Vale, aquí lógicamente tendremos que leer por teclado, luego yo tengo mi escáner 00:03:26
silencio 00:03:37
vale 00:03:53
dato de entrada, solamente este 00:03:54
vale, pues entonces 00:03:57
aquí hay que hacer 00:04:17
lenguaje de signos 00:04:20
o si no, no intercambiéis información 00:04:24
vale, aquí habrá que hacer muchas veces 00:04:27
una suma, un montón de veces 00:04:33
¿Vale? El resultado 00:04:35
De esa suma, pues tendrá que estar en alguna 00:04:38
Variable, por ejemplo aquí 00:04:40
Llamémosle suma 00:04:42
Aquí tendrá que estar el resultado 00:04:43
De esta variable, y aquí habrá que hacer 00:04:46
Un montón de sumas 00:04:48
¿Pero cuál es? Bueno, pues 00:04:50
Dime 00:04:52
Es como que al hacer la condición 00:05:12
Menor o igual, lo mismo 00:05:14
Bueno, habría que ver por qué se te hace 00:05:21
Infinito el bucle, luego lo miramos 00:05:23
Pero, ¿por qué tienes un bucle 00:05:25
infinito, depende del resto de tu código. Si nunca 00:05:27
cambias nada para que la condición se 00:05:30
haga falsa, pues entonces es un buque 00:05:31
infinito. Algo no estás cambiando 00:05:33
dentro. Pero bueno, ya lo miraremos. 00:05:35
Vale, entonces 00:05:37
joder. Aquí va a estar 00:05:38
nuestro resultado. 00:05:43
Y este es nuestro 00:05:46
numerito. ¿Qué es lo que 00:05:47
tenemos que hacer dentro? Pues no sé qué es lo que 00:05:53
tenemos que hacer, pero lo que queremos 00:05:55
conseguir es esta suma. 00:05:57
1 más 2 más 00:05:59
3 más 4 00:06:01
así hasta más n 00:06:02
entonces primero habrá que hacer 00:06:04
esta suma 00:06:06
luego al resultado 00:06:07
obtenido 00:06:11
habrá que hacer ahora esta 00:06:12
y con el resultado obtenido 00:06:14
habrá que hacer otra más 00:06:17
y ahora con ese resultado obtenido habrá que hacer otra más 00:06:18
entonces estamos haciendo un montón 00:06:21
de sumas aquí dentro 00:06:23
vale, entonces ¿cómo podemos 00:06:25
plantear esto? bueno pues 00:06:27
inicialmente mi primer operador 00:06:29
1, mi primer operador por ejemplo 00:06:30
¿Vale? 00:06:33
Puede ser este 00:06:35
¿Vale? Pues ahora 00:06:36
¿Qué hago yo con mi variable suma? 00:06:38
A mi primer operador 00:06:45
A mi primer operador que ahora mismo es este 00:06:47
La suma ahora mismo tiene 1 00:06:49
Es mi primer operador, le voy a sumar 00:06:51
El primer número que toca 00:06:53
Que sería el 2 00:06:55
¿Vale? 00:06:57
Entonces el 2 ¿Cómo lo genero? 00:06:59
Pues venga, vamos a usar una variable 00:07:01
Por ejemplo, pues digo, pues mira, voy a usar una variable adicional i que empieza siendo 1 y le sumo el i, ¿vale? 00:07:03
Ya tendré el 1 más 2. 00:07:12
Y ahora, ¿qué hago con esa suma? ¿Dónde la guardo? 00:07:15
Cualquier operación tengo que llevarla a algún sitio. 00:07:18
¿Dónde guardo esta primera suma? 00:07:21
Bueno, pues vamos a pisar la propia variable suma para que ahora suma tenga esto. 00:07:23
Bueno, pues vamos a pisar la propia variable suma. 00:07:29
Ahora suma tendrá esto de aquí, pero claro me falta dejar el i incrementado porque la siguiente suma va a ser mi nuevo operador, que ahora se ha convertido en 1 más 2, a raíz de esta suma mi nuevo operador, súmale el siguiente que es 3, luego i vamos a dejarlo incrementado. 00:07:31
¿Vale? 00:07:52
Ahora, siguiente vuelta de bucle 00:07:54
Siguiente vuelta de bucle 00:07:56
Mi operador suma, ahora ya era 1 más 2 00:07:58
Le sumo el 3 00:08:01
Y lo vuelvo a pisar en suma 00:08:02
Luego mi nuevo primer operador 00:08:05
Ahora ya es este 00:08:06
Es todo este 00:08:07
Y dejo la incrementado para que ahora sea 4 00:08:09
Vale 00:08:12
Cuando el bucle llega por aquí 00:08:14
Suma mi nuevo operador 00:08:17
Que ahora es este, con el 4 00:08:19
ahora ya tengo la nueva suma que es esta de aquí 00:08:20
luego sobre mi variable suma 00:08:23
voy acumulando o incorporando 00:08:27
a través de esta sentencia 00:08:30
un nuevo valor cada vez 00:08:33
esto es una estructura de acumulador que se llama 00:08:34
mi variable suma es un acumulador 00:08:37
un acumulador que yo aquí inicialmente le he puesto un 1 00:08:40
es un acumulador 00:08:45
vale, la primera vez que entro 00:08:47
sobre esta variable suma 00:08:49
que va acumulando, le sumo el 1 00:08:51
me queda 2 00:08:52
y piso el resultado 00:08:56
que tenía de antes por este nuevo 00:08:59
vale, suma ya, ahora tiene 1 más 1 00:09:00
ha acumulado un numerito más 00:09:03
y lo incremento 00:09:04
para generar el siguiente a sumar 00:09:06
la siguiente vez que vuelvo 00:09:08
mi variable acumuladora, mi acumulador 00:09:10
que es este, ahora se le suma 00:09:12
otro numerito más, vale 00:09:15
perdón, 1 más 2 00:09:16
que es el 3, se le suma un numerito más 00:09:18
y con este valor vuelvo a pisar suma 00:09:22
es decir, ha acumulado otro número más 00:09:25
por eso se comporta como un acumulador 00:09:28
y ahora ahí lo incremento, lo dejo valiendo 4 00:09:30
siguiente vuelta, mi variable acumuladora 00:09:33
esta variable acumuladora 00:09:36
que tenía 1 más 2 más 3 00:09:37
ahora le sumo otro numerito más, el 4 00:09:40
y esa nueva suma pisa el que tenía de antes 00:09:43
luego mi variable acumuladora suma 00:09:48
ahora ya tiene el 1 más 2 más el 3 más el 4 00:09:50
tiene toda esta suma 00:09:52
luego mi variable suma es una variable 00:09:54
que en cada vuelta 00:09:56
de bucle va incorporando un sumando 00:09:58
nuevo, luego es una variable 00:10:00
acumuladora, va acumulando 00:10:02
un sumando nuevo 00:10:04
en este caso en particular 00:10:05
los sumandos que va acumulando 00:10:08
como los voy generando yo con el i 00:10:10
que empieza siendo 1 00:10:12
pues va acumulando primero 00:10:14
bueno, yo empezaría valiendo 2 00:10:15
porque esto lo he inicializado a 1 00:10:20
el primer sumando que suma es el 2 00:10:22
y luego el siguiente es el 3 00:10:26
pero estos sumandos que va acumulando 00:10:29
podrían venir de cualquier lado 00:10:31
podrían venir de que voy leyendo del teclado 00:10:32
da igual, lo que importa de esta estructura 00:10:34
es que entendamos que 00:10:37
yo tengo una variable que inicializa un valor 00:10:38
y se convierte en un acumulador 00:10:41
que tiene un valor inicial 00:10:43
y ahora ya, según va dando vueltas el bucle, 00:10:44
esa variable acumuladora va incorporando un sumando nuevo 00:10:48
y esa nueva suma pisa la anterior. 00:10:53
Siguiente vuelta del bucle, 00:10:57
a esa suma que me había quedado, 00:10:58
incorporo un sumando más y piso lo anterior. 00:11:00
A esa suma que me había quedado en la siguiente vuelta, 00:11:03
incorporo otro sumando más y piso lo anterior. 00:11:06
Luego es una acumuladora de sumas. 00:11:08
¿Qué es lo que varía? 00:11:12
los sumandos que va incorporando, en este caso va incorporando el 2, 3, 4, 5, porque son los que yo voy generando, 00:11:14
pero podría ir incorporando valores sumandos que vengan de cualquier lado, que vengan de cualquier parte, ¿vale? 00:11:21
Bueno, pues a ver, yo he hecho esto así, vamos a dejarlo más bonito, este es mi numerito n que he leído del teclado, 00:11:31
este es este valor y que yo voy sumando y esta es mi suma vale entonces yo había hecho aquí un bucle 00:11:40
la condición todavía nos falta claro la condición todavía nos falta y este bucle hará ya para 00:11:58
dejarlo bonito en lugar de poner suma igual a suma más lo normal es ponerlo así verdad suma más el 00:12:11
el nuevo sumando, ¿vale? 00:12:17
Y ahora aquí, y lo incrementaba. 00:12:19
Entonces, lo normal, 00:12:23
en una estructura de variable que va acumulando, 00:12:25
lo normal es que la variable suma, ¿vale? 00:12:27
Se inicialice a cero. 00:12:32
Porque es el valor neutro, 00:12:36
el elemento neutro de la suma, ¿verdad? 00:12:38
Es lo normal. 00:12:40
Porque la suma 1 más 2 más 3 más n 00:12:41
es igual que 0 más 1 más 2 más n 00:12:45
que es el elemento neutro 00:12:50
entonces una variable que va a acumular sumandos 00:12:52
uno la inicializa siempre a 0 00:12:55
y luego ya le empieza a meter los diferentes sumandos 00:12:57
la inicializamos a 0 00:13:01
y mediante esta sentencia de aquí 00:13:03
mediante esta sentencia 00:13:06
que esta es la sentencia de acumulación 00:13:08
mediante esta sentencia le vamos metiendo los diferentes sumandos 00:13:11
y esos sumandos 00:13:14
¿de dónde salen? 00:13:18
de donde yo necesite, de donde a mí me dé la gana 00:13:19
en este caso esos sumandos salen 00:13:21
del 1, luego 2, luego 3 00:13:24
pues bueno, tendré que construirlos 00:13:26
¿cómo los puedo construir? 00:13:28
pues 00:13:31
por ejemplo los construyo 00:13:31
iniciando la i 00:13:34
a 1 00:13:36
y aquí incrementando 00:13:37
ya están, ya los tengo construidos 00:13:43
el primer sumando que sumo va a ser el 1 00:13:45
Perfecto, va a ser este 00:13:47
Y luego lo dejo incrementado para que sea 2 00:13:48
El siguiente sumando que incorporo a la suma acumulativa va a ser el 2 00:13:51
Muy bien, luego lo dejo incrementado para que se convierta en 3 00:13:55
El siguiente sumando que sumo, por tanto, ya será el 3 00:13:58
Y esta variable suma a los valores parciales va acumulando el siguiente 00:14:01
El siguiente, el siguiente 00:14:08
Cuando el bucle ha terminado, pues ya podré yo mostrar la suma de todo eso 00:14:09
¿Vale? 00:14:14
¿Qué nos falta? ¿Cuándo termino yo? 00:14:19
Bueno, pues cuando tenga que terminar, depende del programa que esté haciendo. 00:14:22
En este ejemplo en particular, ¿qué condición puedo poner yo ahí? 00:14:26
Que la i sea menor o igual. 00:14:30
Claro, mientras, exacto, mientras la i sea menor o igual que n, 00:14:31
y así nos aseguramos de que va sumando, va sumando, va sumando, 00:14:40
siempre y cuando el sumando sea n. 00:14:44
No, porque si es menor o igual que n 00:14:46
El n no lo sumaría 00:14:49
Porque se incrementa después 00:14:52
Entonces, mientras 00:14:53
Y sea menor o igual 00:14:55
Mientras y sea menor 00:14:56
Que estrictamente menor 00:14:58
Mientras sea estrictamente 00:15:00
Menor que n, ¿verdad? 00:15:03
No, no, no, al contrario 00:15:06
No, no, sí, sí, porque luego la suma 00:15:07
O sea, cuando llegaría 00:15:09
Yo que sé, a 100 00:15:11
Luego iría al ciclo otra vez 00:15:12
No, no, no, no 00:15:13
No, no, no, porque el momento 00:15:15
si n es 100, el momento que llega a 100 lo va a hacer 00:15:19
otra vez igual que a 0.1 00:15:21
Claro, por eso 00:15:23
cuando ya he sumado n 00:15:25
n se queda siendo 00:15:27
n más 1, entonces 00:15:29
igual que n más 1, que sería 00:15:31
menor estricto que n más 1 00:15:33
Así, ¿verdad? 00:15:35
El n más 1 ya no lo queremos sumar 00:15:37
Así, menor que n más 1 00:15:40
o menor o igual que n 00:15:41
Como lo teníamos puesto antes, estaba bien, ¿verdad? 00:15:43
Pero es que en el momento de que si es 100 00:15:45
Luego que me haya centrado a 100 00:15:47
O sea, para el valor n queremos entrar 00:15:49
Y para el siguiente no 00:15:52
Claro, luego menor o igual que n 00:15:53
Que era lo primero que habíamos puesto, estaba bien 00:15:55
No, no, sí, sí, sí 00:15:57
¿Vale? 00:15:58
Es que yo lo he hecho igual, pero he puesto el i más más 00:16:00
Claro, si has puesto el i más más antes 00:16:02
Pues tu condición cambia 00:16:05
Para el n queremos entrar 00:16:06
Y ya para n más 1 no queremos entrar 00:16:08
Luego así estaría bien 00:16:11
¿Vale? 00:16:13
Bueno, pues estructura estándar 00:16:14
¿Qué varía? Repito 00:16:16
De dónde llegan los diferentes sumandos 00:16:18
Y cuándo paro de sumar 00:16:21
Es lo único que varía 00:16:23
Todo lo demás 00:16:24
¿Vale? 00:16:26
Entonces 00:16:28
Sí 00:16:29
Vale, pues aquí entonces suma 00:16:33
Igual a cero 00:16:41
E i, que es mi sumando 00:16:42
e i, que es mi sumando, que empiece valiendo 1. 00:16:44
Y ahora ya, mientras i sea menor o igual que n, 00:16:56
suma más igual i. 00:17:07
Vale. 00:17:15
Lenin, ¿puedes volver a tu sitio? 00:17:19
Vale, entonces 00:17:32
Podemos ir 00:17:33
Ajustando un poco de código 00:17:34
Pues bueno, puedo poner el imas 00:17:37
Más después 00:17:39
Que queda más o menos claro 00:17:40
O también lo puedo poner aquí, ¿no? 00:17:42
Que ya esto lo entendemos, ya lo que significa 00:17:45
Como esto está como post 00:17:47
incremento, primero usa la i 00:17:49
para la operación y luego la deja incrementada 00:17:51
entonces, vale 00:17:53
me da igual 00:17:55
si yo lo quisiera poner 00:17:56
como pre-incremento 00:17:59
¿qué tendría que cambiar en este programa 00:18:02
para que siguiera funcionando? 00:18:03
inicializaría 00:18:07
i a cero, efectivamente 00:18:07
porque lo primero que hace es 00:18:09
incrementa la i y luego la utiliza 00:18:10
para la expresión 00:18:13
¿vale? 00:18:14
Pero quizás se ve más claro así 00:18:16
Primero la utilizo para la expresión 00:18:18
Y luego ya la dejo incrementada 00:18:20
Estoy haciendo dos operaciones en la misma 00:18:22
Una suma y un incremento 00:18:25
¿Vale? 00:18:27
Y puestos ya a pedir 00:18:30
Bueno, no he devuelto la suma, lógicamente 00:18:32
Y puestos ya a pedir 00:18:34
Podemos simplificar código también 00:18:41
Quitando alguna variable 00:18:44
Que está de más, ¿verdad? 00:18:46
Es decir, mi variable n 00:18:51
bueno, pero vamos a dejarlo así 00:18:53
ya iremos, vale, porque habrá 00:18:56
algunos que estén más liados de todo 00:18:57
vale, pues 00:18:59
a ver, que esta variable n 00:19:00
solo la estás usando para el valor inicial 00:19:03
podemos esta misma variable 00:19:05
irla decrementando 00:19:06
y empezar la suma al revés 00:19:08
primero sumar n, luego sumar n-1 00:19:11
y la condición sería 00:19:14
mientras n sea 00:19:15
mayor o igual que 1 00:19:16
vale, es decir, podríamos hacerlo así 00:19:19
vamos a volver a inicializar 00:19:21
Suma igual a 0 para reiniciar la suma otra vez y podríamos hacer, mientras n sea mayor o igual que 1, que es el último sumando, pues hacemos suma más igual n y a n la dejamos decrementada. 00:19:23
entonces hacemos la suma pero empezando desde arriba 00:19:44
y utilizamos la propia 00:19:47
variable n que es que ya no nos sirve para nada más 00:19:49
con lo cual podemos irla decrementando 00:19:51
e ir incorporando 00:19:53
claro 00:19:55
con esta versión la i 00:19:57
no nos hace falta, porque la propia 00:19:59
variable n la usamos para ir 00:20:01
generando los sumandos, luego su 00:20:03
primer sumando va a ser el mayor número 00:20:05
pero luego ya la dejamos incrementada 00:20:07
para el siguiente sumando 00:20:09
que será una unidad menor 00:20:11
y la dejamos decrementada para el siguiente sumando 00:20:12
entonces si n es 10 00:20:15
pues el primer valor que suma es el 10 00:20:16
y luego lo deja incrementado 00:20:19
lo deja decrementado a 9 00:20:20
el siguiente que suma es el 9 00:20:22
y ¿cuál es el último que suma? 00:20:23
el 1 porque el bucle ya cuando n ya no sea mayor o igual que 1 00:20:26
ya no entra 00:20:29
entonces otra versión 00:20:30
a ver, n 00:20:32
es que si pone 0 00:20:42
no va a entrar nunca porque n no es mayor o igual que 1 00:20:44
con lo cual te va a devolver suma igual a cero 00:20:47
que está bien 00:20:50
la suma de todos los números comprendidos entre cero y cero es cero 00:20:50
entonces también 00:20:54
estaría bien el resultado 00:20:55
si en es cero no entra en el bucle 00:20:57
pues te devuelve suma cero 00:21:07
a ver si quieres que te salte mensaje sí 00:21:08
pero si tú quieres que si yo le meto 00:21:13
cero eso no tiene por qué ser un error 00:21:15
si yo le meto cero queda todos los números comprendidos 00:21:17
entre cero y cero 00:21:19
dice el enunciado que si es cero 00:21:22
saque un error, ah mayor que cero 00:21:24
vale, vale, vale 00:21:26
pues entonces si podría, o podríamos meter 00:21:27
una validación como ya sabemos hacer con un while 00:21:30
que esté ahí todo el rato mientras no mete un cero 00:21:32
claro, un while 00:21:34
para forzarle que siga 00:21:36
y siga y siga hasta que no meta un cero, vale 00:21:38
vale, pues entonces con esto 00:21:40
podéis hacer 00:21:45
el 7 00:21:47
podéis hacer el 8 00:21:47
el 7 y el 8 00:21:49
son sumas acumulativas también 00:21:54
Lo que cambian son los sumandos, que aquí son solo los múltiplos de 5, entre 1 y 100. 00:21:57
Y aquí cambian los sumandos, que son los múltiplos de 5, que metidos entre ahí, ¿eh? 00:22:04
Entonces, el 7 y el 8. 00:22:09
¿Quién ha hecho el 7 y el 8? 00:22:12
Venga, pues los demás. 00:22:18
7 y 8, venga. 00:22:21
Los hacéis, son como el anterior, cambiando el detallito de dónde salen los sumandos. 00:22:23
Pues 7 y 8 los hacéis en los próximos 10 minutos 00:22:28
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:
1
Fecha:
31 de octubre de 2025 - 13:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
22′ 36″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
592.17 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid