Logical operators in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the logical AND operator (&&) do in Rust?

The logical AND operator (&&) returns true only if both conditions on its sides are true. If either side is false, the result is false.

beginner

What is the result of the logical OR operator (||) if one side is true and the other is false?

The logical OR operator (||) returns true if at least one side is true. So if one side is true and the other is false, the result is true.

beginner

Explain the logical NOT operator (!) in Rust.

The logical NOT operator (!) reverses the value of a boolean. If the value is true, ! makes it false. If false, ! makes it true.

beginner

What will this Rust code print? <br><pre>let a = true;
let b = false;
println!("{}", a && b);</pre>

It will print false because a is true but b is false, and true && false is false.

intermediate

How do logical operators help in decision making in Rust programs?

Logical operators combine multiple conditions to decide if a block of code should run. They help check if all, any, or none of the conditions are true.

What does the expression true || false evaluate to in Rust?

A false

B none

C error

D true

The logical OR (||) returns true if at least one side is true.

Which operator reverses a boolean value in Rust?

A !

B ||

C &&

D ==

The ! operator is the logical NOT, which reverses true to false and false to true.

What is the result of false && true in Rust?

A true if checked first

B true

C false

D error

Logical AND (&&) returns true only if both sides are true; here one side is false.

Which logical operator would you use to check if both conditions are true?

A &&

B ||

C !

D &

&& is the logical AND operator that checks if both conditions are true.

What does the expression !(true && false) evaluate to?

A none

B true

C error

D false

true && false is false, and !false is true.

Explain how the logical AND (&&), OR (||), and NOT (!) operators work in Rust with simple examples.

Think about when each operator returns true or false.

Describe a real-life situation where you might use logical operators in a Rust program.

Consider checking multiple conditions before doing something.

Practice

1. Which logical operator in Rust means AND and returns true only if both conditions are true?

easy

A. !

B. ||

C. &

D. &&

Solution

1. Step 1: Understand the meaning of logical AND

   The AND operator returns true only when both conditions it connects are true.

2. Step 2: Identify Rust's AND operator

   In Rust, the AND operator is written as &&.

3. Final Answer:

   && -> Option D

4. Quick Check:

   AND = && [OK]

Hint: AND operator is double ampersand && in Rust [OK]

Common Mistakes:

• Confusing || (OR) with && (AND)
• Using single & which is bitwise AND
• Mistaking ! for AND

2. Which of the following is the correct syntax to negate a boolean variable flag in Rust?

easy

A. not flag

B. !flag

C. flag!

D. ~flag

Solution

1. Step 1: Recall Rust's NOT operator syntax

   Rust uses the exclamation mark ! before a boolean to negate it.

2. Step 2: Apply negation to variable flag

   Writing !flag returns the opposite boolean value of flag.

3. Final Answer:

   !flag -> Option B

4. Quick Check:

   NOT = ! [OK]

Hint: Negate booleans with ! before the variable [OK]

Common Mistakes:

• Writing negation after the variable (flag!)
• Using 'not' keyword which Rust does not support
• Using ~ which is bitwise NOT, not boolean NOT

3. What is the output of this Rust code?

let a = true;
let b = false;
println!("{}", a || b && !a);

medium

A. Compilation error

B. false

C. true

D. Syntax error

Solution

1. Step 1: Evaluate the expression with operator precedence

   AND (&&) has higher precedence than OR (||), so evaluate b && !a first.
   Here, b = false, a = true, so !a = false.
   Thus, b && !a = false && false = false.

2. Step 2: Evaluate the OR operation

   Now evaluate a || (result) which is true || false.
   This results in true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Operator precedence: && before || = true [OK]

Hint: Remember && before || in expressions [OK]

Common Mistakes:

• Evaluating || before &&
• Ignoring negation operator precedence
• Assuming false because b is false

4. Identify the error in this Rust code snippet:

let x = true;
let y = false;
if x & y {
    println!("Both true");
}

medium

A. Using & instead of && for logical AND

B. Missing semicolon after println!

C. Incorrect variable names

D. No error, code runs fine

Solution

1. Step 1: Check the operator used in the if condition

   The code uses & which is a bitwise AND operator, not logical AND.

2. Step 2: Identify correct logical AND operator in Rust

   Logical AND requires && to combine boolean values properly.

3. Final Answer:

   Using & instead of && for logical AND -> Option A

4. Quick Check:

   Logical AND needs &&, not & [OK]

Hint: Use && for logical AND, & is bitwise AND [OK]

Common Mistakes:

• Confusing bitwise & with logical &&
• Assuming & works for booleans
• Ignoring compiler warnings about operator types

5. You want to check if a number n is between 10 and 20 inclusive in Rust. Which condition correctly uses logical operators?

hard

A. n >= 10 && n <= 20

B. n >= 10 || n <= 20

C. !(n < 10 && n > 20)

D. n > 10 && n < 20

Solution

1. Step 1: Understand the range condition

   To check if n is between 10 and 20 inclusive, both conditions must be true:
   n >= 10 and n <= 20.

2. Step 2: Combine conditions with logical AND

   Use && to ensure both conditions hold simultaneously.
   So the correct condition is n >= 10 && n <= 20.

3. Final Answer:

   n >= 10 && n <= 20 -> Option A

4. Quick Check:

   Range check uses AND (&&) [OK]

Hint: Use && to combine range checks for inclusive conditions [OK]

Common Mistakes:

• Using || which allows values outside the range
• Using strict > and < instead of >= and <=
• Negating conditions incorrectly