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

Practice - 5 Tasks

1fill in blank

easy

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

DSA Python

def is_even(num):
    return (num & [1]) == 0

print(is_even(4))  # True
print(is_even(7))  # False

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

A1

B0

C2

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as mask always returns 0, which is incorrect.

Using the number itself as mask causes errors.

The least significant bit (LSB) of an even number is 0. Using bitwise AND with 1 checks this bit.

2fill in blank

medium

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

DSA Python

def is_odd(num):
    return (num & [1]) == 1

print(is_odd(5))  # True
print(is_odd(8))  # False

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

A0

Bnum

C2

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as mask always returns 0.

Using 2 as mask checks wrong bit.

Odd numbers have the least significant bit set to 1. Bitwise AND with 1 checks this.

3fill in blank

hard

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

DSA Python

def check_even(num):
    if (num & [1]) == 0:
        return True
    else:
        return False

print(check_even(10))  # Should be True
print(check_even(7))   # Should be False

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

A1

B2

C0

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if (num & 1) == 1 means odd, not even.

Using wrong mask value.

For even numbers, the last bit is 0, so (num & 1) == 0 means even.

4fill in blank

hard

Fill both blanks to create a function that returns 'Even' or 'Odd' using bitwise operation.

DSA Python

def even_or_odd(num):
    if (num & [1]) == [2]:
        return 'Even'
    else:
        return 'Odd'

print(even_or_odd(12))  # Even
print(even_or_odd(15))  # Odd

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

A1

B0

C2

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping mask and comparison values.

Using incorrect mask value.

Check last bit with 1; if result is 0, number is even; else odd.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that labels numbers as 'Even' or 'Odd' using bits.

DSA Python

numbers = [1, 2, 3, 4, 5]
result = {num: 'Even' if (num & [1]) == [2] else 'Odd' for [3] in numbers}
print(result)

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

A1

B0

Cnum

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong iteration variable.

Incorrect mask or comparison values.

Use 1 as mask, compare to 0 for even, and iterate with variable 'num'.

Practice

1. What does the expression num & 1 check when determining if a number is even or odd?

easy

A. It checks if the least significant bit of num is 1, indicating odd number.

B. It checks if the number is greater than 1.

C. It shifts the bits of num to the right by 1.

D. It adds 1 to the number.

Solution

1. Step 1: Understand bitwise AND operation

   The expression num & 1 performs a bitwise AND between num and 1, which isolates the least significant bit (rightmost bit) of num.

2. Step 2: Interpret the least significant bit

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

3. Final Answer:

   It checks if the least significant bit of num is 1, indicating odd number. -> Option A

4. Quick Check:

   num & 1 = 1 means odd [OK]

Hint: Check last bit with & 1; 1 means odd, 0 means even [OK]

Common Mistakes:

• Thinking & 1 shifts bits instead of checking last bit
• Confusing bitwise AND with addition
• Assuming & 1 checks if number > 1

2. Which of the following Python code snippets correctly checks if a number n is even using bitwise operators?

easy

A. if n | 1 == 0:
print('Even')

B. if n & 0 == 1:
print('Even')

C. if n & 1 == 0:
print('Even')

D. if n ^ 1 == 0:
print('Even')

Solution

1. Step 1: Analyze each bitwise operation

   if n & 1 == 0: print('Even') uses n & 1 == 0, which checks if the least significant bit is 0, meaning even number. The other options use incorrect bitwise operations or comparisons.

2. Step 2: Confirm correct syntax and logic

   if n & 1 == 0: print('Even') correctly uses bitwise AND and compares to zero to detect even numbers.

3. Final Answer:

   if n & 1 == 0: print('Even') -> Option C

4. Quick Check:

   n & 1 == 0 means even [OK]

Hint: Use 'if n & 1 == 0' to check even numbers [OK]

Common Mistakes:

• Using bitwise OR or XOR instead of AND
• Comparing with wrong values like 1 instead of 0
• Misplacing parentheses causing syntax errors

3. What will be the output of the following code?

def check_even_odd(num):
    if num & 1:
        return 'Odd'
    else:
        return 'Even'

print(check_even_odd(10))
print(check_even_odd(7))

medium

A. Odd
Odd

B. Even
Odd

C. Odd
Even

D. Even
Even

Solution

1. Step 1: Evaluate check_even_odd(10)

   10 in binary ends with 0, so 10 & 1 = 0, condition is false, returns 'Even'.

2. Step 2: Evaluate check_even_odd(7)

   7 in binary ends with 1, so 7 & 1 = 1, condition is true, returns 'Odd'.

3. Final Answer:

   Even Odd -> Option B

4. Quick Check:

   10 even, 7 odd [OK]

Hint: num & 1 true means odd, false means even [OK]

Common Mistakes:

• Confusing return values for even and odd
• Misreading bitwise AND result
• Assuming & 1 returns boolean instead of int

4. Find the error in the following code that tries to print whether a number is even or odd using bits:

def is_even(num):
    if num & 1 = 0:
        return True
    else:
        return False

print(is_even(4))

medium

A. Using single '=' instead of '==' in the if condition

B. Using bitwise AND instead of bitwise OR

C. Missing colon after function definition

D. Incorrect indentation of return statements

Solution

1. Step 1: Identify syntax error in if condition

   The condition uses single '=' which is assignment, not comparison. It should be '==' to compare values.

2. Step 2: Confirm correct syntax for comparison

   Changing '=' to '==' fixes the syntax error and allows the function to work as intended.

3. Final Answer:

   Using single '=' instead of '==' in the if condition -> Option A

4. Quick Check:

   Use '==' for comparison, not '=' [OK]

Hint: Use '==' for comparison in if statements [OK]

Common Mistakes:

• Using '=' instead of '==' in conditions
• Confusing bitwise AND with OR
• Ignoring syntax errors causing runtime failure

5. You want to filter a list of integers and keep only the odd numbers using bitwise operations. Which of the following code snippets correctly achieves this?

hard

A. odds = [x for x in numbers if x ^ 1 == 1]

B. odds = [x for x in numbers if x & 1 == 0]

C. odds = [x for x in numbers if x | 1 == 1]

D. odds = [x for x in numbers if x & 1 == 1]

Solution

1. Step 1: Understand filtering condition for odd numbers

   Odd numbers have least significant bit 1, so x & 1 == 1 filters odd numbers.

2. Step 2: Check each option's logic

   odds = [x for x in numbers if x & 1 == 1] correctly filters odd numbers. odds = [x for x in numbers if x & 1 == 0] filters even numbers. Options C and D use incorrect bitwise operations for this purpose.

3. Final Answer:

   odds = [x for x in numbers if x & 1 == 1] -> Option D

4. Quick Check:

   Filter odds with x & 1 == 1 [OK]

Hint: Use list comprehension with 'x & 1 == 1' to get odd numbers [OK]

Common Mistakes:

• Using 'x & 1 == 0' which filters even numbers
• Using bitwise OR or XOR incorrectly
• Forgetting to compare with 1 explicitly