Operators, I/O and selection, from the beginning

1 · An expression is a machine that makes a value

Every expression in C, from 2 + 3 to a-- && --b, is worked out to produce a single value. Some expressions also have a side effect: they change a variable on the way. Keep those two ideas apart and most trick questions come undone. a + 1 has a value and no side effect. a++ has a value and changes a.

The first rule that surprises people: dividing two ints throws the fraction away. It doesn't round. It chops towards zero.

printf("%d\n", 7 / 2);               // 3, not 3.5
printf("%d\n", 2*3/4 - 3/4*2);       // a past-paper question

For the second line, C works * and / before -, and it works operators of equal rank left to right. So 2*3/4 is 6/4 = 1 (the 0.5 is chopped), and 3/4*2 is 0*2 = 0, because 3/4 is already 0 before the *2 happens. The answer is 1 - 0 = 1. Order matters: 2*3/4 and 3/4*2 look like the same arithmetic, but they aren't.

2 · Mixing int and double

If either side of an arithmetic operator is a double (or float), C converts the other side up and does real division. So the fix for an average is to make one operand a double before the division happens:

int sum = 7, n = 2;
(double) sum / n      // 3.50: sum becomes 7.0 first, then 7.0 / 2
(double) (sum / n)    // 3.00: the int division already chopped to 3
sum / n * 1.0         // 3.00: same problem; 7/2 happened first

A cast, meaning a type name in brackets like (double) or (int), converts the single value right after it. Where you put it decides whether it helps. Going the other way, storing a real number in an int chops it silently. int x = 2.5; stores 2, and clang only warns: implicit conversion from 'double' to 'int' changes value from 2.5 to 2.

Remainders of negative numbers

% gives the remainder, and for negative numbers the remainder takes the sign of the left number: -7 % 2 is −1, and -7 / 2 is −3. That quietly breaks a common odd-number test:

int x = -3;
x % 2 == 1     // 0: false! -3 % 2 is -1, not 1
x % 2 != 0     // 1: the safe way to say "odd"
x % 2 == 0     // the even test is fine: -4 % 2 is 0

The 2024 paper's "negative even values" question relies on the even test working for negatives, and it does.

3 · True and false are just 1 and 0

C has no separate true/false type in these programs. A comparison like x < 5 produces the int 1 if true and 0 if false. Going the other way, anything that isn't 0 counts as true: if (7) runs, if (-3) runs, and only if (0) doesn't.

! flips this: !0 is 1, and ! of anything nonzero is 0. So !5 is 0 and !(-3) is 0.

Past papers love combining these with precedence, meaning which operator grabs its operands first. You don't need the whole C table; this ladder covers every question in the papers, strongest at the top:

Two consequences show up in exams. First, !x < 5 means (!x) < 5, because ! is rank 1. For x = 0 that's 1 < 5 = 1. clang notices and warns: logical not is only applied to the left hand side of this comparison. Second, 3 < 2 < 1 is not maths. It is (3 < 2) < 1 = 0 < 1 = 1. The clang on a Mac (version 21) refuses to compile it at all: error: chained comparison 'X < Y < Z' does not behave the same as a mathematical expression. Older compilers accept it silently, so in an exam, evaluate it the C way.

4 · && and || stop as soon as they know

&& is true only if both sides are true. So if the left side is already 0 (false), the answer is decided, and C does not evaluate the right side at all. || is true if either side is true, so if the left side is already nonzero, C skips the right side. This is called short-circuit evaluation.

On its own that is just efficiency. It matters when the skipped side had a side effect. A --b that is skipped never happens, so b keeps its value. That is the entire trick in several past-paper questions. Step through them below: the stepper highlights each piece as C evaluates it, and strikes through anything it skips.

Grouping matters too. Because && binds tighter than ||, !i && ++j || ++k means (!i && ++j) || ++k. With i = -3, !i is 0, so the && skips ++j. The left group is 0, so || must evaluate ++k. Final values: i = -3, j = 2, k = 1, m = 1.

5 · & is not &&

A single & is a completely different operator: bitwise AND. It writes both numbers in binary and keeps a 1 only where both have a 1 in the same position. Two consequences:

• Both sides are always evaluated. There is no short-circuit, so side effects on the right always happen.
• The result can be 0 even when both sides are "true". 1 & 4: 1 is 001 in binary and 4 is 100, with no 1s in common, so the result is 0. But 1 && 4 is 1.

This is the exact trap in two questions of the 2025 paper, and the official answer key fell into it both times. In Q2b the condition is (y>=0) & (x=x+1). The key assumed x only grows when y >= 0, which would be && behaviour, and answered 14. With &, x=x+1 runs on every pass, and 1 & 4 = 0 blocks a pass the key counted. Compiled, it prints 16. Use the last two buttons on the stepper above to see one pass each way. The same thing happens in Q2h, where a printf sits on the right of & and therefore runs every time: the output is 012348, not the key's 348.

Where & is the right tool: counting 1-bits

int n = 2273, count = 0, i = 1;
for (int j = 0; j < 32; j++) {
    if (n & i) count++;    // is bit j of n a 1?
    i = i << 1;            // move to the next bit: 1, 2, 4, 8, …
}
printf("%d", count);       // 5

i holds a single 1-bit that moves left each pass (i << 1 doubles it). n & i is nonzero exactly when n has a 1 in that position. So the loop counts the 1s in n's binary form.

6 · ++, --, the comma, and = in a condition

You met i++ and ++i in the loops lesson. Postfix hands over the old value and then changes the variable; prefix changes it first and hands over the new value. Past papers hide one inside a condition:

int i = 0;
do {
    if (i == 3) break;
    printf("%d ", i);
} while (i++);       // prints just: 0

First pass: prints 0. Then while (i++) tests the old value, 0, which is false, so the loop ends, even though i has become 1. The output is 0, not 0 1 2.

The comma operator

Inside brackets, a comma between expressions means: evaluate each one left to right, throw every value away except the last, and use that.

int a = 7;
int c = (a >= 7) ? a++ : ++a;     // c = 7, then a = 8
int b = (a+1, c+1, 100, a+c);     // b = a+c = 8+7 = 15

a+1, c+1 and 100 are computed and discarded (clang warns left operand of comma operator has no effect). Only a+c survives. The brackets are essential: without them, the commas would be separating things in the declaration instead.

= inside a condition

if (x = 0) is not a comparison. It assigns 0 to x, and the value of an assignment is the value stored, here 0, so the if is always false. clang warns using the result of an assignment as a condition without parentheses. Sometimes it's deliberate, as in the (x = x + 1) of the 2025 question; usually it's a typo for ==.

7 · Characters are small numbers

A char is stored as an integer code (ASCII). The digit characters '0'…'9' are codes 48…57 in order, the letters 'a'…'z' are 97…122 in order, and pressing Enter sends code 10, written '\n'. Because they're numbers, you can do arithmetic on them:

char c = '7';
printf("%d", c);         // 55: the code
printf("%d", c - '0');   // 7: the digit's value, because 55 - 48 = 7
printf("%c", 'a' + 2);   // c
'z' > 'd'                // 1: letters compare alphabetically

c - '0' is the standard way to turn a digit character into its value. The 2024 paper's 10-mark program hangs on it: read characters until code 10, add up the digit values, and keep the alphabetically highest letter.

8 · if, else, and which if an else belongs to

Nested ifs make a decision tree, and reading one is a matter of following one branch at a time. Here is the 2024 paper's Q12:

if (a > b)
    if (b > c)  printf("s1");
    else        printf("s2");
else
    if (a > c)  printf("s3");
    else        printf("s4");

The path to s2 is "yes, then no", and a "no" to b > c means b <= c, including equality. Options that say b < c lose the equal case. The right option is (c): b < a and b <= c.

The dangling else

Without braces, an else always belongs to the nearest earlier if that doesn't have one yet. Indentation means nothing to the compiler:

int a = 3, b = 5;
if (a > b)
    if (a > 0) printf("x");
else                         // looks like it pairs with a > b …
    printf("y");             // … but it pairs with a > 0
printf("end");               // output: end   (no y!)

Since a > b is false, the whole inner if … else is skipped, and nothing but end prints. clang flags it: add explicit braces to avoid dangling else. The cure is braces, always.

9 · ? : is an if that produces a value

condition ? X : Y evaluates the condition and then only one of X or Y. The whole thing has that value. It's the one C operator with three parts, and its job is to let a choice sit inside an expression:

max = (a > b) ? a : b;

Chains read from left to right like an else-if ladder, because each : leads into the next question. The 2024 paper asked for this rewrite of a grade ladder:

grade = (score >= 90) ? 'A' :
        (score >= 80) ? 'B' :
        (score >= 70) ? 'C' :
        (score >= 60) ? 'D' : 'F';     // score 85 gives 'B'

Because only the chosen branch runs, a ?: can pick which printf happens. printf is a function that returns a value, so it's allowed in an expression: (a == 1) ? printf("One") : (a == 2) ? printf("Two") : printf("Other"); prints Other for a = 5.

10 · switch: jump in, then fall through

A switch is not a set of separate little ifs. It works like this:

1. Evaluate the expression in switch ( … ) once.
2. Jump to the case label with that value. If there's no such label, jump to default, wherever it sits. If there's no default either, skip the whole block.
3. From there, run statements downwards, straight through any later labels, until a break or the closing brace.

Step 3 is the one people forget. The labels are only entry points; they don't stop anything.

Two more past-paper shapes. In 2024 P1 Q7, default is written first, but position doesn't matter: with a = 50, C jumps straight to case 50, runs a-- and breaks, giving 49. default is only used when nothing matches. In 2026 Q2(b), a positive/negative/zero program has no breaks at all, so for a positive number it prints PositiveZero: it enters at case 1 and falls into default. The fix is a break after each case.

11 · scanf reads by pattern; printf returns a count

Think of scanf's format string as a pattern it tries to match against what was typed, left to right, one piece at a time:

• %d and %f first skip any spaces or newlines, then read as many characters as make sense for a number, and stop at the first one that doesn't.
• A width caps how many characters that piece may take: %2d reads at most 2, and %5f at most 5 (the decimal point counts).
• A space in the format means "skip any amount of whitespace here, including none".
• Any other character in the format, such as the - in "%d-%d", must appear exactly in the input. If it doesn't, scanf stops right there and leaves the remaining variables untouched.
• %c does not skip whitespace: it takes the very next character, even a space or an Enter. Write " %c" to skip whitespace first.

Trace 2024 P1 Q2, scanf("%2d %5f %2d", &n, &x, &m) with input 1234.5678 99.88 777:

The output is n= 12,x=34.56,m = 78, and the numbers typed later are never read. In 2024 P1 Q15, scanf("%d-%d", &n, &m) with input 10 20: n gets 10. The next input character is a space, but the format wants a literal -, so scanf gives up and m keeps its initial 0. It prints 10-0.

Match the type letter to the variable, too: %d for int, %f for float, %lf for double, %Lf for long double, %c for char, %u for unsigned int. A mismatch compiles, and clang warns, e.g. format specifies type 'double *' but the argument has type 'long double *'.

printf gives back a number

printf returns how many characters it printed. printf("Hello") prints Hello and has the value 5. The 2024 paper used this to print "HelloWorld" with an if/else where normally only one branch could run:

if (!printf("Hello"))    // prints Hello; value 5; !5 is 0 → false
    printf("Hello");
else
    printf("World");     // runs: output HelloWorld

For output formats: %5.2f means a field at least 5 characters wide with 2 decimals, so 3.14159 prints as 3.14. %.1f rounds to one decimal: 2.75 prints as 2.8.

12 · The rewrite questions

Two papers had a whole section of "rewrite this using…" questions: 20 marks in 2024, and part of 24 in 2025. They test whether you know what each construct means, so learn the three conversions as templates.

switch → nested if-else, with no else if

Each case becomes a test, and "everything else" goes inside the else's braces. The brace nesting is what "no else-if" is checking:

if (drink == 1) {
    printf("Soda: 20 INR\n");
} else {
    if (drink == 2) {
        printf("Juice: 25 INR\n");
    } else {
        if (drink == 3) printf("Water: 10 INR\n");
        else            printf("Invalid selection\n");   // the default
    }
}

if-else ladder ↔ ?: chain

Each if (cond) x = V; becomes cond ? V :, and the final else value ends the chain (the grade example in §9). Go the other way just as mechanically.

for → do-while (and nested)

Move the for's three parts to where a do-while keeps them: initialisation before the do, update at the end of the body, condition in the while. For nested loops, the inner loop's initialisation goes inside the outer body, so it restarts every row:

int count = 1, i = 0;
do {
    int j = 0;                      // inner init: inside, so it resets each row
    do {
        printf("%d ", count);
        count++;
        j++;
    } while (j < 3);
    printf("\n");
    i++;
} while (i < 3);                    // prints 1 2 3 / 4 5 6 / 7 8 9

13 · You're ready: what to do next

That's the whole small print: values and side effects, conversion, 1 and 0, short-circuit, bitwise &, comma, characters, nesting, ?:, switch, and scanf's patterns. To turn it into marks:

• Operators & selection notes: rule cards, three exam-level worked examples, the trap table, and links to every past-paper question on this topic.
• Operators predict-the-output drill: generated questions in these exact shapes, marked instantly. One sheet a day until the mid-sem.
• Past mid-sem papers: every question verbatim, with traced answers and the key's mistakes flagged.