NOT for inverting bits in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this bitwise NOT operation?

Consider the following C code snippet. What will be printed when it runs?

Embedded C

#include <stdio.h>

int main() {
    unsigned char x = 0b10101010;
    unsigned char y = ~x;
    printf("%u\n", y);
    return 0;
}

A 255

B 170

C 0

D 85

💡 Hint

Remember that ~ flips all bits, and unsigned char is 8 bits.

The original value x is 0b10101010 (decimal 170). The bitwise NOT (~) flips all bits, so y becomes 0b01010101, which is decimal 85.

❓ Predict Output

intermediate

What is the output when applying NOT to a signed integer?

Look at this C code. What will it print?

Embedded C

#include <stdio.h>

int main() {
    int x = 0;
    int y = ~x;
    printf("%d\n", y);
    return 0;
}

A 1

B 0

C -1

D 2147483647

💡 Hint

Think about how ~ works on zero in two's complement.

For a signed int, ~0 flips all bits from 000...0 to 111...1, which is -1 in two's complement.

❓ Predict Output

advanced

What is the output of this NOT operation on a 16-bit unsigned short?

Given this code, what will be printed?

Embedded C

#include <stdio.h>
#include <stdint.h>

int main() {
    uint16_t x = 0x00FF;
    uint16_t y = ~x;
    printf("0x%04X\n", y);
    return 0;
}

A 0xFF00

B 0x00FF

C 0xFFFF

D 0x0000

💡 Hint

NOT flips all bits in the 16-bit number.

0x00FF in binary is 0000000011111111. Flipping all bits gives 1111111100000000, which is 0xFF00.

❓ Predict Output

advanced

What is the output of this NOT operation on a signed char with value -1?

Analyze this code and determine the output.

Embedded C

#include <stdio.h>

int main() {
    signed char x = -1;
    signed char y = ~x;
    printf("%d\n", y);
    return 0;
}

A 0

B -128

C 127

D -1

💡 Hint

Remember that -1 in two's complement is all bits set to 1.

For signed char, -1 is 0xFF (all bits 1). ~x flips all bits to 0x00, which is 0.

🧠 Conceptual

expert

Why does using NOT (~) not always simply invert bits in embedded C?

Which statement best explains why applying the NOT operator (~) in embedded C might not always produce a simple bit inversion effect?

A Because the NOT operator only works on unsigned types and causes errors on signed types.

B Because the size of the data type affects how many bits are inverted, and sign extension can change the result.

C Because the NOT operator shifts bits instead of inverting them in embedded C.

D Because the NOT operator converts numbers to floating point before inverting bits.

💡 Hint

Think about how data types and sign affect bitwise operations.

The NOT operator flips all bits of the value, but the number of bits depends on the data type size. For signed types, sign extension and two's complement representation affect the final value, so the result might not look like a simple inversion.

Practice

1.

What does the ~ operator do in embedded C?

easy

A. It flips every bit of the operand (bitwise NOT).

B. It shifts bits to the left by one position.

C. It adds one to the operand.

D. It compares two values for equality.

Solution

1. Step 1: Understand the ~ operator

   The ~ operator is the bitwise NOT operator in C, which flips every bit of its operand.

2. Step 2: Compare with other options

   Other options describe different operations: shifting, addition, and comparison, which are not what ~ does.

3. Final Answer:

   It flips every bit of the operand (bitwise NOT). -> Option A

4. Quick Check:

   ~ operator = bitwise NOT [OK]

Hint: Remember ~ flips bits, like turning 0s to 1s and vice versa [OK]

Common Mistakes:

• Confusing ~ with shift operators
• Thinking ~ adds or subtracts
• Mixing ~ with logical NOT (!)

2.

Which of the following is the correct syntax to invert bits of an unsigned integer x in embedded C?

unsigned int x = 5;
unsigned int y = ?;

easy

A. y = x++;

B. y = !x;

C. y = ~x;

D. y = x & ~x;

Solution

1. Step 1: Identify the bit inversion syntax

   To invert bits, use the bitwise NOT operator ~ directly on the variable.

2. Step 2: Check other options for correctness

   y = !x; uses logical NOT, which returns 0 or 1, not bit inversion. y = x++; increments x, not invert bits. y = x & ~x; ANDs x with its inverse, resulting in zero.

3. Final Answer:

   y = ~x; -> Option C

4. Quick Check:

   Bit inversion syntax = y = ~x; [OK]

Hint: Use ~ directly on variable to invert bits [OK]

Common Mistakes:

• Using ! instead of ~
• Using increment operators by mistake
• Combining & with ~ incorrectly

3.

What is the output of the following code snippet?

unsigned char x = 0b00001111;
unsigned char y = ~x;
printf("%u", y);

medium

A. 240

B. 15

C. 0

D. 255

Solution

1. Step 1: Understand the initial value of x

   x is 0b00001111, which is decimal 15.

2. Step 2: Apply bitwise NOT to x

   ~x flips bits: 00001111 becomes 11110000 in 8 bits, which is decimal 240.

3. Final Answer:

   240 -> Option A

4. Quick Check:

   ~15 (8-bit) = 240 [OK]

Hint: Invert bits of 00001111 to get 11110000 = 240 decimal [OK]

Common Mistakes:

• Confusing logical NOT (!) with bitwise NOT (~)
• Forgetting unsigned type size
• Assuming output is 15 or 255

4.

Find the error in the following code that attempts to invert bits of num and print the result:

int num = 5;
int inverted = ~num;
printf("%u", inverted);

medium

A. The variable inverted should be unsigned char.

B. The ~ operator cannot be used on int types.

C. Missing semicolon after variable declaration.

D. Using %u to print a signed int causes incorrect output.

Solution

1. Step 1: Check the type and format specifier

   Variable inverted is signed int, but printed with %u (unsigned). This mismatch can cause wrong output.

2. Step 2: Verify other options

   The ~ operator works on int types. Semicolons are present. Changing to unsigned char is not necessary but can clarify output.

3. Final Answer:

   Using %u to print a signed int causes incorrect output. -> Option D

4. Quick Check:

   Format specifier must match variable type [OK]

Hint: Match printf format (%d for int, %u for unsigned) [OK]

Common Mistakes:

• Using wrong printf format specifier
• Thinking ~ can't be used on int
• Ignoring signed vs unsigned mismatch

5.

You want to invert bits of a 16-bit unsigned integer val but only for the lower 8 bits, leaving the upper 8 bits unchanged. Which code snippet correctly does this?

unsigned short val = 0xABCD;
unsigned short result = ?;

hard

A. result = ~val & 0xFFFF;

B. result = (val & 0xFF00) | (~val & 0x00FF);

C. result = ~val | 0xFF00;

D. result = val ^ 0xFFFF;

Solution

1. Step 1: Understand the requirement

   Invert only the lower 8 bits of val, keep upper 8 bits as is.

2. Step 2: Analyze each option

   result = (val & 0xFF00) | (~val & 0x00FF); keeps upper 8 bits (val & 0xFF00) and inverts lower 8 bits (~val & 0x00FF), then combines them. result = ~val & 0xFFFF; inverts all 16 bits. result = ~val | 0xFF00; incorrectly sets upper bits to 1. result = val ^ 0xFFFF; flips all bits (XOR with 0xFFFF).

3. Final Answer:

   result = (val & 0xFF00) | (~val & 0x00FF); -> Option B

4. Quick Check:

   Mask upper bits, invert lower bits, combine [OK]

Hint: Mask upper bits, invert lower bits, then combine [OK]

Common Mistakes:

• Inverting all bits instead of just lower 8
• Using OR instead of AND for masking
• Forgetting to combine masked parts