Check if Number is Even or Odd Using Bits in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go code checking even or odd using bits?

Look at the code below. What will it print when run?

DSA Go

package main
import "fmt"
func main() {
    num := 7
    if num&1 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}

A "Odd"

B Compilation error

C "Even"

D Runtime panic

💡 Hint

Check the last bit of the number using bitwise AND with 1.

The bitwise AND of 7 (binary 111) and 1 (binary 001) is 1, which is not zero, so the number is odd.

❓ Predict Output

intermediate

What does this Go code print for number 12 using bitwise check?

Check the output of this code snippet:

DSA Go

package main
import "fmt"
func main() {
    num := 12
    if num&1 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}

A "Odd"

B "Even"

C Compilation error

D Runtime panic

💡 Hint

Even numbers have last bit 0 in binary.

12 in binary ends with 0, so 12 & 1 equals 0, meaning the number is even.

🔧 Debug

advanced

What error does this Go code produce when checking even or odd?

Find the error in this code snippet:

DSA Go

package main
import "fmt"
func main() {
    num := 5
    if num&1 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}

A No error, prints "Even"

B Runtime panic: invalid memory address

C SyntaxError: unexpected = in if condition

D No error, prints "Odd"

💡 Hint

Check the operator used in the if condition.

The code uses assignment '=' instead of comparison '==' in the if condition, causing a syntax error.

🧠 Conceptual

advanced

Why does using bitwise AND with 1 check if a number is even or odd?

Choose the best explanation:

A Because the least significant bit of an odd number is always 1

B Because bitwise AND with 1 multiplies the number by 2

C Because bitwise AND with 1 shifts the number right by one bit

D Because the least significant bit of an even number is always 1

💡 Hint

Think about binary representation of even and odd numbers.

Odd numbers have their least significant bit set to 1, so num & 1 equals 1 for odd numbers.

🚀 Application

expert

What is the output of this Go program that counts even numbers using bitwise check?

Analyze the code and select the correct output:

DSA Go

package main
import "fmt"
func main() {
    nums := []int{2, 3, 4, 5, 6}
    count := 0
    for _, n := range nums {
        if n&1 == 0 {
            count++
        }
    }
    fmt.Println(count)
}

A 4

B 2

C 5

D 3

💡 Hint

Count how many numbers in the list have last bit 0.

Numbers 2, 4, and 6 are even, so count is 3.

Practice

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

easy

A. It checks the least significant bit to see if it is 1 (odd) or 0 (even).

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

C. It divides the number by 2.

D. It adds 1 to the number.

Solution

1. Step 1: Understand bitwise AND operation

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

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 the least significant bit to see if it is 1 (odd) or 0 (even). -> Option A

4. Quick Check:

   num & 1 = 1 means odd, 0 means even [OK]

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

Common Mistakes:

• Thinking & 1 divides the number
• Confusing bitwise AND with addition
• Assuming it checks if number > 1

2. Which of the following Go code snippets correctly checks if an integer n is odd using bitwise operations?

easy

A. if n & 0 == 1 { fmt.Println("Odd") }

B. if n | 1 == 1 { fmt.Println("Odd") }

C. if n ^ 1 == 1 { fmt.Println("Odd") }

D. if n & 1 == 1 { fmt.Println("Odd") }

Solution

1. Step 1: Analyze bitwise AND usage

   The correct way to check oddness is using bitwise AND with 1: n & 1. This isolates the least significant bit.

2. Step 2: Check condition correctness

   if n & 1 == 1 { fmt.Println("Odd") } uses n & 1 == 1, which is true if the number is odd. Other options use incorrect operators or values.

3. Final Answer:

   if n & 1 == 1 { fmt.Println("Odd") } -> Option D

4. Quick Check:

   Use & 1 == 1 to check odd [OK]

Hint: Use 'if n & 1 == 1' to check odd numbers in Go [OK]

Common Mistakes:

• Using bitwise OR instead of AND
• Comparing with 0 instead of 1
• Using XOR which changes bits

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

package main
import "fmt"
func main() {
    n := 14
    if n & 1 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}

medium

A. Even

B. Odd

C. 14

D. Compilation error

Solution

1. Step 1: Evaluate bitwise AND for n=14

   14 in binary is 1110. The least significant bit is 0. So, 14 & 1 = 0.

2. Step 2: Check the if condition

   Since 14 & 1 == 0, the condition is true, so it prints "Even".

3. Final Answer:

   Even -> Option A

4. Quick Check:

   14 & 1 = 0 means Even [OK]

Hint: If n & 1 == 0, number is even [OK]

Common Mistakes:

• Assuming 14 is odd
• Confusing bitwise AND with arithmetic AND
• Expecting output to be the number itself

4. Find the error in this Go code snippet that tries to print if a number is even or odd:

package main
import "fmt"
func main() {
    num := 7
    if num & 1 = 1 {
        fmt.Println("Odd")
    } else {
        fmt.Println("Even")
    }
}

medium

A. Using bitwise AND instead of OR

B. Using single '=' instead of '==' in if condition

C. Missing import statement

D. Variable 'num' not declared

Solution

1. Step 1: Identify the if condition syntax

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

2. Step 2: Understand Go syntax rules

   Go requires '==' for equality checks. Using '=' in if condition causes a compilation error.

3. Final Answer:

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

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 logical AND
• Forgetting to declare variables

5. You want to write a Go function IsEven that returns true if a number is even and false if odd, using bitwise operations. Which of the following implementations is correct?

hard

A. func IsEven(n int) bool { return n & 1 == 1 }

B. func IsEven(n int) bool { return n | 1 == 0 }

C. func IsEven(n int) bool { return n & 1 == 0 }

D. func IsEven(n int) bool { return (n >> 1) == 0 }

Solution

1. Step 1: Understand even number bit pattern

   Even numbers have least significant bit 0, so n & 1 equals 0 for even numbers.

2. Step 2: Verify the correct implementation

   func IsEven(n int) bool { return n & 1 == 0 } is correct because even numbers have LSB 0. The implementation returning n & 1 == 1 checks for odd. The bitwise OR and right shift implementations are incorrect for checking evenness.

3. Final Answer:

   func IsEven(n int) bool { return n & 1 == 0 } -> Option C

4. Quick Check:

   Return true if n & 1 == 0 for even [OK]

Hint: Return n & 1 == 0 to check even numbers [OK]

Common Mistakes:

• Returning true for odd numbers instead of even
• Using right shift incorrectly
• Using bitwise OR instead of AND