Check if Number is Even or Odd Using Bits in DSA Typescript - Build from Scratch

Check if Number is Even or Odd Using Bits

📖 Scenario: You are building a simple program to check if a number is even or odd using bit operations. This is like checking if a number is divisible by 2 without using division or modulus. Bit operations are very fast and useful in many computer programs.

🎯 Goal: Build a TypeScript program that uses bitwise AND to check if a number is even or odd and prints the result.

📋 What You'll Learn

Create a variable called number with the value 29

Create a variable called mask with the value 1

Use a bitwise AND operation between number and mask to find if the number is even or odd

Print "Even" if the number is even, otherwise print "Odd"

💡 Why This Matters

🌍 Real World

Checking even or odd numbers quickly is useful in games, graphics, and low-level programming where speed matters.

💼 Career

Understanding bitwise operations is important for software developers working with embedded systems, performance optimization, and systems programming.

1

Create the number variable

Create a variable called number and set it to 29.

DSA Typescript

// Your code here

Hint

Use const number = 29; to create the variable.

2

Create the mask variable

Create a variable called mask and set it to 1.

DSA Typescript

const number = 29;
// Your code here

Hint

Use const mask = 1; to create the mask variable.

3

Check if number is even or odd using bitwise AND

Create a variable called result and set it to the bitwise AND of number and mask using number & mask.

DSA Typescript

const number = 29;
const mask = 1;
// Your code here

Hint

Use const result = number & mask; to get the last bit.

4

Print if the number is Even or Odd

Use an if statement to check if result equals 0. If yes, print "Even". Otherwise, print "Odd".

DSA Typescript

const number = 29;
const mask = 1;
const result = number & mask;
// Your code here

Hint

If the last bit is 0, the number is even. Otherwise, it is odd.

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