roman numeral printer

/* Int to roman numeral printer by Braden Best (2015) */

#include <stdio.h>

typedef enum{
    I  = 1,
    IV = 4,
    V  = 5,
    IX = 9,
    X  = 10,
    XL = 40,
    L  = 50,
    XC = 90,
    C  = 100,
    CD = 400,
    D  = 500,
    CM = 900,
    M  = 1000,
} Roman_Numeral;

const Roman_Numeral numerals[] = {M, CM, D, CD, C, XC, L, XL, X, IX, V, IV, I};

const char *roman_str(Roman_Numeral r){
    switch(r){
        case I:  return "I";
        case IV: return "IV";
        case V:  return "V";
        case IX: return "IX";
        case X:  return "X";
        case XL: return "XL";
        case L:  return "L";
        case XC: return "XC";
        case C:  return "C";
        case CD: return "CD";
        case D:  return "D";
        case CM: return "CM";
        case M:  return "M";
    }
}

void print_roman(int n){
    int i = 0;
    while(n){
        while(n >= numerals[i]){
            n -= numerals[i];
            fputs(roman_str(numerals[i]), stdout);
        }
        i++;
    }
}

int main(int argc, char **argv){
    int n;
    for (n = 1; n <= 2000; n++){
        printf("%i = ", n);
        print_roman(n);
        printf("\n");
    }
    return 0;
}

/* Prints roman numerals for n {1..2000} */

/* How it works:
 *
 * It's a simple matter of reduction. I start from the largest unit, M, and subtract 1,000 until N < 1000, then continue with progressively smaller units.
 *
 * You'd think IV, IX, etc would be tough to sort out, but when you think of them as a single unit, rather than two separate units, it becomes clear that IX, for example, explicitly means 9, and nothing else. 1999 is MCMXCIX, or M(1000) CM(900) XC(90) IX(9)
 * Roman numerals are actually very simple.
 *
 * However, with 13 possible units, this means either an absurdly ugly if-else chain or 13 while loops. Do not lower yourself to doing this. There is always a better way.
 *
 * So I defined an enumerated type, a lookup function to complement it, and a reducer function to do the job of what would be 13 while loops.
 *
 * The code is now far more readable, with a clear intent, and no need to be riddled with comments explaining every line, as every line is more or less self-explanatory depending on one's skill level.
 *
 * Remember, you will read your code far more than you will write it, so it's essential to know how to make it easily readable. If you can only remember one 'golden rule' for the rest of your life, make it this one.
 *
 * And I urge you to study the above code to understand it.
 */

/*

Updates:

Removed reducer(), combined with print_roman()

Moved Roman_Numeral array to global namespace as a constant to save a little bit on performance. Instead of re-creating the array every time the function is loaded, the array is created once.

print_roman() now runs until n == 0, rather than until it reaches the end of the array.

Removed leftover <stdlib.h> from the char * version of print_roman(), which used malloc()

*/