Logical operators in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if both conditions are true.

Rust

let a = true;
let b = false;
let result = a [1] b;
println!("{}", result);

Drag options to blanks, or click blank then click option'

A&&

B|

C||

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Using || instead of && will return true if either is true.

The && operator returns true only if both a and b are true.

2fill in blank

medium

Complete the code to check if either condition is true.

Rust

let x = false;
let y = true;
let result = x [1] y;
println!("{}", result);

Drag options to blanks, or click blank then click option'

A&

B&&

C||

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using && instead of || will require both to be true.

The || operator returns true if at least one of x or y is true.

3fill in blank

hard

Fix the error in the code to correctly negate the boolean value.

Rust

let flag = true;
let negated = [1]flag;
println!("{}", negated);

Drag options to blanks, or click blank then click option'

Aneg

B!

Cnot

D~

Attempts:

3 left

💡 Hint

Common Mistakes

Using ~ or not which are not valid boolean negation in Rust.

The ! operator negates a boolean value in Rust.

4fill in blank

hard

Fill both blanks to create a condition that is true only if a is true and b is false.

Rust

let a = true;
let b = false;
if a [1] [2] b {
    println!("Condition met");
}

Drag options to blanks, or click blank then click option'

A&&

B||

C!

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using || instead of && will allow b to be true.

The condition uses && to require both parts true, and ! to negate b.

5fill in blank

hard

Fill all three blanks to create a condition that is true if either x is false or y is true and z is true.

Rust

let x = true;
let y = false;
let z = false;
if [1] x [2] y [3] z {
    println!("Complex condition met");
}

Drag options to blanks, or click blank then click option'

A!

B||

C&&

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up operator precedence or forgetting to negate x.

The condition reads: if !x || y && z, which means true if x is false or both y and z are true.

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