Arithmetic, Integer Division and the Modulo Trap

David reads three marks, adds them and divides by 3. The marks are 75, 82 and 82. His program prints 79.

He checks the sum on paper: 239. He checks the division: 79.67. The program is not wrong about the marks and it is not rounding. It is doing a different division from the one he meant.

Zara looks at the line for two seconds and says "all three of those are int". That is the whole lesson.

Five operators, and only one of them is strange

C has five arithmetic operators. Four of them behave the way school taught you.

a + b     sum
a - b     difference
a * b     product
a / b     quotient        integer division when both sides are integers
a % b     remainder       integers only, never a double

Every one of them takes two values and produces a third. Nothing is stored until you write an =.

#include <stdio.h>

int main(void)
{
    int a = 17;
    int b = 5;

    printf("sum        %d\n", a + b);
    printf("difference %d\n", a - b);
    printf("product    %d\n", a * b);
    printf("quotient   %d\n", a / b);
    printf("remainder  %d\n", a % b);
    return 0;
}

sum        22
difference 12
product    85
quotient   3
remainder  2

Read the last two lines together. 17 is three fives with 2 left over, and C hands you the two halves of that sentence separately.

The operands decide the division, not the box

This is the rule David needed. C looks at the two values beside the / and nothing else.

If both are integers, C does integer division: it divides and throws the fraction away. If either one is a double, C does real division.

The type of the variable you assign the answer to has no say in it. By the time the assignment happens, the fraction is already gone.

#include <stdio.h>

int main(void)
{
    int total = 239;

    double wrong = total / 3;
    double right = total / 3.0;

    printf("wrong %.2f\n", wrong);
    printf("right %.2f\n", right);
    return 0;
}

wrong 79.00
right 79.67

Both lines store into a double. Only the second one ever had a fraction to store.

So the fix is never on the left of the =. It is on the right, and it is one character: write 3.0, or cast one operand, which lesson 6 covers properly.

Integer division truncates toward zero

"Throws the fraction away" needs one more word when the answer is negative.

C does not round down. It cuts toward zero. So 7 / 2 is 3, and -7 / 2 is -3, not -4.

This was settled by C99. Older C left the negative case to the compiler, and you may still meet books that say so.

So integer division is not "round down". It is "drop the fraction", and those two sentences disagree on every negative number.

The remainder takes the sign of the left operand

Once division cuts toward zero, the sign of % follows from arithmetic. C guarantees that (a / b) * b + a % b equals a.

Work that backwards and the rule falls out: a % b has the sign of a, whatever b is.

#include <stdio.h>

int main(void)
{
    printf("  7 / 3 = %2d    7 %% 3 = %2d\n", 7 / 3, 7 % 3);
    printf(" -7 / 3 = %2d   -7 %% 3 = %2d\n", -7 / 3, -7 % 3);
    printf("  7 / -3 = %2d   7 %% -3 = %2d\n", 7 / -3, 7 % -3);
    printf(" -7 / -3 = %2d  -7 %% -3 = %2d\n", -7 / -3, -7 % -3);
    return 0;
}

  7 / 3 =  2    7 % 3 =  1
 -7 / 3 = -2   -7 % 3 = -1
  7 / -3 = -2   7 % -3 =  1
 -7 / -3 =  2  -7 % -3 = -1

%% inside a format string prints one percent sign. A single % there would start a specifier.

Read the second row twice. -7 % 3 is -1, and many languages answer 2 instead. Python does. C does not.

So a "wrap this number into the range 0 to 2" line written from Python habit is broken in C for negative input.

Digits, with nothing but / and %

These two operators together take a number apart. % 10 gives the last digit; / 10 removes it.

#include <stdio.h>

int main(void)
{
    int code = 4728;

    printf("last digit      %d\n", code % 10);
    printf("tens digit      %d\n", code / 10 % 10);
    printf("without the last %d\n", code / 10);
    printf("first digit     %d\n", code / 1000);
    return 0;
}

last digit      8
tens digit      2
without the last 472
first digit     4

The tens line reads left to right: divide by 10 first, then take the remainder. / and % have equal precedence, so they run in written order.

So digit work needs no loop and no string. Module 6 will loop over any number of digits; today the count is fixed and known.

Dividing by zero, twice, and neither is a rule

Integer division by zero is undefined behaviour. The standard places no requirement on the program at all.

On the Playground the program stops before printing and the run reports a failure. That is one thing it may do, not something to rely on.

Floating point is a different story. The Playground's compiler follows IEEE 754, where dividing by zero produces infinity.

#include <stdio.h>

int main(void)
{
    double zero = 0.0;

    printf("%f\n", 1.0 / zero);
    printf("%f\n", -1.0 / zero);
    return 0;
}

inf
-inf

Zero divided by zero gives nan instead, which means "not a number". Its printed spelling varies between libraries, so no output block here claims one.

So the honest summary is: guard the divisor yourself. Neither behaviour is a feature you should design around.

#include <stdio.h>

int main(void)
{
    printf("%d\n", 9 / 4);
    printf("%.2f\n", 9 / 4.0);
    return 0;
}

2
2.25

#include <stdio.h>

int main(void)
{
    int minutes = 0;
    scanf("%d", &minutes);

    int hours = minutes / 60;
    int left = minutes % 60;

    printf("%d h %d m\n", hours, left);
    return 0;
}

3 h 25 m

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    scanf("%d %d %d", &a, &b, &c);

    int total = a + b + c;
    double average = total / 3.0;

    printf("total   %d\n", total);
    printf("average %.2f\n", average);
    return 0;
}

total   239
average 79.67

double average = (75 + 82 + 82) / 3;
printf("%.2f\n", average);

double price = 7.5;
printf("%f\n", price % 2);

int index = -1;
printf("%d\n", index % 7);

printf("%d\n", 2 ^ 8);

#include <stdio.h>

int main(void)
{
    printf("%.1f\n", 7 / 2 * 2.0);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int n = 0;
    scanf("%d", &n);

    /* Hundreds with /, units with %, and the middle one needs both. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int m = 0;
    scanf("%d", &m);

    /* Example 2, with the output shape the statement asks for. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    scanf("%d %d %d %d", &a, &b, &c, &d);

    /* Add as integers. Divide by a number that has a decimal point. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int n = 0;
    int d = 0;
    scanf("%d %d", &n, &d);

    /* A comparison is worth 1 or 0, so print it with %d. No if needed. */

    return 0;
}

Next you stop calculating with numbers and start comparing them, and the answer to a comparison turns out to be a number too.