Saltar navegación

20251027 EjerBucles_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 27 de octubre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver 00:00:00
Venga, concentración 00:00:04
Porque de todos 00:00:06
Algunos lo habréis hecho, pero de todos se puede sacar un aprendizaje 00:00:08
A ver, ¿queréis hacer como que me escucháis? 00:00:11
Vale 00:00:18
Bueno, pues entonces, este cambia un poquito 00:00:18
Sigue siendo contar 00:00:21
Luego aquí va a haber una cuenta 00:00:22
Eso sí o sí 00:00:26
Porque este problema, este ejercicio sigue siendo contar algo 00:00:27
Vale, ahora, mi espacio de muestra, mis candidatos a ser contados, ¿cuáles son? 00:00:33
Todos los números comprendidos entre dos solicitados por teclado 00:00:41
Ah, vale, pues ya tengo que leer del teclado, pues venga 00:00:46
Vale, entonces, voy a coger esos dos datos de entrada 00:00:51
el valor inicial 00:01:05
¿vale? 00:01:09
valor inicial de todos ellos 00:01:21
y el valor final 00:01:23
vale, n2 00:01:25
bueno, ya tengo mis dos datos de entrada imprescindibles 00:01:36
el valor inicial y el final 00:01:39
de todo 00:01:42
ese conjunto de elementos 00:01:43
susceptibles de ser contados 00:01:45
de toda mi muestra 00:01:47
vale, entonces 00:01:48
esto va a ser un bucle 00:01:50
lógicamente que va haciendo aparecer 00:01:53
esos elementos 00:01:55
los va haciendo aparecer 00:01:57
sí, sí, sí, pero voy por partes 00:01:58
es como si estuviera haciendo 00:02:02
el hilo de pensamiento 00:02:03
yo voy haciendo primero la arquitectura del programa 00:02:04
y la voy rellenando 00:02:07
de alguna manera lo que intento es 00:02:08
que eduquemos nuestra manera de pensar 00:02:10
que en algunos casos el programa es sencillo 00:02:12
y pues uno lo casca y ya está 00:02:14
y le parece que ni ha pensado 00:02:15
pero bueno, vamos a... 00:02:16
vale, entonces, esto es contar 00:02:18
entonces, esto va a ser una estructura 00:02:20
de este estilo 00:02:22
donde yo tengo que ir haciendo aquí aparecer 00:02:23
los elementos susceptibles de contar 00:02:26
los elementos susceptibles de contar 00:02:28
son todos aquellos 00:02:30
comprendidos entre N1 y N2 00:02:31
luego, con lo que hemos visto 00:02:33
en el ejercicio anterior 00:02:35
pues yo diría, a ver, esta va a ser mi fuente de datos 00:02:36
inicialmente 00:02:40
que sea N1 00:02:42
porque es el primero de todos 00:02:44
en el ejercicio anterior 00:02:46
N era 1 00:02:48
porque yo iba entre 1 y 100 00:02:49
aquí he cambiado 00:02:51
ahora voy entre N1 y N2 00:02:52
Es una extensión de este programa 00:02:55
Donde este es N1 00:02:59
Este es N2 00:03:01
Y este sería el tercer dato 00:03:03
N es mi fuente de datos 00:03:04
Inicialmente es N1 00:03:08
Y se va a ir incrementando 00:03:10
Para ir generando todos 00:03:12
¿Cuándo voy a terminar yo de generar 00:03:13
Mis datos de entrada? 00:03:18
Pues hasta que no haya 00:03:19
Alcanzado N2 00:03:22
Bueno pues me estoy apoyando 00:03:23
la misma estructura del ejercicio anterior. 00:03:26
Tengo que generar mis elementos a contar. 00:03:28
Mis elementos a contar van a ser números. 00:03:31
Luego los guardo aquí. 00:03:34
Y los voy generando partiendo desde el N1 00:03:35
e incrementándolos de uno en uno. 00:03:38
¿Y cuándo? 00:03:42
Pararé cuando N ya haya llegado a ser N2. 00:03:43
Y ahora aquí me faltaría hacer la cuenta. 00:03:46
¿Bajo qué condición incremento la cuenta? 00:03:49
Pues me dicen, 00:03:53
Oye, incrementa la cuenta 00:03:54
Si ese numerito 00:03:56
Que tú vas generando 00:03:57
Si ese numerito es múltiplo de alguien 00:03:59
Ah, vale, si este numerito es múltiplo 00:04:02
De alguien 00:04:04
Y la condición de ser múltiplo, ya sabemos que está 00:04:05
Entonces 00:04:07
Lo cuentas, ah, vale, vale 00:04:09
Pues me falta el alguien, del cual tiene que ser 00:04:11
Múltiplo para que yo sea 00:04:14
Para que lo cuente, ah, vale, pues venga 00:04:15
Lo pedimos aquí, por ejemplo 00:04:17
Vale, pues ya está 00:04:32
Ya puedo completar la condición 00:04:36
Mientras ese número sea múltiplo de m 00:04:38
Ya está 00:04:40
Y tengo una primera versión 00:04:41
¿Vale? 00:04:44
Tengo una primera 00:04:45
Ah, que no está usado 00:04:46
Vale, bueno, me falta mostrar el resultado 00:04:53
Resultado 00:04:55
Y tengo una primera versión 00:05:01
Para la cual me he apoyado 00:05:05
En problemas que ya he resuelto y ya sé hacer 00:05:07
¿Vale? 00:05:09
Como siempre hacemos 00:05:10
uno pues va, según va haciendo 00:05:12
aplicaciones, según va haciendo programas 00:05:14
va resolviendo situaciones 00:05:16
y ese aprendizaje 00:05:17
ya se le queda instalado para apoyarse en él 00:05:19
para luego resolver otras situaciones 00:05:22
parecidas o similares 00:05:24
pues aquí nos hemos aprovechado en este aprendizaje 00:05:25
en el cual hemos contado 00:05:28
números, ya sabemos 00:05:29
cómo irlos generando 00:05:32
pues desde el valor inicial 00:05:33
hasta el final 00:05:35
incrementando 00:05:37
pues ya nos hemos 00:05:38
apoyado en ese conocimiento, pues aquí 00:05:41
la única diferencia es que el valor inicial 00:05:43
ahora cambiaba, que era n1 00:05:44
y el valor final cambiaba, que era n2 00:05:46
pero la forma de generarlos 00:05:49
era igual, partiendo el valor inicial 00:05:51
incrementando hasta el final 00:05:52
¿mi condición cuál era? 00:05:54
ser múltiplo de, ah vale, ya sé cómo hacer 00:05:56
la condición ser múltiplo de algo 00:05:58
aquí lo único que me ha cambiado es que ese algo 00:06:00
ahora no es 7 00:06:03
sino que es un valor que he tenido que pedir 00:06:04
¿vale? pero la estructura es la misma 00:06:06
yo voy contando 00:06:09
y cuando el bucle ha terminado tengo mi resultado 00:06:09
final, hasta que el bucle ha terminado no tengo 00:06:12
el resultado final ¿vale? 00:06:14
entonces 00:06:18
cuando pensáis en programar 00:06:19
tenéis que pensar 00:06:24
en líneas de código 00:06:26
en while, en leaf, en contador 00:06:28
tenéis que pensar siempre 00:06:30
en que vais incorporando patrones lógicos 00:06:31
de alguna manera, vais incorporando patrones 00:06:34
lógicos que luego vais aplicando 00:06:36
si luego escribirlo es lo de menos 00:06:38
pero pensar en términos de patrones que voy incorporando 00:06:40
como contar, como sumar de forma acumulada 00:06:42
como 00:06:44
ir incrementando valores 00:06:45
¿vale? 00:06:48
bueno, pues esta ha sido una primera versión 00:06:50
ahora lógicamente 00:06:52
pues vienen varias cosas, primera 00:06:54
que uno se dé cuenta de que igual puede simplificar 00:06:55
un poquito a lo mejor 00:06:58
¿vale? 00:07:00
sí 00:07:02
que uno se ponga a hacer pruebas 00:07:05
Y haciendo las pruebas vea si funciona 00:07:07
Por ejemplo, vamos a ver todos los múltiplos de 2 00:07:10
Entre 2 00:07:13
Y 10 00:07:14
Múltiplos de 2 00:07:16
Me deberían salir 2, 4, 6, 8, 10, 5 00:07:18
¿Verdad? 00:07:21
Esta prueba la ha pasado 00:07:22
¿Significa eso que mi programa 00:07:24
Este bien? 00:07:26
No, esta prueba la ha hecho 00:07:28
Yo tendría que hacer más pruebas realmente 00:07:29
Hombre, en este programa sencillo 00:07:31
Vale 00:07:34
Por ejemplo 00:07:35
Pues yo que sé, entre 6 y 12 00:07:37
¿Cuántos múltiplos de 3 tengo? Pues 3, 6, 9 y 12 00:07:41
Vale, parece que, pero claro, uno tiene que hacer pruebas buscando también 00:07:45
Los casos límite que se llaman, por ejemplo, oye 00:07:49
¿Y si te voy a buscar las cosquillas? Vamos a ver 00:07:52
Todos los múltiplos entre 4 y 1 00:07:57
Todos los múltiplos de 4, aquí me deberían salir 00:08:01
0, porque 00:08:05
4 y 1 es un intervalo 00:08:07
donde el valor inicial 00:08:10
está después 00:08:11
que el final, luego ese intervalo no tiene 00:08:14
contenido, no tiene valores, me debería salir 0 00:08:16
da la casualidad 00:08:18
de que sale 0, claro, porque ¿qué ha ocurrido aquí? 00:08:20
caso interesante de ver lo que ha hecho 00:08:22
¿qué ha ocurrido aquí? 00:08:23
pues que 00:08:27
n1 es mayor que n2 00:08:27
con lo cual jamás 00:08:30
entra en el bucle 00:08:32
luego la cuenta sigue siendo 0 00:08:33
Pues que bien, que suerte 00:08:35
Ha hecho de casualidad 00:08:37
Porque yo no lo he buscado 00:08:39
Ha hecho lo que tenía que hacer 00:08:40
Si el valor inicial es mayor que el final 00:08:42
No quiero que cuente nada 00:08:46
Porque ahí no hay números en ese intervalo 00:08:48
Y es que de hecho no los va a contar 00:08:50
Porque n1 00:08:52
Que es su valor inicial 00:08:53
N1 ya es mayor que n2 00:08:54
Luego jamás va a entrar en este bucle 00:08:57
¿Vale? 00:08:59
Luego, si n1 es 00:09:01
mayor que n2 00:09:04
nunca entraría al bucle 00:09:07
con lo cual me sale contador 0 00:09:09
vale, ese caso de prueba 00:09:16
le he pasado 00:09:19
pero nos podemos poner a 00:09:19
forzar más casos raros 00:09:22
va a la inicial 3 00:09:24
va a la inicial 7, múltiplos de 0 00:09:26
me sale un error de ejecución 00:09:28
estas letras rojas 00:09:33
significan que el programa ha petado 00:09:35
porque le he obligado a hacer algo 00:09:36
que no puede hacer 00:09:39
y se ha roto 00:09:41
entonces tenemos que evitar 00:09:42
que los programas se rompan 00:09:45
porque la imagen que da el que lo usa 00:09:46
no es lo mismo que el programa me diga 00:09:49
perdona, introdujiste un valor 00:09:51
incorrecto, inténtalo otra vez 00:09:53
no es lo mismo que me diga eso educadamente 00:09:54
a que pum, se rompa 00:09:56
y me salgan estas cosas rojas 00:09:58
entonces, ¿por qué se ha roto? 00:10:00
pues tendremos que mirar por qué se ha roto 00:10:03
claro, porque 00:10:05
en este caso 00:10:07
m, que es el valor que yo he metido, era 0 00:10:09
era 0, ¿verdad? 00:10:11
he metido 0 00:10:13
entonces 00:10:14
esta operación hace una división 00:10:16
de la cual se queda 00:10:22
solo con el resto, es cierto, se queda solo con el resto 00:10:23
pero hace una división 00:10:25
con lo cual la división entre 0 00:10:27
la máquina virtual no puede 00:10:29
hacerla y se rompe 00:10:31
Luego nunca deberíamos llegar a hacer una división por cero 00:10:32
Entonces yo debería evitarlo antes 00:10:36
Hombre, puedo 00:10:38
Por ejemplo, primera forma de evitarlo 00:10:40
Confiar en la bondad 00:10:44
De la humanidad 00:10:46
Y decir, si yo le pido 00:10:46
Que me lo meta distinto de cero 00:10:48
Por favor, voy a confiar en que lo va a hacer 00:10:51
Bueno, hay múltiplos de menos tres también 00:10:53
No, porque este es el valor múltiplo, 00:10:59
no el inicial y el final del intervalo. 00:11:04
Pero vamos, que puedes poner 00:11:11
un inicial menos 3 y 4 00:11:12
y no pasa nada, entre menos 3 y 4 00:11:14
todos los comprendidos que sean múltiplos del que sea. 00:11:15
Es que no lo haces entre 0, 00:11:21
porque este no cambia nunca, 00:11:23
este es inamovible. 00:11:25
El que va cambiando es el n, 00:11:27
el que está aquí, 00:11:30
en el dividendo. 00:11:32
este jamás cambia 00:11:32
este es el número del cual tú quieres ver si es múltiplo 00:11:34
si te han metido 7, va a ser siempre 7 00:11:37
jamás cambia 00:11:39
el que cambia es 00:11:40
el dividendo 00:11:42
entonces 00:11:43
tú puedes, pues eso, confiar en la humanidad 00:11:46
vale, pues hombre, podemos confiar 00:11:49
en la humanidad, pero claro 00:11:53
lógicamente 00:11:55
pues, aunque yo le diga distinto 00:11:56
de cero 00:11:59
Pues él se le puede ir la mano 00:11:59
Y seguiría fallando 00:12:02
¿Qué podemos hacer 00:12:03
Para hacerlo ya súper guay? 00:12:06
Obligarlo 00:12:09
Con un bucle de validación 00:12:09
Como ya sabemos bucles 00:12:11
Que este scan next in no se quede aquí 00:12:13
En un ingenuo scan next in 00:12:16
Vamos a meterlo en un bucle 00:12:18
Que esté ahí todo el rato y mientras no me meta 00:12:20
Uno diferente de cero, yo de ahí no salgo 00:12:22
¿Vale? Este fue el primer 00:12:24
Ejemplo que vimos el viernes cuando vimos bucles 00:12:26
un bucle que valida que el dato cumpla una condición 00:12:28
pues hombre, si yo quiero hacer este programa 00:12:31
completamente robusto 00:12:33
y que no tenga errores horribles 00:12:36
de romperse como este 00:12:40
es que no me queda más remedio 00:12:42
o meto este scan next in en un bucle 00:12:44
o la hemos liado 00:12:49
no pasa nada, vamos a meterlo en un bucle 00:12:51
ya lo hicimos ayer, entonces de nuevo 00:12:54
nos estamos apoyando todo el rato 00:12:56
para hacer las cosas 00:12:59
en cosas que ya hemos resuelto 00:13:00
conclusión 00:13:02
uno tiene que hacerlo todo 00:13:05
mirarlo todo y quedárselo aquí 00:13:06
en la cabeza 00:13:08
para programar la habilidad 00:13:09
más importante 00:13:13
primero es la memoria 00:13:14
aprender, aprender, aprender 00:13:16
estudiar de memoria siempre 00:13:18
todo 00:13:20
y segundo la lógica 00:13:21
porque parece que la memoria no sirve para nada 00:13:23
memoria fundamental, uno no puede programar 00:13:25
si no tiene conocimientos aquí 00:13:28
no teóricos, conocimientos de problemas 00:13:29
que ya he resuelto todos aquí para ir tirando 00:13:32
del hilo 00:13:34
y luego ya le aplica la lógica 00:13:34
para componerlos, pero primero 00:13:38
tiene que tenerlo en la cabeza, luego ya 00:13:40
viene la lógica donde tú los compones 00:13:41
bueno pues como ya vimos 00:13:43
el viernes como hacer una 00:13:45
validación, dijimos 00:13:47
oye pues tú te haces aquí un do while 00:13:49
maravilloso, me haces 00:13:51
un do while 00:13:55
Mientras mi numerito M 00:13:56
Sea igual a 0 00:13:59
La declaración la saco fuera, ¿verdad? 00:14:00
¡Hala! Ya está 00:14:11
Ahora este programa 00:14:11
No se va a romper nunca por la 00:14:13
Por la división aritmética 00:14:16
Porque este bucle 00:14:18
Va a estar aquí pidiendo número, pidiendo número 00:14:20
Pidiendo número 00:14:22
Mientras el número sea 0 00:14:23
Todo el rato ahí 00:14:26
De hecho 00:14:28
No puede ser cero 00:14:31
Intenta otra vez 00:14:36
Y ahí va a estar todo el rato 00:14:40
Le número 00:14:44
Perdón 00:14:45
Este no puede ser 00:14:48
No puede ser cero 00:14:49
Será si el numerito metido 00:14:52
Es igual a cero 00:14:54
Ya está 00:14:55
Ya lo tengo validado 00:15:06
Entonces vamos a volver a ejecutar esto 00:15:08
Hay algún 00:15:10
Tengo el 00:15:14
Hay una llave que me 00:15:18
Do while 00:15:20
Ah, vale, la llave del while es la que me falta 00:15:24
Esta, vale 00:15:26
Vale, pues ahora ya sí 00:15:28
Ejecutamos 00:15:30
Valor inicial, cuatro 00:15:32
Valor final, nueve 00:15:34
Cero, no puede ser cero 00:15:36
No puede ser cero, no puede ser cero 00:15:38
No puede ser cero, ahí está el infinito 00:15:41
Cuatro 00:15:42
¡Hala! Ya está 00:15:44
Ahí está todo el rato, no puede ser cero 00:15:49
No puede ser cero, no puede ser cero 00:15:52
¿Vale? Ahí, validando, validando, validando 00:15:53
¿Perdón? 00:15:56
Espero, espero 00:15:58
Bueno, pues haciendo las pruebas 00:15:59
Hemos visto 00:16:08
Que para algún caso de prueba 00:16:09
Esto petaba, que no me gusta que pete 00:16:11
Pues hemos puesto esta validación 00:16:13
Y ya está, muy bien 00:16:15
vale 00:16:16
el otro caso de prueba 00:16:17
que hemos dicho, que nos ha salido de casualidad 00:16:21
vamos a 00:16:23
aprovechar, por ejemplo, el caso de prueba 00:16:25
que hemos dicho de 00:16:27
voy a meter un valor inicial 00:16:28
8 mayor que 00:16:31
el final, 2 00:16:33
entonces me sale el resultado 0 00:16:34
porque no hay múltiplos 00:16:36
entre 8 y 2 porque 2 va antes de 8 00:16:38
pero bueno, vamos a hacerle 00:16:41
un pequeño tuneo al 00:16:43
programa que es, oye 00:16:45
si te han metido el inicial 00:16:46
más grande que el final 00:16:49
vamos a asumir que entonces queremos 00:16:51
intercambiar uno por otro 00:16:53
¿no? podría ser un requisito 00:16:55
que me dice, le digo yo al cliente 00:16:57
oye, si el valor 00:16:59
inicial que ha metido es mayor que el final 00:17:01
asumo 00:17:03
entonces cero, porque ese intervalo no tiene 00:17:06
nada dentro, no, no, asume 00:17:09
que se ha equivocado, es decir 00:17:11
vamos a turnar el programa para que 00:17:13
Tú le metas dos valores y el más pequeño te lo cuentes siempre como el inicial y el mayor como el final, ¿vale? 00:17:15
Y así se queda un programa más robusto, ¿vale? 00:17:25
Luego, ¿vale? 00:17:29
Entonces, el enunciado se quedaría así. 00:17:36
Vamos a contar todos los múltiplos entre dos números leídos por teclado. 00:17:38
Siempre entre el menor y el mayor. 00:18:03
¿Vale? 00:18:08
Entre el menor y el mayor. 00:18:10
Si me dan 8 y 2, pues entre 2 y 8. 00:18:12
Si me dan 4 y 7, entre 4 y 7. 00:18:14
Si me dan 7 y 15, entre 7 y 15. 00:18:17
Independientemente de los números que me den, 00:18:21
yo voy a contar todos los múltiplos comprendidos, 00:18:23
el más pequeño y el mayor. 00:18:25
Entendéis la modificación, ¿no? 00:18:27
Para que el programa sea más robusto. 00:18:28
Luego, el valor inicial, valor final, 00:18:32
en este caso lo vamos a tomar, 00:18:35
que puede ser que los tenga yo que intercambiar. 00:18:37
Bueno, pues entonces, 00:18:41
si yo quiero que mi programa funcione así, 00:18:42
vamos a tener que hacer esto 00:18:45
si resulta que 00:18:48
n1 me lo han dado 00:18:51
mayor 00:18:53
que n2 00:18:55
los tenemos que intercambiar 00:18:56
¿verdad? los tenemos que intercambiar 00:18:59
si n1 00:19:01
es mayor que n2 00:19:05
quiero intercambiarlos, para no tener que tocar 00:19:07
el resto del programa 00:19:09
que lo que haya en n2 00:19:10
pasa a n1 00:19:13
y lo que haya en n1 pasa a n2 00:19:14
¿vale? 00:19:17
¿entendéis que si con ese tuneo 00:19:19
que a mí me dan dos números N1 y N2 00:19:21
y siempre 00:19:23
quiero contar los múltiplos entre el pequeño 00:19:25
y el mayor, pues si N1 00:19:27
es menor que N2 no pasa nada 00:19:29
mi programa pues 00:19:31
tranquilamente funcionará 00:19:33
partiendo de N1 00:19:34
mientras sea menor que N2 00:19:38
tranquilamente 00:19:40
pero si N1 es mayor que N2 00:19:41
los quiero intercambiar yo 00:19:44
de posición, es decir, quiero que 00:19:46
el pequeño vaya siempre 00:19:48
a n1 00:19:50
menor valor 00:19:51
esté 00:20:00
y el 00:20:06
mayor valor 00:20:08
n2, vale 00:20:12
esto es un 00:20:15
if, porque si se cumple 00:20:17
esta condición, tengo que intercambiarlos 00:20:19
pues esto ya es hacer un código con un if 00:20:21
y la pregunta es, ¿sabríais hacerlo? 00:20:23
Bueno, pues esto hasta aquí lógicamente 00:20:30
todo el mundo ha llegado y es, 00:20:33
si n1 es mayor que n2, tengo que hacer algo. 00:20:35
Tengo que hacer algo, que es intercambiar los valores. 00:20:39
Entonces, lógicamente, 00:20:42
uno que no piensa, 00:20:44
pues le sale a escribir esto que es absolutamente absurdo. 00:20:48
Lógicamente, ¿verdad? 00:20:50
Si uno escribe esto, ha escrito una tontería muy gorda, porque este es N1 que tiene el 7, por ejemplo, y este es N2 que tiene el 3. 00:20:52
Este if sería true porque N1 es mayor que N2. 00:21:13
Entonces, si hacemos esas sentencias, a N1 le damos lo que tiene N2. 00:21:17
muy bien, N1 00:21:22
se queda pisado 00:21:24
y ahora se queda con 3 00:21:26
por lo hemos enseñado lo de N2 00:21:28
y ahora, a N2 le damos 00:21:29
lo que tiene N1, pero es que le queremos dar 00:21:32
lo que tenía de antes 00:21:34
y lo que tenía de antes ha desaparecido 00:21:35
entonces si a N2 le damos N1 00:21:37
a N2 le volvemos a dar su 3 00:21:39
con lo cual, lo que tenía el N1 00:21:41
de antes, lo hemos tirado a la basura 00:21:44
no podemos 00:21:46
recuperarlo para dárselo a N2 00:21:48
otra vez, ¿qué nos falta? 00:21:50
Pues una tercera variable para este no perderlo, para este no perderlo. 00:21:52
Entonces, ¿qué queremos? 00:21:59
Sí, a n1 le queremos dar lo que tiene n2, pero antes querremos haber guardado este 7 antes, para no perderlo. 00:22:01
Oye, vamos a llevar este 7 antes, aquí, antes. 00:22:08
Entonces, nos falta aquí antes llevarlo a una variable para que no se pierda. 00:22:13
el 7 que tenía 00:22:17
vamos a llevarlo a una variable aus 00:22:20
para que no te pierdas 00:22:22
ahora ya sí a n1 le meto n2 00:22:23
ahora ya sí 00:22:26
y el 7 que estaba aquí guardadito 00:22:27
a la espera, ahora ya lo recupero 00:22:30
y se lo paso a n2 00:22:33
ahora ya lo recupero y se lo paso a n2 00:22:35
¿vale? 00:22:37
entonces una variable intermedia 00:22:39
entonces Python tiene una 00:22:40
forma de hacerlo a la vez 00:22:45
Sí, porque como es para vagos 00:22:47
No recuerdo qué operador es el de intercambiar 00:22:52
Es un operador 00:22:56
Que te intercambia el valor de una variable por otra 00:22:58
No recuerdo qué operador es 00:23:00
Porque Java es para listos 00:23:03
Entonces 00:23:11
Python ofrece muchos atajos 00:23:12
Muchas cosas 00:23:14
Mucha simplificación 00:23:14
Entonces te evites 00:23:18
La que no piensas 00:23:20
Entonces es muy 00:23:21
Vale, pues entonces 00:23:22
Esto por tanto, me falta esto de aquí 00:23:29
Vamos a guardar 00:23:31
Primero lo que hay en N1 00:23:35
Ahora ya se lo pisoteo 00:23:37
Se lo pisoteo 00:23:39
Y ahora ya 00:23:41
Ese valor 00:23:42
Reservado, que estaba ahí reservadito 00:23:45
Se lo paso en el 2 00:23:48
Pues ahora ya ese caso de prueba 00:23:49
Lo va a pasar 00:23:52
Todos los múltiplos de 2 00:23:54
Comprendidos entre 8 y 2 00:23:58
Perfecto 00:24:00
Aunque mi valor inicial era mayor 00:24:02
No pasa nada, lo ha intercambiado 00:24:04
¿Vale? 00:24:05
Pues todo el programa completo está claro 00:24:20
¿Quién ha dicho no? 00:24:22
Yo he pensado en un poco más pequeño 00:24:26
Para el valor de la nota 00:24:27
A ver, y por último, por último, por último, uno ya podría decir, uy, la verdad es que estoy usando variables de más. 00:24:29
No pasa nada. 00:24:45
Esta versión está estupenda y está muy bien porque es muy clara. 00:24:46
Uno podría decir, estoy usando variables de más. 00:24:49
y es, este valor 00:24:51
n que yo me he inventado 00:24:54
aquí 00:24:56
para empezar valiendo el n1 00:24:56
y irse incrementando 00:25:00
es que puedo usar 00:25:02
ya la propia variable n1 00:25:04
¿verdad? 00:25:05
es decir 00:25:09
mi variable 00:25:10
claro 00:25:10
o sea, yo ahora, esto se ha quedado 00:25:13
vale 00:25:16
Vale, yo tenía mis datos de entrada 00:25:20
Que son 00:25:32
Y N2 00:25:35
Que N1, por ejemplo, puede ser 2 00:25:37
Y N2, 8, los que sean 00:25:40
Y ahora yo me he inventado 00:25:42
Un numerito N 00:25:44
Que empieza valiendo 00:25:45
N1, empieza valiendo 2 00:25:48
Y luego ya se va incrementando 00:25:50
Luego ya se va incrementando con N++ 00:25:51
Y este, luego valdrá 3 00:25:54
Luego 4, este ya es el que meto dentro del bucle 00:25:56
y se va incrementando 00:25:59
vale, y la condición es 00:26:02
mientras n sea 00:26:06
menor o igual 00:26:08
que el n2, este de aquí 00:26:09
vale 00:26:11
mientras n sea menor o igual 00:26:13
que n2 00:26:21
que es este 00:26:22
así es como lo tenemos hecho 00:26:26
este n se va incrementando 00:26:27
pero claro, esta variable n1 00:26:29
ahí ya se ha quedado muerta de risa 00:26:32
esta variable n1 00:26:34
solo me está valiendo 00:26:35
para dar un valor inicial a n 00:26:37
porque yo he hecho n igual a n1 00:26:40
solo me ha valido 00:26:42
para dar un valor inicial a n 00:26:44
y luego se queda ahí muerta de risa y ya está 00:26:45
pues claro 00:26:47
vamos a usar esta propia n1 00:26:49
vamos a usarla como n 00:26:51
¿vale? entonces 00:26:53
esta propia variable n1 00:26:55
la utilizo 00:26:58
con lo cual n1 su valor inicial 00:26:59
es n1 lógicamente, es ella misma 00:27:02
su valor inicial es el que me han metido 00:27:04
es ella misma, n1 00:27:06
y ahora la voy incrementando 00:27:08
la voy incrementando 00:27:10
esta propia n1 00:27:12
y ya está, entonces esa otra 00:27:13
variable n, pues no hace 00:27:16
falta que la use, uso la propia n1 00:27:18
que ya tiene su valor inicial 00:27:20
la voy incrementando a n1 00:27:22
la voy incrementando 00:27:24
su propio valor inicial 00:27:26
la voy incrementando a este 00:27:27
y cuando haya llegado a ser N2 00:27:29
¿vale? 00:27:32
la N2 00:27:34
no la puedo reutilizar 00:27:35
porque N2 tiene que conservar su valor 00:27:37
entre iteraciones 00:27:39
porque la evalúo cada vez 00:27:40
en la condición 00:27:43
¿vale? la N2 no la puedo reutilizar 00:27:44
N2 tiene que conservar su valor 00:27:48
porque está en esta condición 00:27:49
pero la N1 la puedo reutilizar 00:27:52
claro, sí 00:27:54
aquí sí 00:28:11
si este valor lo queremos conservar 00:28:12
porque luego queremos mostrar algo 00:28:16
sí, vale 00:28:18
pero si no 00:28:19
necesitamos conservarlo 00:28:22
No lo voy a, como lo voy a estudiar a lo virtual, no lo voy a cambiar para no hacer mucho lío, pero bueno, más o menos situados. 00:28:34
Vale, pues antes de pasar al 6, perdón, ¿qué código? O sea, ¿este? 00:28:50
Ah, perdón. 00:29:04
Pues esperamos que los bucles en todas sus... 00:29:19
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:
2
Fecha:
27 de octubre de 2025 - 11:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 26″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
248.25 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid