Check if Number is Even or Odd Using Bits in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code snippet?

This JavaScript code uses bitwise AND to check if a number is even or odd. What will it print?

DSA Javascript

const num = 7;
if ((num & 1) === 0) {
  console.log('Even');
} else {
  console.log('Odd');
}

A "Odd"

B "Even"

C SyntaxError

D "Undefined"

💡 Hint

The bitwise AND with 1 checks the least significant bit of the number.

The number 7 in binary ends with 1, so (7 & 1) equals 1, which is not zero, so it prints 'Odd'.

❓ Predict Output

intermediate

What does this function return for input 10?

This function uses bitwise operations to check if a number is even. What is the return value when input is 10?

DSA Javascript

function isEven(n) {
  return (n & 1) === 0;
}
console.log(isEven(10));

A undefined

B false

C TypeError

D true

💡 Hint

Even numbers have their least significant bit as 0.

10 in binary ends with 0, so (10 & 1) is 0, making the function return true.

🔧 Debug

advanced

What error does this code produce?

This code attempts to check if a number is odd using bitwise AND. What error or output does it produce?

DSA Javascript

const num = 5;
if ((num & 1) === 1) {
  console.log('Odd');
} else {
  console.log('Even');
}

A SyntaxError

B "Odd"

C "Even"

D TypeError

💡 Hint

Check the operator used inside the if condition.

The code uses assignment '=' instead of comparison '===' inside the if condition, causing a SyntaxError.

❓ Predict Output

advanced

What is the output of this code with negative number?

This code checks if a negative number is even or odd using bitwise AND. What will it print?

DSA Javascript

const num = -4;
if ((num & 1) === 0) {
  console.log('Even');
} else {
  console.log('Odd');
}

A "Undefined"

B "Even"

C TypeError

D "Odd"

💡 Hint

Bitwise operations work on two's complement binary representation.

Negative even numbers have least significant bit 0 in two's complement, so it prints 'Even'.

🧠 Conceptual

expert

Why does using bitwise AND with 1 check if a number is even or odd?

Choose the best explanation for why the expression (number & 1) === 0 determines if a number is even.

A Because bitwise AND with 1 converts the number to its absolute value before checking parity.

B Because bitwise AND with 1 shifts the number right by one bit, dividing it by 2.

C Because the least significant bit of an even number is always 0, so AND with 1 results in 0.

D Because bitwise AND with 1 checks if the number is divisible by 3.

💡 Hint

Think about binary representation of even and odd numbers.

In binary, even numbers end with 0, so AND with 1 yields 0; odd numbers end with 1, so AND with 1 yields 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