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

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

O(1)

Understanding Time Complexity

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

How does the time to check change as the number gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func isEven(num int) bool {
    return (num & 1) == 0
}
    

This code checks the last bit of the number to decide if it is even or odd.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Bitwise AND operation on the number and 1.
• How many times: Exactly once per function call, no loops or recursion.

How Execution Grows With Input

Checking the last bit takes the same time no matter how big the number is.

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

Pattern observation: The number size does not affect the time; it stays constant.

Final Time Complexity

Time Complexity: O(1)

This means the check takes the same tiny amount of time no matter how big the number is.

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 size of the number does not matter.

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. 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