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

Practice - 5 Tasks

1fill in blank

easy

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

DSA Go

if num & [1] == 0 {
    fmt.Println("Even")
} else {
    fmt.Println("Odd")
}

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

A2

B0

C1

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of 1 in the bitwise AND operation.

Using the number itself instead of 1 for masking.

Using bitwise AND with 1 checks the least significant bit. If it is 0, the number is even.

2fill in blank

medium

Complete the code to print "Odd" when the number is odd using bitwise operation.

DSA Go

if num & [1] != 0 {
    fmt.Println("Odd")
} else {
    fmt.Println("Even")
}

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

A1

B0

C2

Dnum

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of 1 in the bitwise AND operation.

Checking for equality to 0 instead of inequality.

If the least significant bit masked by 1 is 1, the number is odd.

3fill in blank

hard

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

DSA Go

if (num [1] 1) == 0 {
    fmt.Println("Even")
} else {
    fmt.Println("Odd")
}

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

A^

B&

C|

D<<

Attempts:

3 left

💡 Hint

Common Mistakes

Using bitwise OR '|' instead of AND '&'.

Using XOR '^' which toggles bits.

The bitwise AND operator '&' is used to check the least significant bit.

4fill in blank

hard

Fill both blanks to create a function that returns true if a number is even using bits.

DSA Go

func isEven(num int) bool {
    return (num [1] 1) [2] 0
}

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

A&

B==

C!=

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' for comparison.

Using '|' instead of '&' for masking.

Use bitwise AND '&' to mask the least significant bit and compare it to 0 with '=='.

5fill in blank

hard

Fill all three blanks to create a function that returns true if a number is odd using bits.

DSA Go

func isOdd(num int) bool {
    return (num [1] 1) [2] 0
}

fmt.Println(isOdd([3]))

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

A&

B!=

C5

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '!=' for odd check.

Using even number for test input.

Use bitwise AND '&' to mask the least significant bit, check if it is not equal to 0 with '!=', and test with number 5.

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