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

Check if Number is Even or Odd Using Bits

📖 Scenario: Imagine you are building a simple tool that tells if a number is even or odd. Instead of using normal division, you will use a fast method with bits, like checking if a light switch is on or off.

🎯 Goal: Build a small program that uses bit operations 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 bitMask with the value 1

Use a bitwise AND operation between number and bitMask to check if the number is even or odd

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

💡 Why This Matters

🌍 Real World

Bitwise operations are used in low-level programming, game development, and performance-critical applications to quickly check or change data.

💼 Career

Understanding bitwise operations helps in roles like embedded systems developer, systems programmer, and software engineer working on optimization.

1

Create the number variable

Create a variable called number and set it to 29.

DSA Javascript

// Create a variable called number and set it to 29
// Your code here

Hint

Use const number = 29; to create the variable.

2

Create the bitMask variable

Create a variable called bitMask and set it to 1.

DSA Javascript

const number = 29;
// Create a variable called bitMask and set it to 1
// Your code here

Hint

Use const bitMask = 1; to create the variable.

3

Check if number is even or odd using bitwise AND

Use an if statement to check if number & bitMask is equal to 1. If yes, the number is odd; otherwise, it is even.

DSA Javascript

const number = 29;
const bitMask = 1;
// Use if statement to check if number & bitMask equals 1
// Your code here

Hint

Use if ((number & bitMask) === 1) to check odd, else even.

4

Print the result

Run the program and print "Odd" if the number is odd, otherwise print "Even".

DSA Javascript

const number = 29;
const bitMask = 1;
if ((number & bitMask) === 1) {
    console.log("Odd");
} else {
    console.log("Even");
}
// Program prints Odd or Even

Hint

Run the code to see the output Odd because 29 is odd.

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