Check if Number is Even or Odd Using Bits in DSA Javascript

Mental Model

The last bit of a number in binary tells if it is even or odd. If the last bit is 0, the number is even; if 1, it is odd.

Analogy: Think of a parking lot where cars park in pairs. If there is an extra car without a pair, it means the total number is odd. The last bit is like checking if there is an extra car.

Number in binary:  ... b3 b2 b1 b0
                       ↑
                    last bit (b0)

Dry Run Walkthrough

Input: number = 5

Goal: Determine if 5 is even or odd using bit operations

Step 1: Convert 5 to binary: 0101

binary: 0 1 0 1

Why: We need to see the last bit to check even or odd

Step 2: Perform bitwise AND with 1: 0101 & 0001

result: 0001

Why: AND with 1 isolates the last bit

Step 3: Check if result is 1

result = 1 means odd

Why: Last bit 1 means number is odd

Result:

5 is odd

Annotated Code

DSA Javascript

class BitChecker {
  static isEven(num) {
    // Check last bit using AND with 1
    return (num & 1) === 0;
  }
}

// Driver code
const number = 5;
if (BitChecker.isEven(number)) {
  console.log(`${number} is even`);
} else {
  console.log(`${number} is odd`);
}

return (num & 1) === 0;

Isolate last bit to check if it is zero (even) or one (odd)

Output

5 is odd

Complexity Analysis

Time: O(1) because bitwise AND is a single operation regardless of number size

Space: O(1) because no extra memory is used beyond input and output

vs Alternative: Using modulo (%) operator also takes O(1) but bitwise AND is faster and more direct

Edge Cases

number = 0

Returns even because 0 & 1 = 0

DSA Javascript

return (num & 1) === 0;

number = 1

Returns odd because 1 & 1 = 1

DSA Javascript

return (num & 1) === 0;

negative numbers (e.g., -2)

Works correctly because bitwise AND checks last bit of two's complement

DSA Javascript

return (num & 1) === 0;

When to Use This Pattern

When you need to quickly check if a number is even or odd without division, use bitwise AND with 1 because it directly inspects the last binary bit.

Common Mistakes

Mistake: Using modulo operator (%) instead of bitwise AND when bitwise is required for performance
Fix: Replace num % 2 with (num & 1) for faster bit-level check

Mistake: Checking if (num & 1) === 1 and returning true for even instead of odd
Fix: Remember (num & 1) === 0 means even, (num & 1) === 1 means odd

Summary

Checks if a number is even or odd by looking at its last binary bit.

Use when you want a fast, simple way to test evenness without division.

The last bit of a binary number tells if it is even (0) or odd (1).

Practice

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

easy

A. Left shift by 1 (number << 1)

B. OR with 1 (number | 1)

C. XOR with 1 (number ^ 1)

D. AND with 1 (number & 1)

Solution

1. Step 1: Understand bitwise AND with 1

   The least significant bit (rightmost bit) of a number determines if it is even or odd. ANDing with 1 extracts this bit.

2. Step 2: Check the result of number & 1

   If the result is 0, the number is even; if 1, it is odd.

3. Final Answer:

   AND with 1 (number & 1) -> Option D

4. Quick Check:

   Least significant bit check = AND with 1 [OK]

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

Common Mistakes:

• Using OR instead of AND
• Using XOR which flips bits
• Using left shift which multiplies number

2. Which of the following JavaScript expressions correctly checks if num is odd using bitwise operators?

easy

A. (num & 1) === 0

B. (num | 1) === 1

C. (num & 1) === 1

D. (num ^ 1) === 0

Solution

1. Step 1: Understand the bitwise AND check

   Using (num & 1) extracts the last bit. If it equals 1, the number is odd.

2. Step 2: Match expression to odd check

   Expression (num & 1) === 1 returns true only for odd numbers.

3. Final Answer:

   (num & 1) === 1 -> Option C

4. Quick Check:

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

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

Common Mistakes:

• Checking for 0 instead of 1 for odd
• Using OR or XOR instead of AND
• Confusing equality check with assignment

3. What will be the output of the following JavaScript code?

function isEven(num) {
  return (num & 1) === 0 ? 'Even' : 'Odd';
}
console.log(isEven(10));
console.log(isEven(7));

medium

A. "Even" followed by "Odd"

B. "Odd" followed by "Even"

C. "Even" followed by "Even"

D. "Odd" followed by "Odd"

Solution

1. Step 1: Evaluate isEven(10)

   10 in binary ends with 0, so (10 & 1) === 0 is true, returns 'Even'.

2. Step 2: Evaluate isEven(7)

   7 in binary ends with 1, so (7 & 1) === 0 is false, returns 'Odd'.

3. Final Answer:

   "Even" followed by "Odd" -> Option A

4. Quick Check:

   10 is even, 7 is odd [OK]

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

Common Mistakes:

• Mixing up output order
• Assuming bitwise AND returns boolean directly
• Confusing bitwise AND with logical AND

4. The following code is intended to check if a number is odd. What is the error?

function checkOdd(num) {
  if (num & 1 === 1) {
    return 'Odd';
  } else {
    return 'Even';
  }
}

medium

A. Missing parentheses around (num & 1)

B. Using bitwise OR instead of AND

C. Incorrect return values

D. Function missing return type

Solution

1. Step 1: Analyze operator precedence

   Bitwise AND (&) has lower precedence than ===, so expression evaluates as num & (1 === 1).

2. Step 2: Fix expression with parentheses

   Correct expression is (num & 1) === 1 to check last bit properly.

3. Final Answer:

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

4. Quick Check:

   Use parentheses to ensure correct bitwise check [OK]

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

Common Mistakes:

• Ignoring operator precedence
• Using bitwise OR instead of AND
• Assuming bitwise AND returns boolean

5. You want to filter an array of numbers to keep only even numbers using bitwise operations. Which code snippet correctly does this?

const numbers = [3, 4, 7, 8, 10];
const evens = numbers.filter(num => ???);
console.log(evens);

hard

A. num & 1 === 1

B. (num & 1) === 0

C. num | 1 === 0

D. (num ^ 1) === 0

Solution

1. Step 1: Understand filtering even numbers

   Even numbers have last bit 0, so (num & 1) === 0 is true for evens.

2. Step 2: Apply filter condition

   Using numbers.filter(num => (num & 1) === 0) keeps only even numbers.

3. Final Answer:

   (num & 1) === 0 -> Option B

4. Quick Check:

   Filter evens with (num & 1) === 0 [OK]

Hint: Filter evens by checking (num & 1) === 0 [OK]

Common Mistakes:

• Using odd check instead of even
• Using OR or XOR instead of AND
• Missing parentheses causing wrong precedence