Saltar navegación

20241017 ProgrEstruct-Bucles-ejercicios_1 - 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 20 de octubre de 2024 por Raquel G.

18 visualizaciones

Más información Transcripción

Descargar la transcripción

Lo habéis hecho muy bien. 00:00:00
A ver, ¿qué pasa con el ejercicio 2? 00:00:02
¿Qué habréis dicho? ¡Uh, qué tontería! 00:00:06
Claro, entonces vosotros habéis leído y habéis dicho. 00:00:14
Como yo. Vamos a ver. 00:00:18
Vale, vosotros habéis leído y habéis visto. 00:00:24
Mostrar por pantalla los números del 1 hasta el 5. 00:00:27
Vale, entonces 00:00:31
Hombre, pues dice, jolín 00:00:34
Pues vaya programa más tonto, ¿no? 00:00:36
Ups 00:00:46
A ver 00:00:47
Claro, efectivamente 00:00:59
Habéis sacado las conclusiones correctas 00:01:08
Vale, entonces 00:01:11
¿Mostrar los números de 1 al 5? 00:01:14
Pues ya está, ya tengo hecho mi programa 00:01:16
¿Vale? 00:01:18
Silencio 00:01:21
¿Vale? ¿No tengo hecho mi programa 00:01:22
De mostrar números de 1 al 5? 00:01:24
Pues sí, son 5 líneas, no son tantas 00:01:26
¿Vale? Entonces 00:01:29
Primero, tampoco perdamos de vista 00:01:30
Que hay veces 00:01:32
Que las cosas, si tienen un camino 00:01:34
Simple y sencillo 00:01:36
Para resolverse, pues no 00:01:38
Renunciemos a él 00:01:40
¿vale? pero ¿cuál es la pega de este 00:01:41
programa? desde luego 00:01:44
funciona perfectamente y cumple 00:01:46
requisitos, que es lo que tiene que hacer 00:01:48
una aplicación, cumplir requisitos 00:01:50
es decir, hacer lo que le han pedido 00:01:52
pero esta aplicación 00:01:53
no es escalable 00:01:56
que se llama, es decir, ahora me piden 00:01:58
un pequeño cambio 00:02:00
me dicen, ay porfa, sí, pero es que me he 00:02:02
equivocado, no era de 1 a 5, era de 1 a 00:02:04
5.000, entonces 00:02:06
claro, escalar esta aplicación 00:02:08
incorporarle esa funcionalidad 00:02:10
implica escribir 00:02:12
4.500 líneas más 00:02:14
entonces cuando hacer una pequeña 00:02:15
modificación en un código 00:02:18
implica un cambio tan 00:02:19
grande como escribir 4.000 líneas más 00:02:22
seguramente es que algo 00:02:24
he hecho mal en mi diseño 00:02:26
entonces repito 00:02:27
este programa está bien, son 5 líneas y está estupendo 00:02:29
pero no es escalable 00:02:32
no es fácilmente ampliable 00:02:34
vale 00:02:36
entonces uno dice, bueno, previendo 00:02:36
que yo tenga que ampliar este código 00:02:40
que tenga que escalar sus posibilidades 00:02:42
previendo lo digo, hombre, estoy haciendo 00:02:44
varias veces lo mismo 00:02:46
pues como yo sé que tengo 00:02:47
una sentencia while para hacer varias veces 00:02:50
lo mismo, pues en lugar de 00:02:52
hacer tanto system out 00:02:54
pues me hago aquí 00:02:56
un while y este 00:02:58
while que sea el que se 00:03:02
encargue de repetir 00:03:04
vale, pero en el momento 00:03:05
en el cual decido 00:03:08
que meto aquí un while 00:03:09
para repetir esto, digo 00:03:12
estupendo, ahora ya esto se puede 00:03:14
hacer una mil, quince mil 00:03:17
las veces que haga falta, no tengo yo que 00:03:18
escribirlo system out, pero claro 00:03:20
tengo que terminar de completar el bucle, diríamos 00:03:22
a ver, pero aquí me faltan 00:03:24
cosas, primero 00:03:26
este bucle mostraría 00:03:28
uno todo el rato, no queremos 00:03:31
que muestre une, uno, queremos 00:03:32
que muestre algo que es 00:03:34
variable, primero mostrará uno, luego 00:03:36
dos, luego tres, entonces 00:03:38
Pues al mostrar algo que es variable ya me lo están diciendo, me están diciendo, hombre, muestra ahí una variable, muestra una variable, muestra una variable, porque es algo que cambia. Ah, vale, pues ahora ya sigo pensando. Y esta variable que muestro, ¿de dónde va? Desde 1 y todos sus incrementos. Pues bueno, inicialmente que tenga 1, ¿vale? Vale, ya me he aproximado más. 00:03:40
Pero claro, ese valor variable 00:04:04
Entre qué valores tiene que ir variando 00:04:07
Tiene que ir variando 00:04:09
Entre 1, luego 2, luego 3, luego 4 00:04:13
Pues tendré que incrementarlo en algún momento 00:04:15
Lo puedo dejar incrementado ahí o no 00:04:17
Y me siguen faltando cosas 00:04:19
Pero cuánto tiempo voy a estar 00:04:21
Yo ejecutando estos system out 00:04:24
Pues mientras que 00:04:25
N sea menor o igual que 5 00:04:27
Vale 00:04:29
Entonces 00:04:31
he ganado 00:04:32
una línea de código, no he ganado más 00:04:34
respecto a hacer los 5 00:04:37
System Outprint LN 00:04:38
solo he ganado una línea de código 00:04:40
bueno, pues lo tenía comodísimo, me hago 00:04:42
5 System Outprint LN 00:04:44
pero este programa ha ganado 00:04:45
en lo que realmente necesitamos 00:04:47
y es que sea escalable 00:04:50
me dicen, uy me equivoqué, son 50.000 00:04:52
ah, no pasa nada 00:04:55
son 50.000, no pasa nada 00:04:56
te cambio esto, y ya está 00:04:58
pues con una mínima modificación 00:05:00
este programa ya 00:05:02
lo puedo yo ampliar 00:05:04
a un montón de posibilidades 00:05:06
la versión anterior, uy me he equivocado 00:05:08
eran 50.000, pues tengo que escribir 00:05:10
49.595 00:05:12
95 líneas más 00:05:15
que no es la idea 00:05:18
entonces los programas no es solo que sean 00:05:19
bonitos, que funcionen, que no sé qué 00:05:22
sino que además los diseños 00:05:24
sean modificables de forma sencilla 00:05:26
bueno pues este era el objetivo en realidad 00:05:28
de este ejercicio simplemente aparte de platicar 00:05:31
con el while 00:05:34
pues ver que se puede hacer lo mismo de varias formas 00:05:34
distintas 00:05:38
normalmente la sencillez 00:05:39
siempre es la mejor claro pero la escalabilidad 00:05:44
también 00:05:46
vale entonces 00:05:46
este que cambia pues cambia 00:05:49
respecto a otro es lo mismo 00:05:52
pero saltándose un número 00:05:53
¿no? entonces 00:05:55
En este 00:05:57
Bueno, esto de aquí 00:05:59
Si hacemos exactamente lo que nos pide 00:06:03
Si hacemos exactamente lo que nos pide 00:06:05
Pues tendríamos que completar a tres bucles 00:06:11
Primero cinco, luego cincuenta 00:06:13
Y luego quinientos 00:06:15
Y así hago exactamente lo que me pide 00:06:16
Pues no del todo 00:06:22
Efectivamente, no hago exactamente lo que me pide 00:06:26
Porque, claro, tengo que volver 00:06:28
A empezar desde uno 00:06:30
Tengo que volver a empezar desde uno 00:06:32
Ahora si hace exactamente 00:06:34
lo que me pide, de 1 al 5, de 1 al 50 00:06:36
de 1 al 500 00:06:38
el 2 es lo mismo pero 00:06:39
me tengo que saltar números, luego ya el bucle 00:06:42
lo complico un poquito porque meto un if dentro 00:06:44
nada más, entonces el 3 00:06:46
es lo mismo que el anterior 00:06:56
el 3 es lo mismo pero ahora 00:06:58
parto de 1 00:07:09
y acabo en 100 00:07:11
parto de 1 y acabo 00:07:12
en 100, luego este límite lo cambio 00:07:15
pero no los muestro todos 00:07:17
¿vale? no los muestro todos 00:07:19
Aquí me falta incluir un if dentro 00:07:21
Tengo que mostrar 00:07:24
Solo los números comprendidos 00:07:26
En ese intervalo 00:07:28
Que no sean múltiplos de 5 00:07:29
Solo los que no lo sean 00:07:31
Luego si el resto de dividir 00:07:33
En entre 5 es diferente 00:07:35
De 0 00:07:38
Entonces 00:07:38
A la tercera 00:07:42
Voy a poner la llave para que no 00:07:43
Vale 00:07:47
Pues este es el mismo que el anterior 00:07:53
Muestro entre 1 y 100 00:07:55
Esta vez entre 1 y 100 00:07:57
Pero los muestro todos 00:07:58
No, no los muestro todos 00:07:59
Muestro solamente aquellos que no sean múltiplos de 5 00:08:02
Luego de la lista 00:08:05
Estoy sacando a estos 00:08:08
Y no me olvido de incrementar 00:08:09
Claro 00:08:12
¿Vale? ¿Estaría bien esto? 00:08:12
¿Sí? 00:08:28
Vamos a ejecutarlo 00:08:29
A ver si está tan bien como decís 00:08:32
Efectivamente 00:08:34
Ahí estoy, aunque no lo parezca 00:08:40
Estoy en un bucle infinito 00:08:42
Mi programa es un bucle infinito 00:08:44
Ahí se ha quedado parado 00:08:46
O lo paro aquí o lo he liado 00:08:49
Entonces, ¿por qué es un bucle infinito? 00:08:51
Porque 00:08:54
En cuanto llega 00:08:55
El primer múltiplo de 5 00:08:59
Ya aquí no entra 00:09:00
Con lo cual n se queda sin incrementar 00:09:02
Entonces n se va a quedar plantado en 5 00:09:04
El resto de su vida 00:09:07
Porque nunca jamás voy a entrar aquí 00:09:08
Luego nunca lo voy a incrementar 00:09:11
Claro, entonces no es tan trivial 00:09:13
El salto de uno a otro 00:09:15
Cuidadín, ese no es el sitio 00:09:16
De incrementar la n 00:09:19
La n la quiero incrementar, tanto si es múltiplo de 5 00:09:20
Como si no 00:09:23
Entonces queda más claro 00:09:24
Bueno, a ver 00:09:27
N empieza siendo 1, lo voy incrementando 00:09:36
Y mientras no sea múltiplo de 5 00:09:38
lo muestro, hombre 00:09:41
lo podría hacer aquí también 00:09:42
¿verdad? 00:09:45
a que lo podría hacer ahí 00:09:48
esto ya se es más confuso porque 00:09:49
esto lo hace siempre 00:09:51
el while siempre 00:09:52
evalúa esta condición, siempre entra aquí 00:09:55
entonces, coge n 00:09:57
múltiplo de 5 y la deja incrementada 00:09:59
para la siguiente, ¿vale? 00:10:01
pero cuidadín 00:10:04
que el que muestra aquí es el siguiente 00:10:05
luego tampoco está bien 00:10:07
tendría que poner más más n en el i 00:10:08
si pongo más más n, pero entonces 00:10:10
tengo que partir de lo anterior. 00:10:14
En el while, dentro del while, pero 00:10:17
tendrías que partir de más más. 00:10:18
¿Aquí te refieres? 00:10:21
Fuera de ahí. 00:10:22
Yo lo pondría en plan abajo, dentro del while, pero fuera de ahí. 00:10:24
Sí, es que eso es lo que había hecho antes, 00:10:27
pero os he dicho, aquí se queda 00:10:29
muy claro, ¿no? 00:10:30
Ahí sí. 00:10:32
Ese es su sitio. Pero lo que he dicho es, aquí está 00:10:34
claro, aquí lo vemos todo claro. Y luego he 00:10:36
dicho, para pillaros como siempre, 00:10:38
o si no, pues lo pongo aquí 00:10:40
o si no, lo pongo aquí 00:10:44
entonces aquí es cuando este código no es idéntico 00:10:45
a poner n más más abajo 00:10:49
porque aquí se queda incrementado antes de mostrar 00:10:50
luego voy a estar mostrando el siguiente 00:10:53
del que estoy comprobando si es múltiplo de 5 o no 00:10:57
voy a estar mostrando el siguiente 00:11:00
¿veis? de hecho me está mostrando múltiplos de 5 00:11:01
que no debería 00:11:05
Que no debería 00:11:06
Claro, porque es el siguiente 00:11:07
Claro, me está mostrando el siguiente 00:11:08
Al que estoy evaluando 00:11:11
¿Vale? 00:11:13
Entonces el 96 no me lo mostrará 00:11:15
Porque es el siguiente, el 95 00:11:17
Y el 95 sí que es múltiplo de 5 00:11:18
Entonces cuidado con los pequeños cambios que hacéis 00:11:20
Este no tenemos duda de que este es el correcto 00:11:23
Esto está bien, ¿verdad? 00:11:26
Claro 00:11:28
Aquí, numerito 00:11:28
¿Es múltiplo de 5? 00:11:30
pues lo muestro 00:11:34
¿es múltiplo de 5? 00:11:36
sí, luego esta condición es falsa 00:11:38
no hago nada, y en ambos casos lo incremento 00:11:40
entonces cuidado 00:11:42
por compactar código y dejarlo 00:11:44
todo compacto, cuidado porque hay veces que 00:11:46
a lo mejor uno se le escapa un detalle y ya el programa 00:11:48
no hace lo que tiene que hacer, no pasa nada 00:11:50
si es que no hay que pagar por las líneas 00:11:52
de código extra, no pasa nada 00:11:54
entonces si dejan más claro el código 00:11:56
se ponen, entonces hombre 00:11:58
este bucle se ve mucho más claro si este 00:12:00
n más más está aquí, en lugar 00:12:02
¿vale? en lugar de estar aquí, con lo cual 00:12:04
luego decrementar el valor otra vez 00:12:06
patatín, patatán, etc 00:12:08
¿vale? 00:12:09
n más más y luego poner n menos 1 00:12:13
para mostrar 00:12:15
ya, pero entonces ya sí que estamos 00:12:16
con lo sencillo que es así, ¿verdad? 00:12:18
vale, pues entonces 00:12:23
estos dos, claro, clarísimo 00:12:24
estamos usando el bucle para mostrar simplemente 00:12:27
y ya está 00:12:29
Ahora, hasta aquí estábamos mostrando 00:12:30
El 2 y el 3 eran para mostrar cositas y ver 00:12:36
El 4, ahora vamos a contar 00:12:39
Ejercicio 4, vamos a contar 00:12:42
Incorporamos un poquito más 00:12:44
Vale, pues venga 00:12:46
El 4 00:12:50
Bueno, a ver, el resultado final es una cuenta 00:12:52
Han sido tantos 00:13:01
Entonces, tú tendrás que contar de alguna manera 00:13:02
la otra cosa es que me digas con qué variable lo hagas 00:13:05
lo haces incrementando, decrementando, ¿qué utilizas? 00:13:07
¿vale? 00:13:10
pero el resultado final es una cuenta 00:13:12
¿vale? entonces tienes que contar 00:13:13
de la manera que sea, pero tienes que contar 00:13:15
vale, pues venga, ejercicio 4 00:13:17
vale, pues aquí 00:13:19
de nuevo, si lo vamos haciendo 00:13:33
pasito por pasito 00:13:35
pasito por pasito 00:13:38
silencio que me estáis distrayendo 00:13:39
vale, si lo vamos haciendo 00:13:42
paso por paso, siguiendo todas 00:13:45
las líneas 00:13:47
venga, me han dicho que 00:13:49
¿datos de entrada? ninguno 00:13:51
ningún dato de entrada, no tengo que leer nada, vale 00:13:52
tengo que hacer una cuenta 00:13:55
una cuenta tengo que hacer, bueno 00:13:57
pues entonces un contador 00:13:59
me va a venir muy bien 00:14:01
y cuando tengo que hacer una cuenta 00:14:03
esto, acaba siendo esto 00:14:05
acaba siendo algo así 00:14:07
vale, tengo que hacer una cuenta 00:14:09
acaba siendo algo así 00:14:11
vale, ¿qué tengo que contar? 00:14:12
Tengo que contar números. 00:14:15
Luego tiene que haber una variable en algún sitio 00:14:18
que vaya recogiendo cada uno de los valores 00:14:21
que yo voy contando. 00:14:25
Porque voy a contar números. 00:14:28
Pues esa variable para eso. 00:14:30
Vale, sigo pensando. 00:14:31
Números. 00:14:33
¿Esos números entre qué valores oscilan? 00:14:34
Entre 1 y 100. 00:14:38
Luego, inicialmente, el primero a contar es el 1. 00:14:40
pero ¿cuándo terminaré yo 00:14:43
con todos ellos? 00:14:46
¿cuándo terminaré? 00:14:49
pues terminaré cuando n 00:14:51
ya haya llegado a 101 00:14:52
o lo que es lo mismo, estaré contando 00:14:54
mientras n sea igual que 100 00:14:56
luego ya he avanzado mucho 00:14:57
he decidido que son números lo que voy a contar 00:15:00
luego una variable n tiene que haber ahí 00:15:02
para ir recibiendo cada uno de los que voy 00:15:03
teniendo en cuenta 00:15:06
¿qué recorrido hago? 00:15:07
pues desde el 1 hasta el 100 00:15:10
pues entonces parto del 1 y la condición 00:15:12
está clara cuál es 00:15:14
y si voy recorriendo todos ellos 00:15:15
en algún momento tendré que incrementarlos 00:15:18
tendré que incrementarlos, vale 00:15:21
pues ya estoy avanzando mucho 00:15:22
y mi cuenta cuando la incremento, que sabía que era aquí 00:15:23
colgando mi cuenta, mi cuenta la incremento 00:15:26
para cada n que sea 00:15:29
múltiplo de 7, ah vale, pues ya tengo 00:15:30
lo que me faltaba, cuidado que esta cuenta 00:15:32
solo se incrementa 00:15:34
el resto de dividir en entre 7 00:15:38
es 0, solo se incrementa ahí 00:15:40
¿Vale? Es el mismo ejercicio que hemos hecho 00:15:42
Pero el otro era múltiplo de dos 00:15:45
Pues lo mismo, hemos repetido lo mismo 00:15:46
Una y otra vez 00:15:49
Está fuera de lift 00:15:50
Está fuera de lift 00:15:51
Que sea buen hábito 00:15:52
No significa que cuando lo veáis sin llaves 00:16:00
Automáticamente no penséis 00:16:03
Ah, vale, no tengo llaves, solo es la siguiente 00:16:04
¿Vale? 00:16:06
Vale 00:16:09
El total es 00:16:10
y aquí yo tengo ya 00:16:15
mi cuenta de múltiplos 00:16:17
de 7 00:16:20
vale, y ya está, ya me he hecho 00:16:20
mi ejercicio 00:16:23
vale, pues venga, ahora sí que 00:16:24
paramos aquí 00:16:28
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
18
Fecha:
20 de octubre de 2024 - 18:28
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
16′ 32″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
70.64 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid