Saltar navegación

20251111 EjerBucles_9 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 11 de noviembre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues momento en el cual leemos el enunciado, para entender exactamente qué nos han pedido. 00:00:00
Solicitar un número por teclado, y a partir de ahí mostrar todos los números inferiores a él que cumplan la condición de ser primo. 00:00:07
vale 00:00:18
pues entonces ya nos hacemos 00:00:20
como ya, ver si un número 00:00:22
es primo o no 00:00:24
ya lo hemos hecho 00:00:26
automáticamente decimos, uy esto me va a ser fácil 00:00:28
porque se apoya 00:00:30
en algo que ya sé hacer 00:00:32
porque ya lo he hecho, que es dado un número cualquiera 00:00:34
a ver si es primo o no 00:00:36
¿en qué cambia este 00:00:38
enunciado? que eso de 00:00:40
ver si un número es primo o no, lo voy a 00:00:42
tener que hacer un montón de veces 00:00:44
en particular lo voy a tener que hacer 00:00:46
para todos los inferiores al dato de entrada 00:00:48
luego es 00:00:50
lo que ya hemos hecho, ver si un número es primo 00:00:51
o no, pero hacer eso dentro de un bucle 00:00:54
que vaya recorriendo 00:00:56
todos los números inferiores 00:00:58
al que me han dado 00:01:00
luego de nuevo como casi siempre 00:01:01
uno construye un programa, hace un diseño 00:01:04
que se va apoyando 00:01:06
en cosas que ya sabe y va construyendo el algoritmo 00:01:08
aquí ya 00:01:10
lo que se nos ocurre es eso, repito 00:01:12
como a mí me dan un número 00:01:13
un único número 00:01:16
tengo que recorrer todos los inferiores 00:01:17
a él, luego ahí hay un primer bucle 00:01:20
este, el siguiente, siguiente 00:01:22
siguiente, un primer bucle 00:01:24
y ahora en cada bucle ¿qué hago? 00:01:25
ver 00:01:29
si el número en el que estoy es primo o no lo es 00:01:30
si lo es lo muestro 00:01:32
y si no pues nada, ver si es primo o no 00:01:33
sé hacerlo, pues esa parte 00:01:36
que va dentro del bucle gordo 00:01:38
es hacer lo que ya hemos hecho 00:01:40
y ya está, y con eso construimos el programa gordo 00:01:42
y luego ya si la versión que nos 00:01:44
queda, pues vemos que la podemos 00:01:46
reducir, dejar más bonita, quitar variables 00:01:48
refactorizar 00:01:51
de alguna manera, pues lo hacemos 00:01:52
vale, pues hala, venga 00:01:53
¿cómo vamos a leer del teclado? 00:01:57
pues el escáner 00:02:01
y ya está, y leemos el número 00:02:02
introduzca número 00:02:13
o ingrese, como me ponéis en el examen 00:02:25
continuamente 00:02:28
los que venís del otro lado del charco 00:02:29
me ponéis ingrese 00:02:32
y los que venís de aquí 00:02:33
me ponéis todo tipo de palabras 00:02:36
extrañas 00:02:38
vale, pues a ver, ya está 00:02:39
vale, ahora ya 00:02:48
tenemos el dato de entrada 00:02:57
pues ahora ya un bucle que 00:02:58
recorra todos los números que van 00:03:01
entre 1 y n 00:03:03
bueno, habría que preguntarle 00:03:05
¿cuándo quieres que 00:03:06
haga la comprobación de todos los inferiores 00:03:09
a él hasta 2 o hasta 1 00:03:11
porque el 1 ya sabemos que no es primo 00:03:14
pues bueno, esos pequeños detalles se podrían aclarar 00:03:15
¿vale? ahora aquí no queda 00:03:18
muy claro, esos pequeños detallitos 00:03:20
la lista de números primos 00:03:22
y fríos a ese número 00:03:24
pues podríamos directamente, mira 00:03:25
entre 00:03:27
entre él y 2 00:03:29
el 1 ya no lo contabilizamos, está fuera de categoría 00:03:31
por ejemplo, y ya está 00:03:34
vale, pues un bucle que recorra 00:03:35
todos los números comprendidos 00:03:38
entre 2 y el que me han dado 00:03:40
que los recorra a todos 00:03:41
¿con qué estructura lo haríais? 00:03:43
pues con un for 00:03:47
porque el for te permite 00:03:48
de forma sencilla declarar una variable 00:03:50
y esa variable que se vaya incrementando 00:03:52
arrancando desde 2 00:03:54
lo podemos hacer con un while pero habría que hacer una variable 00:03:55
fuera y esa variable se iría 00:03:58
incrementando, pero ¿para qué 00:04:00
si tenemos un for que ya tiene 00:04:02
huequitos dentro para hacer eso? 00:04:04
pues como el for ya me 00:04:07
permite hacer eso 00:04:08
para mis numeritos 00:04:09
empezando desde 2 00:04:13
mientras 00:04:15
num sea menor 00:04:18
o igual que el número 00:04:20
que me han dado 00:04:22
no, num es mi variable interna del bucle 00:04:23
n es el que me han dado 00:04:28
incrementando num 00:04:29
num es el i 00:04:31
lo que pasa es que lo he cambiado 00:04:33
para favorecer que no seáis tan rígidos 00:04:35
y estrictos 00:04:38
Que hay veces que, ¡Dios mío, un for sin un i! 00:04:40
Eso está mal. 00:04:42
¿Qué más da? 00:04:44
Hay que favorecer un poquito también 00:04:46
la plasticidad cerebral. 00:04:48
Vale, pues este bucle 00:04:50
me va ofreciendo 00:04:51
números. Me va ofreciendo números 00:04:54
desde el 2 hasta el n, me los va ofreciendo. 00:04:56
Repito, un while 00:04:59
también me los podría ofrecer, pero tendría que 00:05:00
declarar num arriba y luego irlo incrementando 00:05:02
dentro. Pues como ya 00:05:04
tengo el for que me permite 00:05:06
poner esto dentro 00:05:08
que sería como ponerlo aquí 00:05:10
pues me permite ponerlo dentro 00:05:11
y poner esto aquí 00:05:13
que sería como ponerlo aquí debajo 00:05:14
pues lo hago con un for 00:05:16
y más cómodo y más bonito 00:05:17
ahora 00:05:18
este algoritmo en modo caja negra 00:05:20
pues sería 00:05:24
si num es primo 00:05:24
si num es primo 00:05:27
pues 00:05:29
mostrar num 00:05:31
el programa se convertiría en esto 00:05:34
y ya estaría mi programa 00:05:37
para todos los inferiores 00:05:39
si el número es primo lo muestro 00:05:41
ya tengo mi primer boceto 00:05:43
y ya he hecho mucho, ya he hecho un montón 00:05:45
ahora voy 00:05:47
desglosando, ahora voy yendo al detalle 00:05:49
el detalle que se me ha quedado ahí colgando 00:05:53
num es primo, tengo yo alguna condición sencilla 00:05:57
para poner si un número es primo o no 00:06:00
no, no lo tenemos 00:06:02
porque de hecho ya habíamos hecho un ejercicio 00:06:03
que era de un número, te decía si era primo o no. 00:06:05
Y tuvimos que hacer 00:06:07
todo un bucle para que lo hiciera. 00:06:08
Bueno, pues entonces, esto así 00:06:11
no lo puedo hacer. 00:06:13
Entonces, ¿cómo 00:06:15
averiguábamos si un número 00:06:15
era primo o no? Pues lo hicimos 00:06:19
en su momento así. 00:06:21
Voy a asumir 00:06:24
de partida 00:06:25
que es primo. 00:06:26
Es decir, que no tiene ningún divisor 00:06:29
comprendido. Entre 00:06:31
dos y ese número 00:06:33
menos 1, y ahora voy a ver 00:06:35
si me llega un contraejemplo 00:06:37
hasta luego 00:06:38
voy a ver si me llega un contraejemplo 00:06:45
entonces, íbamos tirando 00:06:48
los datos a comprobar 00:06:50
los datos a comprobar, los íbamos 00:06:52
tirando con un for 00:06:54
desde i igual a 00:06:55
mientras i sea menor 00:06:59
que num 00:07:02
incrementando i, vamos a ver si 00:07:03
encontrábamos un contraejemplo 00:07:06
número es divisible 00:07:09
por este i 00:07:12
ah, le habíamos encontrado un contraejemplo 00:07:13
luego es primo 00:07:16
igual a true 00:07:18
perdona, false 00:07:20
vale, esto es lo que habíamos hecho, tal cual 00:07:21
para averiguar si un número era primo 00:07:24
o no lo era, habíamos hecho esto 00:07:26
tal cual, pues ya está, yo ya lo sé 00:07:28
hacer, lo pongo aquí 00:07:30
¿verdad? lo he escrito bien, ¿no? 00:07:31
asumo de partida que no tiene ningún divisor 00:07:33
voy tirando todos los comprendidos 00:07:36
entre 2 y una unidad inferior a él 00:07:38
voy tirando 00:07:41
en cuanto encuentre un divisor 00:07:41
puedo automáticamente cambiar ya 00:07:44
mi suposición de partida 00:07:47
y decir que no puede ser primo 00:07:48
vale, pues ahora ya sí que tenemos 00:07:50
ya la condición 00:07:53
ahora ya sí que la tenemos 00:07:54
y ya la puedo poner aquí y completar 00:07:56
la parte que me faltaba 00:07:58
vale 00:08:00
y ya está 00:08:02
entonces empezaría a tirar las pruebas 00:08:06
a ver si lo he escrito bien 00:08:10
si alguna me casca, que pasa con los casos 00:08:12
extraños y ahí tiraría 00:08:14
pero bueno, vamos a ejecutarlo porque hay 00:08:15
alguna burrada muy gruesa 00:08:20
dime 00:08:22
es primo en el if es igual a 00:08:24
es primo igual a true 00:08:25
claro, claro, porque lo que 00:08:27
hace el if es mirar si esto que hay aquí 00:08:29
es true o false 00:08:32
es primo ya es un boolean 00:08:33
ya es una caja que tiene dentro true o false 00:08:36
entonces poner esto 00:08:38
y poner esto 00:08:40
es la misma cosa 00:08:41
te da igual decir 00:08:44
llueve 00:08:46
el boolean podría ser llueve 00:08:48
pues te daría igual decir llueve 00:08:50
que decir que llueve 00:08:52
es verdad 00:08:54
son dos enunciados idénticos 00:08:55
son dos enunciados idénticos 00:08:57
entonces hombre 00:08:58
lo que pasa es que queda raro 00:09:00
entonces este 00:09:01
mira el contenido de esprimo 00:09:05
si el contenido de esprimo es true 00:09:06
o lo que es lo mismo si es igual a true 00:09:08
que es lo mismo que decir que su valor es true 00:09:10
pues ya está 00:09:12
se muestra esto 00:09:13
entonces 00:09:14
a ver, primos inferiores 00:09:17
pues todos esos 00:09:24
son los inferiores a 24 00:09:27
bueno, pues no hace falta que nos detengamos 00:09:28
más con esto 00:09:33
de nuevo 00:09:35
otro ejemplo 00:09:37
de la 00:09:39
pauta lógica de alguna manera 00:09:40
uno pues 00:09:42
sabe que herramientas tiene, que son las decisiones 00:09:44
los bucles y dar valor a las variables 00:09:46
con expresiones, ya está, no tiene más herramientas 00:09:48
que esas y con esas lo tiene que hacer 00:09:50
todo y ahora ya 00:09:52
pues hacemos un diseño que conjuga 00:09:54
esas herramientas y que 00:09:56
basado 00:09:58
en cosas que ya hemos 00:09:59
resuelto, sabiendo como funcionan los bucles 00:10:02
las decisiones, pues yo me hago 00:10:04
mi boceto, voy completando las partes 00:10:06
y ya está 00:10:08
Sí, sí, sí 00:10:09
¿Eh? 00:10:23
Ay, estás ahí 00:10:26
Tiene 00:10:27
No, tiene el perfil que 00:10:28
hace falta, es que tiene ganas de avanzar 00:10:31
de aprender, de saber 00:10:33
Es un vicioso de la programación 00:10:34
Pues ya está 00:10:37
Realmente es lo que debería ocurrirnos a todos 00:10:38
A mí me ocurre 00:10:42
el que esto te genere adicción 00:10:43
y estés deseando ir a tu casa 00:10:45
Para seguir probando cosas 00:10:47
Y cuando las aplicaciones son más gordas 00:10:49
Pues más adición te genera 00:10:53
Porque claro, más errores te pueden dar 00:10:55
Más ganas tienes de ponerte a ver si lo arreglas 00:10:56
Claro, podéis haceros ahí cualquier cosa 00:10:58
En cuanto ya veamos clases 00:11:07
Podéis hacer lo que os dé la gana 00:11:09
Vale, venga 00:11:11
¿Algún otro a corregir? 00:11:15
Venga, pues vale 00:11:24
Vamos a hacer el 24 00:11:26
Y luego ya nos vamos a 00:11:29
RAIS 00:11:35
Venga 00:11:36
¿Qué dice este? 00:11:47
Este enunciado ya es más largo 00:11:51
Entonces uno se hace una primera leída para entender de qué va 00:11:53
Y luego ya lo puede ir desmenuzando 00:11:55
Pues un programa que te pide 00:11:57
Dos números 00:11:59
máximo y mínimo, dos valores extremos 00:12:00
de un intervalo y un número de intentos 00:12:05
vale, pues el programa ¿qué hace? 00:12:07
te genera él internamente, sin que el usuario lo conozca 00:12:10
claro, un número aleatorio entre esos dos números 00:12:13
y a partir de ahí empieza a preguntarle 00:12:15
al usuario, introduce número, introduce número 00:12:19
cada vez que el usuario introduce un número comprueba 00:12:21
si es mayor o menor 00:12:25
que el que la ha seleccionado 00:12:28
como el número objetivo 00:12:30
le informa, le dice ahorita no me intento 00:12:31
claro, si el usuario 00:12:35
acierta, pues dice, ya la hayas ganado 00:12:37
ya está, nada más 00:12:38
y si se pasa el número de intentos 00:12:39
le dice, pues no, has perdido porque has pasado el número de intentos 00:12:42
bueno, pues la combinación 00:12:45
de todo eso, entonces un primer diseño 00:12:47
en la cabeza ya podemos pensar 00:12:49
la primera parte, pedir 00:12:50
los extremos del intervalo y generar el aleatorio 00:12:52
esa primera parte, pues ya está 00:12:55
Leer los dos datos, extremos y pide general lectorio. 00:12:58
Luego ahora ya vendrá un bucle, que es un bucle que está todo el rato. 00:13:02
Pide número, me da mi resultado. 00:13:07
Pide número, me da mi resultado. 00:13:10
Ese bucle cuando terminará. 00:13:11
Cuando el número introducido sea igual que el objetivo o me haya pasado el número de intentos. 00:13:13
Cuando el bucle ya ha terminado, pues ya dices, has ganado, has perdido, lo que sea. 00:13:20
Entonces ya más o menos una primera estructura en la cabeza ya tenemos. 00:13:24
pedir el dato y generar el aleatorio 00:13:27
el bucle que va actuando 00:13:30
pidiendo los números 00:13:32
y dando la realimentación que toque 00:13:34
ese bucle 00:13:36
ya habrá que perfilar cuál es su condición 00:13:38
de finalización 00:13:40
y luego ya decir el resultado final 00:13:41
si has ganado, entonces ya con eso en la cabeza 00:13:44
más o menos, pues ya podemos 00:13:46
empezar a escribir y hacer un primer 00:13:48
boceto, pero el tener antes 00:13:50
en la cabeza una idea de cómo lo vamos 00:13:52
a construir, eso es imprescindible 00:13:54
Si queremos no andar ahí mareando la pardiz y al final a las 2 horas preguntas a la HGPT. 00:13:56
Bueno, ¿qué digo yo a las 2 horas? Ojalá, a los 5 minutos. 00:14:02
Pues venga, EGER24. 00:14:07
Como vamos a pedirle números, pues necesitamos esto. 00:14:11
Vale, introduzca número, el número menor del intervalo. 00:14:26
Y ahora vamos a pedirle que introduzca el número mayor. 00:14:37
hala, ya tenemos los dos extremos 00:14:41
del intervalo en el cual 00:14:52
el programa tiene que generar su aleatorio 00:14:54
bueno, pues aquí 00:14:56
vamos a tener que tirar 00:14:58
de algunas funciones 00:15:00
que ya están hechas en Java 00:15:02
para hacer cosas 00:15:04
¿vale? entonces esa es la base 00:15:05
de la programación de entrada de objetos 00:15:08
que hay ya muchísimo código hecho 00:15:09
en clases, como ya veremos 00:15:12
y tú lo puedes invocar 00:15:14
para que se ejecute 00:15:16
y te dé el resultado, si tuviéramos que hacerlo 00:15:18
todo de cero nosotros sería imposible 00:15:20
entonces ya hay 00:15:22
dentro de las 200.000.200.448.300.900.320 00:15:24
clases que ya hay hechas y funciones 00:15:31
pues dentro de todas esas 00:15:33
hay una que te permite 00:15:34
generar un número aleatorio 00:15:37
entre decimal 00:15:39
entre cero y uno 00:15:41
vale, pues cuál es 00:15:43
esa 00:15:46
pues dice aquí, utiliza 00:15:48
de la clase math o random 00:15:50
vale, pues a ver 00:15:52
aunque no podemos entender 00:15:54
muy bien, ¿por qué lo llamamos 00:15:56
así? pues vamos a 00:15:59
entonces 00:16:01
si uno pone aquí math y pone 00:16:02
puntito 00:16:04
se le abren un montón de 00:16:05
posibilidades que son funciones 00:16:08
que hacen cosas y te dan resultados 00:16:10
un montón 00:16:12
¿Vale? Pues logaritmos 00:16:13
De todo 00:16:16
Raíces cuadradas 00:16:17
Senos, cosenos 00:16:20
De todo 00:16:22
Y entre todas ellas 00:16:23
Pues hay una 00:16:27
Que es 00:16:30
Random, jolín, que no la he encontrado 00:16:32
Que es esta 00:16:44
¿Eh? 00:16:45
Sí, entonces, más random 00:16:48
Si uno mira la ayuda, te dice 00:16:50
Te da un valor decimal 00:16:51
comprendido entre 0.0 y 1.0 00:16:54
pseudo aleatorio 00:16:58
lógicamente 00:17:02
porque la aleatoriedad no existe 00:17:03
hay que simularla 00:17:05
no hay absolutamente ningún proceso aleatorio 00:17:06
en el universo como la va a haber 00:17:09
dentro de una CPU 00:17:10
que es Sota, Caballo y Rey 00:17:13
entonces bueno 00:17:15
tendrá su proceso 00:17:16
interno de generar el número aleatorio 00:17:19
que tiene que ver 00:17:21
pues que cosas hay únicas 00:17:23
La única cosa que hay única 00:17:25
Para la CPU es la hora del sistema 00:17:27
¿Vale? 00:17:30
Si llegamos hasta los milisegundos 00:17:32
Nanosegundos, eso sí que es único 00:17:34
A cada nanosegundo que pasa 00:17:35
Estás en una hora distinta 00:17:37
Entonces pues a partir del único 00:17:38
Dato único que hay 00:17:41
Que es la hora del sistema 00:17:43
Con precisión de nanosegundos 00:17:44
Pues a partir de ahí te simula 00:17:47
Lo que para el usuario podría ser un número aleatorio 00:17:48
Pero hombre, no existe 00:17:51
La aleatoriedad 00:17:53
Lo saco de la nada 00:17:55
Pues no, no lo puedes sacar de la nada 00:17:56
Tienes que simularlo 00:17:57
Y bueno, esto lo digo como curiosidad 00:17:58
Pues lo simulará, intuyo yo 00:18:00
Y creo que es así 00:18:02
Del único patrón único que tiene 00:18:03
Que es la ola del sistema 00:18:06
Vale, pues entonces te simula 00:18:07
Un número pseudo aleatorio 00:18:09
De hecho es honesto 00:18:11
Y te lo dice 00:18:12
Te dice que es pseudo aleatorio 00:18:13
No va a mentir y tirarse el pisto 00:18:15
Con que es aleatorio 00:18:17
Vale, y además uniformemente distribuido 00:18:18
O sea, todos los números se supone que son iguales de probables dentro de ese rango 0.0 y 1.0. 00:18:22
¿Esto es exactamente lo que queremos? 00:18:29
No, lo queremos entre mínimo y máximo. 00:18:32
Claro, pero como somos tan listos, pues podemos hacer una transformación, 00:18:36
una pequeña transformación, para convertir este número aleatorio decimal entre 0,0 y 1,0, 00:18:42
convertirlo a un número aleatorio entero entre mínimo y máximo, 00:18:49
que es lo que queremos, ¿vale? 00:18:52
Como afortunadamente somos listos y nos vamos a ver en situaciones 00:18:54
en las cuales tenemos que hacer operaciones, cambiar, transformar, 00:18:57
pues, y vamos a poder hacerlo, pues aquí también podremos. 00:19:01
Por ejemplo, en este caso de aquí, 00:19:05
vale, yo tengo math.random 00:19:14
que me genera un número decimal 00:19:33
entre 0,0 y 0,1, perdón, 1,0, 1,0, vale. 00:19:37
Si yo quiero 1 decimal entre 0 y 27 o entre 0 y 14, 00:19:51
lo tendría muy fácil, lo multiplico por este número, ¿verdad? 00:19:58
si me dicen 1, un aleatorio decimal entre 0 y n, por ejemplo, el numerito n, pues bueno, este primer paso lo tengo facilísimo, 00:20:01
este primer paso podría ser más punto random, no sé qué he puesto, multiplicado por n, ¿verdad?, ya lo tendríamos, 00:20:18
un aleatorio entre 0 y n 00:20:32
o sea, si yo multiplico por n 00:20:35
este intervalo lo extiendo 00:20:36
si este intervalo 00:20:39
entre 0 y 1,0 00:20:47
lo multiplico por n 00:20:48
lo extiendo hasta 0,0 00:20:49
y n,0 00:20:53
si multiplico por n 00:20:54
lo extiendo así 00:20:57
¿qué quiero que sea entero? 00:20:58
lo tendría facilísimo 00:21:02
le hago el casting 00:21:03
¿qué quiero que sea entero? 00:21:04
le hago el casting 00:21:13
Bueno, pues con esta tontería podría generar un número entero aleatorio entre 0 y n, ¿vale? Lo que pasa es que aquí no lo quiero entre 0 y n, aquí lo quiero entre mínimo y máximo, ¿vale? 00:21:14
que un aleatorio entre mínimo y máximo 00:21:35
no entre 0 00:21:37
y un n cualquiera 00:21:39
no entre 0 y un n cualquiera 00:21:41
sino entre mínimo y máximo 00:21:43
bueno, pero puedo hacer una transformación 00:21:44
es decir, voy a generarme 00:21:46
un aleatorio 00:21:49
si esta distancia de aquí 00:21:51
mínimo y máximo, imaginaos que esta distancia 00:21:55
la llamo d 00:21:57
pues me voy a generar un aleatorio entre 0 y d 00:21:58
y ese aleatorio se lo sumo 00:22:01
a mínimo 00:22:03
ya está, ya lo he conseguido, ¿verdad? 00:22:04
Imaginaos que esta distancia 00:22:07
Que me genero es 3 00:22:10
Aquí tendría el 3 00:22:11
Se lo sumo a mínimo 00:22:12
Y ya tengo ese valor 00:22:14
¿Vale? 00:22:16
Entonces me genero un aleatorio 00:22:18
Entre 0 y esta distancia de aquí 00:22:19
Para que me dé este incremento 00:22:22
Entre 0 y esta distancia 00:22:25
Me da este incremento 00:22:26
Y luego este incremento 00:22:27
Se lo sumo a mínimo 00:22:28
Y ya está 00:22:29
Luego esto 00:22:30
Se convertiría en 00:22:32
Generar un aleatorio 00:22:36
Entre 0 y esto 00:22:38
¿Vale? 00:22:42
Ya tengo un número entero aleatorio 00:22:45
Entre 0 y esta distancia 00:22:47
Y ahora ya 00:22:52
A esto le sumo el min 00:22:54
Y ya lo tengo 00:22:56
¿Vale? 00:22:59
¿No es más fácil sumar 0 más min? 00:23:01
O sea 00:23:03
0 más min 00:23:03
Bueno, 0 más min 00:23:06
En el cielo lo puedes quitar 00:23:09
min más eso 00:23:10
no te entiendo 00:23:11
tienes un intervalo 00:23:12
tengo un intervalo 00:23:16
entonces mi forma de construir el número es 00:23:18
generar aleatoriamente este incremento 00:23:19
este incremento generarlo aleatoriamente 00:23:22
y ahora a este que sería esto 00:23:24
y ahora a este 00:23:26
incremento le sumo min 00:23:31
con lo cual el numerito 00:23:33
que genero pues ya será o este 00:23:35
o este o este es decir el incremento 00:23:36
lo genero aleatoriamente y se lo sumo a min 00:23:38
y ahora ya el número que me da 00:23:41
pues será 1 comprendido en este intervalo 00:23:43
o sea, genera un incremento 00:23:46
a ver, el extremo 00:23:55
si, el problema del extremo 00:23:56
derecho es que como esto es 0,0 00:23:59
1,0 00:24:01
si el 1,0 00:24:02
no se genera, si se genera 00:24:05
se podría hacer aleatoriamente alguna vez 00:24:07
entonces 00:24:09
tú dices que este nunca se podría 00:24:10
generar 00:24:15
No, bueno, estoy haciendo el casting 00:24:16
para quedarme con la parte decimal. 00:24:25
Entonces, bueno, yo aquí estoy asumiendo 00:24:27
que 00:24:29
el 1,0 00:24:30
se va a generar alguna vez. Es cierto que 00:24:32
es muy improbable. Entonces, 00:24:35
al quitarle el int, 00:24:37
pues sí que podrías llegar a generar 00:24:39
este incremento 00:24:41
y cuando generes este incremento, 00:24:42
pues te daría el máximo 00:24:45
pero será cuando este math random 00:24:47
te genere el 1,0 00:24:49
exactamente 00:24:51
que hombre 00:24:52
habría que ver si están 00:24:53
incluidos los extremos en el math.ram 00:24:57
habría que ver lo que dice 00:25:00
la ayuda 00:25:01
claro, luego está la otra librería 00:25:02
random, que tiene otros métodos 00:25:09
¿vale? 00:25:11
más específicos de aleatoriedad 00:25:12
y tiene otras cosas, pero 00:25:14
yo he puesto esto de aquí, pues yo que sé 00:25:16
Para que penséis un poco 00:25:18
Solamente para que penséis un poquito 00:25:19
Es que yo lo que he pensado 00:25:21
Tú el 1 lo multiplicas por n 00:25:24
Porque claro, 1 por n es n 00:25:27
Pero no lo puedes multiplicar por 0 00:25:29
Porque habría 0 siempre 00:25:31
Pero si le sumas el mínimo 00:25:32
Claro, es que le estoy sumando el mínimo 00:25:33
O sea, cuando te dé 0 00:25:37
Y eso más o menos 1000 00:25:39
Bueno, porque al mínimo 00:25:40
Le tengo que sumar el incremento aleatorio 00:25:43
Lo que es aleatorio es el incremento 00:25:45
vale, y max menos min 00:25:47
es este incremento entero 00:25:50
vale 00:25:52
vale, pues es una 00:25:52
posibilidad, vale 00:26:01
pues si usamos esto 00:26:05
si usáramos esto 00:26:07
pero ya digo que podéis 00:26:14
usar de random 00:26:16
también se desplegan 00:26:18
un montón de funciones 00:26:20
para generar aleatorios y cosas raras 00:26:21
pero bueno, quería yo que 00:26:24
hiciéramos un poco este cálculo para 00:26:27
vale, pues entonces lo que yo he escrito 00:26:29
es el número aleatorio, el número objetivo 00:26:32
sería 00:26:34
al aleatorio 0,0 00:26:37
entre 0,0 y 1,0 00:26:41
lo multiplico por 00:26:43
la diferencia 00:26:47
entre mayor y menor 00:26:49
para generar el incremento aleatorio 00:26:51
mayor, menos, menor 00:26:53
ahora 00:26:55
a ese incremento aleatorio 00:26:57
a todo ese incremento aleatorio 00:26:59
le hago el casting a entero 00:27:03
para quitarle la parte decimal 00:27:04
y ahora 00:27:06
le sumo el mínimo 00:27:08
para ese incremento menor 00:27:10
para que ese incremento se sume al menor 00:27:12
bueno 00:27:18
más o menos esto simula 00:27:19
una aleatoriedad entre mayor y menor 00:27:21
más o menos 00:27:23
tampoco nos vamos a poner muy exquisitos 00:27:24
vale 00:27:27
ahora ya tengo simul aleatorio 00:27:29
que lo podéis haber generado de otra manera 00:27:32
como sea, da igual 00:27:33
esta es una posibilidad que más o menos 00:27:34
simularía un aleatorio entre mayor y menor 00:27:38
ahora ya sí que viene un bucle 00:27:40
que estamos todo el rato 00:27:41
le número 00:27:42
opera con él 00:27:45
vale, entonces uno podría 00:27:46
plantearse esto así 00:27:50
mientras la condición 00:27:51
que sea no se cumpla 00:27:54
vamos a hacerlo con un do while 00:27:55
si os parece 00:27:57
porque es lee número, opera con él 00:27:58
y cuando lleguemos a la condición queremos tener ya el número leído 00:28:02
bueno, pues vamos a suponer que me lo planteamos así 00:28:06
¿qué va a hacer este bucle todo el rato? 00:28:11
va a estar todo el rato pidiendo número 00:28:14
guardando el intento 00:28:17
¿qué ocurre con el intento? 00:28:28
el intento lo podemos declarar y guardar aquí dentro 00:28:34
pero ¿cuándo vamos a salir del bucle? 00:28:39
vamos a salir del bucle cuando el intento sea igual al objetivo 00:28:47
luego tiene toda la pinta de que esta condición de aquí 00:28:52
va a involucrar la variable intento 00:28:56
la va a involucrar, tiene toda la pinta 00:29:02
porque una de las razones por las que se sale del bucle 00:29:04
es porque el número introducido sea igual al objetivo 00:29:07
entonces como tiene toda la pinta de que la va a involucrar 00:29:10
Como yo declaré esto dentro de este bloque 00:29:13
No voy a poder acceder a esa variable aquí fuera 00:29:16
Es imposible, no voy a poder acceder 00:29:20
Con lo cual vamos a declararla fuera 00:29:22
Aunque la leamos dentro 00:29:24
Que es donde la tenemos que leer 00:29:26
Ahora ya sí, leemos número 00:29:27
Ahora podemos hacer ya 00:29:33
Si es mayor 00:29:36
que el objetivo 00:29:44
te has pasado por arriba 00:29:52
pues le puedes decir 00:29:56
te has pasado 00:29:59
si intento 00:30:04
como son condiciones excluyentes 00:30:09
pues lo podemos hacer con un if el se if 00:30:16
porque son excluyentes 00:30:18
si pudieran ser a la vez varias 00:30:19
Recordad que no es un if, el se if 00:30:23
Serán if separados, pero estas son excluyentes 00:30:25
O eres mayor, o eres menor, o eres igual 00:30:27
No hay tutía 00:30:29
Pues si intento es menor 00:30:29
Que el objetivo 00:30:32
Entonces tú le dices 00:30:34
Pues no has llegado 00:30:37
Y si no es ni mayor 00:30:41
Ni menor que el objetivo 00:30:46
Es que has acertado 00:30:48
Entonces le dices 00:30:49
Has acertado 00:30:52
vale, nos vamos aproximando a la versión 00:30:55
pero bueno, hay que completarla 00:30:59
falta esta condición y faltan cosas 00:31:01
porque 00:31:02
el enunciado nos dice 00:31:04
que 00:31:06
tiene que salir 00:31:07
como mucho 00:31:14
hay un número de intentos 00:31:16
que se pide al principio, que no lo hemos pedido 00:31:17
vamos a pedir 00:31:20
vamos a decirle número de intentos 00:31:22
número de intentos 00:31:24
que quieres darte 00:31:38
vale 00:31:39
pues entonces 00:31:52
esta condición que va a involucrar 00:31:55
va a involucrar 00:31:58
que intento 00:32:00
sea igual al objetivo 00:32:02
y también va a involucrar 00:32:04
no habernos pasado el número de intentos 00:32:06
entonces aquí podríamos pensar 00:32:08
bueno, me voy a hacer un contador 00:32:10
lo voy incrementando y que la condición sea 00:32:11
mientras el contador sea menor que el número de intentos 00:32:14
vale, podemos hacerlo así 00:32:16
lo que pasa es que, ¿para qué usar 00:32:19
una variable adicional contadora 00:32:21
si esta variable 00:32:23
número de intentos ya no la usamos para nada más? 00:32:25
No podríamos irla decrementando y cuando 00:32:28
llegue a cero, pues ya está. 00:32:29
En lugar de hacer un contador, 00:32:32
¿vale? Esta sería una opción. 00:32:35
Como yo tengo que contar, 00:32:36
pues podemos hacer la opción 00:32:37
un contador igual a cero. 00:32:39
Aquí en cada intento 00:32:42
vamos contando. 00:32:44
Y cuando salimos 00:32:46
del bucle 00:32:49
una parte de la condición del bucle 00:32:50
es mientras contador 00:32:53
sea menor 00:32:55
que num de intentos 00:32:56
como el contador ha llegado al número de intentos 00:32:58
ya vas a salir 00:33:01
¿vale? 00:33:02
lo único es eso, que num intentos 00:33:07
como eso no tenemos que conservar su valor para nada 00:33:09
no nos hace falta 00:33:12
podríamos no usar una variable 00:33:12
adicional, decir bueno voy a ir decrementando 00:33:16
num intentos y cuando llegue a cero 00:33:18
Y ya está. Entonces podemos ahorrarnos esta variable de contador, podemos ahorrarnos esto y decir mientras numIntentos sea mayor que cero. 00:33:19
y a numintentos además 00:33:37
lo voy a decrementar cada vez 00:33:39
a numintentos 00:33:42
comparo a ver si sigue siendo mayor que 0 00:33:46
y después de haber hecho 00:33:48
la comparación lo dejo decrementado 00:33:50
que os lía mucho 00:33:52
que el decremento se haga 00:33:56
a la vez que la condición 00:33:58
bueno pues lo decrementáis 00:34:00
aquí dentro, ponéis aquí numintentos 00:34:02
menos menos y aquí os limitáis a compararlo 00:34:04
y se acabó 00:34:06
vale 00:34:10
O bien lo decrementáis aquí a la vez 00:34:10
Que lo comparáis 00:34:14
O bien lo decrementáis aquí 00:34:15
Y aquí lo comparáis sin más 00:34:17
¿Vale? Estamos haciendo 00:34:22
No estamos haciendo exactamente lo mismo 00:34:25
Porque aquí primero se decrementa 00:34:28
Y luego se compara y tal y como yo lo he puesto 00:34:30
Primero se compara y luego se decrementa 00:34:32
Vale, entonces 00:34:33
Luego ya, uno cuando haga pruebas 00:34:36
Tiene que pulir esto 00:34:38
Uy, que tengo que quitarle a una, que me he pasado, que no sé qué 00:34:39
se va puliendo, que uno va construyendo 00:34:42
su primera versión 00:34:44
vale, pues ahora mismo 00:34:46
este parece que es un bucle 00:34:48
que está todo el rato diciéndote esto 00:34:50
y sale cuando hayas sacado 00:34:52
los intentos 00:34:54
pero claro, no solo 00:34:55
también tiene que salir si has acertado 00:34:57
también tiene que salir si has acertado 00:35:00
luego esta condición 00:35:02
habrá que combinarla 00:35:05
y aquí como la combino 00:35:06
con un AND o con un OR 00:35:09
es la condición que te hace que sigas 00:35:10
con cualquiera 00:35:21
de las dos que se cumpla ya sales 00:35:23
luego para seguir 00:35:25
tiene que cumplirse las dos 00:35:27
es decir, la otra condición es 00:35:28
n diferente 00:35:30
en un, perdón 00:35:32
intento, perdón 00:35:35
la otra condición es intento 00:35:36
diferente del blanco 00:35:40
estas serían las dos condiciones involucradas 00:35:42
esta es la que hace 00:35:45
esta hace que sigas 00:35:48
y esta también hace que sigas 00:35:49
entonces 00:35:52
sales 00:35:53
cuando alguna de las dos falla 00:35:55
entonces que pones, and or 00:35:58
quien vota por and 00:36:01
quien vota por or 00:36:10
yo también voto por and 00:36:13
en cuanto una de las dos 00:36:21
se haga false, ya tienes que irte. 00:36:24
Con lo cual, en cuanto una de las dos se haga false, 00:36:28
quieres que la global se haga false para irte de ahí. 00:36:31
Entonces, para que la global se haga false 00:36:34
en cuanto una de las dos se haga false, 00:36:37
tiene que ser un and. 00:36:39
Es decir, tú te vas a ir de ese while por dos posibilidades. 00:36:41
O bien porque esta sea false, porque ya hayas llegado a cero. 00:36:45
O bien porque esta sea false, porque hayas encontrado el blanco. 00:36:48
con cualquiera de las dos que sea 00:36:52
falsa te vas 00:36:55
entonces lo que a ti te interesa es que cuando 00:36:55
una de las dos lo sea, el total lo sea 00:36:59
entonces 00:37:01
para que eso ocurra tiene que ser un and 00:37:02
porque si esto es un or 00:37:04
y de repente ya se ha cubierto esta 00:37:05
condición, esta es falsa 00:37:09
pero esta seguiría siendo true, con lo cual tú 00:37:11
volverías arriba otra vez y no 00:37:12
tienes que salir en cuanto una cualquiera 00:37:14
de las dos, la que sea, se ha hecho falsa 00:37:17
entonces tienes que conseguir 00:37:19
que la global sea false 00:37:21
cuando una de las dos lo sea. 00:37:23
Entonces, conseguir 00:37:26
que la global sea false cuando una de las dos 00:37:27
lo sea, se consigue con un and. 00:37:29
¿Vale? 00:37:33
Vale, pues este sería 00:37:40
un primer boceto. 00:37:41
Este sería un primer boceto. 00:37:51
Lo que pasa es que aquí ya habrá detallitos 00:37:53
Que no vayan bien 00:37:55
Porque vamos a hacer una primera prueba 00:37:57
Por ejemplo 00:37:59
Vamos a hacer una primera prueba 00:38:02
El número menor 00:38:03
En el 2 00:38:11
Y número mayor 00:38:12
10 para no estar ahí 2 horas 00:38:13
Vale 00:38:16
Número de intentos 00:38:17
7 intentos para salir 00:38:19
Haga intento 00:38:21
Es el 3, no has llegado 00:38:23
Es el 5, no has llegado 00:38:25
es el 7, has acertado 00:38:27
y termina 00:38:30
vale, esta prueba, pues bien, ha hecho lo que tenía que hacer 00:38:30
vale, vamos a hacer 00:38:34
otra prueba 00:38:36
introduzca número menor, 2 00:38:36
introduzca número mayor, 10 00:38:41
número de intentos, 2 intentos 00:38:43
para forzar ahora 00:38:46
a que termine por el número de intentos 00:38:47
a ver si lo hace bien, haga intento 00:38:49
el 2, no has llegado 00:38:51
haga intento, el 3 00:38:53
no has llegado 00:38:55
y ha terminado 00:38:56
ha terminado y es que 00:38:58
porque he consumido el número de intentos 00:39:00
luego ha funcionado bien, pero hombre 00:39:01
es que ni me informa, ni siquiera me dice 00:39:04
has consumido el número de intentos 00:39:06
no me está informando 00:39:08
entonces hombre, algo me falta 00:39:09
es decir, cuando yo salgo ya 00:39:12
cuando yo he terminado y ya he roto el bucle 00:39:14
porque ya he terminado 00:39:16
debería ir a decir 00:39:17
debería ir de alguna manera a distinguir 00:39:19
si he llegado porque he alcanzado el blanco 00:39:21
o porque he consumido el número de intentos 00:39:24
para en función de eso decir un mensaje u otro 00:39:26
pues entonces 00:39:28
eso es muy fácil de detectar 00:39:30
¿cuándo habré salido yo 00:39:32
si número de intentos 00:39:34
es igual a cero? 00:39:36
¿vale? 00:39:39
he acabado los intentos 00:39:40
y además no he acertado 00:39:42
porque podría haber coincidido 00:39:45
que haya acabado los intentos 00:39:46
en la vez que he acertado 00:39:48
entonces si ha coincidido 00:39:50
ahí no quiero que me diga 00:39:52
has conseguido el número de intentos 00:39:54
Entonces, si has consumido los intentos y además de haber consumido los intentos, intento es diferente de target, es decir, y además de haberlos consumido, pues en este caso has agotado intentos. 00:39:56
es decir, has salido por aquí 00:40:19
pero no has salido por ahí, por esa no 00:40:23
no lo has acertado 00:40:25
porque podrías haber salido por aquí 00:40:27
y también coincidir que es que en ese has acertado 00:40:31
entonces te estaría diciendo, por aquí has acertado 00:40:34
y por aquí te diría esa gota de intentos 00:40:37
sería un poco feo 00:40:39
aún así, igual nos puede bailar algún caso extremo 00:40:41
vamos a probar 00:40:44
introduzca número menor 00:40:47
2, 10, número de intentos 00:40:50
2, haga intento 00:40:53
el 3, te has pasado 00:40:55
entonces si me he pasado está claro 00:40:56
cuál es, el 2, has acertado, vale 00:40:59
es que esta prueba 00:41:00
no me ha valido 00:41:03
número menor, el 2 otra vez 00:41:03
número mayor 00:41:08
el 29 00:41:09
para asegurarme de favorecer 00:41:12
que no genere el 2 00:41:14
número de intentos, 2 intentos 00:41:16
Venga, primer intento 00:41:18
No has llegado 00:41:20
No has llegado y has agotado intentos 00:41:21
Porque yo le he dicho dos intentos 00:41:24
Y efectivamente los he agotado 00:41:26
Sin haber acertado 00:41:29
¿Vale? 00:41:30
Vale, pues bueno 00:41:42
Pues así lo podemos dejar 00:41:43
Es una versión 00:41:46
Habréis hecho a lo mejor algo un poco distinto 00:41:46
Que te muestre el mensaje en otro sitio 00:41:49
De otra manera 00:41:51
Pero bueno, esencialmente es esto 00:41:52
Un bucle que está todo el rato 00:41:55
comprobando una condición 00:41:56
además va contando 00:41:58
y ya está 00:42:00
vale 00:42:02
venga pues vamos a parar aquí un momentito 00:42:05
y luego ya introducir 00:42:09
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:
3
Fecha:
11 de noviembre de 2025 - 20:25
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
482.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid