#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char const * const unites[]     = {"zero", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf"};
char const * const unites_irr[] = {"onze", "douze", "treize",  "quatorze", "quinze", "seize"};
char const * const dizaines[]   = {"dix", "vingt", "trente",  "quarante", "cinquante", "soixante", "soixante", "quatre-vingt", "quatre-vingt"};
char const * const centaines[]  = {"cent", "mille", "million", "milliard", "billion", "trillion", "quatrillion", "quintillon"};

void
error (char * msg) {
    fprintf(stderr, "Erreur : %s.\n", msg);
}

char*
removeZeroes (char * s) {
 while (*s == '0')
        ++s;

    return s;
}

void
trim (char * s) {
    int i, j;

    for (i=j = 0; s[i] != '\0'; i++) {
        s[j] = s[i];
        if (s[i] != ' ')
            j++;
    }
    s[j] = '\0';
}

void
_centaine (char * src, char * dst, int index) {
    int centaine = *src-'0';
    int dizaine = *(src+1)-'0';
    int unite = *(src+2)-'0';

    if (centaine > 1) {
        strcat(dst, unites[centaine]);
        strcat(dst, " ");
    }
    strcat(dst, "cent");

    if (index != 2 && centaine > 1 && 0 == dizaine+unite) { /* Doit-on rajouter un 's'  */
        strcat(dst, "s");
    }
}

/**
 * Retourne irr
 * irr = 0 => pas d'irregularite
 * irr = 1 => sauter les unitees
 * irr = 2 => unitees irregulieres (onze, douze, ...)
 */
int
_dizaine (char * src, char * dst, int index) {
    int irr = 0;
    int dizaine = *src-'0';
    int unite = *(src+1)-'0'; /* Equivalent a : src[1]-'0'  */

    if (dizaine != 0) {
        if (7 == dizaine || 9 == dizaine || (dizaine == 1 && 0 < unite && unite < 7)) { /* Les unites seront-elles irrégulières ? */
            irr = 2;
        }

        if (!(dizaine == 1 && 0 < unite && unite < 7)) {
            /* la dizaine ne vaut pas 1 et unite n'appartient pas à l'intervalle ]0, 7[ */
            strcat(dst, dizaines[dizaine-1]);
        } else {
            /* Cas de onze, ..., seize */
            strcat(dst, unites_irr[unite-1]);
            irr = 1; /* On doit donc sauter les prochaines unites */
        }

        if ( !(0 < unite && unite < 7) && (7 == dizaine || 9 == dizaine)) { /* Soixante-dix et quatre-vingt-dix */
                strcat(dst, "-dix");
                irr = 0;
            }

        if (0 == unite) {
            irr = 1; /* On saute les unites puisque elles sont nulles */
            if (8 == dizaine && index != 2) { /* On n'a pas affaire à qatre-vingt mille :  */
                strcat(dst, "s");
            }
        }
    }

    return irr;
}

void
_unite (char * src, char * dst, int dizaine, int irr) {
    int unite = *src-'0';

    if (unite != 0) {
        if (0 == dizaine) {
            strcat(dst, unites[unite]);
        } else {
            if (1 == unite) {
                if (8 == dizaine || 9 == dizaine) { /* quatre-vingt-un et quatre-vingt-onze */
                    strcat(dst, "-");
                } else {
                    strcat(dst, " et ");
                }
            }
            if (unite != 1) {
                strcat(dst, "-");
            }
            if (2 == irr) {
                    strcat(dst, unites_irr[unite-1]);
            } else {
                strcat(dst, unites[unite]);
            }
            
        }
    }

}

char*
z0zero (char * src, char * dst) {
    int index; /* Sert à savoir sur quel bloc on travail, centaines, milliers, millions, etc, ...  */
    int SIndex; /* Sert à savoir si on travaille sur une unite (=0), une dizaine (=1), une centaine (=2)  */
    char * tmp, * for_free; /* Copie de src */
    int irr;
    size_t len, i;
    div_t blocks;

    tmp = malloc (strlen(src)+1); /* Sous entendu : sizeof(char) = 1  */
    if (NULL == tmp) {
        error("Malloc a flanche");
        return NULL;
    }
    for_free = tmp; /* On sauvegarde l'adresse a liberer plus tard */
    
    strcpy(tmp, src); /* Et hop, j'ai les droits d'ecriture  */
    trim(tmp);
    tmp = removeZeroes(tmp);
    len = strlen(tmp);
    dst[0] = '\0';

    if (0 == len) {
        sprintf(dst, "%s", unites[len]);
        free(for_free);
        return dst;
    }
    if (len > 3*8) {
        error("Nombre trop grand");
        dst = NULL;
        free(for_free);
        return dst;
    }

    blocks = div(len, 3);
    index = (blocks.rem > 0) ? blocks.quot+1 : blocks.quot; /* equivalent a : ceil(len/3)  */
    SIndex = len-3*(index-1)-1; /* 0 : unite, 1 : dizaine, 2 : centaine  */

    for (i = 0 ; tmp[i] ; ++i) {
        int centaine, dizaine, unite; /* Ne pas confondre avec les chaine globales (leurs noms se finissent par s)  */
        centaine = dizaine = unite = 0;
        irr = 0; /* Pas d'irregularite au debut  */

        if (2 == SIndex) {
            centaine = tmp[i]-'0';
            if (centaine != 0) {
                if (i != 0) strcat(dst, " ");
                _centaine(tmp+i, dst, index);
            }
            ++i; /* On passe au dizaines  */
            --SIndex;
        }
        if (1 == SIndex) {
            dizaine = tmp[i]-'0';
            if (dizaine != 0) {
                if (i != 0) strcat(dst, " ");
                irr= _dizaine(tmp+i, dst, index);
            }
            ++i; /* On passe au unites  */
            --SIndex;
        }
        if (0 == SIndex) {
            unite = tmp[i]-'0';
            if (!(1 == unite && 4 == strlen(tmp+i)) && (unite != 0 && irr != 1)) { /* On ne doit pas sauter les unites */
                if (i != 0 && dizaine == 0) strcat(dst, " ");
                _unite(tmp+i, dst, dizaine, irr);
            }
        }
        if (index > 1 && centaine+dizaine+unite != 0) { /* Si on est au moins a mille */
            if (!(0 == centaine && 0 == dizaine && 1 == unite && len == 4)) { /* Pas d'espace avant mille tout court */
                strcat(dst, " ");
            }
            strcat(dst, centaines[index-1]);
            if (index != 2 && (unite > 1 || centaine+dizaine > 0)) {
                strcat(dst, "s");
            }
        }
        index--; /* On change de bloc de 3 chiffres  */
        SIndex = 2;
    }

    free(for_free);

    return dst;
}

int main (void) {
    char *x[] =
    { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13",
    "14", "15", "16", "17", "18", "19", "20", "21", "29", "30", "40", "42",
    "51",
    "60", "69", "70", "71", "77", "80", "81", "85", "90", "91", "99", "100",
    "101",
    "110", "130", "173", "196", "200", "205", "217", "223", "256", "268",
    "273",
    "280", "297", "734", "1 000", "1 001", "1 017", "1 020", "1 032", "1 111",
    "2 000",
    "2 100", "2 200", "3 003", "3 780", "10 000", "10 005", "10 900", "11 000",
    "11 700",
    "12 000", "18 805", "61 400", "77 010", "80 000", "80 078", "90 000", "92 002",
    "97 459",
    "100 000", "100 007", "204 003", "310 857", "700 005", "1 000 000", "2 000 000",
    "2 001 001",
    "72 424 600", "79 828 480", "200 000 000", "708 000 000", "1 000 000 000", "2 000 000 000",
    "2 000 500 000",     "2 000 780 001", "999 999 999 999 999 999 999 999"
  };
    int i, n = sizeof x / sizeof *x;

    for (i = 0; i < n; i++) {
        char NombreEnLettres[500] = {""};
        z0zero(x[i], NombreEnLettres);
        if (NombreEnLettres != NULL)
            printf("%s => %s.\n", x[i], NombreEnLettres);
    }

    return EXIT_SUCCESS;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *unites[10]=  {"","un",  "deux", "trois", "quatre",  "cinq",  "six",  "sept",    "huit",    "neuf"};
char *dizaine1[10]={"dix", "onze","douze","treize","quatorze","quinze","seize","dix-sept","dix-huit","dix-neuf"};
char *dizaine2[9]={ "",   "vingt","trente","quarante","cinquante","soixante","soixante","quatre-vingt","quatre-vingt"};

/*mes fonctions pour compter */
void Traduit(int i,char *chaine);

int main(void)
{
    int i;
    char resultat[100];
    for (i=0;i<100;i++)
    {
        Traduit(i,resultat);
        printf("%d ---> %s\n",i,resultat);
        strcpy(resultat,"");//efface le resultat !
    }
    return 0;
}


void Traduit(int i,char *chaine)
{
    // cas du zero
    if (i==0)
    { strcpy (chaine,"zero"); }
    //je compte de 1 a 9
    if ( (i>0) && (i<10) )
    { strcpy (chaine,unites[i]); }

    //je compte de 10 à 19
    if ( (i>=10) && (i<20) )
    { strcpy (chaine,dizaine1[i-10]); }

    //je compte de 20 à 99
    if ( (i>=20) && (i<100) )
    {
        int idizaine = i / 10;   //extraction du chiffre dizaine
        int iunite   = i % 10; // extraction de l'unite

        strcpy(chaine,dizaine2[idizaine-1]);
        if ( ((idizaine>1) && (idizaine<7)) || (idizaine == 8) )
            {
                 if (iunite !=0) {strcat(chaine,"-");}
                 strcat(chaine,unites[iunite]);
            }
        if ( (idizaine==7) || (idizaine==9) )
        {
                 strcat(chaine,"-");
                 strcat(chaine,dizaine1[iunite]);
        }

    }
}