Set Clear Toggle a Specific Bit in DSA Go - Build from Scratch

Set Clear Toggle a Specific Bit

📖 Scenario: Imagine you have a simple control panel with 8 switches represented by bits in a number. Each bit can be ON (1) or OFF (0). You want to learn how to turn a specific switch ON, OFF, or flip it without changing the others.

🎯 Goal: You will write a Go program that can set (turn ON), clear (turn OFF), and toggle (flip) a specific bit in an 8-bit number. This helps you control individual switches easily.

📋 What You'll Learn

Create a variable number with the value 0b00001100 (12 in decimal).

Create a variable bitPosition with the value 2 (counting bits from 0, right to left).

Write code to set the bit at bitPosition in number.

Write code to clear the bit at bitPosition in number.

Write code to toggle the bit at bitPosition in number.

Print the results after each operation in binary format.

💡 Why This Matters

🌍 Real World

Controlling hardware switches, flags in software, or permissions often uses bits to represent ON/OFF states efficiently.

💼 Career

Understanding bit manipulation is important for embedded systems, game development, network programming, and performance-critical applications.

1

Create the initial number and bit position

Create a variable called number and set it to 0b00001100 (which is 12 in decimal). Also create a variable called bitPosition and set it to 2.

DSA Go

# Create the variable number with value 0b00001100 and bitPosition with value 2
# Your code here

Hint

Use := to create variables in Go. Binary numbers start with 0b.

2

Set the bit at bitPosition

Using the variables number and bitPosition, create a new variable called setBit that sets (turns ON) the bit at bitPosition in number.

DSA Go

package main

func main() {
    number := 0b00001100
    bitPosition := 2
    // Set the bit at bitPosition in number
    // Your code here
}

Hint

Use bitwise OR | and left shift 1 << bitPosition to set a bit.

3

Clear the bit at bitPosition

Using the variables number and bitPosition, create a new variable called clearBit that clears (turns OFF) the bit at bitPosition in number.

DSA Go

package main

import "fmt"

func main() {
    number := 0b00001100
    bitPosition := 2
    setBit := number | (1 << bitPosition)
    // Clear the bit at bitPosition in number
    // Your code here
    fmt.Printf("Set bit: %08b\n", setBit)
}

Hint

Use bitwise AND NOT &^ with 1 << bitPosition to clear a bit.

4

Toggle the bit at bitPosition and print all results

Using the variables number and bitPosition, create a new variable called toggleBit that toggles (flips) the bit at bitPosition in number. Then print the values of setBit, clearBit, and toggleBit in 8-bit binary format using fmt.Printf.

DSA Go

package main

import "fmt"

func main() {
    number := 0b00001100
    bitPosition := 2
    setBit := number | (1 << bitPosition)
    clearBit := number &^ (1 << bitPosition)
    // Toggle the bit at bitPosition in number
    // Your code here
    // Print setBit, clearBit, and toggleBit
    // Your code here
}

Hint

Use bitwise XOR ^ with 1 << bitPosition to toggle a bit. Use fmt.Printf("%08b\n", value) to print 8-bit binary numbers.

Practice

1. What does the operation num |= (1 << 3) do to the number num?

easy

A. Sets the 4th bit of num to 1

B. Clears the 4th bit of num to 0

C. Toggles the 4th bit of num

D. Checks if the 4th bit of num is set

Solution

1. Step 1: Understand bit shifting

   The expression 1 << 3 shifts 1 left by 3 bits, resulting in binary 00001000, which targets the 4th bit.

2. Step 2: Apply bitwise OR to set bit

   Using |= with this mask sets the 4th bit of num to 1 without changing other bits.

3. Final Answer:

   Sets the 4th bit of num to 1 -> Option A

4. Quick Check:

   Set bit = |= (1 << position) [OK]

Hint: Use OR with shifted 1 to set a bit [OK]

Common Mistakes:

• Confusing set with clear operation
• Using wrong bit position (off by one)
• Thinking it toggles instead of sets

2. Which of the following Go code snippets correctly clears the 2nd bit (bit index 1) of an integer variable num?

easy

A. num &= (1 << 1)

B. num |= (1 << 1)

C. num &= ^(1 << 1)

D. num ^= (1 << 1)

Solution

1. Step 1: Identify clearing operation

   To clear a bit, we AND num with the inverse mask that has 0 at the target bit and 1 elsewhere.

2. Step 2: Use bitwise AND with negated mask

   ^(1 << 1) creates a mask with all bits 1 except the 2nd bit 0. ANDing clears that bit.

3. Final Answer:

   num &= ^(1 << 1) -> Option C

4. Quick Check:

   Clear bit = &= ^(1 << position) [OK]

Hint: Use AND with negated shifted 1 to clear bit [OK]

Common Mistakes:

• Using OR instead of AND to clear
• Not negating the mask
• Confusing bit index counting

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

package main
import "fmt"
func main() {
    num := 10 // binary 1010
    num ^= (1 << 1)
    fmt.Println(num)
}

medium

A. 10

B. 8

C. 12

D. 14

Solution

1. Step 1: Understand initial value and bit positions

   Number 10 in binary is 1010. Bit positions (0-based) from right: bit0=0, bit1=1, bit2=0, bit3=1.

2. Step 2: Toggle 2nd bit (bit index 1) using XOR

   XOR with (1 << 1) toggles bit1. Bit1 is 1, toggling it changes to 0. New binary: 1000 which is 8.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   Toggle bit = ^= (1 << position) [OK]

Hint: XOR toggles bit: 1->0 or 0->1 [OK]

Common Mistakes:

• Confusing toggle with set or clear
• Misreading bit positions
• Calculating decimal incorrectly

4. The following Go code is intended to clear the 3rd bit (bit index 2) of num. What is the error?

num := 15
num &= (1 << 2)

medium

A. It sets the 3rd bit instead of clearing it

B. No error, it correctly clears the 3rd bit

C. It toggles the 3rd bit instead of clearing

D. It clears all bits except the 3rd bit

Solution

1. Step 1: Analyze the operation performed

   The code does num &= (1 << 2), which ANDs num with 00000100 (only 3rd bit set).

2. Step 2: Understand effect on bits

   This clears all bits except the 3rd bit, effectively keeping only the 3rd bit if it was set, not clearing it.

3. Final Answer:

   It clears all bits except the 3rd bit -> Option D

4. Quick Check:

   Clear bit = &= ^(1 << position) [OK]

Hint: Use AND with negated mask to clear bit [OK]

Common Mistakes:

• Using AND with mask instead of negated mask
• Confusing clear with set or toggle
• Assuming &= (1 << n) clears bit

5. You have an integer num initially 0. You want to toggle the 1st bit, set the 3rd bit, and clear the 2nd bit in this order. Which sequence of operations achieves this correctly in Go?

hard

A. num ^= (1 << 0); num |= (1 << 2); num &= ^(1 << 1)

B. num |= (1 << 0); num ^= (1 << 2); num &= ^(1 << 1)

C. num &= ^(1 << 1); num ^= (1 << 0); num |= (1 << 2)

D. num |= (1 << 2); num ^= (1 << 0); num &= ^(1 << 1)

Solution

1. Step 1: Toggle 1st bit (bit 0)

   Use XOR with (1 << 0) to toggle the 1st bit: num ^= (1 << 0).

2. Step 2: Set 3rd bit (bit 2)

   Use OR with (1 << 2) to set the 3rd bit: num |= (1 << 2).

3. Step 3: Clear 2nd bit (bit 1)

   Use AND with negated mask to clear 2nd bit: num &= ^(1 << 1).

4. Final Answer:

   num ^= (1 << 0); num |= (1 << 2); num &= ^(1 << 1) -> Option A

5. Quick Check:

   Toggle, Set, Clear in order with ^=, |=, &= ^ [OK]

Hint: Toggle ^=, Set |=, Clear &= ^ in correct order [OK]

Common Mistakes:

• Mixing order of operations
• Using wrong operators for each action
• Not negating mask when clearing