Set Clear Toggle a Specific Bit in DSA Python

Mental Model

We change one specific bit in a number to 1, 0, or flip it without affecting other bits.

Analogy: Imagine a row of light switches where each switch controls one light. Setting a bit is like turning a specific switch on, clearing is turning it off, and toggling is flipping its current state.

Number bits: 0 0 1 0 1 1 0 1
Positions:  7 6 5 4 3 2 1 0
Toggle bit 3 -> flip the switch at position 3

Dry Run Walkthrough

Input: number = 45 (binary 00101101), bit position = 3

Goal: Set, clear, and toggle the bit at position 3 in the number 45

Step 1: Set bit 3 to 1 using OR with mask 1 << 3

00101101 (45) OR 00001000 (8) = 00101101 (45)

Why: Bit 3 is already 1, so setting it keeps the number unchanged

Step 2: Clear bit 3 to 0 using AND with inverse mask ~(1 << 3)

00101101 (45) AND 11110111 (247) = 00100101 (37)

Why: Clearing bit 3 turns that bit off, changing number from 45 to 37

Step 3: Toggle bit 3 using XOR with mask 1 << 3

00100101 (37) XOR 00001000 (8) = 00101101 (45)

Why: Toggling flips bit 3 back on, restoring number to 45

Result:

Final numbers after operations:
Set bit 3: 45 (00101101)
Clear bit 3: 37 (00100101)
Toggle bit 3: 45 (00101101)

Annotated Code

DSA Python

class BitManipulator:
    def __init__(self, number: int):
        self.number = number

    def set_bit(self, pos: int) -> int:
        # Set bit at pos to 1
        self.number |= (1 << pos)
        return self.number

    def clear_bit(self, pos: int) -> int:
        # Clear bit at pos to 0
        self.number &= ~(1 << pos)
        return self.number

    def toggle_bit(self, pos: int) -> int:
        # Flip bit at pos
        self.number ^= (1 << pos)
        return self.number

if __name__ == '__main__':
    num = 45  # binary 00101101
    pos = 3
    bm = BitManipulator(num)

    set_result = bm.set_bit(pos)
    print(f'Set bit {pos}: {set_result} ({set_result:08b})')

    clear_result = bm.clear_bit(pos)
    print(f'Clear bit {pos}: {clear_result} ({clear_result:08b})')

    toggle_result = bm.toggle_bit(pos)
    print(f'Toggle bit {pos}: {toggle_result} ({toggle_result:08b})')

self.number |= (1 << pos)

Set bit at position pos to 1 by OR with mask

self.number &= ~(1 << pos)

Clear bit at position pos to 0 by AND with inverted mask

self.number ^= (1 << pos)

Toggle bit at position pos by XOR with mask

Output

Set bit 3: 45 (00101101)

Clear bit 3: 37 (00100101)

Toggle bit 3: 45 (00101101)

Complexity Analysis

Time: O(1) because bitwise operations take constant time regardless of number size

Space: O(1) because no extra space is needed beyond variables

vs Alternative: Using bitwise operations is much faster and simpler than converting to string or array and manipulating bits manually

Edge Cases

bit position is 0 (least significant bit)

Operations correctly affect the rightmost bit

DSA Python

self.number |= (1 << pos)

bit position is larger than number bit length

Bit is set/cleared/toggled at that position, effectively extending number's binary representation

DSA Python

self.number |= (1 << pos)

number is 0 initially

Setting bit turns number positive; clearing or toggling behaves as expected

DSA Python

self.number |= (1 << pos)

When to Use This Pattern

When you need to change a single bit in a number quickly, use set, clear, or toggle bit patterns because they directly manipulate bits without loops or conversions.

Common Mistakes

Mistake: Using AND instead of OR to set a bit, which can clear other bits
Fix: Use OR with mask to set a bit without affecting others

Mistake: Forgetting to invert mask when clearing a bit, causing wrong bits to be cleared
Fix: Use NOT (~) on mask before AND to clear only the target bit

Mistake: Using addition or subtraction to set or clear bits, which can cause errors
Fix: Use bitwise operators OR, AND, XOR for precise bit manipulation

Summary

It changes one specific bit in a number to 1, 0, or flips it.

Use it when you want to control individual bits efficiently in a number.

The key is to create a mask with 1 shifted to the bit position and use OR, AND with NOT, or XOR to set, clear, or toggle.

Practice

1. What does the operation num | (1 << k) do to the number num in terms of its bits?

easy

A. Sets the k-th bit of num to 1

B. Clears the k-th bit of num to 0

C. Toggles the k-th bit of num

D. Checks if the k-th bit of num is set

Solution

1. Step 1: Understand bitwise OR with shifted 1

   The expression 1 << k creates a number with only the k-th bit set to 1.

2. Step 2: Apply OR operation to set bit

   Using num | (1 << k) sets the k-th bit of num to 1 without changing other bits.

3. Final Answer:

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

4. Quick Check:

   OR with 1 at bit k sets that bit [OK]

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

Common Mistakes:

• Confusing OR with AND operation
• Thinking it clears or toggles the bit
• Misunderstanding bit positions starting at 0

2. Which of the following Python expressions correctly clears (sets to 0) the k-th bit of an integer num?

easy

A. num & (1 << k)

B. num ^ (1 << k)

C. num | ~(1 << k)

D. num & ~(1 << k)

Solution

1. Step 1: Understand clearing a bit

   To clear the k-th bit, we want to keep all bits except the k-th bit set to 0.

2. Step 2: Use AND with NOT mask

   The mask ~(1 << k) has all bits set to 1 except the k-th bit which is 0. ANDing with this clears the k-th bit.

3. Final Answer:

   num & ~(1 << k) -> Option D

4. Quick Check:

   AND with inverted mask clears bit [OK]

Hint: AND with NOT of shifted 1 clears bit [OK]

Common Mistakes:

• Using OR instead of AND to clear bits
• Forgetting to invert the mask
• Using XOR which toggles instead of clears

3. What is the output of the following code?

num = 42  # binary 101010
k = 1
result = num ^ (1 << k)
print(result)

medium

A. 40

B. 43

C. 44

D. 41

Solution

1. Step 1: Convert num and identify bit

   42 in binary is 101010. The bit positions (0-based) from right are: bit 0=0, bit 1=1, bit 2=0, bit 3=1, bit 4=0, bit 5=1.

2. Step 2: Toggle bit 1 using XOR

   1 << 1 is 2 (binary 10). XOR toggles bit 1: original bit 1 is 1, toggled to 0. So binary becomes 101000 which is 40 decimal.

3. Final Answer:

   40 -> Option A

4. Quick Check:

   XOR toggles bit 1 from 1 to 0 [OK]

Hint: XOR toggles bit; check original bit to find result [OK]

Common Mistakes:

• Confusing XOR with OR or AND
• Miscounting bit positions
• Forgetting bits are zero-indexed from right

4. The following code is intended to clear the 3rd bit (0-based) of num. What is the error?

num = 29  # binary 11101
k = 3
num = num | ~(1 << k)
print(num)

medium

A. Incorrect bit shift direction

B. Using OR instead of AND to clear the bit

C. Missing parentheses around bitwise NOT

D. No error, code works correctly

Solution

1. Step 1: Understand clearing bit logic

   To clear a bit, we must AND with the inverse mask, not OR.

2. Step 2: Identify incorrect operator usage

   The code uses OR (|) which sets bits, so it cannot clear the bit. It should use AND (&).

3. Final Answer:

   Using OR instead of AND to clear the bit -> Option B

4. Quick Check:

   Clear bit requires AND with NOT mask [OK]

Hint: Clear bit uses AND with NOT mask, not OR [OK]

Common Mistakes:

• Using OR instead of AND to clear bits
• Confusing bitwise NOT precedence
• Assuming code works without testing

5. You have a number num = 0. You want to toggle bits 0, 2, and 4 in sequence using the expression num = num ^ (1 << k). What is the final decimal value of num after toggling these bits?

hard

A. 15

B. 31

C. 21

D. 10

Solution

1. Step 1: Toggle bit 0 on num=0

   num = 0 ^ (1 << 0) = 0 ^ 1 = 1 (binary 00001)

2. Step 2: Toggle bit 2 on num=1

   num = 1 ^ (1 << 2) = 1 ^ 4 = 5 (binary 00101)

3. Step 3: Toggle bit 4 on num=5

   num = 5 ^ (1 << 4) = 5 ^ 16 = 21 (binary 10101)

4. Final Answer:

   21 -> Option C

5. Quick Check:

   Toggling bits 0,2,4 sets bits to 1, sum 1+4+16=21 [OK]

Hint: Toggle bits one by one with XOR, sum powers of two [OK]

Common Mistakes:

• Toggling bits in wrong order
• Miscounting bit positions
• Adding instead of XORing bits