Operadores lógicos Parte 1

Parte de la sección Fundamentals del Journey de Rust de Coddy — lección 20 de 75.

Los operadores lógicos se utilizan para comprobar combinaciones de comparaciones que devuelven true o false.

Por ejemplo, la siguiente declaración contiene dos comparaciones:

¿Es 5 mayor que 3 y menor que 6?

Operador	Significado	Ejemplo
`&&`	And - `true` si todos los operandos son `true`	`a && b`
`\|\|`	Or - `true` si cualquier operando es `true`	`a \|\| b`
`!`	Not - `true` si el operando es `false`	`!a`

Veamos algunos ejemplos,

5 es mayor que 3 y 1 es igual a 1,

let b1: bool = (5 > 3) && (1 == 1); // es true

Explicación: Todos los operandos son true, por lo que b1 contendrá true (la operación and es true si ambos operandos son true) .

5 no es igual a 4 o 5 es igual a 2,

let b2: bool = !(5 == 4) || (5 == 2); // es verdadero

Explicación: El primer operando (5 != 4) es true, por lo que b2 también es true (la operación or es true si cualquiera de los operandos es true)

1 no es igual a 1 o falso,

let b3: bool = !(1 == 1) || false; // contiene false

Explicación: Todos los operandos son false, por lo que b3 contendrá false (operación or).

no (3 es mayor que 4),

let b4: bool = !(3 > 4); // es true

Explicación: El operando es false, por lo que b4 contendrá true (operación not).

no (5 es mayor que 10 o 5 es mayor que 1),

let b5: bool = !(5 > 10 || 5 > 1); // contiene false

Explicación: 5 > 10 || 5 > 1 es true (uno de los operandos es true), así que en total b5 es false (operación not).

Desafío

Principiante

Se te proporciona código, reemplaza los signos de interrogación de las variables b1 y b2 con valores booleanos para que b3 contenga true.

Hay más de una solución correcta.

Hoja de referencia

Los operadores lógicos se utilizan para comprobar combinaciones de comparaciones que devuelven true o false.

Operador	Significado	Ejemplo
`&&`	And - `true` si todos los operandos son `true`	`a && b`
`\|\|`	Or - `true` si cualquier operando es `true`	`a \|\| b`
`!`	Not - `true` si el operando es `false`	`!a`

Ejemplos:

let b1: bool = (5 > 3) && (1 == 1); // true (ambos operandos son true)
let b2: bool = !(5 == 4) || (5 == 2); // true (el primer operando es true)
let b3: bool = !(1 == 1) || false; // false (ambos operandos son false)
let b4: bool = !(3 > 4); // true (el operando es false, por lo que la operación not devuelve true)
let b5: bool = !(5 > 10 || 5 > 1); // false (la expresión interior es true, por lo que la operación not devuelve false)

Pruébalo tú mismo

fn main() {
    // Escribe tu código a continuación
    let b1: bool = ?;
    let b2: bool = ?;
    let b3: bool = b1 || b2;
    
    // No cambies la línea de abajo
    println!("b3 = {}", b3);
}