Set Clear Toggle a Specific Bit in DSA C++

Mental Model

Bits are like tiny switches that can be turned on, off, or flipped individually inside a number.

Analogy: Imagine a row of light switches in your house. Each switch controls one light. You can turn a switch on, off, or flip it without affecting the others.

Number bits: 0 0 1 0 1 0 1 0
Positions:  7 6 5 4 3 2 1 0
Toggle bit at position 3 -> changes that bit only

Dry Run Walkthrough

Input: number = 42 (binary 00101010), toggle bit at position 3

Goal: Flip the bit at position 3 from 1 to 0 or 0 to 1

Step 1: Create mask by shifting 1 left by 3 positions

mask = 00001000 (binary), number = 00101010

Why: Mask isolates the bit at position 3 to toggle

Step 2: Apply XOR between number and mask to flip bit 3

result = 00100010 (binary) = 34 decimal

Why: XOR flips the bit where mask has 1, keeps others same

Result:

00100010 (binary) = 34 decimal

Annotated Code

DSA C++

#include <iostream>
using namespace std;

// Function to toggle a specific bit at position 'pos'
int toggleBit(int number, int pos) {
    int mask = 1 << pos; // create mask with 1 at pos
    return number ^ mask; // XOR flips the bit at pos
}

int main() {
    int number = 42; // binary 00101010
    int pos = 3; // bit position to toggle
    int result = toggleBit(number, pos);
    cout << "Original number: " << number << " (binary 00101010)\n";
    cout << "After toggling bit at position " << pos << ": " << result << " (binary 00100010)\n";
    return 0;
}

int mask = 1 << pos; // create mask with 1 at pos

create mask to isolate bit at position pos

return number ^ mask; // XOR flips the bit at pos

flip the bit at pos using XOR operation

Output

Original number: 42 (binary 00101010)

After toggling bit at position 3: 34 (binary 00100010)

Complexity Analysis

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

Space: O(1) because only a few variables are used for mask and result

vs Alternative: Using arithmetic or string conversion to flip bits is slower and more complex than direct bitwise operations

Edge Cases

toggling bit at position 0 (least significant bit)

correctly flips the rightmost bit

DSA C++

int mask = 1 << pos;

toggling bit at a position larger than number bit length

creates mask beyond current bits, toggling that bit adds it as 1

DSA C++

int mask = 1 << pos;

toggling bit on zero number

sets the bit at pos to 1

DSA C++

return number ^ mask;

When to Use This Pattern

When you need to change a single bit inside a number without affecting others, use bitwise operations like toggle with XOR for efficient manipulation.

Common Mistakes

Mistake: Using AND or OR instead of XOR to toggle bit
Fix: Use XOR (^) because it flips bits; AND clears bits; OR sets bits

Mistake: Not shifting 1 by pos to create mask, using wrong mask
Fix: Always create mask by shifting 1 left by pos: 1 << pos

Summary

It flips (toggles) a specific bit in a number from 0 to 1 or 1 to 0.

Use it when you want to change one bit without touching others in a number.

The key is to create a mask with 1 at the target bit and XOR it with the number.

Practice

1. What does the operation num |= (1 << k) do to the integer num in C++?

easy

A. Toggles the k-th bit of num

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

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

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

Solution

1. Step 1: Understand the bit shift operation

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

2. Step 2: Apply bitwise OR to set the bit

   Using |= with this mask 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 B

4. Quick Check:

   num |= (1 << k) sets bit k [OK]

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

Common Mistakes:

• Confusing set with clear operation
• Using AND instead of OR to set bits
• Misunderstanding bit positions starting from 0

2. Which of the following is the correct syntax to clear the 3rd bit (0-indexed) of an integer variable num in C++?

easy

A. num &= ~(1 << 3);

B. num |= (1 << 3);

C. num ^= (1 << 3);

D. num = (num & (1 << 3));

Solution

1. Step 1: Create mask to clear bit

   1 << 3 sets only the 3rd bit. Negating it with ~ creates a mask with all bits 1 except the 3rd bit 0.

2. Step 2: Use AND assignment to clear bit

   Applying &= with this mask clears the 3rd bit of num while keeping others unchanged.

3. Final Answer:

   num &= ~(1 << 3); -> Option A

4. Quick Check:

   AND with negated mask clears bit [OK]

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

Common Mistakes:

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

3. What is the output of the following C++ code?

int num = 10; // binary 1010
num ^= (1 << 1);
std::cout << num << std::endl;

medium

A. 8

B. 10

C. 12

D. 14

Solution

1. Step 1: Understand initial value and bit positions

   num = 10 in binary is 1010. Bits are indexed from 0 (rightmost). Bit 1 is currently 1.

2. Step 2: Toggle the 1st bit using XOR

   num ^= (1 << 1) toggles bit 1. Since bit 1 is 1, toggling it changes it to 0. New binary: 1000 (decimal 8).

3. Final Answer:

   8 -> Option A

4. Quick Check:

   Toggle bit 1 of 1010 = 1000 = 8 [OK]

Hint: XOR toggles bits; 1 flips, 0 stays same [OK]

Common Mistakes:

• Confusing toggle with set or clear
• Miscounting bit positions starting at 1 instead of 0
• Assuming XOR always sets bit

4. Identify the error in the following code snippet that attempts to clear the 2nd bit of num:

int num = 15;
num = num & (1 << 2);
std::cout << num << std::endl;

medium

A. It sets only the 2nd bit instead of clearing it

B. It toggles the 2nd bit instead of clearing it

C. It clears all bits except the 2nd bit

D. It causes a syntax error due to missing parentheses

Solution

1. Step 1: Analyze the mask used

   The mask (1 << 2) has only the 2nd bit set to 1, all others 0.

2. Step 2: Understand the effect of AND with mask

   ANDing num with this mask keeps only the 2nd bit of num and clears all others. This is opposite of clearing the 2nd bit.

3. Final Answer:

   It clears all bits except the 2nd bit -> Option C

4. Quick Check:

   AND with mask keeps bit, does not clear it [OK]

Hint: Use AND with negated mask to clear bits, not plain mask [OK]

Common Mistakes:

• Using mask directly instead of negated mask
• Confusing AND with OR for clearing bits
• Assuming AND with mask clears bit

5. Given an integer num, which expression correctly toggles the 0th bit only if it is currently set (1), otherwise leaves num unchanged?

hard

A. num ^= 1;

B. num &= ~1;

C. num |= 1;

D. if ((num & 1) == 1) num ^= 1;

Solution

1. Step 1: Check if 0th bit is set

   The condition (num & 1) == 1 checks if the least significant bit is 1.

2. Step 2: Toggle 0th bit only if set

   If the bit is set, num ^= 1 toggles it to 0. Otherwise, no change is made.

3. Final Answer:

   if ((num & 1) == 1) num ^= 1; -> Option D

4. Quick Check:

   Toggle only if bit set using condition [OK]

Hint: Check bit before toggling to avoid unwanted changes [OK]

Common Mistakes:

• Toggling bit unconditionally
• Using OR or AND which always set or clear bit
• Not checking bit state before toggle