Check if Number is Even or Odd Using Bits in DSA C# - Time & Space Complexity

Time Complexity: Check if Number is Even or Odd Using Bits

O(1)

Understanding Time Complexity

We want to understand how fast we can check if a number is even or odd using bit operations.

The question is: how does the time to check change as the number gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

bool IsEven(int number)
{
    return (number & 1) == 0;
}
    

This code checks if the last bit of the number is 0, which means the number is even.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: A single bitwise AND operation.
• How many times: Exactly once per function call, no loops or recursion.

How Execution Grows With Input

Checking the last bit takes the same time no matter how big the number is.

Input Size (n)	Approx. Operations
10	1
100	1
1000	1

Pattern observation: The operation count stays the same even if the number grows larger.

Final Time Complexity

Time Complexity: O(1)

This means the check takes the same amount of time no matter how big the number is.

Common Mistake

[X] Wrong: "Checking bits takes longer for bigger numbers because they have more bits."

[OK] Correct: The operation only looks at the last bit, so it does not depend on the number size.

Interview Connect

Knowing this quick bit check shows you understand how computers work with numbers efficiently, a useful skill in many coding problems.

Self-Check

"What if we checked if a number is divisible by 4 using bits? How would the time complexity change?"

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