Check if Number is Even or Odd Using Bits in DSA Javascript - Time & Space Complexity

Time Complexity: Check if Number is Even or Odd Using Bits

O(1)

Understanding Time Complexity

We want to know how fast we can check if a number is even or odd using bits.

How does the time needed change when the number gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

const number = 42;
console.log(isEven(number));
    

This code checks if a number is even by looking at its last bit.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: A single bitwise AND operation.
• How many times: Exactly once per function call.

How Execution Grows With Input

Checking the last bit does not depend on the size of the number.

Input Size (n)	Approx. Operations
10	1
100	1
1000	1

Pattern observation: The operation count stays the same no matter how big the number is.

Final Time Complexity

Time Complexity: O(1)

This means the check takes the same tiny amount of time no matter the number size.

Common Mistake

[X] Wrong: "Checking bits takes longer for bigger numbers because they have more bits."

[OK] Correct: We only look at the last bit, so the number size does not affect the time.

Interview Connect

Knowing this quick bit check shows you understand how computers work with numbers efficiently.

Self-Check

"What if we checked multiple bits to find if a number is divisible by 4? How would the time complexity change?"

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