Problem: Bit Toggle. Solve this hands-on electronics task on EWskills.

Approach: In binary, toggling a bit can be done using the XOR (^) operator. The 5th bit (0-based index) is represented by 1 << 5 , which equals 32 (decimal) . N ^ 32 flips only the 5th bit of N. Code Implementation: #include <stdio.h> int toggleFifthBit(int n) { return n ^ (1 << 5); // Toggle the 5th bit using XOR } int main() { int n; scanf("%d", &n); printf("%d", toggleFifthBit(n)); return 0; } Explanation: If the 5th bit is 0 , XOR with 32 will set it to 1 . If the 5th bit is 1 , XOR with 32 will reset it to 0 . Time Complexity: O(1) (constant time operation). Space Complexity: O(1) (no extra space used).

2. Bit Toggle

Write a C program to toggle the 5th bit (0-based index) of a given integer.

The program should take an integer N as input.
It should toggle the 5th bit of N (i.e., flip the bit at position 5: if 0, make it 1; if 1, make it 0).

Note: The 5th bit is at position 5(0-based indexing). For example, in the binary number 100100, the 5th bit is 1.

Examples

Input: 10
Explanation:
Binary representation of 10 is 00001010.
Toggling the 5th bit (position 5) results in 00101010, which is 42 in decimal.
Expected Output: 42
Input: 31
Explanation:
Binary representation of 31 is 00011111.
Toggling the 5th bit (position 5) results in 01011111, which is 95 in decimal.
Expected Output: 95
Input: 0
Explanation:
Binary representation of 0 is 00000000.
Toggling the 5th bit (position 5) results in 00100000, which is 32 in decimal.
Expected Output: 32

Need Help? Refer to the Quick Guide below

In C, bitwise operations allow direct manipulation of individual bits within a byte, word, or register. These operations are performed using the following operators:

| → Bitwise OR — typically used to set a bit
& → Bitwise AND — used to clear or check a bit
^ → Bitwise XOR — used to toggle (invert) a bit
~ → Bitwise NOT — used to flip all bits (1 to 0, 0 to 1)
<<, >> → Bit shift left/right — used to move bit positions

Common bit-masking patterns:

reg |= (1 << n);     // Set bit n
reg &= ~(1 << n);    // Clear bit n
reg ^= (1 << n);     // Toggle bit n
if (reg & (1 << n))  // Check if bit n is set

These operations are used to target and modify only specific bits, without disturbing others.

8-bit Visualization Example

Bit	7	6	5	4	3	2	1	0
Value	128	64	32	16	8	4	2	1

E.g.

To set bit 3 → reg |= (1 << 3)
To clear bit 6 → reg &= ~(1 << 6)
To check bit 0 → reg & (1 << 0)
To toggle but 3 → reg ^= (1 << 3)

32-bit Register Usage

Bitwise techniques apply the same way for uint32_t types — often used in 32-bit MCUs for status/configuration registers.

Example:

ctrl_reg |= (1U << 23); // Set bit 23 in a 32-bit control register

Common Pitfalls (Practical Tips)

Forgetting parentheses: 1 << n must be inside parentheses during masking:
✅ reg |= (1 << 4) vs ❌ reg |= 1 << 4 & 0xF
Using signed types: Never use int for register work — use uint8_t, uint16_t, or uint32_t.
Signed values may cause undefined behavior when shifting, as MSB (Most Significant Bit) used for sign.
Wrong shift width: Shifting more than the data type width (e.g. 1 << 32 on a 32-bit int) is undefined.
Accidental overwrite:

reg = (1 << 2); // WRONG: overwrites entire register  
reg |= (1 << 2); // RIGHT: sets only the 2nd bit

Check before toggle: Be careful when toggling flags — you may unintentionally clear a set flag.

Relevance in Embedded/Firmware

All MCU peripherals are controlled via register bits — timers, GPIOs, UART, ADC, interrupts, etc.
Bit masking ensures safe modification without overwriting unrelated fields.
Used in flags, control masks, interrupt status checks, and power/clock configuration.