Bit Manipulation Basics AND OR XOR NOT Left Right Shift in DSA Go - Time & Space Complexity

Time Complexity: Bit Manipulation Basics AND OR XOR NOT Left Right Shift

O(n)

Understanding Time Complexity

Bit manipulation operations are basic steps computers use to handle numbers at the smallest level.

We want to know how the time to do these operations changes as the size of the number grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func bitOperations(x, y uint32) (uint32, uint32, uint32, uint32, uint32, uint32) {
    and := x & y
    or := x | y
    xor := x ^ y
    not := ^x
    leftShift := x << 1
    rightShift := x >> 1
    return and, or, xor, not, leftShift, rightShift
}
    

This code performs basic bitwise AND, OR, XOR, NOT, and shifts on two 32-bit numbers.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Each bitwise operation processes all bits of the input numbers.
• How many times: For 32-bit numbers, each operation touches 32 bits once.

How Execution Grows With Input

Each operation looks at every bit once, so the work grows directly with the number of bits.

Input Size (bits)	Approx. Operations
8	8 operations per bitwise call
32	32 operations per bitwise call
64	64 operations per bitwise call

Pattern observation: Doubling the number of bits doubles the work needed.

Final Time Complexity

Time Complexity: O(n)

This means the time to do bitwise operations grows linearly with the number of bits in the input.

Common Mistake

[X] Wrong: "Bitwise operations are instant and take the same time no matter the number size."

[OK] Correct: While hardware is very fast, each bit must be processed, so larger numbers take proportionally more time.

Interview Connect

Understanding bitwise operation costs helps you write efficient low-level code and shows you know how computers handle data.

Self-Check

"What if we used 128-bit numbers instead of 32-bit? How would the time complexity change?"

Practice

1. What is the result of the bitwise AND operation between 6 and 3? (6 = 110 in binary, 3 = 011 in binary)

easy

A. 2

B. 1

C. 3

D. 0

Solution

1. Step 1: Convert numbers to binary

   6 in binary is 110, 3 in binary is 011.

2. Step 2: Perform bitwise AND

   110 AND 011 = 010 in binary, which is 2 in decimal.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   6 & 3 = 2 [OK]

Hint: AND keeps bits set in both numbers only [OK]

Common Mistakes:

• Confusing AND with OR operation
• Not converting numbers to binary before operation
• Mixing decimal and binary values

2. Which of the following is the correct syntax in Go to perform a bitwise XOR between variables a and b?

easy

A. c := a & b

B. c := a && b

C. c := a ^ b

D. c := a | b

Solution

1. Step 1: Recall Go bitwise operators

   In Go, '^' is the bitwise XOR operator.

2. Step 2: Match syntax

   c := a ^ b uses '^' correctly for XOR. Other options use logical AND (&&), OR (|), and AND (&).

3. Final Answer:

   c := a ^ b -> Option C

4. Quick Check:

   Bitwise XOR uses '^' in Go [OK]

Hint: XOR operator in Go is '^' symbol [OK]

Common Mistakes:

• Using '&&' which is logical AND, not bitwise
• Confusing OR '|' with XOR '^'
• Using '&' which is bitwise AND, not XOR

3. What is the output of the following Go code?

package main
import "fmt"
func main() {
  var x uint8 = 12  // binary 00001100
  var y uint8 = 5   // binary 00000101
  fmt.Println(x | y)
  fmt.Println(x & y)
  fmt.Println(x ^ y)
}

medium

A. 15
4
9

B. 14
4
9

C. 15
5
8

D. 13
4
9

Solution

1. Step 1: Convert x and y to binary

   x = 12 = 00001100, y = 5 = 00000101.

2. Step 2: Calculate bitwise OR, AND, XOR

   OR: 00001100 | 00000101 = 00001101 (13 decimal)
   AND: 00001100 & 00000101 = 00000100 (4 decimal)
   XOR: 00001100 ^ 00000101 = 00001001 (9 decimal)

3. Step 3: Verify output

   Output lines are:
   13
   4
   9

4. Final Answer:

   13 4 9 -> Option D

5. Quick Check:

   Bitwise OR, AND, XOR results match 13, 4, 9 [OK]

Hint: OR sets bits from either number, AND only common bits [OK]

Common Mistakes:

• Mixing up OR and XOR results
• Incorrect binary conversion
• Confusing decimal output values

4. The following Go code is intended to left shift the number 3 by 2 bits. Identify the error.

package main
import "fmt"
func main() {
  var a int = 3
  var b int = 2
  var c int = a << b
  fmt.Println(c)
}

medium

A. Error: shift count must be unsigned integer

B. No error, output is 12

C. Error: cannot shift int by int

D. Error: missing parentheses around shift

Solution

1. Step 1: Understand Go shift rules

   In Go, shift count must be unsigned integer or untyped constant. Here, b is int but allowed.

2. Step 2: Calculate left shift

   3 << 2 means shifting bits of 3 (00000011) left by 2 bits: 00001100 = 12 decimal.

3. Final Answer:

   No error, output is 12 -> Option B

4. Quick Check:

   3 << 2 = 12 [OK]

Hint: Shift count can be int variable in Go if within range [OK]

Common Mistakes:

• Assuming shift count must be uint explicitly
• Thinking parentheses are required around shift
• Confusing shift operators with arithmetic operators

5. Given a 8-bit unsigned integer n, write a Go expression using bitwise operators to toggle (flip) the 3rd bit (counting from 0, right to left) of n. Which expression correctly does this?

hard

A. n ^ (1 << 3)

B. n & (1 << 3)

C. n | (1 << 3)

D. ~n & (1 << 3)

Solution

1. Step 1: Understand toggling a bit

   Toggling means flipping the bit: if 0 becomes 1, if 1 becomes 0.

2. Step 2: Use XOR to toggle

   XOR with 1 flips the bit, XOR with 0 keeps it same. So, n ^ (1 << 3) flips the 3rd bit.

3. Step 3: Check other options

   AND keeps bit only if both are 1 (no toggle), OR sets bit to 1 (no toggle), NOT and AND combination does not toggle.

4. Final Answer:

   n ^ (1 << 3) -> Option A

5. Quick Check:

   XOR with mask toggles bit [OK]

Hint: XOR with 1 flips bit, XOR with 0 keeps bit same [OK]

Common Mistakes:

• Using AND or OR which don't toggle bits
• Confusing NOT operator usage
• Incorrect bit position shift