# Toggling k-th bit of a number

## Introduction

Toggling k-th bit of a number involves changing the state of a specific bit in a binary representation of a number from 0 to 1 or vice versa. This operation is commonly used in various algorithms and applications, such as data manipulation, bitwise operations, and setting or clearing flags in control registers.

In this guide, we will explore the concept of toggling the k-th bit and provide examples to help you understand and implement this operation effectively.

## Understanding Toggling k-th bit of a number

Toggling k-th bit of a number refers to the process of changing the state of a specific bit at position “k” within the binary representation of that number.

• If the k-th bit is currently 0, it is changed to 1, and if it’s 1, it is changed to 0.
• This operation is typically accomplished using bitwise XOR with a mask that has only the k-th bit set to 1, effectively flipping the bit’s value while leaving the other bits unchanged.

## Example :

Example 1:

Input: n = 12, k = 3
Output: 8

Explanation:

The binary representation of 12 is 1100. In binary, it has the third bit set to 1. By toggling the 3rd bit (k=3), we change it from 1 to 0, resulting in the binary representation 1000, which is equal to 8 in decimal.

Example 2:

Input: n = 75, k = 5
Output: 91

Explanation:

The binary representation of 75 is 1001011. In binary, it has the fifth bit set to 0. By toggling the 5th bit (k=5), we change it from 0 to 1, resulting in the binary representation 1011011, which is equal to 91 in decimal.

## Toggling a Bit: The XOR Operation

The most common method for toggling the k-th bit of a number is by using the XOR (^) operation. XORing a number with a mask that has only the k-th bit set will change the state of that bit, making it 0 if it was 1 and 1 if it was 0.

• Toggling the k-th bit: number ^ (1 << k)

## Program for Toggling k-th Bit

Here’s a code snippet :

```def toggle_kth_bit(num, k):
# Create a mask with only the k-th bit set to 1

# Use XOR to toggle the k-th bit

return result

#Let us take an example
number = 10  # Binary: 1010 (decimal 10)
k = 2       # Toggle the 2nd bit from the right

result = toggle_kth_bit(number, k)
print("The number after toggling the", k, "-th bit is", result)
```

### Output :

```The number after toggling the 2 -th bit is 8.
```

### Explanation :

The Python program toggles the 2nd bit of the number 10. It uses bitwise operations: it creates a mask with only the 2nd bit set to 1 (binary 0010) and then XORs it with the original number. This operation changes the 2nd bit from 1 to 0, resulting in 8. The program prints “The number after toggling the 2 -th bit is 14.”

## More Examples on Toggling K-th bit

Here’s a code snippet :

```def toggle_kth_bit(num, k):
# Create a mask with only the k-th bit set to 1

# Use XOR to toggle the k-th bit

return result

# Example usage:
number = 27  # Binary: 11011 (decimal 27)
k = 3       # Toggle the 3rd bit from the right

result = toggle_kth_bit(number, k)
print("The number after toggling the", k, "-th bit is", result)
```

### Output :

```The number after toggling the 3 -th bit is 31.
```

### Explanation :

The program toggles the 3rd bit of the number 27, which is represented as 11011 in binary. Using the XOR operation, it changes the 3rd bit from 0 to 1. The binary representation becomes 11111, equivalent to 31 in decimal. The program outputs “The number after toggling the 3 -th bit is 31,” demonstrating how to efficiently toggle specific bits in binary numbers.

## Practical Applications of Flipping i-th bit

Following are the practical application for toggling k-th bit of a number :

## Complexity analysis of Toogling k-th bit

The complexity analysis of toggling the k-th bit of a number is straightforward since it primarily involves bitwise operations, which are typically very efficient.

Time Complexity:

• The time complexity of toggling the k-th bit of a number is constant, O(1), because it involves a fixed number of bitwise operations, regardless of the size of the number or the bit position.
• In most programming languages, shifting and XOR operations are very efficient and can be performed in constant time.

Space Complexity:

• The space complexity is also O(1), as it doesn’t require any additional data structures or memory allocation.
• The original number, the mask, and the result all use constant space.
##### To wrap it up:

In conclusion, the operation of toggling the k-th bit of a number is : By employing bitwise XOR operations, developers can easily manipulate and control specific bits within numbers. This operation has widespread use in settings such as flag management, data compression, error correction, and hardware control.

### Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Question 1.

Can I toggle multiple bits at once?

Yes, you can toggle multiple bits simultaneously by using a bitmask that represents the combination of bits you want to change.

Question 2.

What is the difference between shifting and toggling a bit?

Shifting a bit involves moving it to a different position, while toggling a bit flips its value from 0 to 1 or from 1 to 0.

Question 3.

Why would I need to toggle a bit in a number?

Toggling bits is crucial in various applications, including configuration settings, data compression, error detection and correction, and low-level hardware control.

## Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others