Check if Number is Even or Odd Using Bits in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a number is even using bitwise AND.

DSA C#

bool isEven = (num & [1]) == 0;

Drag options to blanks, or click blank then click option'

A2

B1

Cnum

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as bitmask always returns 0.

Using 2 checks the second bit, not the last bit.

The least significant bit of an even number is 0. Using bitwise AND with 1 checks this bit.

2fill in blank

medium

Complete the code to print "Odd" if the number is odd using bitwise operation.

DSA C#

if ((num & [1]) != 0) Console.WriteLine("Odd");

Drag options to blanks, or click blank then click option'

A0

B2

C1

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 always results in false condition.

Using 2 checks wrong bit.

Bitwise AND with 1 checks if the least significant bit is 1, which means the number is odd.

3fill in blank

hard

Fix the error in the code to correctly check if a number is even using bits.

DSA C#

bool isEven = (num [1] 1) == 0;

Drag options to blanks, or click blank then click option'

A|

B<<

C^

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Using OR (|) does not isolate bits.

Using XOR (^) changes bits.

Using shift (<<) moves bits instead of checking.

The bitwise AND operator (&) is used to check the least significant bit.

4fill in blank

hard

Fill both blanks to complete the code that prints "Even" or "Odd" based on bitwise check.

DSA C#

if ((num [1] [2]) == 0) Console.WriteLine("Even"); else Console.WriteLine("Odd");

Drag options to blanks, or click blank then click option'

A&

B|

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using OR (|) instead of AND (&) changes bits.

Using 0 as mask always returns 0.

Use bitwise AND (&) with 1 to check the last bit. If result is 0, number is even.

5fill in blank

hard

Fill all three blanks to create a method that returns true if a number is even using bitwise operations.

DSA C#

public bool IsEven(int num) {
    return (num [1] [2]) [3] 0;
}

Drag options to blanks, or click blank then click option'

A&

B1

C==

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using OR (|) instead of AND (&).

Comparing with 1 instead of 0.

Using equality operator incorrectly.

The method uses bitwise AND (&) with 1 and compares result to 0 to check evenness.

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