Problem: Identify Trap in Signed vs Unsigned Comparison. Solve this hands-on electronics task on EWskills.

#include <stdio.h> #include <stdint.h> int safe_compare(int8_t a, uint8_t b) { if (a < 0) { return 1; // Any negative number is less than any uint8_t } return (uint8_t)a < b; } int main() { int8_t a; uint8_t b; scanf("%hhd %hhu", &a, &b); printf("%d", safe_compare(a, b)); return 0; } What is the trap here? When comparing int8_t a = -1; and uint8_t b = 1;, the compiler promotes a to uint8_t, which becomes 255, so 255 < 1 becomes false — this is the trap. Why it matters in firmware? Sensor values, register flags, buffer sizes — mixing signed/unsigned is common Mistakes here can cause faulty condition checks, loops, and bugs that are hard to trace Solution Logic If a < 0, then clearly a < b regardless of b Else, safely cast a to uint8_t and compare

125. Identify Trap in Signed vs Unsigned Comparison

You are given two variables:

A signed 8-bit integer int8_t a
An unsigned 8-bit integer uint8_t b

Your task is to:

Compare them using if (a < b)
Return 1 if the condition is true, else 0

You must understand and handle the signed-to-unsigned promotion trap. Use your own logic to make the comparison accurate as per actual numeric intent.

Example-1

Input: a = -1, b = 1
Output: 1
(Since -1 is less than 1)

Example-2

Input: a = 250, b = 240
Output: 1
(Since a is int_8t, it can hold value -128 to +127 only, so if we assign 250 it will be considered as -6 in decimal)

Example-3

Input: a = -128, b = 255
Output: 1

Need Help? Refer to the Quick Guide below

This guide helps you understand all the tricky, often misunderstood arithmetic behaviors in C, especially relevant for firmware development where correctness and efficiency matter.

1. Unsigned Integer Overflow (Wraparound)

uint8_t a = 250;
uint8_t b = 10;
uint8_t c = a + b;  // c = 4

Why?

uint8_t can store 0 to 255.
250 + 10 = 260, but 260 % 256 = 4 (wraps around).
If we check it binary representation of 260= 1 0000 0100
If you check last 8-bits, it's value is 4, and uint8_t can hold only last last 8 bits, so it shows the value as 4 only.

2. Signed Integer Overflow (Undefined Behavior)

int8_t a = 120;
int8_t b = 10;
int8_t c = a + b;  // UB

Why?

int8_t max = 127. 120 + 10 = 130, which can't be represented.
As int8_t can hold value from (0 to +127) & (-1 to -127), where MSB bit (7th-bit) defines the sign. (1= negative, 0= positive)
C says signed overflow = undefined behavior.

3. Unsigned Integer Underflow (Wraparound)

uint8_t a = 5;
uint8_t b = 10;
uint8_t c = a - b;  // c = 251

Why?

5 - 10 = -5, but for unsigned: 256 - 5 = 251 (wraps backwards).

4. Signed Integer Underflow (Undefined Behavior)

int8_t a = -120;
int8_t b = 20;
int8_t c = a - b;  // UB

Why?

-120 - 20 = -140, which is less than -128. Undefined behavior.

5. Signed/Unsigned Comparison Trap

int a = -1;
unsigned int b = 1;
if (a < b)  // FALSE!

Why?

a is promoted to unsigned: becomes 4,294,967,295 (on 32-bit)
So a > b is actually true!

6. Mixing Signed and Unsigned in Addition

uint8_t a = 255;
int8_t b = -1;
int result = a + b;  // 254

Why?

Both are promoted to int: 255 + (-1) = 254.
Safe here, but not always — be cautious.

7. Promotion in Arithmetic (Truncation)

uint8_t a = 250, b = 10;
uint8_t sum = a + b;  // sum = 4

Why?

a + b = 260 (promoted to int), but assigned back to 8-bit → wraps to 4.

8. Division by Zero

int a = 5, b = 0;
int c = a / b;  // Undefined

Why?

Cannot divide by zero. Causes crash or exception.

9. Modulo by Zero

int a = 10, b = 0;
int c = a % b;  // Undefined

Why?

Same as division. Compiler may not catch it.

10. Negative Modulo Behavior

int a = -7, b = 3;
int r = a % b;  // -1

Why?

Result follows sign of dividend (a = -7), so result = -1.

11. Invalid Shift Amounts

int a = 1;
int b = -1;
a << b;       // Undefined
1 << 40;      // Undefined on 32-bit

Why?

Shifting by negative or >= width is undefined.

12. Left Shift Overflow (Signed)

int8_t a = 64;
a <<= 2;  // UB

Why?

64 << 2 = 256 → cannot be stored in 8-bit signed → UB.

13. Right Shift on Negative Values

int8_t a = -4;
int8_t b = a >> 1;  // May be -2 or 126

Why?

Depends on whether it's arithmetic or logical shift. Implementation-defined.

14. Unsigned Loop Trap

uint8_t i;
for (i = 3; i >= 0; i--)  // Infinite loop!

Why?

i never becomes < 0, it wraps to 255.

15. Pre/Post-Increment Chaos

int i = 1;
int x = i++ + ++i;  // UB

Why?

Multiple writes to i without sequence point. Result is undefined.

16. Float to Int Precision Loss

float f = 3.9;
int x = f;  // x = 3

Why?

Truncation happens — no rounding.

17. Integer Division Truncates

int a = 5, b = 2;
int result = a / b;  // 2

Why?

Fractions are discarded (5/2 = 2.5 → 2).

18. Casting Negative to Unsigned

int8_t a = -1;
uint8_t b = (uint8_t)a;  // 255

Why?

Two's complement conversion. -1 becomes 0xFF (255).

19. Float to Int Conversion

float f = -2.8;
int x = f;  // x = -2

Why?

Truncates toward zero.

20. Overflow in Compound Expressions

uint8_t a = 250, b = 10;
uint8_t c = (a + b) / 2;  // c = 2

Why?

a + b = 260 → wraps to 4 → 4 / 2 = 2

✔ Fix:

uint16_t temp = a + b;
uint8_t c = temp / 2;  // Correct: 130