Check if Number is Even or Odd Using Bits in DSA Javascript - Deep Dive

Overview - Check if Number is Even or Odd Using Bits

What is it?

Checking if a number is even or odd using bits means looking at its binary form to decide if it divides evenly by two. Instead of using division or remainder operations, we use a simple bit check. This method is very fast and efficient because computers work with bits directly. It helps us quickly tell if a number ends with a 0 or 1 in binary, which means even or odd.

Why it matters

This exists because checking even or odd is a common task in programming and math. Using bits makes this check faster and uses less computing power. Without this, programs would rely on slower division or remainder operations, which can add up in big calculations or systems. It helps in making software and devices run smoother and faster.

Where it fits

Before this, you should know what binary numbers are and how computers represent numbers. After learning this, you can explore other bitwise operations like AND, OR, XOR, and how they help in optimization and low-level programming.

Mental Model

Core Idea

The last bit of a number's binary form tells if it's even (0) or odd (1).

Think of it like...

It's like checking if a light switch is off or on; off means even, on means odd.

Number in binary: ... b3 b2 b1 b0
Check last bit (b0):
  0 -> Even number
  1 -> Odd number

Build-Up - 6 Steps

1

Foundation

Understanding Even and Odd Numbers

Concept: Introduce what even and odd numbers are in simple terms.

Even numbers are those that can be divided by 2 without any leftover. Odd numbers leave a remainder of 1 when divided by 2. For example, 4 is even because 4 ÷ 2 = 2 exactly, and 5 is odd because 5 ÷ 2 = 2 remainder 1.

Result

You can tell if a number is even or odd by dividing by 2 and checking the remainder.

Understanding the basic definition of even and odd numbers is essential before exploring faster methods.

2

Foundation

Binary Numbers and Last Bit Importance

Concept: Explain binary numbers and why the last bit matters.

Computers store numbers in binary, which uses only 0s and 1s. Each digit is called a bit. The last bit (rightmost) shows if the number is even or odd: if it's 0, the number is even; if it's 1, the number is odd. For example, 6 in binary is 110 (last bit 0), and 7 is 111 (last bit 1).

Result

You see that the last bit directly indicates even or odd status.

Knowing that the last bit controls even/odd helps us use bit operations instead of division.

3

Intermediate

Using Bitwise AND to Check Even or Odd

🤔Before reading on: do you think checking the last bit with AND 1 will tell even or odd? Commit to your answer.

Concept: Introduce the bitwise AND operation to isolate the last bit.

Bitwise AND compares each bit of two numbers and returns 1 only if both bits are 1. To check if a number is even or odd, we do number & 1. This keeps only the last bit. If the result is 0, the number is even; if 1, it's odd. For example, 4 & 1 = 0 (even), 5 & 1 = 1 (odd).

Result

Using bitwise AND with 1 quickly tells if a number is even or odd.

Understanding bitwise AND lets you perform fast checks without division.

4

Intermediate

Implementing Even/Odd Check in JavaScript

🤔Before reading on: do you think the bitwise AND method is faster than using % operator in JavaScript? Commit to your answer.

Concept: Show how to write a simple JavaScript function using bitwise AND.

function isEven(num) { return (num & 1) === 0; } function isOdd(num) { return (num & 1) === 1; } // Example usage: console.log(isEven(10)); // true console.log(isOdd(7)); // true

Result

The functions return true or false correctly for even and odd numbers.

Seeing the code helps connect the theory to practical programming.

5

Advanced

Why Bitwise Check is More Efficient

🤔Before reading on: do you think bitwise operations use less CPU cycles than modulo? Commit to your answer.

Concept: Explain the performance advantage of bitwise operations over modulo.

Modulo (%) involves division, which is slower for computers. Bitwise AND operates directly on bits, which is a single CPU instruction and much faster. This matters in performance-critical code or when checking many numbers quickly.

Result

Bitwise check reduces computation time and improves efficiency.

Knowing the efficiency gain helps choose the right method in real applications.

6

Expert

Edge Cases and Signed Numbers in Bitwise Checks

🤔Before reading on: do you think bitwise AND works the same for negative numbers? Commit to your answer.

Concept: Discuss how negative numbers are represented and how bitwise checks behave.

Negative numbers use two's complement in binary. The last bit still indicates even or odd correctly. For example, -3 in binary ends with 1, so it's odd. However, care is needed when using bitwise operations with non-integers or very large numbers in JavaScript due to 32-bit limits.

Result

Bitwise even/odd checks work for negative integers but watch out for non-integers and large values.

Understanding number representation prevents bugs in edge cases.

Under the Hood

Bitwise AND compares each bit of two numbers. When ANDed with 1 (binary 000...001), it isolates the last bit of the number. This last bit determines evenness: 0 means even, 1 means odd. Internally, CPUs execute this as a single, fast instruction without division.

Why designed this way?

Computers use binary because it's simple and reliable with two states (0 and 1). Bitwise operations are designed to manipulate these bits directly for speed and efficiency. Checking even or odd by last bit is a natural consequence of binary representation and hardware design.

Number bits:  ... b3 b2 b1 b0
AND with:       000...0001
Result:         000...00b0
If b0=0 -> even
If b0=1 -> odd

Myth Busters - 3 Common Misconceptions

Quick: Does (num & 1) === 1 always mean the number is odd? Commit yes or no.

Common Belief: People think (num & 1) === 1 only works for positive numbers.

Reality: It works for negative integers too because two's complement keeps the last bit consistent for even/odd.

Why it matters: Believing otherwise may cause unnecessary complex code or bugs when handling negative numbers.

Quick: Is bitwise AND with 1 faster than modulo (%) in all programming languages? Commit yes or no.

Common Belief: Some believe bitwise AND is always faster than modulo everywhere.

Reality: While generally faster, some modern compilers optimize modulo for powers of two, making speed differences negligible.

Why it matters: Assuming speed differences without testing can lead to premature optimization or confusion.

Quick: Can bitwise AND check even/odd for decimal (floating-point) numbers? Commit yes or no.

Common Belief: People think bitwise AND works for any number type.

Reality: Bitwise operations only work on integers; floating-point numbers must be converted or handled differently.

Why it matters: Using bitwise on floats causes unexpected results or errors.

Expert Zone

1

Bitwise operations in JavaScript work on 32-bit signed integers, so very large numbers lose precision during bitwise checks.

2

Using bitwise AND for even/odd is a micro-optimization; in many cases, readability with modulo (%) is preferred unless profiling shows a bottleneck.

3

Two's complement representation ensures the last bit's meaning for even/odd holds for negative numbers, a subtlety often overlooked.

When NOT to use

Avoid bitwise checks for non-integer numbers, very large integers beyond 32-bit range, or when code clarity is more important than micro-optimization. Use modulo (%) for general-purpose checks or languages without efficient bitwise support.

Production Patterns

In performance-critical code like graphics, games, or embedded systems, bitwise even/odd checks are common. Also used in algorithms where bit manipulation is frequent, such as hashing or compression.

Connections

Modulo Operation

Alternative method to check even or odd using division remainder.

Understanding bitwise checks deepens knowledge of modulo as both reveal number properties but differ in efficiency.

Two's Complement Number Representation

Underlying binary format that ensures bitwise checks work for negative numbers.

Knowing two's complement explains why the last bit reliably indicates even or odd for signed integers.

Digital Electronics

Bitwise operations mirror how hardware circuits process binary signals.

Recognizing bitwise checks as hardware-level operations connects software logic to physical computing devices.

Common Pitfalls

#1 Using bitwise AND on floating-point numbers.

Wrong approach:

let num = 4.5;
let isEven = (num & 1) === 0;
console.log(isEven); // Unexpected result

Correct approach:

let num = 4.5;
let isEven = (Math.floor(num) & 1) === 0;
console.log(isEven); // Correct result

Root cause:

Bitwise operations only work on integers; floating-point numbers must be converted first.

#2 Assuming bitwise AND is always faster than modulo without testing.

Wrong approach:

function isEven(num) {
return (num & 1) === 0;
}
// Used everywhere without profiling

Correct approach:

function isEven(num) {
return num % 2 === 0;
}
// Use bitwise only after confirming performance need

Root cause:

Premature optimization without measuring actual performance gains.

#3 Ignoring negative numbers in bitwise even/odd checks.

Wrong approach:

function isOdd(num) {
return (num & 1) === 1;
}
console.log(isOdd(-3)); // true
console.log(isOdd(-2)); // false
// But some think negative numbers break this

Correct approach:

function isOdd(num) {
return (num & 1) === 1;
}
// Works correctly for negative integers due to two's complement

Root cause:

Misunderstanding of two's complement representation.

Key Takeaways

The last bit of a binary number directly shows if it is even or odd.

Using bitwise AND with 1 is a fast way to check even or odd without division.

Bitwise checks work correctly for negative integers because of two's complement.

Bitwise operations only work on integers, so convert floats before checking.

While bitwise is efficient, always consider readability and test performance before choosing it over modulo.

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