Concrete mathematics : a foundation for computer science

84 INTEGER FUNCTIONS
more than one line’s worth of text. If 37 lines of text are being divided into
five columns, we would therefore prefer the arrangement on the right:
8 8 8 5 8 8 7 7 7
Furthermore we want to distribute the lines of text columnwise-first deciding
how many lines go into the first column and then moving on to the second,
the third, and so on-because that’s the way people read. Distributing row
by row would give us the correct number of lines in each column, but the
ordering would be wrong. (We would get something like the arrangement on
the right, but column 1 would contain lines 1, 6, 11, . . . , 36, instead of lines
1, 2, 3, . . ' ) 8 as desired.)
A row-by-row distribution strategy can’t be used, but it does tell us how
many lines to put in each column. If n is not a multiple of m, the rowby-row
procedure makes it clear that the long columns should each contain
[n/ml lines, and the short columns should each contain Ln/mJ. There will
be exactly n mod m long columns (and, as it turns out, there will be exactly
n mumble m short ones).
Let’s generalize the terminology and talk about ‘things’ and ‘groups’
instead of ‘lines’ and ‘columns’. We have just decided that the first group
should contain [n/ml things; therefore the following sequential distribution
scheme ought to work: To distribute n things into m groups, when m > 0,
put [n/ml things into one group, then use the same procedure recursively to
put the remaining n’ = n- [n/ml things into m’ = m- 1 additional groups.
For example, if n = 314 and m = 6, the distribution goes like this:
remaining things remaining groups [things/groups]
314 6 53
261 5 53
208 4 52
156 3 52
104 2 52
52 1 52
It works. We get groups of approximately the same size, even though the
divisor keeps changing.
Why does it work? In general we can suppose that n = qm + r, where
q = Ln/mJ and r = n mod m. The process is simple if r = 0: We put
[n/ml = q things into the first group and replace n by n’ = n - q, leaving