Check if Number is Even or Odd Using Bits in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the expression num & 1 check in a number?

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

beginner

Why can we use bitwise AND with 1 to determine if a number is even or odd?

Because the least significant bit (rightmost bit) of an integer in binary is 1 if the number is odd and 0 if even.

beginner

Write a simple JavaScript function to check if a number is even using bitwise operators.

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

beginner

What is the output of 5 & 1 and what does it mean?

5 & 1 equals 1, meaning 5 is odd.

intermediate

Can this bitwise method be used for negative numbers to check even or odd? Why or why not?

Yes, because the least significant bit still indicates odd or even regardless of sign in two's complement representation.

What does the bitwise expression num & 1 return for an even number?

A 1

B 0

C num

D -1

For even numbers, the least significant bit is 0, so num & 1 returns 0.

Which bit of a binary number determines if it is even or odd?

A Most significant bit

B Second bit from left

C Least significant bit

D Middle bit

The least significant bit (rightmost bit) determines if a number is even (0) or odd (1).

What will isEven(10) return if isEven uses return (num & 1) === 0;?

A true

B false

C 10

D undefined

10 is even, so 10 & 1 is 0, making the function return true.

What is the output of 7 & 1?

A 0

B 6

C 7

D 1

7 in binary ends with 1, so 7 & 1 returns 1 indicating odd.

Is the bitwise method for checking even or odd faster than using modulus (%) operator?

A Yes, bitwise operations are generally faster

B No, modulus is faster

C Both are equally fast

D Depends on the number

Bitwise operations are low-level and generally faster than modulus operations.

Explain how to check if a number is even or odd using bitwise operators.

Think about the rightmost bit in binary.

Write a JavaScript function using bitwise operators to return 'Even' or 'Odd' for a given number.

Use (num & 1) to decide.

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