Saltar navegación

20251001-ProgEstr-OperadoresBits - 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 1 de octubre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, la otra condición que habíamos dicho, que era Boolean condición 2, esta era la del aprobado, esta tenía una nota de examen y otra de recuperación, vale, y la condición 2, aquí estaba claro cuál era, 00:00:00
Nota examen 00:00:27
Mayor o igual 00:00:29
Que 5 00:00:31
O nota examen 00:00:34
Más 00:00:39
Nota recuperación 00:00:40
Aquí sí que paréntesis obligatorios 00:00:43
Lógicamente para hacer la división 00:00:46
Entre 2 00:00:47
Mayor o igual 00:00:50
Que 5 00:00:52
¿Vale? 00:00:54
Y esta sería nuestra condición 00:00:56
La pongo aquí abajo para que se vea mejor 00:00:58
nota examen, pues la que sea 00:00:59
el aviso 00:01:05
el aviso cual era 00:01:11
el aviso era, tenías que presentarte 00:01:16
al examen 00:01:21
tu nota era menor que 5 00:01:21
y habiendo tenido 00:01:24
que presentar al examen 00:01:26
resulta que tu nota de recuperación 00:01:28
es igual a 00:01:31
menos 1, este sería 00:01:32
el aviso, verdad 00:01:34
estás suspenso y además de estar 00:01:35
suspenso, no te has presentado 00:01:40
¿Vale? 00:01:42
Y la de los acompañantes 00:01:46
Pues teníamos 00:01:48
Aquí a dos personas 00:01:51
Y la idea es 00:01:53
Si pasan o no pasan 00:01:58
Entonces 00:02:00
Aquí con tres 00:02:08
Pues efectivamente la podemos poner 00:02:13
Para hacerlo 00:02:15
Más sencillo 00:02:19
Si la edad de una de ellas 00:02:20
Es mayor o igual que 21 00:02:22
Ya pasan las dos 00:02:24
¿Vale? Entonces 00:02:25
si la edad de este es mayor o igual que 21 00:02:27
las dos pasan, muy bien 00:02:33
pero también pasan, luego or 00:02:35
también pasan si la edad del segundo es mayor o igual que 21 00:02:38
ahí también pasan 00:02:41
pero también pasan 00:02:43
si la edad del primero es mayor o igual que 18 00:02:46
y voy a ponerlas aquí abajo 00:02:51
esta y esta 00:02:55
y si la edad del segundo 00:02:57
es mayor o igual que 18 00:03:03
mayor o igual que 18 00:03:04
¿vale? 00:03:09
esta es la tercera condición 00:03:12
aquí también los paréntesis 00:03:14
están por claridad 00:03:26
porque yo mentalmente he pensado en tres ideas 00:03:27
la primera mayor de 21 00:03:30
o la segunda mayor de 21 00:03:32
o las dos mayores de edad 00:03:34
entonces como hemos pensado en esas tres ideas 00:03:35
pues esto lo hemos puesto 00:03:38
entre paréntesis porque es 00:03:40
la primera idea, la segunda y la tercera 00:03:42
pero de nuevo 00:03:44
si yo observo esta condición y veo como funciona 00:03:45
podría quitar los paréntesis 00:03:48
e independientemente 00:03:50
de la prioridad c, funciona 00:03:53
si es mayor o igual que 21 00:03:54
resulta que no, pues está falso 00:03:56
esta resulta que tampoco 00:03:58
pues está falso 00:04:01
ahora miraría esta 00:04:02
esta es 19 00:04:04
esta es true, vale 00:04:05
pero como luego el total del estresor 00:04:08
ya va en true 00:04:10
porque esta es false, false 00:04:11
or true, porque es 19 00:04:14
pero dependemos ahora de este and 00:04:16
porque es un and 00:04:18
entonces si esta también es true 00:04:19
porque es 19 o 20 00:04:22
la total lo será 00:04:24
en este ejemplo 00:04:26
luego ya una vez que lo he observado 00:04:27
puedo quitar los paréntesis y va a funcionar igual 00:04:30
pero para qué 00:04:32
Seguramente quien lo vea 00:04:33
Lo va a ver más claro así 00:04:36
Y me arriesgo a cometer menos errores 00:04:38
Me arriesgo a que la condición no exprese 00:04:41
Lo que yo quería 00:04:43
Quitando paréntesis alegremente 00:04:43
O sea, hacer los códigos cortos 00:04:46
No significa que sean mejores 00:04:50
Si a la máquina virtual le da igual 00:04:52
Luego va a ejecutar lo mismo 00:04:53
Hacer los códigos cortos 00:04:54
Tiene el peligro de que son menos claros 00:04:57
A la hora de leerlos y de entenderlos 00:04:59
Bueno 00:05:02
En el listado ese de ejercicios 00:05:11
Luego al final hay condiciones 00:05:13
Y todo eso para practicar 00:05:15
Lo que pasa es que vamos a ver antes el operador ternario 00:05:17
Para que esas aplicaciones 00:05:21
Esos programitas se puedan hacer un poquito mejor 00:05:22
¿Qué operadores son estos? 00:05:24
¿Cuáles? Estos son los lógicos 00:05:31
O booleanos 00:05:32
Entonces si volvemos aquí 00:05:33
Porque esto le vamos a dar ya 00:05:36
dos patadas para mandarla a la porra 00:05:37
porque nos estamos aburriendo mucho 00:05:40
si volvemos a nuestra 00:05:41
a nuestra lista de operadores 00:05:46
aritméticos 00:05:49
la asignación 00:05:51
concatenación 00:05:53
la precedencia de operadores 00:05:58
que ante la duda 00:06:02
paréntesis 00:06:04
pero bueno la básica de multiplicación 00:06:05
de divisiones antes que sumas esa la sabemos 00:06:08
lo de promoción automática y casting 00:06:10
también lo hemos hablado sobre ello 00:06:13
estos de unarios 00:06:16
los relacionales 00:06:17
hemos hablado de ellos 00:06:21
y estos son con los que 00:06:23
estamos los booleanos o lógicos 00:06:25
¿vale? que hemos hablado 00:06:27
de ellos con algún 00:06:29
ejemplo y ya está 00:06:31
y ahora 00:06:32
aquí tenéis rollete 00:06:34
que deberíais 00:06:37
leeros, pero bueno, vuelve sobre lo mismo 00:06:39
una y otra vez, y ahora ya nos viene 00:06:41
este rollo, que lo vamos a mencionar 00:06:43
pero, para que sepáis 00:06:45
lo que es, pero ni lo vamos a practicar ni nada 00:06:47
porque no merece la pena 00:06:49
y es una cosa 00:06:51
muy específica 00:06:53
que son los operadores ya a nivel 00:06:54
de bit, ¿quién usa operadores 00:06:58
a nivel de bit? 00:07:00
pues nadie, es una cosa muy específica 00:07:01
vale, voy a mencionar solamente 00:07:03
lo que es 00:07:06
que son los que están aquí en esta 00:07:07
tablita, en esta 00:07:12
tablita, vamos a mencionar lo que es 00:07:15
y os lo podéis leer 00:07:17
y practicar 00:07:19
si queréis, probarlo en Java 00:07:21
lo practicáis y ya está, pero es que no lo vamos 00:07:23
a usar jamás, así que 00:07:25
nos vamos a quedar con eso 00:07:27
entonces estos operadores de aquí 00:07:28
vale 00:07:31
se basan 00:07:38
vale, estos operadores lo que consiguen 00:07:40
es trabajar, si yo tengo 00:07:52
una variable en memoria, que ya sabes 00:07:54
que una variable en memoria es esto. 00:07:56
Pero si unos hay puestos. 00:07:59
¿Cuántos en total? 00:08:01
Depende del tipo 00:08:03
de datos. Si es int, ya sabemos que 00:08:04
es 32. Si es byte, sabemos 00:08:06
que es 8. 00:08:08
Bueno, pues esto es una variable. 00:08:11
Nosotros 00:08:13
trabajamos con la variable en su conjunto. 00:08:13
Si es un entero, usamos la variable 00:08:16
entera que representa 7 00:08:18
para sumar la otra variable entera. 00:08:20
que nos da 12 y todo ese 12 va a otra variable, 00:08:22
trabajamos con el valor de esa variable en completo, ¿vale? 00:08:25
No trabajamos a nivel de bit, 00:08:30
porque es que esto tiene muy poco significado real. 00:08:32
Cada bit suelte muy poco significado. 00:08:35
Lo que tiene significado es que todo el conjunto, ¿vale? 00:08:37
Es que todo el conjunto es un número, 00:08:41
significa un número. 00:08:45
Eso sí que tiene significado, ¿vale? 00:08:45
¿para qué puede 00:08:48
servir trabajar a nivel de bits? 00:08:51
pues cuando los bits los interpretamos como 00:08:52
sensores tipo on off 00:08:54
pues por ejemplo tengo una lista de 8 sensores 00:08:56
y cada bit 00:08:58
me controla un sensor si está 00:09:00
activo o inactivo en función de si ese bit 00:09:02
es 0 o es 1, para ese tipo de 00:09:04
cosas extrañas 00:09:06
pero en Java normalmente se hacen aplicaciones 00:09:07
comerciales, no se hacen aplicaciones de control industrial 00:09:10
ni de nada, pero bueno 00:09:12
existen operadores que nos permiten 00:09:13
trabajar con los bits por separado 00:09:16
que son estos, vamos a mencionar un poco 00:09:18
lo que hacen, pero sin practicarlo ni sin nada 00:09:20
pero no merece la pena perder el tiempo con ello 00:09:22
vale 00:09:24
estos operadores, todos ellos, salvo 00:09:25
este último 00:09:29
lo que reciben a derecha y a izquierda 00:09:30
son dos variables 00:09:33
en el numerito en general 00:09:36
dos variables normales, un int 00:09:37
un long, un byte 00:09:40
dos numeritos 00:09:42
es lo que reciben 00:09:43
incluso estas de aquí, porque 00:09:44
Este and es el mismo símbolo que el and lógico, 00:09:47
pero no hay confusión porque cuando aquí le damos condiciones 00:09:53
nos referimos al and lógico de arriba. 00:09:57
Pero cuando lo que le damos es numeritos, 00:10:00
nos referimos a este que vamos a explicar. 00:10:04
Cuando le damos un int o un long. 00:10:05
Luego no hay confusión sobre cuando yo veo esto en un programa, 00:10:07
¿a qué me estoy refiriendo? 00:10:11
¿A este operador de bits que ahora explicamos cuál o al and de arriba? 00:10:12
depende, si lo que hay aquí 00:10:15
son condiciones 00:10:17
boolean, si lo que hay aquí son boolean 00:10:18
no hay ninguna duda, me refiero a land, a land de dos 00:10:21
boolean, boolean este and boolean 00:10:23
el otro 00:10:25
pero si lo que tengo son dos variables enteras 00:10:26
me refiero a este otro 00:10:29
que ahora vemos lo que hay 00:10:31
bueno, pues este 00:10:33
de aquí, le damos dos variables 00:10:35
a y b 00:10:37
esta de aquí y esta de aquí 00:10:38
y lo que hace es 00:10:42
coge la primera y va moviendo los bits 00:10:43
hacia la izquierda 00:10:47
tantas posiciones como diga este número 00:10:49
si este número B te dice 3 00:10:51
pues coge la variable A 00:10:54
y mueve hacia la izquierda 00:10:56
3 posiciones 00:10:58
luego 3 bytes desaparecerán 00:10:59
se volatilizarán 00:11:02
y por la izquierda entran 3 ceros 00:11:04
es un desplazamiento de los bits 00:11:08
por aquí entran los ceros 00:11:10
el desplazamiento es hacia la izquierda 00:11:14
entonces 00:11:16
los más significativos se caen 00:11:16
y por la zona menos 00:11:20
significativa entran ceros 00:11:22
¿cuántos desplazamientos? tantos como el 00:11:23
numerito B te indique 00:11:26
¿para qué te puede servir 00:11:27
desplazar? bueno pues si tú efectivamente 00:11:30
estás haciendo una rotación de 00:11:32
sensores, lo que sea 00:11:34
en realidad se corresponde 00:11:35
a una multiplicación por dos 00:11:38
desplazar en binario 00:11:40
todo a la izquierda es multiplicar por 2 00:11:42
desplazar 00:11:44
dos veces a la izquierda es multiplicar por 4 00:11:46
por 2 elevado a 2 00:11:48
desplazar tres veces a la izquierda es multiplicar por 8 00:11:49
por 2 elevado a 3 00:11:52
del binario que habéis estudiado 00:11:53
pues cada desplazamiento a la izquierda 00:11:55
es una multiplicación por 2 00:11:59
luego es una forma rápida de multiplicar por 2 00:12:00
es decir, esto 00:12:02
imaginaos que tenemos una variable 00:12:04
pues eso 00:12:08
una variable a 00:12:09
que la multiplico por 2 00:12:12
pues esta operación es la misma 00:12:14
que esta 00:12:16
lo de arriba y lo de abajo hace lo mismo 00:12:18
me da igual multiplicar esta variable por 2 00:12:23
que desplazar todos los bits a la izquierda a una posición 00:12:25
esta es lo mismo 00:12:27
pero desplazando a la derecha 00:12:32
lo mismo 00:12:34
desplazas a la derecha tantos bits 00:12:36
como haya aquí 00:12:38
en realidad se traduce a dividir entre 2 00:12:39
¿vale? 00:12:42
Luego me da igual a entre 2 que desplazar a la derecha una cantidad. 00:12:44
Normalmente dividimos y multiplicamos, no lo hacemos con desplazamientos. 00:12:50
Este es, a ver, estos dos, los dos son desplazamientos a la derecha, 00:13:01
pero uno propaga el bit de signo y otro no. 00:13:07
Recordad que cuando un número es negativo, su bit más significativo es 1, ¿verdad? 00:13:11
cuando es negativo, según el complemento a 2 00:13:15
su bit más significativo es 1 00:13:18
y cuando es positivo es 0 00:13:20
pues el desplazamiento así 00:13:21
con dos flechitas solo 00:13:24
propaga el bit de signo, lo conserva 00:13:25
entonces lo que entra por la izquierda son unos 00:13:28
lo que entra son unos, lo propaga 00:13:30
sin embargo 00:13:32
este desplazamiento 00:13:34
lo que mete por la izquierda son 00:13:35
ceros, independientemente de que el bit 00:13:38
de signo sea 1, es la única diferencia 00:13:40
lo que yo meto por la izquierda 00:13:42
en este desplazamiento 00:13:44
en esto de aquí meto ceros 00:13:45
y en este de aquí 00:13:48
meto lo que tenga el bit de signo 00:13:50
si el bit de signo tiene uno, pues propago el uno 00:13:51
si no tiene 00:13:54
si tiene cero, propago el cero 00:13:56
es la única diferencia entre uno y otro 00:13:58
y esto de aquí abajo 00:13:59
este operador de aquí abajo 00:14:03
¿y los tres signos de mayor? 00:14:07
¿en qué se trabaja? 00:14:13
en desplazar a la derecha tantas posiciones 00:14:14
como hagas este de aquí 00:14:17
y a la izquierda lo que metes es ceros 00:14:18
¿sí o sí? 00:14:21
Aunque el número, es decir, si tú tienes... 00:14:23
No, porque el de arriba, imagínate que en el de arriba el número A es el menos 7. 00:14:27
Entonces, el menos 7, pues es el numerito que sea, yo que sé, algo así será. 00:14:34
Bueno, este no sé cuál es este, menos 8, no lo sé. 00:14:40
Y entonces, este es el A y vamos a desplazar el A a la izquierda dos posiciones, por ejemplo. 00:14:44
Pues se mueven todos a la izquierda dos posiciones, pero lo que entra por los dos huecos libres es lo mismo que tenga el bid de signo. 00:14:53
Como este tenía uno, porque el número negativo, entran unos, entran unos por aquí. 00:15:01
Pero sin embargo, si el numerito A fuera, en vez del menos siete, fuera el siete, pues por ejemplo, yo que sé, fuera esto, 00:15:07
al desplazar los dos se mueven todos los dos, pero lo que entra por aquí es cero. 00:15:14
es decir, con esta opción de arriba 00:15:18
lo que entra por la izquierda 00:15:22
es 1 o es 0 00:15:24
en función de cómo sea el bit de signo 00:15:26
si es 1 entran 1 00:15:28
si no entran 0 00:15:30
eso es para conservar la división 00:15:30
tal cual, porque si entran 1 00:15:34
tú realmente estás haciendo la división 00:15:36
y si tienes menos 8 00:15:38
y desplazas entre 2 00:15:40
se te queda el menos 4 00:15:42
porque estás propagando con 1 00:15:44
el 1 en negativo es como si fuera 0 00:15:46
Entonces, esta versión 00:15:48
Es la que es realmente la división 00:15:51
Valiéndote tanto 00:15:53
Sin número negativo como positivo 00:15:55
Sí, la de arriba 00:15:56
Claro, y esto es dividir en potencias de 2 00:15:59
Y esto es desplazar 00:16:03
Pero no se corresponde con una división 00:16:07
Porque no conservas el signo 00:16:09
Claro, esto es si los bits tienen otro sentido 00:16:10
A lo mejor pues eso 00:16:14
Cada bit tiene un significado distinto 00:16:15
que se corresponde con un display 00:16:16
y tú mueves todos los displays. 00:16:18
No es una división de números. 00:16:20
¿Vale? 00:16:25
En esta metes ceros 00:16:25
independientemente de lo que tengan los bits. 00:16:27
Metes ceros. 00:16:28
¿Vale? 00:16:30
Y estas de aquí 00:16:31
es hacer el and y el or 00:16:32
pero de los bits, 00:16:35
no del número. 00:16:36
Esta de aquí, 00:16:43
pues tú tienes aquí el a, 00:16:45
que es este numerito, 00:16:47
por ejemplo. 00:16:48
Y tienes el b, 00:16:50
por ejemplo, esto. 00:16:57
pues el resultado es otro numerito 00:16:58
y lo que se va haciendo es bit por bit 00:17:01
como si fuera el and de cada bit 00:17:04
asumiendo que el 1 es true y el 0 es false 00:17:07
entonces esto a and b 00:17:10
pues iríamos numerito por numerito 00:17:14
0 and 0, 0 00:17:18
1 y 1, 1 00:17:19
0 y 1, 0 00:17:21
es como multiplicar 00:17:23
1 y 0, 0 00:17:24
1 y 0, 0 otra vez 00:17:26
1 y 0, 0 00:17:28
0 y 1, 0 00:17:29
y 0 y 1, 0 00:17:32
es decir, se quedan todos a 0 00:17:33
salvo en el que hubiera dos 1 00:17:36
ese es el único 00:17:37
salvo en el que hubiera dos 1, todo lo demás son 0 00:17:38
pues eso es lo que hace esta operación 00:17:42
entre dos números 00:17:45
pues va bit por bit 00:17:46
haciendo como si fuera la multiplicación 00:17:48
por ejemplo, esta operación 00:17:51
si la haces con 0, haces a 00:17:58
and 0 00:17:59
es como poner a cero todos los sensores 00:18:00
porque la cera 00:18:03
con el cero 00:18:05
pones a cero todos, por ejemplo 00:18:06
y esto 00:18:08
es en lugar de hacer 00:18:12
el and de bit por bit, el or 00:18:16
en este caso 00:18:17
en este caso el or sería 00:18:19
cero and cero, cero 00:18:27
uno y uno, uno, cero y uno, uno 00:18:29
porque es el or 00:18:32
uno y cero, uno, cero y uno, uno 00:18:33
uno y cero, uno 00:18:35
cero y uno, uno, cero y uno y uno 00:18:36
¿vale? entonces al hacer 00:18:39
un or con uno, por ejemplo 00:18:41
pues es como poner a uno todo 00:18:43
este tipo 00:18:45
de aplicaciones a bits, de bits 00:18:47
más asociadas pues eso, a displays, a sensores 00:18:49
a darle un significado a cada bit 00:18:51
suelto, es para 00:18:53
lo que tienen sentido estos 00:18:55
operadores de aquí, de desplazar 00:18:57
los bits, cambiarlos uno a uno 00:18:59
pero en aplicaciones 00:19:01
reales, pues bueno, son cosas 00:19:03
muy específicas, por eso no vamos a hacer ejemplos 00:19:05
si es que no lo vamos a utilizar en todo el curso 00:19:07
pero bueno, hay que 00:19:09
mencionarlo para que no parezca que os ocultamos 00:19:11
información 00:19:13
y este sería el 00:19:14
el OR exclusivo 00:19:18
el OR exclusivo pues es 00:19:22
tienen que ser distintos 00:19:25
para que sea uno, el OR exclusivo 00:19:27
tienen que ser distintos para que sea uno 00:19:28
claro, por ejemplo 00:19:30
uno y uno, que aquí no hay ninguna combinación 00:19:33
uno y uno sería cero 00:19:34
sin embargo con el anormal 00:19:36
1 y 1 es 1 00:19:38
pues con el or exclusivo 00:19:39
0 y 0 y 1 y 1 00:19:41
son 0 00:19:47
solo son 1, 0 y 1, 1 y 0 00:19:49
y este que es un operador 00:19:51
que se pone delante de la variable que sea 00:19:57
lo único que hace es 00:19:59
invertir los bits 00:20:01
va bit por bit y los invierte 00:20:02
si yo hago esto de a 00:20:04
me invierte los bits 00:20:07
El que esté a cero le pone a uno 00:20:09
Y el que esté a uno le pone a cero 00:20:11
Bueno, pues son operaciones a nivel de bits 00:20:12
Muy específicas 00:20:23
Y que salvo para hacer alguna multiplicación 00:20:24
O alguna cosa 00:20:27
Realmente no tiene mucho 00:20:28
Mucha utilidad 00:20:30
¿Y para qué te sirve esto? 00:20:32
¿En el mundo real? 00:20:34
¿Para programar en máquina? 00:20:36
Yo no lo uso 00:20:39
No, con mi examinador no 00:20:39
No lo he usado en mi vida 00:20:41
No lo sé 00:20:44
Pero, pues, si tú tienes una, imagínate que tuvieras unos requisitos de memoria, de rendimiento de memoria muy grandes, o sea, una aplicación que exige una fiabilidad extrema, entonces, en ese caso, tiene sentido que aproveches los bits al límite y que le des un significado y que, por ejemplo, si a ti hay un dato que lo único que te importa es si es true o false o si pasa o no pasa, 00:20:45
pues, ¿para qué usar 8 variables boolean? 00:21:15
Puedes usar un byte y que cada uno de esos bits, 00:21:19
en función de si es 0 y 1, te indique si eso pasa o no. 00:21:23
Entonces, optimizas el uso de la memoria 00:21:26
en aplicaciones en las que tengan unos requisitos, 00:21:28
a lo mejor, de rendimientos muy específicos. 00:21:30
Lo que te permite esto es aprovechar la información. 00:21:33
No te estamos malgastando información todo el rato. 00:21:35
Uno declara un int, ¿y qué números ponen int? 00:21:37
La mayoría de los bits te están sobrando. 00:21:40
Cuando tú declaras una condición 00:21:42
Con una variable boolean 00:21:45
Boolean ocupa en memoria 00:21:46
No sé si 8 o 16 bits 00:21:48
Pero es que solamente tiene dos posibilidades 00:21:50
O true o false 00:21:53
Pues usar tantos bits para eso 00:21:53
Cuando un solo bit te valdría 00:21:55
Pues para aplicaciones en las cuales 00:21:57
El rendimiento sea muy grande 00:21:59
Pero vamos 00:22:00
Son situaciones muy específicas 00:22:01
Y si seguimos con 00:22:05
Operadores de bits 00:22:08
Pues bueno, aquí tenéis un rollete 00:22:10
que lo especifica 00:22:11
y aquí la tabla 00:22:14
de precedencia de operadores 00:22:23
pero normalmente uno conoce 00:22:25
siempre lo básico 00:22:27
que es que estos van por delante 00:22:28
del más y el menos 00:22:32
y efectivamente 00:22:33
aquí ya lo tenemos resuelto 00:22:36
que yo no lo recordaba 00:22:37
por eso lo quería probar 00:22:38
el AND siempre se ejecuta 00:22:41
antes del OR 00:22:44
entonces si no ponéis paréntesis 00:22:44
los and 00:22:46
se van a hacer antes que los or 00:22:48
siempre 00:22:50
entonces esto es más confuso que las sumas y restas 00:22:50
nos es más confuso las operaciones 00:22:54
lógicas que las aritméticas 00:22:56
entonces 00:22:57
no tengáis miedo de abusar de los paréntesis 00:22:59
en expresiones lógicas 00:23:02
lo peor que puede ocurrir 00:23:04
es que sobren 00:23:06
pero si faltan es grave 00:23:07
y ahora ya 00:23:09
esta hojita que es 00:23:14
un poco el recordatorio 00:23:16
el repaso de los operadores que vamos a manejar 00:23:17
la olvidamos porque ya sabemos 00:23:20
con algunos ejemplos además 00:23:24
los operadores que vamos a manejar 00:23:26
salvo ya este 00:23:28
que es el famoso operador ternario 00:23:29
al que hace referencia 00:23:33
estos ejercicios de aquí 00:23:36
que estáis haciendo para practicar 00:23:43
pues estos de aquí hacen referencia ya 00:23:45
a este operador ternario, ¿vale? 00:23:48
Entonces una vez visto eso, pues ya 00:23:51
podéis hacer todo esto 00:23:53
todos los que hay aquí 00:23:54
para poner un poquito en práctica esta primera parte 00:23:56
de variables, operadores, asignaciones 00:23:59
pues venga 00:24:01
vamos a mencionar esto del operador ternario 00:24:06
bueno, vamos a pasar 00:24:09
lista y así descansamos unos minutitos 00:24:12
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:
1 de octubre de 2025 - 17:31
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 16″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
464.29 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid