Logical patterns (and, or, not) in C Sharp (C#) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the and logical pattern check in C#?

The and pattern checks if both conditions are true. It returns true only if all parts are true.

beginner

How does the or logical pattern work in C#?

The or pattern returns true if at least one of the conditions is true. It only returns false if all parts are false.

beginner

What is the purpose of the not logical pattern in C#?

The not pattern reverses the condition. If the condition is true, not makes it false, and vice versa.

beginner

Given bool a = true; and bool b = false;, what is the result of a and b?

The result is false because and requires both to be true, but b is false.

beginner

Explain the difference between and and or logical patterns.

and requires all conditions to be true to return true. or requires only one condition to be true to return true.

What does the and logical pattern return if one condition is false?

A True

B Depends on the other condition

C False

D Throws an error

The and pattern returns false if any condition is false.

Which logical pattern returns true if at least one condition is true?

A not

B or

C and

D xor

The or pattern returns true if any condition is true.

What does the not logical pattern do to a true condition?

A Changes it to false

B Throws an error

C Keeps it true

D Ignores it

The not pattern reverses the condition from true to false.

If a = true and b = false, what is the result of a or b?

A Error

B False

C Null

D True

or returns true if at least one condition is true.

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

A and

B xor

C not

D or

The and pattern checks if both conditions are true.

Describe how the logical patterns and, or, and not work in C#.

Think about when each pattern returns true or false.

Give an example of using and and or logical patterns in a simple C# if statement.

Use variables with true/false values.

Practice

1.

Which logical operator in C# means both conditions must be true?

and, or, or not?

easy

A. and

B. or

C. not

D. xor

Solution

1. Step 1: Understand the meaning of logical operators

   The and operator requires both conditions to be true for the whole expression to be true.

2. Step 2: Compare with other operators

   or means one or both conditions are true, not negates a condition, and xor means exactly one condition is true.

3. Final Answer:

   and -> Option A

4. Quick Check:

   and means both true [OK]

Hint: Remember: and = both true, or = any true, not = reverse [OK]

Common Mistakes:

• Confusing 'and' with 'or'
• Thinking 'not' means both true
• Mixing 'xor' with 'and'

2.

Which of these is the correct C# syntax for the logical NOT operator?

?

easy

A. not x

B. x!

C. !x

D. ~x

Solution

1. Step 1: Recall C# logical NOT syntax

   In C#, the logical NOT operator is ! placed before the variable or expression.

2. Step 2: Check other options

   not x is not valid C# syntax, ~x is bitwise NOT, and x! is invalid.

3. Final Answer:

   !x -> Option C

4. Quick Check:

   Logical NOT uses ! before expression [OK]

Hint: Logical NOT is always ! before the variable [OK]

Common Mistakes:

• Using 'not' keyword instead of !
• Confusing bitwise ~ with logical !
• Placing ! after the variable

3.

What is the output of this C# code?

bool a = true;
bool b = false;
if (a && !b) {
    Console.WriteLine("Yes");
} else {
    Console.WriteLine("No");
}

medium

A. No

B. Yes

C. True

D. False

Solution

1. Step 1: Evaluate variables and conditions

   Variable a is true, b is false, so !b is true.

2. Step 2: Evaluate the if condition

   a && !b becomes true && true, which is true, so the if block runs.

3. Final Answer:

   Yes -> Option B

4. Quick Check:

   true and not false = true [OK]

Hint: Remember ! reverses boolean, so !false = true [OK]

Common Mistakes:

• Ignoring the ! operator
• Thinking false && true is true
• Confusing output strings with boolean values

4.

Find the error in this C# code snippet:

bool x = true;
if (x && !x) {
    Console.WriteLine("True");
} else {
    Console.WriteLine("False");
}

medium

A. Using single & instead of &&

B. Missing semicolon after if statement

C. Incorrect use of Console.WriteLine

D. Contradictory condition: x and not x can never be true

Solution

1. Step 1: Analyze the condition logic

   The condition x && !x means x is true AND x is false at the same time, which is impossible.

2. Step 2: Check syntax correctness

   The syntax is correct: && is used properly, semicolons and Console.WriteLine are fine.

3. Final Answer:

   Contradictory condition: x and not x can never be true -> Option D

4. Quick Check:

   True and not true = false always [OK]

Hint: Check if condition can ever be true logically [OK]

Common Mistakes:

• Thinking condition can be true
• Confusing & with &&
• Looking for syntax errors when logic is the issue

5.

You want to write a C# switch expression that returns "Valid" only if age is between 18 and 30 inclusive, and hasID is true. Which pattern correctly uses logical operators?

return (age, hasID) switch {
    ??? => "Valid",
    _ => "Invalid"
};

hard

A. var (a, id) when a >= 18 && a <= 30 && id

B. (>= 18 and <= 30 and true, hasID)

C. var a when a >= 18 && a <= 30 && hasID == true

D. (>= 18 and <= 30, true)

Solution

1. Step 1: Understand switch pattern matching with tuples

   The switch matches a tuple (age, hasID). To check conditions on both, use a when clause with logical operators.

2. Step 2: Analyze each option

   var (a, id) when a >= 18 && a <= 30 && id correctly uses tuple deconstruction var (a, id) and checks a >= 18 && a <= 30 && id (where id is boolean). Others are invalid syntax or misuse logical operators.

3. Final Answer:

   var (a, id) when a >= 18 && a <= 30 && id -> Option A

4. Quick Check:

   Tuple pattern with when and && is correct [OK]

Hint: Use tuple deconstruction with when and && for multiple conditions [OK]

Common Mistakes:

• Trying to use and inside tuple without when
• Misplacing logical operators outside when clause
• Not deconstructing tuple properly