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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a number is even using bitwise AND.

DSA Javascript

function isEven(num) {
  return (num & [1]) === 0;
}

Drag options to blanks, or click blank then click option'

A1

B0

C2

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 in bitwise AND which always returns 0.

Using 2 which checks the wrong bit.

The bitwise AND with 1 checks the least significant bit. If it is 0, the number is even.

2fill in blank

medium

Complete the code to check if a number is odd using bitwise AND.

DSA Javascript

function isOdd(num) {
  return (num & [1]) === 1;
}

Drag options to blanks, or click blank then click option'

A2

B0

C1

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Checking equality with 0 instead of 1.

Using 2 which checks the wrong bit.

Bitwise AND with 1 isolates the least significant bit. If it is 1, the number is odd.

3fill in blank

hard

Fix the error in the code to correctly check if a number is even using bits.

DSA Javascript

function checkEven(num) {
  if ((num [1] 1) === 0) {
    return true;
  } else {
    return false;
  }
}

Drag options to blanks, or click blank then click option'

A>>

B&

C^

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR (|) which does not isolate bits correctly.

Using XOR (^) which toggles bits.

The bitwise AND operator (&) is used to check the least significant bit to determine evenness.

4fill in blank

hard

Fill both blanks to complete the function that returns 'Even' or 'Odd' using bitwise operation.

DSA Javascript

function evenOrOdd(num) {
  if ((num [1] [2]) === 0) {
    return 'Even';
  } else {
    return 'Odd';
  }
}

Drag options to blanks, or click blank then click option'

A&

B|

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR (|) instead of AND (&).

Using 0 instead of 1 for the mask.

Using bitwise AND (&) with 1 checks the least significant bit. If it is 0, the number is even; otherwise, odd.

5fill in blank

hard

Fill all three blanks to create a concise function returning true if number is odd, false otherwise.

DSA Javascript

const isOdd = num => (num [1] [2]) [3] 1;

Drag options to blanks, or click blank then click option'

A&

B1

C===

D!==

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR (|) instead of AND (&).

Using inequality (!==) instead of equality (===).

The function uses bitwise AND (&) with 1, then checks if the result is equal (===) to 1 to determine oddness.

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