Checking if a bit is set in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this bit check code?

Consider the following C code snippet that checks if the 3rd bit (bit index 2) of a number is set. What will be printed?

Embedded C

unsigned int num = 10; // binary 1010
if (num & (1 << 2)) {
    printf("Bit is set\n");
} else {
    printf("Bit is not set\n");
}

A Bit is not set

B Bit is set

C Compilation error

D Runtime error

💡 Hint

Remember that bits are counted from 0 starting at the least significant bit.

The number 10 in binary is 1010. The bits are indexed 3 2 1 0 from left to right. Bit 2 (third bit) is 0, so the condition is false and "Bit is not set" is printed.

❓ Predict Output

intermediate

What does this code print when checking bit 0?

Given the code below, what will be the output?

Embedded C

unsigned char val = 1; // binary 00000001
if (val & 1) {
    printf("LSB is set\n");
} else {
    printf("LSB is not set\n");
}

A Compilation error

B LSB is not set

C LSB is set

D Runtime error

💡 Hint

LSB means least significant bit, which is bit 0.

The value 1 in binary is 00000001, so bit 0 is set. The condition is true and "LSB is set" is printed.

❓ Predict Output

advanced

Output of checking bit 5 in a signed integer

What will this code print?

Embedded C

int x = -32; // binary representation depends on two's complement
if (x & (1 << 5)) {
    printf("Bit 5 is set\n");
} else {
    printf("Bit 5 is not set\n");
}

A Bit 5 is not set

B Bit 5 is set

C Undefined behavior

D Compilation error

💡 Hint

Remember two's complement representation for negative numbers.

In two's complement, -32 is represented with bit 5 set (since 32 = 1 << 5). So the bitwise AND is non-zero and "Bit 5 is set" is printed.

❓ Predict Output

advanced

What error does this code produce?

What error will this code cause?

Embedded C

unsigned int num = 5;
if (num & (1U << 32)) {
    printf("Bit 32 is set\n");
} else {
    printf("Bit 32 is not set\n");
}

A Undefined behavior due to shift overflow

B No error, prints "Bit 32 is not set"

C Compilation error

D Runtime error

💡 Hint

Check the size of unsigned int and the shift operation limits.

Shifting 1 by 32 bits on a 32-bit unsigned int is undefined behavior in C. This can cause unpredictable results or runtime errors.

🧠 Conceptual

expert

How many bits are set in this mask?

Given the mask 0xAA55 (hexadecimal), how many bits are set to 1 in its 16-bit binary representation?

A 12

B 6

C 10

D 8

💡 Hint

Convert hex to binary and count the 1s.

0xAA55 in binary is 1010101001010101. Counting the 1s gives 8 bits set.

Practice

1. What does the expression (num & (1 << 3)) != 0 check in embedded C?

easy

A. If the 1st bit (bit 0) of num is set to 1

B. If the 4th bit (bit 3) of num is set to 1

C. If num is equal to 8

D. If num is an even number

Solution

1. Step 1: Understand the bit shift operation

   The expression 1 << 3 shifts 1 left by 3 bits, creating a mask with only the 4th bit set (value 8).

2. Step 2: Apply bitwise AND to check the bit

   The bitwise AND num & (1 << 3) isolates the 4th bit of num. If this result is not zero, the bit is set.

3. Final Answer:

   Checks if the 4th bit (bit 3) of num is set to 1 -> Option B

4. Quick Check:

   Bitwise AND with mask = non-zero means bit set [OK]

Hint: Use (1 << bit) & num to check bit set quickly [OK]

Common Mistakes:

• Confusing bit position with bit value
• Forgetting bits start at 0
• Using OR instead of AND to check bits

2. Which of the following is the correct syntax to check if the 2nd bit (bit 1) of variable x is set in embedded C?

easy

A. if (x & 1) { /* bit is set */ }

B. if (x | (1 << 1)) { /* bit is set */ }

C. if (x << 1) { /* bit is set */ }

D. if (x & (1 << 1)) { /* bit is set */ }

Solution

1. Step 1: Identify the mask for bit 1

   The mask for the 2nd bit is 1 << 1, which equals 2.

2. Step 2: Use bitwise AND to check the bit

   Using x & (1 << 1) checks if bit 1 is set. If the result is non-zero, the bit is set.

3. Final Answer:

   if (x & (1 << 1)) { /* bit is set */ } -> Option D

4. Quick Check:

   Bitwise AND with shifted 1 checks bit [OK]

Hint: Use & with (1 << bit) to check bits, not | or << alone [OK]

Common Mistakes:

• Using bitwise OR (|) instead of AND (&)
• Using left shift on variable instead of mask
• Checking wrong bit position

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

unsigned int num = 13; // binary 1101
if (num & (1 << 2))
    printf("Bit 2 is set\n");
else
    printf("Bit 2 is not set\n");

medium

A. Compilation error

B. Bit 2 is not set

C. Bit 2 is set

D. No output

Solution

1. Step 1: Convert num to binary and identify bit 2

   Number 13 in binary is 1101. Bits are numbered from 0 (rightmost). Bit 2 is the third bit from right, which is 1.

2. Step 2: Check bit 2 using bitwise AND

   The expression num & (1 << 2) equals 13 & 4 which is 4 (non-zero), so the condition is true.

3. Final Answer:

   Bit 2 is set -> Option C

4. Quick Check:

   Bit 2 in 1101 is 1, so output is "Bit 2 is set" [OK]

Hint: Convert number to binary, check bit position with mask [OK]

Common Mistakes:

• Miscounting bit positions starting at 1 instead of 0
• Assuming bit 2 is zero without checking
• Confusing bitwise AND with OR

4. The following code is intended to check if bit 5 of flags is set. What is the error?

unsigned int flags = 0x20;
if (flags & 5 << 1) {
    // bit is set
}

medium

A. Incorrect operator precedence causes wrong mask

B. Bit shift should be on variable, not constant

C. Missing parentheses around bit shift

D. Using bitwise OR instead of AND

Solution

1. Step 1: Analyze operator precedence in expression

   The expression flags & 5 << 1 is evaluated as flags & (5 << 1) due to operator precedence (<< higher than &).

2. Step 2: Understand the intended mask and fix

   The intended mask is 1 << 5 to check bit 5. The current expression does not create the correct mask.

3. Final Answer:

   Incorrect operator precedence causes wrong mask -> Option A

4. Quick Check:

   Use parentheses: flags & (1 << 5) to fix [OK]

Hint: Always use parentheses around (1 << bit) mask [OK]

Common Mistakes:

• Not using parentheses causing wrong evaluation
• Shifting wrong constant (5 instead of 1)
• Confusing bit positions and mask values

5. You have an 8-bit status register status. Write a condition to check if either bit 1 or bit 3 is set. Which of the following is correct?

hard

A. if (status & ((1 << 1) | (1 << 3))) { /* bit 1 or 3 set */ }

B. if ((status & (1 << 1)) && (status & (1 << 3))) { /* bit 1 or 3 set */ }

C. if (status | (1 << 1) | (1 << 3)) { /* bit 1 or 3 set */ }

D. if (status & (1 << (1 + 3))) { /* bit 1 or 3 set */ }

Solution

1. Step 1: Create mask for bits 1 and 3

   Use bitwise OR to combine masks: (1 << 1) | (1 << 3) creates a mask with bits 1 and 3 set.

2. Step 2: Use bitwise AND to check if either bit is set

   Check if status & mask is non-zero to confirm if either bit is set.

3. Final Answer:

   if (status & ((1 << 1) | (1 << 3))) { /* bit 1 or 3 set */ } -> Option A

4. Quick Check:

   Combine masks with |, check with & for any bit set [OK]

Hint: Combine bit masks with | inside parentheses before & [OK]

Common Mistakes:

• Using && instead of | to combine masks
• Using + instead of | causing wrong mask
• Using bitwise OR on variable instead of mask