Check if Number is Even or Odd Using Bits in DSA C# - Build from Scratch

Check if Number is Even or Odd Using Bits

📖 Scenario: Imagine you are building a simple program that helps a cashier quickly decide if a number is even or odd using a fast method with bits. This can be useful in many places where speed matters, like games or embedded devices.

🎯 Goal: You will create a program that uses bit operations to check if a number is even or odd and then prints the result.

📋 What You'll Learn

Create an integer variable named number with the value 29.

Create an integer variable named bitMask with the value 1.

Use a bitwise AND operation between number and bitMask to check if the number is even or odd.

Print "Even" if the number is even, otherwise print "Odd".

💡 Why This Matters

🌍 Real World

Bitwise operations are used in low-level programming, embedded systems, and performance-critical applications to quickly check properties like even or odd.

💼 Career

Understanding bitwise operations is important for software developers working with system programming, game development, and optimization tasks.

1

Create the number variable

Create an integer variable called number and set it to 29.

DSA C#

# Your code here

Hint

Use int number = 29; to create the variable.

2

Create the bit mask variable

Create an integer variable called bitMask and set it to 1.

DSA C#

int number = 29;
# Your code here

Hint

The bit mask is used to check the last bit of the number.

3

Check if number is even or odd using bitwise AND

Use an if statement to check if (number & bitMask) == 0. If true, the number is even; otherwise, it is odd.

DSA C#

int number = 29;
int bitMask = 1;
# Your code here

Hint

The bitwise AND & checks the last bit of the number.

4

Print the result

Print "Even" if the number is even, otherwise print "Odd" using Console.WriteLine.

DSA C#

int number = 29;
int bitMask = 1;
if ((number & bitMask) == 0)
{
    Console.WriteLine("Even");
}
else
{
    Console.WriteLine("Odd");
}
# Your code here

Hint

The output should be Odd because 29 is not divisible by 2.

Practice

1. Which bit operation can be used to check if a number is even or odd in C#?

easy

A. Using bitwise OR with 1 (number | 1)

B. Using bitwise XOR with 1 (number ^ 1)

C. Using bitwise AND with 1 (number & 1)

D. Using bitwise NOT (~number)

Solution

1. Step 1: Understand bitwise AND with 1

   Bitwise AND with 1 checks the least significant bit of the number.

2. Step 2: Check least significant bit for even or odd

   If the least significant bit is 0, the number is even; if 1, it is odd.

3. Final Answer:

   Using bitwise AND with 1 (number & 1) -> Option C

4. Quick Check:

   Least significant bit check = number & 1 [OK]

Hint: Check last bit with & 1 to find even or odd fast [OK]

Common Mistakes:

• Using bitwise OR instead of AND
• Using XOR which toggles bits
• Using NOT which flips all bits

2. Which of the following C# code snippets correctly checks if num is odd using bits?

easy

A. if ((num & 1) == 0) { Console.WriteLine("Odd"); }

B. if ((num ^ 1) == 1) { Console.WriteLine("Odd"); }

C. if ((num | 1) == 1) { Console.WriteLine("Odd"); }

D. if ((num & 1) == 1) { Console.WriteLine("Odd"); }

Solution

1. Step 1: Understand bitwise AND check for odd

   Odd numbers have least significant bit 1, so (num & 1) == 1 means odd.

2. Step 2: Verify code logic

   if ((num & 1) == 1) { Console.WriteLine("Odd"); } prints "Odd" when (num & 1) equals 1, correctly identifying odd numbers.

3. Final Answer:

   if ((num & 1) == 1) { Console.WriteLine("Odd"); } -> Option D

4. Quick Check:

   Odd check = (num & 1) == 1 [OK]

Hint: Use (num & 1) == 1 to check odd numbers [OK]

Common Mistakes:

• Checking (num & 1) == 0 for odd (actually even)
• Using OR or XOR instead of AND
• Confusing equality check with assignment

3. What is the output of the following C# code?

int num = 14;
if ((num & 1) == 0)
    Console.WriteLine("Even");
else
    Console.WriteLine("Odd");

medium

A. Odd

B. Even

C. 14

D. Error

Solution

1. Step 1: Calculate bitwise AND of 14 and 1

   14 in binary is 1110; 1110 & 0001 = 0, so (num & 1) == 0 is true.

2. Step 2: Determine output based on condition

   Since condition is true, it prints "Even".

3. Final Answer:

   Even -> Option B

4. Quick Check:

   14 & 1 = 0 means Even [OK]

Hint: Even numbers have last bit 0, so (num & 1) == 0 [OK]

Common Mistakes:

• Assuming 14 is odd
• Confusing bitwise AND with OR
• Expecting numeric output instead of string

4. Find the error in this C# code that checks if a number is odd:

int num = 7;
if (num & 1 == 1)
    Console.WriteLine("Odd");
else
    Console.WriteLine("Even");

medium

A. Missing parentheses around (num & 1)

B. Using bitwise OR instead of AND

C. Incorrect variable type for num

D. No error, code is correct

Solution

1. Step 1: Analyze operator precedence

   In C#, equality (==) has higher precedence than bitwise AND (&), so 'num & 1 == 1' parses as 'num & (1 == 1)', which is 'num & 1'. This does not compare (num & 1) to 1 as intended.

2. Step 2: Identify the error

   Missing parentheses around (num & 1) causes incorrect evaluation. Correct code should be 'if ((num & 1) == 1)'.

3. Final Answer:

   Missing parentheses around (num & 1) -> Option A

4. Quick Check:

   Use parentheses to ensure correct precedence [OK]

Hint: C# precedence: == > & , so use parentheses to ensure correct evaluation [OK]

Common Mistakes:

• Misjudging precedence (thinking & > ==)
• Using bitwise OR instead of AND
• Assuming parentheses are not required

5. You want to write a C# method that returns "Even" or "Odd" for any integer using bitwise operations. Which of these implementations is correct and efficient?

public string CheckEvenOdd(int num) {
    // Options:
    // A) return (num & 1) == 0 ? "Even" : "Odd";
    // B) return (num | 1) == 0 ? "Even" : "Odd";
    // C) return (num ^ 1) == 0 ? "Even" : "Odd";
    // D) return (~num & 1) == 0 ? "Even" : "Odd";
}

hard

A. Option A

B. Option B

C. Option C

D. Option D

Solution

1. Step 1: Evaluate each option's logic

   Option A correctly checks if least significant bit is 0 for even; others use incorrect bitwise logic.

2. Step 2: Confirm correctness and efficiency

   Option A uses simple bitwise AND and ternary operator, efficient and clear.

3. Final Answer:

   Option A -> Option A

4. Quick Check:

   Use (num & 1) == 0 for even check [OK]

Hint: Use (num & 1) == 0 ? "Even" : "Odd" for quick check [OK]

Common Mistakes:

• Using OR or XOR which give wrong results
• Using NOT which flips bits incorrectly
• Ignoring ternary operator for return