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

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 light switch that can be either off (0) or on (1). The last bit is like that switch showing if the number is even (off) or odd (on).

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 bits to check the last one

Step 2: Check last bit using bitwise AND with 1: 0101 & 0001

result = 1

Why: AND with 1 isolates the last bit

Step 3: Since result is 1, number is odd

5 is odd

Why: Last bit 1 means odd number

Result:

5 is odd

Annotated Code

DSA Typescript

class NumberChecker {
  static isEven(num: number): boolean {
    // Check last bit: 0 means even
    return (num & 1) === 0;
  }
}

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

return (num & 1) === 0;

Check last bit by ANDing with 1; if 0, number is even

Output

5 is odd

Complexity Analysis

Time: O(1) because bitwise AND is a single operation

Space: O(1) because no extra space is needed

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 Typescript

return (num & 1) === 0;

number = 1

Returns odd because 1 & 1 = 1

DSA Typescript

return (num & 1) === 0;

negative numbers like -2

Works correctly because bitwise AND checks last bit regardless of sign

DSA Typescript

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 bit.

Common Mistakes

Mistake: Using modulo operator (%) instead of bitwise AND when the goal is to learn bit operations
Fix: Replace modulo with bitwise AND: use (num & 1) === 0 to check evenness

Summary

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

Use it 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. What does the expression num & 1 check when determining if a number is even or odd?

easy

A. It checks if num is greater than 1.

B. It checks if the least significant bit of num is 1, indicating odd number.

C. It checks if num is divisible by 2 without remainder.

D. It checks if num is negative.

Solution

1. Step 1: Understand bitwise AND with 1

   The expression num & 1 isolates the least significant bit (rightmost bit) of the number.

2. Step 2: Interpret the least significant bit

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

3. Final Answer:

   It checks if the least significant bit of num is 1, indicating odd number. -> Option B

4. Quick Check:

   num & 1 = 1 means odd [OK]

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

Common Mistakes:

• Thinking & 1 checks divisibility by 2
• Confusing bitwise AND with logical AND
• Assuming it checks if number is negative

2. Which of the following TypeScript code snippets correctly checks if a number n is even using bitwise operators?

easy

A. if ((n & 1) === 0) { console.log('Even'); } else { console.log('Odd'); }

B. if ((n | 1) === 0) { console.log('Even'); } else { console.log('Odd'); }

C. if ((n & 0) === 1) { console.log('Even'); } else { console.log('Odd'); }

D. if ((n ^ 1) === 0) { console.log('Even'); } else { console.log('Odd'); }

Solution

1. Step 1: Understand bitwise AND with 1

   The expression n & 1 extracts the least significant bit of n.

2. Step 2: Check if least significant bit is zero

   If (n & 1) === 0, the number is even; otherwise, it is odd.

3. Final Answer:

   if ((n & 1) === 0) { console.log('Even'); } else { console.log('Odd'); } -> Option A

4. Quick Check:

   Use n & 1 === 0 for even check [OK]

Hint: Use (n & 1) === 0 to check even numbers [OK]

Common Mistakes:

• Using bitwise OR instead of AND
• Comparing with wrong values like 0 or 1 incorrectly
• Using XOR without understanding its effect

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

const numbers = [2, 3, 4, 5];
numbers.forEach(num => {
  if (num & 1) {
    console.log(num + ' is Odd');
  } else {
    console.log(num + ' is Even');
  }
});

medium

A. 2 is Odd
3 is Odd
4 is Odd
5 is Odd

B. 2 is Even
3 is Even
4 is Even
5 is Even

C. 2 is Odd
3 is Even
4 is Odd
5 is Even

D. 2 is Even
3 is Odd
4 is Even
5 is Odd

Solution

1. Step 1: Evaluate bitwise AND for each number

   For each number, num & 1 checks the last bit: 2 & 1 = 0 (even), 3 & 1 = 1 (odd), 4 & 1 = 0 (even), 5 & 1 = 1 (odd).

2. Step 2: Print corresponding output

   Numbers with num & 1 === 1 print 'Odd', others print 'Even'.

3. Final Answer:

   2 is Even 3 is Odd 4 is Even 5 is Odd -> Option D

4. Quick Check:

   Bitwise check matches even/odd output [OK]

Hint: Check each number's last bit; 1 means odd, 0 means even [OK]

Common Mistakes:

• Assuming all numbers are odd
• Confusing bitwise AND with logical AND
• Printing wrong labels for even/odd

4. Identify the error in this TypeScript code that tries to check if a number x is odd using bits:

function isOdd(x: number): boolean {
  return x & 1 === 1;
}

medium

A. The bitwise AND operator has lower precedence than ===, causing wrong evaluation.

B. The function should use bitwise OR instead of AND.

C. The function should return a string, not boolean.

D. There is no error; the code works correctly.

Solution

1. Step 1: Check operator precedence in expression

   Bitwise AND (&) has lower precedence than strict equality (===), so x & 1 === 1 is evaluated as x & (1 === 1).

2. Step 2: Understand the evaluation result

   1 === 1 is true, which converts to 1, so expression becomes x & 1. This returns a number, not a boolean, causing unexpected behavior.

3. Step 3: Fix the expression with parentheses

   Use parentheses: (x & 1) === 1 to ensure correct evaluation order.

4. Final Answer:

   The bitwise AND operator has lower precedence than ===, causing wrong evaluation. -> Option A

5. Quick Check:

   Use parentheses: (x & 1) === 1 [OK]

Hint: Use parentheses around bitwise operation before comparison [OK]

Common Mistakes:

• Ignoring operator precedence
• Using bitwise OR instead of AND
• Returning wrong data type

5. You want to filter an array of numbers to keep only the even ones using bitwise operations in TypeScript. Which code snippet correctly achieves this?

const nums = [10, 15, 22, 33, 40];
const evens = nums.filter( /* your code here */ );
console.log(evens);

hard

A. nums.filter(num => (num & 1) === 1)

B. nums.filter(num => (num | 1) === 0)

C. nums.filter(num => (num & 1) === 0)

D. nums.filter(num => (num ^ 1) === 0)

Solution

1. Step 1: Understand filtering condition for even numbers

   Even numbers have their least significant bit as 0, so (num & 1) === 0 checks for even numbers.

2. Step 2: Apply filter with correct condition

   Using nums.filter(num => (num & 1) === 0) returns only even numbers from the array.

3. Step 3: Verify output

   For [10, 15, 22, 33, 40], the filtered array is [10, 22, 40].

4. Final Answer:

   nums.filter(num => (num & 1) === 0) -> Option C

5. Quick Check:

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

Hint: Filter with (num & 1) === 0 to get even numbers [OK]

Common Mistakes:

• Using bitwise OR or XOR incorrectly
• Filtering for odd numbers instead of even
• Missing parentheses causing wrong evaluation