Logical operators in Rust - Mini Project: Build & Apply

Logical Operators in Rust

📖 Scenario: You are building a simple program to check if a person is eligible for a special discount based on their age and membership status.

🎯 Goal: Create a Rust program that uses logical operators to decide if a person qualifies for the discount.

📋 What You'll Learn

Create variables with exact names and values as instructed

Use logical AND and OR operators correctly

Print the final eligibility result exactly as specified

💡 Why This Matters

🌍 Real World

Logical operators help decide if conditions are met, like checking eligibility for discounts or access.

💼 Career

Understanding logical operators is essential for writing conditions in software development, from simple checks to complex decision-making.

1

Create initial variables

Create a variable called age with the value 25 and a variable called is_member with the value true.

Rust

# Create variables 'age' and 'is_member' with the specified values
// Your code here

Hint

Use let to create variables. age is a number, is_member is a boolean.

2

Add minimum age requirement

Create a variable called min_age and set it to 18.

Rust

fn main() {
    let age = 25;
    let is_member = true;
    // Create variable 'min_age' with value 18
    // Your code here
}

Hint

Use let min_age = 18; to create the variable.

3

Check eligibility with logical operators

Create a variable called is_eligible that is true if age is greater than or equal to min_age and is_member is true. Use the logical AND operator &&.

Rust

fn main() {
    let age = 25;
    let is_member = true;
    let min_age = 18;
    // Create 'is_eligible' using logical AND
    // Your code here
}

Hint

Use age >= min_age && is_member to combine conditions.

4

Print the eligibility result

Print the value of is_eligible using println! exactly as Eligible: true or Eligible: false.

Rust

fn main() {
    let age = 25;
    let is_member = true;
    let min_age = 18;
    let is_eligible = age >= min_age && is_member;
    // Print eligibility result
    // Your code here
}

Hint

Use println!("Eligible: {}", is_eligible); to print the result.

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