Logical operators (&&, ||, !) in Ruby - Time & Space Complexity

Time Complexity: Logical operators (&&, ||, !)

O(1)

Understanding Time Complexity

Logical operators help decide true or false in code. We want to see how using them affects how long the code takes to run.

How does the number of checks grow when we use these operators?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

    def check_values(a, b, c)
      if a && b || !c
        return true
      else
        return false
      end
    end
    

This code checks three values using logical AND, OR, and NOT to decide true or false.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Evaluating three logical conditions once each.
• How many times: Each condition is checked only once per call.

How Execution Grows With Input

Each time the function runs, it checks three values. The number of checks stays the same no matter what.

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

Pattern observation: The number of operations does not grow with input size; it stays constant.

Final Time Complexity

Time Complexity: O(1)

This means the time to run the code stays the same no matter how big the input is.

Common Mistake

[X] Wrong: "Logical operators slow down the program a lot when inputs grow."

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

Interview Connect

Understanding how simple checks like logical operators behave helps you explain code efficiency clearly and confidently.

Self-Check

"What if we checked logical operators inside a loop over an array? How would the time complexity change?"

Practice

1. What does the Ruby logical operator && do?

easy

A. Checks if two values are equal

B. Returns true if at least one condition is true

C. Reverses the truth value of a condition

D. Returns true only if both conditions are true

Solution

1. Step 1: Understand the meaning of &&

   The && operator means 'and' in Ruby, so it returns true only if both sides are true.

2. Step 2: Compare with other operators

   || returns true if one or both are true, and ! reverses truth. Equality checks with ==.

3. Final Answer:

   Returns true only if both conditions are true -> Option D

4. Quick Check:

   && means AND = D [OK]

Hint: && means both must be true to get true [OK]

Common Mistakes:

• Confusing && with ||
• Thinking && reverses values
• Mixing && with equality operator

2. Which of the following is the correct way to write a NOT operation in Ruby?

easy

A. !x

B. ~x

C. not x

D. x != true

Solution

1. Step 1: Identify Ruby's NOT operator syntax

   Ruby uses ! before a value to reverse its truth value.

2. Step 2: Check other options

   not x is valid but less common; ~x is bitwise NOT; x != true is a comparison, not logical NOT.

3. Final Answer:

   !x -> Option A

4. Quick Check:

   Logical NOT = C [OK]

Hint: Use ! before a value to reverse true/false [OK]

Common Mistakes:

• Using ~ instead of ! for logical NOT
• Confusing != with NOT operator
• Using 'not' keyword instead of !

3. What is the output of this Ruby code?

puts (true || false) && !false

medium

A. nil

B. false

C. true

D. SyntaxError

Solution

1. Step 1: Evaluate inside parentheses

   true || false is true because at least one side is true.

2. Step 2: Evaluate the NOT operator

   !false is true because NOT false is true.

3. Step 3: Evaluate the AND operator

   Now we have true && true, which is true.

4. Final Answer:

   true -> Option C

5. Quick Check:

   (true || false) && !false = A [OK]

Hint: Evaluate parentheses, then !, then && [OK]

Common Mistakes:

• Evaluating && before ||
• Forgetting to apply ! operator
• Assuming false because of || false

4. Find the error in this Ruby code snippet:

if !true || false
  puts "Yes"
else
  puts "No"
end

medium

A. No error; code runs and prints "No"

B. The ! operator cannot be used with true

C. The || operator should be && here

D. Missing parentheses around !true

Solution

1. Step 1: Check syntax of logical operators

   Using ! with true is valid and reverses it to false. The || operator is also valid here.

2. Step 2: Evaluate the condition

   !true is false, so condition is false || false, which is false. The else branch runs printing "No".

3. Step 3: Confirm no syntax errors

   The code syntax is correct and will run without errors.

4. Final Answer:

   No error; code runs and prints "No" -> Option A

5. Quick Check:

   Logical operators used correctly = B [OK]

Hint: !true is valid; check logic, not syntax [OK]

Common Mistakes:

• Thinking !true is invalid
• Confusing || with &&
• Expecting syntax error without parentheses

5. You want to check if a variable x is NOT between 10 and 20 inclusive in Ruby. Which condition correctly uses logical operators?

hard

A. !(x >= 10 && x <= 20)

B. x < 10 || x > 20

C. x <= 10 && x >= 20

D. !(x < 10 || x > 20)

Solution

1. Step 1: Understand the range condition

   Being between 10 and 20 inclusive means x >= 10 && x <= 20.

2. Step 2: Find the NOT of the range

   The NOT of being between 10 and 20 is being less than 10 OR greater than 20, so x < 10 || x > 20.

3. Step 3: Check options

   !(x >= 10 && x <= 20) negates the range but is correct logically; x < 10 || x > 20 directly expresses the NOT condition without negation. x <= 10 && x >= 20 is impossible (x can't be both <=10 and >=20). !(x < 10 || x > 20) negates the NOT condition, so it's the original range.

4. Final Answer:

   x < 10 || x > 20 -> Option B

5. Quick Check:

   NOT between 10 and 20 = A [OK]

Hint: NOT between means less than OR greater than [OK]

Common Mistakes:

• Using AND instead of OR for NOT condition
• Confusing negation placement
• Choosing impossible conditions