Party Planner

Arithmetic, and two kinds of division

C does sums with symbols close to the ones on paper:

• + adds
• - subtracts
• * multiplies, using a star rather than an x

So guests * slices_each means the guests multiplied by the slices each, worked out the moment that line runs. Division is where C hands you a choice you do not get on paper, and that choice is what this exercise is about.

Picture seventeen apples shared between five friends. There are two sensible answers, not one. The first is "three each" — how many whole apples everybody walks away with. The second is "two left in the bowl" — the ones that could not be shared out evenly. When both numbers are int, C gives you an operator for each:

• / counts the whole groups, truncated toward zero, so 17 / 5 is 3
• % reports what is left over, so 17 % 5 is 2

% has nothing to do with percentages here; it means remainder, the part that would not fit. Both operators hand back plain whole numbers, which is exactly what you want when the things being counted cannot sensibly be cut in half — apples, chairs, boxes, pizzas.

A worked example

#include <stdio.h>

int main(void) {
    int apples = 17;
    int friends = 5;
    int each = apples / friends;
    int over = apples % friends;

    printf("Apples each .. %d\n", each);
    printf("Left in bowl . %d\n", over);
    return 0;
}

Running that prints two lines:

Apples each .. 3
Left in bowl . 2

Two operators, the same pair of numbers, two different and equally true answers. The rows of dots are nothing clever — they are part of the text inside the quotes, doing the job of the ruled line on a paper form.

Your turn

The editor has a party to plan. Twenty-three guests are coming, each one will eat three slices, and a pizza turns up cut into eight.

The program already multiplies the guests by the slices to get the total number of slices wanted, and it already prints the whole summary block. Two lines are unfinished:

int pizzas = 0;
int extra = 0;

Replace each 0 with a sum built from slices_needed and per_pizza. Give pizzas the number of whole pizzas the order fills, and extra the slices that spill past them.

Then run it and read the block back. If the last two numbers still show 0, nothing has been changed yet — the program compiles and runs perfectly happily with zeros in it, it just plans a party with no food.

When it works you get a genuine answer: eight whole pizzas cover sixty-four slices, and five slices are still wanted on top. In real life you would order the ninth pizza and have three slices going spare.

If something goes wrong

C will not warn you that 69 / 8 throws away a remainder — that is simply what / does when both sides are int. If you want the fractional answer instead, 8.625, you would need at least one side to be a double, which the variables-and-types lesson covers; a pizza count has no use for it here.

The other thing worth watching is the two operators landing the wrong way round. Nothing breaks and the block prints as neatly as ever, but the figures stop hanging together. Leftover slices must always come to fewer than eight — if that line reads 8 or more, there is another whole pizza hiding inside it.

Change it, run it, change it again. Nothing here can break.