Logical operators in Rust - Time & Space Complexity

Time Complexity: Logical operators

O(1)

Understanding Time Complexity

Logical operators combine true/false values to make decisions in code.

We want to see how using these operators affects how long the program takes to run.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn check_values(a: bool, b: bool, c: bool) -> bool {
    a && b || c
}

fn main() {
    let result = check_values(true, false, true);
    println!("{}", result);
}
    

This code uses logical AND and OR to combine three true/false values and returns the result.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Evaluating a few logical operators on fixed inputs.
• How many times: Each operator runs once per function call; no loops or repeated steps.

How Execution Grows With Input

Since the number of logical checks is fixed, the time does not grow with input size.

Input Size (n)	Approx. Operations
1	3 logical checks
10	3 logical checks
100	3 logical checks

Pattern observation: The number of operations stays the same no matter how big the input is.

Final Time Complexity

Time Complexity: O(1)

This means the time to run the code stays constant, no matter the input size.

Common Mistake

[X] Wrong: "Logical operators take longer as inputs grow because they combine values."

[OK] Correct: Logical operators here only check a fixed number of values, so time does not increase with input size.

Interview Connect

Understanding that simple logical checks run in constant time helps you explain code efficiency clearly and confidently.

Self-Check

"What if we changed the function to check logical operators on an array of booleans instead of just three values? How would the time complexity change?"

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