Check if Number is Even or Odd Using Bits in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the least significant bit (LSB) of a binary number tell us about the number?

The least significant bit (LSB) tells us if the number is even or odd. If LSB is 0, the number is even; if LSB is 1, the number is odd.

beginner

How can you check if a number is even using bitwise AND in C?

Use the expression (number & 1). If the result is 0, the number is even; if it is 1, the number is odd.

intermediate

Why is using bitwise operations to check even or odd numbers efficient?

Bitwise operations work directly on binary digits and are faster than division or modulus operations, making them efficient for checking even or odd.

beginner

What is the output of this C code snippet?

int n = 6; if (n & 1) printf("Odd"); else printf("Even");

The output is "Even" because 6 in binary ends with 0, so (6 & 1) is 0.

intermediate

Explain the difference between using modulus (%) and bitwise AND (&) to check even or odd.

Modulus (%) divides the number and checks the remainder, which is slower. Bitwise AND (&) checks the last bit directly, which is faster and uses less CPU.

Which bitwise operation is used to check if a number is even or odd?

A NOT (~)

B AND (&) with 1

C XOR (^) with 1

D OR (|) with 1

AND (&) with 1 isolates the least significant bit to check if the number is even or odd.

What does the expression (number & 1) return if the number is odd?

A 0

B number itself

C -1

D 1

For odd numbers, the least significant bit is 1, so (number & 1) returns 1.

Why might bitwise checking be preferred over modulus for even/odd checks in embedded systems?

A Bitwise is faster and uses less CPU

B Bitwise is slower but more readable

C Bitwise uses less memory

D Modulus is not supported in embedded systems

Bitwise operations are faster and use less CPU, which is important in resource-limited embedded systems.

What is the output of this code?

int x = 7; if (x & 1) printf("Odd"); else printf("Even");

A Odd

B Even

C 7

D Error

7 is odd, so (7 & 1) is 1, printing "Odd".

If (number & 1) == 0, what can we say about the number?

A It is odd

B It is negative

C It is even

D It is zero

If the least significant bit is 0, the number is even.

Describe how to check if a number is even or odd using bitwise operations in C.

Think about the last bit in binary.

Explain why bitwise operations are efficient for checking even or odd numbers compared to modulus.

Consider how computers handle bits versus division.

Practice

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

easy

A. Shift the number right by 1

B. Check the least significant bit using AND with 1

C. XOR the number with 1

D. Invert all bits of the number

Solution

1. Step 1: Understand the least significant bit (LSB)

   The LSB of a binary number determines if it is even or odd: 0 means even, 1 means odd.

2. Step 2: Use AND operation with 1 to isolate LSB

   Performing bitwise AND with 1 keeps only the LSB. If result is 0, number is even; if 1, odd.

3. Final Answer:

   Check the least significant bit using AND with 1 -> Option B

4. Quick Check:

   LSB & 1 = 0 (even) or 1 (odd) [OK]

Hint: Use n & 1 to check even or odd quickly [OK]

Common Mistakes:

• Using XOR instead of AND to check LSB
• Checking the most significant bit instead
• Using bit shift without checking bits

2. Which of the following C code snippets correctly checks if an integer n is odd using bitwise operators?

easy

A. if ((n & 1) == 1) printf("Odd");

B. if ((n >> 1) == 1) printf("Odd");

C. if ((n & 1) == 0) printf("Odd");

D. if ((n ^ 1) == 1) printf("Odd");

Solution

1. Step 1: Understand bitwise AND with 1

   Using n & 1 isolates the least significant bit. If it equals 1, the number is odd.

2. Step 2: Check condition for odd number

   The correct condition is (n & 1) == 1 to print "Odd".

3. Final Answer:

   if ((n & 1) == 1) printf("Odd"); -> Option A

4. Quick Check:

   n & 1 == 1 means odd [OK]

Hint: Use (n & 1) == 1 to detect odd numbers [OK]

Common Mistakes:

• Checking for == 0 to print odd (actually even)
• Using right shift instead of AND
• Using XOR incorrectly for odd check

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

int n = 14;
if (n & 1)
    printf("Odd");
else
    printf("Even");

medium

A. Odd

B. Compilation error

C. Even

D. 14

Solution

1. Step 1: Evaluate n & 1 for n = 14

   Binary of 14 is 1110. The least significant bit is 0. So, 14 & 1 = 0.

2. Step 2: Check the if condition

   Since (n & 1) is 0 (false), the else block executes, printing "Even".

3. Final Answer:

   Even -> Option C

4. Quick Check:

   14 is even, so output is Even [OK]

Hint: Check LSB: 0 means even, 1 means odd [OK]

Common Mistakes:

• Assuming 14 is odd because it ends with 4
• Confusing bitwise AND with logical AND
• Expecting output "14" instead of even/odd

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

int n = 7;
if (n & 1 == 1)
    printf("Odd");
else
    printf("Even");

medium

A. Missing parentheses around (n & 1)

B. Using == instead of = in if condition

C. Incorrect use of bitwise OR instead of AND

D. No error, code works fine

Solution

1. Step 1: Analyze operator precedence in condition

   In C, == has higher precedence than &. So expression is evaluated as n & (1 == 1).

2. Step 2: Evaluate the expression and fix

   Since (1 == 1) is true (1), expression becomes n & 1, which is correct but confusing. To avoid this, parentheses should be used: (n & 1) == 1.

3. Final Answer:

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

4. Quick Check:

   Use (n & 1) == 1 to ensure correct evaluation [OK]

Hint: Use parentheses: (n & 1) == 1 to avoid precedence errors [OK]

Common Mistakes:

• Ignoring operator precedence causing wrong evaluation
• Using assignment = instead of comparison ==
• Confusing bitwise AND with logical AND

5. You want to write a function in C that returns 1 if a number is odd and 0 if even, using bitwise operators. Which of the following implementations is correct and efficient?

int isOdd(int n) {
    // Choose one
}

hard

A. return (n >> 1) & 1;

B. return !(n & 1);

C. return n ^ 1;

D. return (n & 1) == 1 ? 1 : 0;

Solution

1. Step 1: Understand the goal of the function

   The function should return 1 if n is odd, 0 if even, using bitwise operations.

2. Step 2: Evaluate each option

   return (n & 1) == 1 ? 1 : 0; correctly returns 1 if LSB is 1 (odd), else 0. return (n >> 1) & 1; returns the second least significant bit, incorrect. return n ^ 1; returns n XOR 1, which changes the number, not a boolean. return !(n & 1); returns 1 if even, opposite of requirement.

3. Final Answer:

   return (n & 1) == 1 ? 1 : 0; -> Option D

4. Quick Check:

   Use (n & 1) == 1 to detect odd and return 1 [OK]

Hint: Return (n & 1) == 1 for odd check function [OK]

Common Mistakes:

• Using bit shift instead of checking LSB
• Returning modified number instead of boolean
• Negating the condition incorrectly