Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 10-10-23 - 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 10 de octubre de 2023 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues entonces, uno le está enunciado, como siempre, y primero se asegura que lo entiende. 00:00:01
Entonces, todo el mundo sabe lo que es un número primo, ¿verdad? 00:00:11
Un número primo es un número que solo es divisible por sí mismo y la unidad. 00:00:15
Eso está claro, ¿no? 00:00:20
Bueno, pues entonces, el programa, dado un número, tiene que saber si es primo o no. 00:00:23
entonces, si quitamos 00:00:28
la restricción de que tenga que ser menor de 10 00:00:30
la hemos liado 00:00:32
porque entonces uno ahora ya que ha entendido 00:00:34
lo que es un número primo 00:00:36
y se pone a pensar cómo hacerlo 00:00:37
pues entonces 00:00:39
empieza a pensar, vale 00:00:41
para ver si el número es primo tengo que 00:00:43
dividir, si el número es n 00:00:45
tengo que dividirlo entre n-1 00:00:47
y luego entre n-2 00:00:49
y entre n-3, entre n-4 00:00:51
hasta que llegue a 2 00:00:53
y si ninguna de las divisiones 00:00:54
Eso es lo que habría que plantearse como hacerlo, ¿verdad? 00:00:57
Pero claro, el problema es que si la cantidad de divisiones que hay que hacer cambia. 00:01:02
Si el número es 32, habrá que hacer 30 divisiones, desde 31 hasta 1. 00:01:06
Si el número es 100, habrá que hacer 98 divisiones, desde 99 hasta 2. 00:01:11
Entonces, hay que hacer un conjunto de sentencias un número variable de veces, 00:01:18
que a priori no sabemos, pues eso precisamente son bucles. 00:01:23
un conjunto de sentencias que se hacen varias veces 00:01:25
eso es un bucle 00:01:28
como no sabemos hacer un bucle, no podemos hacer este programa 00:01:29
si quitamos la restricción de que sea menor de 10 00:01:32
no podemos hacerlo todavía 00:01:34
por eso está añadida la restricción de que sea menor de 10 00:01:35
entonces con esa restricción ya podemos pensar 00:01:38
¿cómo puedo yo saber si un número 00:01:40
que sé que el usuario 00:01:42
lo va a hacer bien 00:01:45
y va a meterlo a menor de 10 partiendo de esa restricción 00:01:46
es primo? 00:01:48
bueno, pues es que lo tenemos muy fácil 00:01:50
¿cuáles son los números primos menores de 10? 00:01:52
Pues el 2, el 3, el 5 y el 7 00:01:54
¿No? Pues ya está 00:01:58
Si el número es uno de esos es primo 00:02:00
Y se acabó 00:02:02
Entonces 00:02:03
Ahora se trata de poner la condición 00:02:05
Y ya, bueno, leemos el numerito 00:02:08
Leemos el número 00:02:10
Vale, pues venga 00:02:27
A ver, Adrián 00:02:39
Digo Adrián, joder con Adrián 00:02:39
Andrés 00:02:41
¿Cómo pongo la condición? 00:02:42
¿Para qué pones esa condición? 00:02:45
Pero si n es menor que 10, entonces aquí ¿qué hago? 00:03:02
Esta condición que pongo 00:03:07
Yo he puesto 00:03:09
Tú has puesto 00:03:11
n es igual a 2 00:03:11
Para que sea el primo 00:03:14
Luego n es igual a 3 00:03:17
¿Cómo luego n? 00:03:18
¿Qué más? Dígame 00:03:21
Luego las dos estas de o 00:03:21
Eso sí 00:03:23
n es igual a 3 00:03:24
Bueno, para que no se alargue tanto, voy a quitar los... 00:03:26
Bueno, no lo voy a quitar, que es que así tan apiñado esto no se debe hacer nunca. 00:03:45
Vale, pues ya está. 00:03:53
Vale, y un else si uno quiere. 00:04:06
Vale. 00:04:24
Bueno, está claro lo que hemos hecho aquí, ¿no? 00:04:25
Entonces, primera cosa. 00:04:27
Como veis, esta es la primera vez que yo he hecho un if que no tiene else asociado. 00:04:29
O sea, este if tiene dentro una única sentencia. 00:04:35
Que es esta, porque esto es una única sentencia. 00:04:39
Es una sentencia compleja porque es una sentencia if, pero es una sola 00:04:41
Entonces, como es una sola 00:04:44
Yo puedo aquí no poner llaves 00:04:46
Si las pongo no pasa nada 00:04:48
No sobran 00:04:50
Las puedo poner y no pasa nada 00:04:51
Pero puedo no ponerlas 00:04:53
¿Vale? Podría no ponerlas porque 00:04:56
Lo que hay dentro es una única sentencia 00:04:58
Sentencia compleja 00:05:00
Sentencia if, pero es una única sentencia 00:05:02
¿Vale? 00:05:04
Igual que aquí, dentro de a su vez el if anidado 00:05:06
Tampoco he puesto llaves 00:05:08
Porque lo que tiene dentro es una única sentencia 00:05:09
¿Vale? Solo una 00:05:11
Primera cosa 00:05:13
Segunda cosa 00:05:14
Ayer todos los if que poníamos tenían un else 00:05:15
¿Vale? Pues el else no es obligatorio 00:05:20
Yo no hace falta que especifique 00:05:23
¿Qué hago en el caso de que la condición no se cumpla? 00:05:27
A lo mejor en el caso de que la condición no se cumpla 00:05:31
Yo no quiero hacer nada 00:05:33
En ese caso 00:05:34
No hace falta que lo deje así en blanco 00:05:36
Simplemente no pongo el ELSI y se acabó 00:05:39
¿Vale? 00:05:42
Podría dejarlo así 00:05:45
Y esto sería idéntico a haber puesto esto 00:05:46
Uy, perdona, esto no 00:05:48
Idéntico a haber puesto esto 00:05:49
Idéntico 00:05:54
¿Vale? 00:05:55
Eso es como si 00:05:56
¿Vale? En mi diagrama de flujo 00:05:58
En mi diagrama de flujo famoso 00:06:04
Esta es mi condición 00:06:06
Pues la rama del SI 00:06:09
La rama del SI hace lo que tenga que hacer 00:06:10
Y la rama del no, no hace nada 00:06:20
Pero la rama del no existe 00:06:23
Y luego esto se junta por aquí abajo 00:06:24
Y el programa continúa, así 00:06:27
¿Vale? Viene por aquí 00:06:28
Esto es un if sin else 00:06:30
Un if sin else 00:06:33
Que la condición que hay aquí se cumple 00:06:35
Pues hago esto 00:06:37
Que no se cumple, no hago nada 00:06:39
Y esta estructura se puede poner 00:06:40
¿Vale? 00:06:43
Y entonces, si estamos en esa situación 00:06:44
Un if que en la rama del no 00:06:46
No se hace nada 00:06:49
Eso se programa 00:06:49
No poniéndole ese directamente 00:06:52
No poniéndolo 00:06:55
¿Vale? En lugar de ponerlo con llaves vacías 00:06:55
No ponerlo 00:06:59
Pero si lo pongo y no quiero hacer nada 00:07:00
Con llaves vacías, por supuesto 00:07:03
Porque si no pongo las llaves 00:07:04
Y luego mi programa sigue por aquí 00:07:05
Haciendo cualquier cosa 00:07:07
Por ejemplo, adiós o lo que sea 00:07:08
Cuidado, obviamente 00:07:10
Si yo no la pongo, las llaves vacías 00:07:22
Ya sabéis lo que significa eso 00:07:24
Significa que como este él se no tiene llave 00:07:25
La única sentencia que va dentro 00:07:27
Es la que va inmediatamente después 00:07:30
Y ya a partir de ahí 00:07:31
Iría el resto del programa 00:07:33
Entonces esto es 00:07:35
En la rama del no 00:07:37
Hace esto 00:07:39
No, no quiero eso 00:07:40
Quiero una rama del no vacía 00:07:42
Pues si quiero una rama del no vacía 00:07:44
Así sí, así sí es una rama del no vacía 00:07:45
Y luego ya el programa continúa por ahí abajo 00:07:49
¿Vale? 00:07:51
Pero repito 00:07:52
si en la rama del no coincide 00:07:53
que no quiero yo hacer nada 00:07:56
que no quiero hacer nada, mi if es este 00:07:57
pues entonces 00:07:59
puedo no ponerle el se 00:08:01
y me queda más compacto 00:08:03
¿vale? 00:08:06
el if hay que ponerlo siempre 00:08:08
la rama del si hay que ponerla 00:08:10
siempre, o sea si yo tengo 00:08:12
un if 00:08:14
yo tengo mi diagrama de flujo 00:08:14
y resulta que mi 00:08:19
lo que yo estoy programando ahora es esto 00:08:20
que la condición se cumple 00:08:26
pues entonces en ese caso 00:08:28
en el caso de que se cumpla no hagas nada 00:08:30
y terminas 00:08:32
que la condición no se cumple 00:08:33
pues en ese caso sí 00:08:35
haz algo, lo que sea 00:08:37
y luego ya terminas 00:08:38
que yo he hecho un diagrama de flujo 00:08:41
y he llegado a este punto 00:08:44
una condición, la que sea 00:08:45
si se cumple no hago nada 00:08:47
y si no se cumple lo hago 00:08:49
Pues programar esto 00:08:51
Si que me obliga a hacer el if 00:08:53
Si yo quisiera programar esto 00:08:54
Como el if no lo puedo eliminar 00:08:56
Tendría que programarlo así 00:08:57
En el caso de que la condición se cumpla 00:08:59
Poniendo aquí la condición 00:09:02
Que fuera 00:09:04
Pues vacío 00:09:05
Esto si que lo tengo que poner si o si 00:09:07
Y en el caso de que no se cumpla 00:09:09
Pues ahora ya si que pondría lo que hay aquí debajo 00:09:11
Lo que hay aquí 00:09:14
Ya si que lo pondría 00:09:14
Si lo que yo quiero programar es esto 00:09:16
Es este if 00:09:21
Que la rama del sí es la vacía 00:09:22
Y la del no es la que tiene algo 00:09:24
Pues tengo que hacerlo así 00:09:26
El if se queda vacío 00:09:27
Y en el else lleva algo 00:09:29
¿Vale? 00:09:30
Lo que pasa es que esto es feo 00:09:33
Programar esto así, uno te diría 00:09:35
Oye, cámbialo, pon la condición al revés 00:09:37
Pon la condición al revés 00:09:40
Pon la negada, justo la negada 00:09:42
Y así la rama del sí es la que tiene algo dentro 00:09:44
Y te quitas el else 00:09:47
¿No? 00:09:48
O sea, encontrarse esto es muy feo 00:09:48
Hace lo que tiene que hacer 00:09:51
Si la condición se cumple, no hace nada 00:09:53
Y si no se cumple, hace esto, ¿verdad? 00:09:55
Hace lo que tiene que hacer, que es esto de aquí 00:09:58
Es esta idea, si se cumple, hace esto 00:09:59
Y si no, hace esto 00:10:01
Pero hombre, el programa queda muy feo 00:10:02
Pues entonces, aquí tendría mucho más sentido 00:10:04
Obviamente, transformar el código 00:10:06
Transformarlo 00:10:09
Poner la negada de la condición 00:10:10
Poner la negada 00:10:13
Y meter entonces ahora ya 00:10:14
esta sentencia aquí dentro 00:10:16
y ya pasar del else 00:10:18
ahora ya sí 00:10:20
si no se cumple esta condición 00:10:21
si no se cumple, haz esto 00:10:24
y esto es una forma más compacta 00:10:26
obviamente, de expresar esta idea 00:10:28
de aquí abajo 00:10:30
si no se cumple esto, haz esto de aquí 00:10:31
si no se cumple 00:10:34
mucho mejor que hacer si se cumple 00:10:35
vacío y si no se cumple esto 00:10:38
mucho mejor negarla 00:10:40
si no se cumple, ¿vale? 00:10:41
o sea, recordad este operador 00:10:44
booleano, que ya hemos estudiado 00:10:46
booleano 00:10:48
que significa 00:10:49
el negado de la condición que hay después 00:10:51
el negado, entonces si yo la niego 00:10:54
pues en la rama del sí haré 00:10:56
lo que haría en la rama del no 00:11:00
si tuviera la condición sin negar 00:11:02
¿vale? 00:11:04
entonces de nuevo, un mismo código se puede programar de muchas maneras 00:11:06
pero bueno, la idea es que quede lo más bonito posible 00:11:09
¿vale? 00:11:11
luego eso por un lado 00:11:14
Voy a ponerlo aquí 00:11:16
El else es opcional 00:11:17
Si no se hace nada 00:11:20
En esa rama 00:11:24
Vale, eso primera cosa 00:11:28
Segunda cosa 00:11:29
If anidados 00:11:31
Él ha querido además 00:11:33
Hacer solo esta operación 00:11:36
Si n es menor que 10 00:11:38
Porque si n es mayor que 10 00:11:39
Pues no tiene sentido hacerla 00:11:40
Vale, bueno, vale, pues no pasa nada 00:11:42
Eso ha implicado hacer un if anidado 00:11:43
¿verdad? primero verificamos 00:11:46
que el número que hemos introducido es menor que 10 00:11:48
primero lo verificamos 00:11:50
y cuando ya hemos verificado que sí, que cumple la condición 00:11:51
que nosotros necesitamos para que el programa tenga sentido 00:11:54
para que tenga sentido 00:11:57
entonces ya comprobamos a ver si es uno de esos 00:11:58
¿vale? pues para programar 00:12:00
esa idea he usado if anidados 00:12:02
¿vale? 00:12:04
los if anidados 00:12:07
en la mayoría de los casos 00:12:09
también son feos, esto hace lo que 00:12:10
tiene que hacer, está claro, pero son feos 00:12:12
¿Cómo desanidaríais este if? 00:12:14
¿Cómo podríais cambiar el código? 00:12:17
Cambiarlo para que hiciera lo mismo 00:12:20
Pero solo tuviera un if 00:12:21
¿Cómo lo podríais cambiar? 00:12:23
Para que no tuviera dos if anidados 00:12:29
Venga, que alguien me diga algo 00:12:31
Es decir, cambiar este código 00:12:41
Para que haga lo mismo 00:12:44
Pero no tenga 00:12:45
Un if 00:12:47
sí, lo que quieres decir es 00:13:03
vamos a meter 00:13:07
esta condición y esta 00:13:08
en la misma condición 00:13:10
este código lo que hace es 00:13:12
si n es menor que 10 00:13:14
y además de ser menor que 10 00:13:16
una vez que se ha metido en el if 00:13:18
cumple esto, entonces es primo 00:13:19
pues eso lo puede expresar como una única condición 00:13:22
¿verdad? 00:13:25
si n es menor que 10 y 00:13:26
n es igual a 2 o n es igual a 3 00:13:28
Pues entonces es primo 00:13:30
Lo podría meter en una condición, ¿verdad? 00:13:31
Por ejemplo, vamos a ponerlo aquí 00:13:35
100 es menor que 10 00:13:36
Y además de ser menor que 10 00:13:50
Uy, perdón 00:13:53
Y además de ser menor que 10 00:13:58
Resulta que cumple todo esto 00:14:00
¿Vale? 00:14:02
Aquí para evitar ambigüedad 00:14:14
Sí que tiene sentido ya poner el paréntesis 00:14:16
Porque aquí estamos haciendo el AND de dos cosas 00:14:18
De esta condición 00:14:20
Y de esta otra 00:14:22
De las dos en conjunto 00:14:23
Si no ponemos el paréntesis 00:14:26
Si no lo ponemos 00:14:28
Esto haría primero este AND 00:14:30
Y luego haría este OR 00:14:32
Este OR, este OR 00:14:34
¿Vale? Entonces para evitar ambigüedad 00:14:35
Es el AND lógico de 00:14:37
Esta condición y esta condición 00:14:40
Si se cumplen 00:14:43
Simultáneamente ambas 00:14:45
Entonces ahora ya podemos poner 00:14:46
Primo 00:14:48
Es que no quiero que evalúe el resto 00:14:50
A ver, siempre, a ver 00:15:18
Es que lo de dos barras y una 00:15:20
Yo no sé si os da un poco de confusión 00:15:21
Vamos a ver, no quiero 00:15:24
Dos barras 00:15:25
Dos barras o una barra 00:15:28
Tú en cualquier caso vas a hacer el or 00:15:29
De las dos cláusulas que haya 00:15:32
Siempre 00:15:34
Y el resultado final va a ser siempre el mismo 00:15:35
Da igual que haya una barra o dos, va a ser siempre el mismo 00:15:37
Pero ¿cuál es la diferencia? 00:15:39
Si tú pones dos barras 00:15:42
O sea, a ver 00:15:43
Tú imagínate que tienes el or de dos condiciones 00:15:45
¿Vale? 00:15:48
Tienes el or de dos condiciones 00:15:50
Por ejemplo, aquí 00:15:51
Vamos a ver 00:15:53
Si lo terminamos de entender claro 00:15:54
Imagínate que tenemos aquí una condición 00:15:58
Sí, pero vamos a dejarlo más claro para que sea parte 00:15:59
No, boolean b igual 00:16:04
n igual a 7 00:16:07
n igual a 5, por ejemplo 00:16:11
Y aquí vamos a leer el numerito 00:16:16
n igual a 00:16:18
scan.next.in 00:16:20
vale 00:16:25
vamos a hacer 00:16:26
los dos booleanos 00:16:31
con una barra y con dos barras 00:16:34
b1 y b2 00:16:36
vale, estas son 00:16:37
mis dos alternativas, ¿no? 00:16:39
poner una barra o poner las dos 00:16:42
vale, pues tanto el booleano 00:16:43
1 como el booleano 2 00:16:46
tanto el booleano, van a hacer el or 00:16:48
de las dos, entonces el booleano 00:16:50
b1 va a ser true 00:16:52
Si es igual a 7 o si es igual a 5 00:16:54
Y el booleano 2 igual 00:16:57
Ahí no hay ningún cambio 00:16:59
Va a ser true si n es igual a 7 00:17:01
O si n es igual a 5 00:17:03
Sobre eso no hay ningún cambio 00:17:05
Ahora entramos ya en cuanto a la definición del or 00:17:06
Ahora entramos ya en modo ejecución 00:17:09
Ahora ya vamos a un caso real 00:17:11
Vamos a un caso real 00:17:13
Y ahora ya tenemos un número real 00:17:15
n, 7 por ejemplo 00:17:17
Vale, pues entonces la máquina virtual 00:17:19
Coge el 7 y se pone a evaluar 00:17:21
n igual a 7, sí 00:17:23
ah, pues entonces me da igual 00:17:25
lo que ocurra después 00:17:27
porque el or con que uno solo 00:17:29
se atruya es true 00:17:31
entonces le da igual lo que ocurra después 00:17:32
no lo evalúa 00:17:36
no lo evalúa porque ya sabe que el resultado final es true 00:17:37
cuando pones las dos barras 00:17:39
¿vale? ¿qué haría el boolean b2? 00:17:41
coge el numerito 00:17:44
n igual a 7, sí 00:17:45
ya sé que el resultado es true, pero como me han puesto una barra 00:17:46
me obligan a evaluar la segunda 00:17:49
me obligan a evaluarla, venga pues la evalúo 00:17:51
¿no igual a 5? no 00:17:53
entonces la diferencia entre una barra y dos 00:17:54
es en tiempo de ejecución 00:17:58
habrá ejecuciones 00:18:00
en las cuales 00:18:01
aplique la diferencia de ejecuciones en las que no 00:18:02
entonces siempre es mucho más interesante 00:18:06
la doble barra que la primera 00:18:08
porque en las ejecuciones 00:18:09
en las cuales cuando tú has evaluado la primera 00:18:12
ya tienes el resultado final 00:18:14
¿para qué vas a seguir evaluando y perdiendo tiempo? 00:18:16
entonces siempre por defecto 00:18:18
se usan dos 00:18:20
Siempre, ¿no? 00:18:20
Partimos de la base de que estos dos booleanos 00:18:23
Da igual el valor de n 00:18:25
Da igual, b1 y b2 00:18:27
Siempre va a tener el mismo valor 00:18:29
Siempre, porque es un or 00:18:30
Y el or funciona siempre igual 00:18:32
El tema es la máquina virtual 00:18:33
Cómo lo ejecuta 00:18:35
Qué hace, qué pasos da para obtener el resultado 00:18:37
Qué pasos da, es la única diferencia 00:18:40
Cuando hay el doble or, los pasos que da es 00:18:41
Coge la primera 00:18:44
True o false 00:18:45
True, anda, lo que tengo después es un or 00:18:47
pues entonces es que me da igual lo que vaya después 00:18:50
sé que va a ser un true el final 00:18:52
sé que va a ser un true, porque true or con 00:18:54
false es true y true or con true es true 00:18:56
entonces dice, ¿qué más me da? 00:18:58
si sé que el resultado final es true, paso de la 00:19:00
segunda, vale 00:19:02
cuando se encuentra solo una barra 00:19:04
evalúa la primera, es true 00:19:06
está claro, entonces 00:19:08
siempre interesa la doble barra 00:19:10
porque así te 00:19:12
evitas que la máquina virtual haga un 00:19:14
trabajo que no lo necesita 00:19:16
¿Eso está claro? 00:19:17
Vale, pues entonces 00:19:21
¿Por qué existen dos? 00:19:23
Porque si siempre el resultado del booleano 00:19:25
Siempre es el mismo 00:19:27
Eso está claro, siempre es el mismo 00:19:28
Porque es el or de este y este 00:19:30
Cuando n sea 5, tanto este como este dan true 00:19:32
Cuando n sea 4, tanto este como este dan false 00:19:35
Cuando n sea menos 5 00:19:38
Tanto este como este dan false 00:19:39
Cuando n sea 7 00:19:41
Tanto este como este dan true 00:19:43
O sea, los dos booleanos siempre van a tener un valor, siempre, sea cual sea el valor de n, siempre. 00:19:44
Pues entonces, ¿qué sentido, qué interés tiene que haya dos formas de expresarla? 00:19:50
Pues lo que hemos explicado, el funcionamiento de la máquina virtual, entonces es, 00:19:57
cuando hay dos barras, evalúa esta, que eso ya ha sido suficiente para el resultado final, 00:20:01
pasa de lo que hay a continuación. 00:20:08
Estupendo. 00:20:11
Cuando hay una única barra 00:20:11
Evalúa este 00:20:13
Que el resultado ya ha sido suficiente 00:20:15
No pasa, lo evalúa 00:20:17
En este ejemplo no vale para nada 00:20:19
Pero imagínate que tenemos 00:20:21
Expresiones en las cuales 00:20:23
Además de hacer una condición 00:20:25
Hacemos cosas 00:20:28
Que son los ejemplos que poníamos 00:20:29
Como por ejemplo este 00:20:30
El más fácil de entender 00:20:31
Claro, aquí 00:20:32
Para evaluar esta condición 00:20:35
Luego además después le estás dando la orden de incrementar 00:20:37
Entonces, aquí sí que hay una diferencia enorme 00:20:40
Entre estas dos sentencias 00:20:43
Aquí sí 00:20:45
Porque aquí, cuando tú le metas 7 00:20:47
El boolean B1 va a ser true 00:20:50
Está claro, ya el boolean B2 también 00:20:52
Eso no cambia 00:20:53
El resultado final va a ser true 00:20:54
Pero la diferencia es que pasa con las variables que hay aquí dentro 00:20:56
Cuando tú le des 7 00:20:59
Como esto es true 00:21:01
Esto ya no lo hace 00:21:02
Porque B1 ya es true 00:21:04
Y al no hacerlo, N no se queda incrementado 00:21:05
pero cuando le damos esta 00:21:08
y en el 7, esto lo hace 00:21:11
B2 ya es true 00:21:13
igual que era B1 00:21:14
pero le obligamos a que entre aquí también 00:21:16
le obligamos 00:21:19
y al entrar, entonces ya sí que deja en incrementado 00:21:20
entonces la diferencia entre por 2 barras y 1 00:21:23
es cuando en las secuencias 00:21:25
que tenemos después 00:21:27
además de tener la expresión de la condición 00:21:28
el igual, el distinto, además hacemos algo 00:21:31
con las variables 00:21:33
como asignarlas, incrementarlas 00:21:34
Porque eso se va a hacer o no se va a hacer 00:21:36
En algunos casos 00:21:38
Por ejemplo, cuando le damos n igual a 3 00:21:39
Cuando le damos n igual a 3 00:21:42
En esa ejecución concreta de n igual a 3 00:21:43
Estas sí que hacen lo mismo 00:21:46
Porque como esta es falsa 00:21:47
n igual a 3, la doble barra se ve obligada a entrar 00:21:50
Porque esta es falsa 00:21:53
Entonces se ve obligada a entrar y entonces ya lo incrementa 00:21:54
Y cuando n es igual a 3 00:21:56
Evalúa las dos obligatoriamente 00:21:58
Y esta ya lo incrementa 00:22:00
Entonces en las ejecuciones en las que le pasemos n igual a 3 00:22:01
Esto y esto hacen lo mismo 00:22:05
Pero en las ejecuciones en las que le pasemos 00:22:06
N igual a 7 00:22:09
Esta y esta actúan de forma distinta 00:22:10
Porque esta entra aquí y esta no 00:22:12
¿Vale? 00:22:14
Entonces siempre por defecto doble barra 00:22:16
Porque le ahorramos trabajo a la máquina virtual 00:22:18
Salvo que tengamos una condición 00:22:20
Que está después en la que además 00:22:22
De tener la condición hacemos algo 00:22:25
En ese caso sí ponemos una barra 00:22:26
Pero son casos muy puntuales 00:22:29
Entonces por eso siempre vais a ver en los códigos 00:22:31
Que siempre se pone la doble barra o el doble and 00:22:36
Porque es lo más rápido 00:22:38
Para la máquina virtual 00:22:39
Pasa de lo que viene a continuación 00:22:41
¿Entendido? 00:22:43
¿Todo el mundo? 00:22:47
Bueno, vale, pues entonces 00:22:49
Este código que 00:22:50
Lo hemos cambiado este código para que no anide 00:22:52
Y hemos puesto si n es menor que 10 00:22:55
Y además de ser menor que 10 00:22:58
Es igual a 2 o igual a 3 00:23:00
O igual a 5 o igual a 7 00:23:02
Cuidadito con el paréntesis 00:23:04
Aquí sí que tenemos que ponerlo 00:23:06
Porque es esta condición 00:23:08
Por un lado n menor que 10 00:23:10
Y además n igual a 2 o n igual a 3 00:23:11
O n igual a 4 o n igual a 5 00:23:14
O n igual a 7 00:23:16
O sea, son dos condiciones 00:23:16
Que evaluamos por separado 00:23:18
Y luego el and de las dos 00:23:20
Vale, es primo 00:23:22
Y si no, no primo 00:23:24
Vale, pues ahora hago yo la pregunta 00:23:25
Voy a quitar esto para que 00:23:27
Se vea todo el código junto 00:23:31
Este código de arriba 00:23:34
y este código de abajo 00:23:37
este código 00:23:42
y este código 00:23:43
son idénticos 00:23:45
a efectos de ejecución 00:23:48
podríamos decir que son dos códigos idénticos 00:23:49
que hacen siempre lo mismo 00:23:52
el de arriba y el de abajo 00:23:53
¿tú dirías que sí? 00:23:55
venga 00:24:04
¿cuántos dicen que sí? 00:24:05
que el código de arriba y el código de abajo 00:24:06
son idénticos 00:24:08
cuando digo que son idénticos 00:24:09
es que sea cual sea el dato de entrada 00:24:10
que es n, el resultado va a ser siempre el mismo 00:24:13
hay dos votos así 00:24:16
sí pero, es sí o no 00:24:19
no hay pero sin programación, es sí o no 00:24:21
lógica binaria, ¿son idénticos? 00:24:23
sea cual sea el dato de n 00:24:25
de entrada, ¿hacen lo mismo? 00:24:27
tú dices que no 00:24:31
¿por qué no? 00:24:31
claro, a ver 00:24:40
no hacen lo mismo 00:24:42
para todos los casos de n 00:24:44
vamos a imaginar un caso de que n sea 00:24:45
12 mayor que 10 00:24:48
el de arriba, si n es mayor que 10, directamente no entra aquí, no hace nada. 00:24:49
Es decir, el programa no muestra nada, se queda callado. 00:24:56
Si n es 12, ¿verdad? 00:24:59
Pero aquí, si n es 12, esto ya le da false, con lo cual esto ya pasa, 00:25:02
porque false and lo que sea es false, y es un doble and, le da false, 00:25:07
y al hacer false entra en el el sí. 00:25:12
Entonces, para todos los valores de entrada mayores o iguales que 10, 00:25:15
El código de arriba dice 00:25:18
Se queda callado 00:25:19
Y el código de abajo dice 00:25:21
No primo 00:25:23
Entonces para ese conjunto de casos de entrada 00:25:24
Mayores o iguales que 10 00:25:27
El programa no hace lo mismo 00:25:29
Para los menores que 10 sí 00:25:31
Para todos los menores que 10 sí 00:25:33
Porque para los menores que 10 00:25:35
Entra aquí 00:25:37
Si además se cumple esto 00:25:37
Que es este and 00:25:39
Si además se cumple hace primo 00:25:40
Y si no se cumple hace esto 00:25:42
Que es esto 00:25:44
Entonces, no para todos los casos de entrada hace lo mismo 00:25:45
Solo para los mayores o para los menores de 10 00:25:49
¿Vale? Para los mayores o iguales de 10 00:25:53
Este se calla porque se iría a este else que no hace nada, que no existe 00:25:57
Y este para los mayores o iguales que 10, esto le da false 00:26:01
Porque esta es false y se mete aquí 00:26:05
¿Vale? 00:26:07
Otra cosa es que eso nos importe o no nos importe 00:26:10
Si nos importa y queremos que para los valores de n mayores o iguales que 10 no lo diga, nos lo diga, pues entonces tendríamos que cambiar este código y aquí sí que implicaría anidar otro if. 00:26:13
En el otro caso, si n es mayor o igual que 10, decir mayor o igual, no decir nada y si no lo es, decir no primo, pero tendríamos que anidar aquí entonces también otro if. 00:26:24
bueno, ¿a dónde quiero ir a parar? 00:26:35
no mencionamos ayer 00:26:40
un poco antes de irnos 00:26:42
que precisamente para evitar 00:26:44
anidarif en los códigos 00:26:46
Java nos daba una forma 00:26:47
compacta de explicarlo 00:26:50
cuando yo quería contemplar varias posibilidades 00:26:52
que es justo este caso 00:26:54
en este caso lo que me estoy dando cuenta 00:26:55
es que en realidad yo quiero contemplar tres 00:26:57
número mayor o igual que diez 00:26:59
ser primo o ser no primo 00:27:01
son tres 00:27:04
Pues si son tres 00:27:05
Tres no se puede hacer con un if-else 00:27:07
De ahí es que, de ahí me ha venido lo de tener que anidar 00:27:09
¿Vale? De ahí me ha venido 00:27:11
De ahí me ha venido lo de tener que anidar 00:27:13
Porque son tres 00:27:15
Bueno, pues cuando tengo más de dos posibilidades 00:27:16
En lugar de ir anidando 00:27:20
Y dentro de los if 00:27:21
Para ir abriendo ramas, ir abriendo ramas 00:27:23
Que sería la forma de ir contemplando 00:27:25
Uy, se estaba así detrás 00:27:27
¿Cuándo has llegado tú? 00:27:28
No, era Kevin, el que faltaba 00:27:31
Ah, vale, tengo un contigo 00:27:36
vale, vale, vale 00:27:37
no, no, no, no, no 00:27:38
le he puesto falta a Kevin 00:27:41
sí, creo 00:27:42
sí, vale 00:27:45
bueno, entonces, ¿entendéis lo que estoy diciendo? 00:27:47
que cuando 00:27:50
tenemos un programa 00:27:51
en el cual yo tengo varias posibilidades 00:27:53
más de dos, como este 00:27:56
que yo digo, ah no 00:27:57
voy a mostrar, oprimo o no oprimo 00:27:59
o mayor o igual que 10 00:28:02
cuando tengo más de dos, es que con un único if-else 00:28:03
es imposible, no puedo 00:28:05
Porque con un if else solo puedo mostrar dos cosas 00:28:07
O esta o la otra 00:28:10
Con un if else es imposible 00:28:11
Entonces tenemos que anidar 00:28:12
Como aquí hemos anidado 00:28:14
Si n es mayor que 10, primo y no primo 00:28:17
Y si no 00:28:19
Mayor o igual que 10 00:28:20
Y aquí igual, si quiero distinguir 00:28:23
Si es mayor o igual que 10, me toca anidar aquí dentro 00:28:24
O sea, si hay más de dos opciones 00:28:26
Tengo que ir anidando para ir abriendo ramas 00:28:28
¿Verdad? 00:28:30
Aquí, si yo tengo más opciones 00:28:38
No lo llamemos términos de condiciones 00:28:40
En términos de posibilidades de resultado 00:28:46
De posibilidades de resultado 00:28:50
Cuando tengo varios caminos 00:28:51
Entonces yo aquí tendría tres caminos 00:28:53
Si n es mayor o igual que 10 00:28:56
Si n es primo, si n es menor que 10 00:28:58
O si n es no primo 00:28:59
Entonces con un único if no puedo 00:29:00
Porque con un único if tengo dos caminos 00:29:02
Entonces tendría que abrirlo 00:29:03
¿Verdad? 00:29:06
N es menor que 10 00:29:06
Pues ahora abro aquí 00:29:10
Vale 00:29:12
Y además es primo 00:29:13
Pues entonces abriría 00:29:15
Tendría que abrir, es que no me queda otra 00:29:18
Abriría por aquí 00:29:20
Y abriría por aquí 00:29:21
Entonces voy abriendo ramas 00:29:23
Cada if anidado me va abriendo otro camino 00:29:24
Cada if que anide me abre más y más 00:29:27
¿Verdad? 00:29:28
Entonces, ayer cuando nos fuimos 00:29:31
Cuando dijimos 00:29:33
cuando yo identifico que un programa 00:29:35
tiene varios caminos 00:29:38
distintos, en lugar de anidar 00:29:40
id dentro del id, dentro del if 00:29:42
o dentro del else, en lugar de anidar 00:29:44
porque se me queda un programa muy feo 00:29:45
Java nos da una forma compacta de hacerlo 00:29:47
¿verdad? queda la sentencia como 00:29:49
venga, ¿quién era el que había estudiado? 00:29:51
tú, habías estudiado entre un cuarto de hora 00:29:56
y media hora, entonces contéstame 00:29:57
cuando, pues lo que acabo de decir 00:30:00
siempre lo acabo de decir 00:30:03
Claro, pues en general, hay que hacer un caso cuando hables. 00:30:05
Bueno, pues lo que he dicho es, cuando tenemos varios... 00:30:12
Pero mírame también. 00:30:14
Mira, vosotros vais a una empresa y cuando alguien os habla, 00:30:17
no le atendéis y luego le decís que no te ha escuchado 00:30:21
y es que duráis un día de práctica, duráis uno. 00:30:23
Y si todo ocurre a mí, a yo y a mí me estáis en la práctica 00:30:27
y de verdad que os echan, os digo en serio que os echan. 00:30:29
A ti me dicen que no contestéis tal cual. 00:30:32
La verdad es que si dejan a vosotros y no contestáis o no miréis, es que os echan a la calle. 00:30:33
Porque sobra gente. 00:30:39
Entonces, por favor, tenéis que aprender ya a desarrollar conductas que sean compatibles con que os echen a la calle. 00:30:40
¿Vale? 00:30:48
Entonces, como te estoy preguntando, no vas a escuchar. 00:30:49
Vale. 00:30:51
Primero, segundo, o para que te vuelva a preguntar, mírame y escúchame. 00:30:52
Bueno, pues entonces, cuando tenemos un problema con varios caminos posibles, 00:30:55
es primo, no es primo, no es igual que 10 00:30:59
no nos queda más remedio que anidar y dentro de él 00:31:02
¿verdad? que es todo lo mismo 00:31:04
¿verdad que sí? 00:31:05
como a mi ari ya dijimos ayer que era muy feo 00:31:07
ya dijimos ayer 00:31:10
que teníamos la posibilidad 00:31:11
de enjabar y desarrollar de manera 00:31:14
más compacta, dejamos la otra sentencia 00:31:16
pues la pregunta es 00:31:17
¿esa sentencia cuál es? 00:31:19
una forma que tiene 00:31:29
el java de 00:31:30
permitirnos anidar 00:31:31
y de forma 00:31:34
más compacta, no teniendo ahí 00:31:36
¿qué se entiende? ¿cómo la llamábamos? 00:31:38
la imaginamos ayer y pusimos un ejemplo 00:31:40
¿quién me lo dice? 00:31:42
el seguir 00:31:44
el seguir 00:31:45
hay allá y de verdad 00:31:47
el futuro hay que curárselo mucho 00:31:51
bueno, pues este es un caso 00:31:53
este es un ejemplo de eso 00:31:58
vale, aquí tenemos 00:32:00
tres posibilidades 00:32:02
identificamos que tenemos tres posibilidades 00:32:03
vamos a borrar ya esto 00:32:05
a ver 00:32:09
Lo vamos a escribir aquí 00:32:15
Tenemos tres caminos para este programa 00:32:17
¿Vale? Tenemos tres caminos 00:32:22
Hemos identificado camino uno 00:32:23
El camino uno es mostrar es primo 00:32:26
Camino dos 00:32:30
Mostrar es no primo 00:32:34
Y camino tres 00:32:37
Que aquí es donde ha venido el problema que me ha obligado a Anidarif 00:32:39
Camino tres 00:32:42
Es mayor o igual de diez 00:32:43
¿Vale? Tres caminos 00:32:45
Si yo tengo tres posibilidades, repito por la próxima vez 00:32:55
Es que voy a tener que anidarif 00:32:58
¿Qué es lo que he hecho arriba? Voy a tener que anidarlos 00:32:59
Primero puedo distinguir una cosa 00:33:01
Luego distinguir la otra 00:33:03
Vale, pues entonces en lugar de anidarlos 00:33:04
Teníamos la sentencia if, el seif 00:33:06
Que tiene esta estructura 00:33:08
Y la primera condición que me llevaría 00:33:09
Por el primer camino 00:33:13
El rollo que yo quiera 00:33:14
El seif, la siguiente condición 00:33:15
Que me lleva por el otro camino 00:33:19
condición para el camino 1 00:33:21
lo pongo así 00:33:23
esta condición que me lleva al camino 2 00:33:26
y aquí lo que sea para el camino 2 00:33:30
y así puedo seguir hasta el infinito 00:33:34
el save condición 00:33:36
que me lleva al 00:33:39
camino 3 00:33:41
como si tuviera tropecientos caminos 00:33:44
y luego a la sentencia del save 00:33:48
que tiene esa estructura 00:34:05
Le puedo añadir un else 00:34:06
Que es 00:34:07
Si no se cumple ninguna de las anteriores 00:34:09
¿Vale? 00:34:12
Entonces esta sentencia es como si hiciéramos 00:34:27
Si se cumple la condición camino 1 00:34:29
Y me tira dentro del if 00:34:31
Y se cumple camino 2 00:34:33
Y me tira dentro del if 00:34:35
Y se cumple camino 3 00:34:37
Entonces eso sería un anidamiento muy complicado 00:34:38
Bueno, pues entonces 00:34:40
Como ya entendemos lo que es un if 00:34:42
Que significa anidarlo y todo eso 00:34:43
Ya podemos usar esta sentencia 00:34:46
que de forma más clara 00:34:48
me recoge esa situación 00:34:50
situación en la que mi programa puede hacer 00:34:52
varias cosas, más de dos 00:34:54
más de dos 00:34:56
cada una de ellas se asocia a una condición, está clara 00:34:57
esta sí es esta condición 00:35:00
esta sí es esta otra, esta sí es esta otra 00:35:02
cada una se asocia a una condición 00:35:04
pues ya está, planta un if, el se if 00:35:05
y la máquina virtual lo interpreta 00:35:07
primero evalúa esta condición 00:35:09
si es cierta, hace lo que hay aquí 00:35:11
y se acabó, y continuamos por abajo 00:35:13
que no es cierta 00:35:15
se va a la siguiente 00:35:17
que esa es cierta, hace lo que hay aquí dentro 00:35:18
y se acabó, y continuamos abajo 00:35:21
que no lo es 00:35:23
se va a evaluar esta, que es cierta 00:35:24
hace lo que hay dentro 00:35:27
que no lo es 00:35:28
y ya termina, y se va por aquí, que no lo es, pasa a la siguiente 00:35:30
que lo es 00:35:33
hace lo que hay dentro y se acabó, se va abajo 00:35:35
que tampoco lo es, pues ya se va a leerse 00:35:37
vale, entonces esta es la estructura 00:35:40
que ya plantamos cuando tenemos un programa 00:35:42
que tiene varias posibilidades, cada una de ellas recogidas con una condición. 00:35:45
En lugar de hacerlo con la sentencia básica, if, else e ir anidando, que se hace más pesado, 00:35:50
pues identificamos los caminos, la condición que me lleva a cada camino y ya está, y planto el if, else e if. 00:35:56
Bueno, pues en este caso era la situación que teníamos. Tenemos tres caminos. 00:36:04
Voy a poner esto así. 00:36:09
Vale, pues este es el caso en el que estábamos 00:36:11
Tenemos un dato de entrada 00:36:17
Tres posibilidades 00:36:18
Esto, esto y esto 00:36:20
Pues ya está, vamos a plantar un if, el se, if 00:36:21
Con estas tres posibilidades y se acabó 00:36:23
Y nos va a quedar un programa más bonito, seguramente 00:36:26
Pues venga, plantamos la primera 00:36:28
N es 00:36:30
Venga 00:36:33
N es mayor o igual que 10 00:36:35
Bueno, hemos dicho que mayor o igual que 10 es el caso 00:36:38
Pues ya está, 100 es mayor o igual que 10 00:36:45
No pongo 00:36:47
Llaves 00:36:50
Porque solo hay una sentencia 00:36:52
Pues entonces 00:36:53
Mostrar es mayor o igual que 10 00:36:54
Pues venga 00:36:58
Un momento 00:36:59
O igual que 10 00:37:02
Vale 00:37:04
Ahora, ese camino ya está 00:37:06
Si es mayor o igual que 10, me voy por este camino 00:37:09
Que no es mayor o igual que 10 00:37:11
Pues me planto aquí mi else if 00:37:14
Que sería 00:37:17
Es ya la otra condición 00:37:25
Toda esta 00:37:27
N es igual a 2 00:37:29
O igual a 3 o igual a 5 o igual a 7 00:37:37
Pues entonces 00:37:39
Es primo 00:37:41
La siguiente 00:37:43
Como ya es 00:37:50
Si no se cumple con las anteriores 00:37:51
Pues entonces la puedo meter en un else 00:37:52
No hace falta que ponga un else if 00:37:54
Que sea n diferente de 2 00:37:57
Y diferente de 3 00:37:59
Y diferente de 5 00:38:00
Y diferente de 7 00:38:01
Vale, pues así queda mucho más claro 00:38:03
Para el que lo ve 00:38:12
Y no hay ningún if anidado a la vista 00:38:13
Para la máquina virtual lo hay 00:38:16
Lo que pasa es que nosotros no lo vemos 00:38:18
Si n es mayor o igual que 10 00:38:19
Hace esto, que no 00:38:22
Es como si anidara un if dentro del else 00:38:23
Que no 00:38:26
¿Cumple esto? Pues es primo 00:38:26
que no, no primo, ya está, tengo cada camino 00:38:30
contemplado en una condición 00:38:32
cada camino contemplado en una condición 00:38:34
¿vale? 00:38:35
a ver 00:38:42
podría haber cambiado el orden, uno pone el orden 00:38:43
que le parece más claro, podría haber puesto primero 00:38:45
esta condición, n si de alguno 00:38:47
de estos, entonces es primo 00:38:49
que no, ahora te pones 00:38:51
n mayor o igual que 10, da igual, en realidad 00:38:53
en el orden en el que lo ponga 00:38:55
¿vale? estas de aquí da igual 00:38:56
porque se van haciendo una por una y cuando 00:38:59
encuentra una que es cierta, ya 00:39:01
hace esa 00:39:02
vale 00:39:04
pues vamos a parar un momentito 00:39:05
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
10 de octubre de 2023 - 12:49
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
39′ 15″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
749.33 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid