ioccc/1993/plummer

To build:

    make alt

We recommend that you try the alternate version first to get a better idea of what this entry looked like back in 1993. The alternate version sleeps (via usleep(3)) in between writes, defaulting at 1000 microseconds (but reconfigurable). If you wish to see the original entry then see original code below.

If you wish to speed the entry up, say to 500 microseconds between writes, try:

    make clobber SLEEP=500 alt

Alternatively if you wish to slow it down, say to 1500 microseconds between writes, try:

    make clobber SLEEP=1500 alt

To use:

    ./plummer.alt number arg

where:

• number is a number (try 21701)
• arg is any argument

Wait until you're bored enough to send intr/ctrl-c to exit or until the Vogons build that hyperspace bypass.

Try:

    ./try.alt.sh

    ./try.alt.sh 21701

    SLEEP=500 ./try.alt.sh

    SLEEP=900 ./try.alt.sh 789789789789789

    ./try.alt.sh 789789789

    SLEEP=400 ./try.alt.sh 42424242424242

    SLEEP=1000 ./try.alt.sh xyzzyzzyx

    SLEEP=1200 ./try.alt.sh xyzzyzzyx 5555

Original code:

This version, the original, does not sleep in between writes, and is thus much faster, at least with modern systems.

Original build:

    make all

Original use:

Use plummer as you would plummer.alt above.

Original try:

    ./try.sh

    ./try.sh 21701

    ./try.sh 789789789789789

    ./try.sh 789789789

    ./try.sh 42424242424242

    ./try.sh xyzzyzzyx

    ./try.sh xyzzyzzyx 5555

Judges' remarks:

For extra credit: What happens when 'number' contains non-numeric characters, and why?

Author's remarks:

This program prints out all numbers up to a given number of digits on a single line. When the largest number is reached, the program starts again with 0. It takes two arguments: the first argument specifies the number to start counting from and uses leading 0s to indicate the number of digits, the second argument can be anything but must be present.

Variable names are single characters chosen for their similarity to other characters (O for 0 (zero), l for 1 (one), S for 5 (five) in some fonts, and _ for ... well nothing really, but it is easy to miss). To prevent the need for strlen(3), the fact that argv is laid out sequentially is exploited (i.e. argv[i + 1] == argv[i] + strlen(argv[i]) + 1). This is not portable (by the books), but it seems to work everywhere I try (actually, for VMS, that only holds for i > 1). Also, I depend on the fact that a carriage return causes the line just written to be overwritten. lint (and most compilers) complain that there is no control path leading to a return from main(). At 125 characters, it still fits on a single line (for those of us who don't mind ruining our eyes with 132 column screens).

NOTICE to those who wish for a greater challenge:

If you want a greater challenge, don't read any further: just try to understand the program via the source.

If you get stuck, come back and read below for additional hints and information.

How this entry works:

The first statement points the base of l (the argument vector) to be the first argument by incrementing it. It then assigns O to point to the character before the first character of the second argument which also happens to be the NUL termination of the first argument. *O gets a \r assigned to it. Finally 0 is assigned to the first character of the second argument which has the effect of NUL terminating the first argument after the carriage return had removed its NUL termination. I really tried to make the last part of that statement part of the original expression, but the best I could do was attach it with a comma (against the advice of K&R). The for loop runs the next for loop continuously (actually until the machine crashes or the user gets tired of seeing the counting). The next for loop is the meat of the program. In the initialization statement, the string pointed to by l (the first argument containing the digits used for counting followed by a \r) is printed, and _ is started at the least significant digit in the string. In the test portion, _ is ensured not to be past the beginning of the string (the most significant digit), and the digit pointed to by _ is incremented and checked to be sure that it is greater than 9 (written here as (S+*O+S)*S). If the test fails, either the string has been incremented or each digit in the string has been reset to 0. If the test succeeded, the iteration statement assigns 0 (written here as (S+*O)*S (which has the added bonus of having the code be a cry for help)) to *_ and decrements _ to point to the next more significant digit to be incremented; it is done only when a carry situation results (*_ has been incremented past 9).

The inspiration for this program came from actual code which dealt with scanning for a unique temporary filename by appending a successively larger number to the end of a string.