Kata

Kata NombreEnLettres en Perl

Une fois n’est pas coutume, ce Kata a un nom français. Disons que vous travaillez pour une banque, sur une machine a rédiger les chèques. Dans le cadre de la défense de la langue Française le ministère de la culture demande que désormais les machines indiquent le montant en toute lettres, comme les êtres humains, en suivant les recommandations orthographiques de 1990. En gros, les séparateurs entre composants des chiffres sont des tirets au lieu de parfois des espaces e.g. on écrit vingt-et-un et dix-sept au lieu de vingt et un et dix-sept.

Pour ceux que cela intéresse on peut trouver les règles d’écriture détaillées des nombres en français ici.

Mise en place de l’environnement de tests

D’abord le framework de tests. `Test::More` fera parfaitement l’affaire. Cela nous donne les deux fichiers suivants. J’ai déjà inclu le premier test: vérifier que Nombre en Lettres de ‘0’ affiche ‘zero’.

TestsNombresEnLettres.pl

#!perl
use Test::More tests => 2;

unshift @INC, '.';
require_ok 'NombresEnLettres.pl';

ok(nombres_en_lettres(0) eq 'zero');

NombresEnLettres.pl

#!perl
use strict;
use warnings;

sub nombres_en_lettres {
    return "zero";
}

1;

Les nombres à 1 chiffre

Après ‘zero’, le tests suivant naturel c’est de savoir afficher ‘un’ et de manière plus générale tous les nombres à un chiffre.

ok nombres_en_lettres(0) eq 'zero';
ok nombres_en_lettres(1) eq 'un';
ok nombres_en_lettres(2) eq 'deux';
ok nombres_en_lettres(3) eq 'trois';
ok nombres_en_lettres(4) eq 'quatre';
ok nombres_en_lettres(5) eq 'cinq';
ok nombres_en_lettres(6) eq 'six';
ok nombres_en_lettres(7) eq 'sept';
ok nombres_en_lettres(8) eq 'huit';
ok nombres_en_lettres(9) eq 'neuf';

L’implémentation est directe avec une table de hash.

sub nombres_en_lettres {
 my $p = pop;
 my %chiffres = (
 0 => 'zero',
 1 => 'un',
 2 => 'deux',
 3 => 'trois',
 4 => 'quatre',
 5 => 'cinq',
 6 => 'six',
 7 => 'sept',
 8 => 'huit',
 9 => 'neuf'
 );
 return $chiffres{$p}
}

Nombres à deux chiffres

On peut poursuivre de la même manière pour 10, 11, 12, 13, 14, 15 et 16, en effet chaque nouveau nombre correspond à un nouveau mot qu’il suffit d’introduire dans le dictionnaire. Le prochain test intéressant est 17. En effet l’écriture de ce nombre est formée des deux mots ‘dix’ et ‘sept’ déjà connus reliés par un trait d’union. On poursuit donc les tests jusqu’à 17, en en profitant pour donner un nom aux tests pour clarifier la sortie.

<pre>ok nombres_en_lettres(10) eq 'dix'      , 'dix';
ok nombres_en_lettres(11) eq 'onze'     , 'onze';
ok nombres_en_lettres(12) eq 'douze'    , 'douze';
ok nombres_en_lettres(13) eq 'treize'   , 'treize';
ok nombres_en_lettres(14) eq 'quatorze' , 'quatorze';
ok nombres_en_lettres(15) eq 'quinze'   , 'quinze';
ok nombres_en_lettres(16) eq 'seize'    , 'seize';
ok nombres_en_lettres(17) eq 'dix-sept' , 'dix-sept';

Lorsque on lance les tests par `perl TestsNombresEnLettres.pl`on obtient désormais:

1..19
ok 1 - require 'NombresEnLettres.pl';
ok 2 - zero
ok 3 - un
ok 4 - deux
ok 5 - trois
ok 6 - quatre
ok 7 - cinq
ok 8 - six
ok 9 - sept
ok 10 - huit
ok 11 - neuf
ok 12 - dix
ok 13 - onze
ok 14 - douze
ok 15 - treize
ok 16 - quatorze
ok 17 - quinze
ok 18 - seize
not ok 19 - dix-sept
#   Failed test 'dix-sept'
#   at TestsNombresEnLettres.pl line 24.
# Looks like you failed 1 test of 19.

La modification nécessaire pour faire passer ce test est mineure, le programme donne désormais:

sub nombres_en_lettres {
    my $p = pop;
    my %chiffres = (
         0 => 'zero',
         1 => 'un',
         2 => 'deux',
         3 => 'trois',
         4 => 'quatre',
         5 => 'cinq',
         6 => 'six',
         7 => 'sept',
         8 => 'huit',
         9 => 'neuf',
        10 => 'dix',
        11 => 'onze',
        12 => 'douze',
        13 => 'treize',
        14 => 'quatorze',
        15 => 'quinze',
        16 => 'seize',
    );
    if ($p > 16){
        return sprintf "%s-%s", $chiffres{10}, $chiffres{$p%10};
    }
    return $chiffres{$p}
}

La modification précédente pose toutefois quelques soucis lorsqu’on veut introduire les nouveaux mots isolés correspondant aux dizaines, aux centaines ou aux milliers qu’a priori on espérait pouvoir introduire de la même manière que les chiffres.

ok nombres_en_lettres(20) eq 'vingt'    , 'vingt';
ok nombres_en_lettres(30) eq 'trente'   , 'trente';
ok nombres_en_lettres(40) eq 'quarante' , 'quarante';
ok nombres_en_lettres(50) eq 'cinquante', 'cinquante';
ok nombres_en_lettres(60) eq 'soixante' , 'soixante';
ok nombres_en_lettres(100) eq 'cent'    , 'cent';
ok nombres_en_lettres(1000) eq 'mille'  , 'mille';

Cependant une modification mineure suffit à nouveau à corriger le programme.

sub nombres_en_lettres {
    my $p = pop;
    my %nombres = (
         0 => 'zero',
         1 => 'un',
         2 => 'deux',
         3 => 'trois',
         4 => 'quatre',
         5 => 'cinq',
         6 => 'six',
         7 => 'sept',
         8 => 'huit',
         9 => 'neuf',
        10 => 'dix',
        11 => 'onze',
        12 => 'douze',
        13 => 'treize',
        14 => 'quatorze',
        15 => 'quinze',
        16 => 'seize',
        20 => 'vingt',
        30 => 'trente',
        40 => 'quarante',
        50 => 'cinquante',
        60 => 'soixante',
       100 => 'cent',
      1000 => 'mille',
    );
    if (defined($nombres{$p})){
            return $nombres{$p};
    }
    else {
        return sprintf "%s-%s", $nombres{10}, $nombres{$p%10};
    }
}

Vingt-deux et Vingt et un

Nous choisissons de tester d’abord 22 avant 21, le cas parait en effet plus simple. Pour le faire passer il suffit de prendre en compte la dizaine au lieu de toujours afficher ‘dix’ comme chiffre des dizaines.

sub nombres_en_lettres {
...
    if (defined($nombres{$p})){
            return $nombres{$p};
    }
    else {
        return sprintf "%s-%s", $nombres{int($p/10)*10}, $nombres{$p%10};
    }
}

‘Vingt et un’ est un peu plus complexe, il faut en effet introduire le nouveau mot clé ‘et’ en plus des tirets dans le cas de l’unité.

sub nombres_en_lettres {
...
    if (defined($nombres{$p})){
        return $nombres{$p};
    }
    else {
        my $dizaines = int($p/10);
        my $unites = $nombres{$p%10};
        if ($unites eq 'un'){
            return sprintf "%s-et-%s", $nombres{$dizaines*10}, $unites;
        }
        else {
            return sprintf "%s-%s", $nombres{$dizaines*10}, $unites;
        }
    }
}

Les irrégularités de la langue française : soixante-dix, quatre-vingt, quatre-vingt-dix

Désormais notre convertisseur sait traiter tous les nombres inférieurs à soixante-dix. En belge ou en canadien le principe utilisé fonctionnerait même jusqu’à cent. Pas en français de France. La faute à un systèmes qui compte par vingtaines plutôt que par dizaine entre soixante et cent.

Pour supporter 70, la solution est simple: si le nombre est supérieur à soixante, nous allons effectivement compter par vingtaines, c’est à dire augmenter de dix le chiffre des unités et diminuer de un le chiffre des dizaines. Cela nécessite un petit refactoring pour convertir l’unité en texte un peu plus tardivement, mais cela reste très simple. Il y a aussi un second problème, cela ne fonctionne que jusqu’à 16, mais pour 17, 18 et 19 nous avons déjà des nombres composés et un texte avec 99 par exemple échoue. La solution est très simple : rajouter ces trois entrées à la table des nombres.

sub nombres_en_lettres {
...
    if (defined($nombres{$p})){
        return $nombres{$p};
    }
    else {
        my $dizaines = int($p/10);
        my $unites = $p%10;
        if ($dizaines > 6){
            $unites += 10;
            $dizaines -= 1;
        }
        if ($unites == 1){
            return sprintf "%s-et-%s",
                $nombres{$dizaines*10},
                $nombres{$unites};
        }
        else {
            return sprintf "%s-%s",
                $nombres{$dizaines*10},
                $nombres{$unites};
        }
    }
}

On commence à avoir du code dupliqué, un petit refactoring s’impose.

sub nombres_en_lettres {
...
        my $dizaines = int($p/10);
        my $unites = $p%10;
        if ($dizaines > 6){
            $unites += 10;
            $dizaines -= 1;
        }
        my $separateur = "-";
        if ($unites == 1){
            $separateur = " et ";
        }
        return $nombres{$dizaines*10}.$separateur.$nombres{$unites};
}

Le cas de 80 semble difficile, car c’est un cas unique. En fait en regardant le code la réponse est simple. Puisque c’est un cas unique autant ajouter l’entrée « quatre-vingt » à la table des nombres de base. Ce qui suffit en effet à traiter le cas de tous les nombres de 80 à 99. Notre programme fonctionne désormais pour tous les nombres jusqu’à cent compris.

Les centaines

Le prochain test qui va clairement échouer est 101, en effet nous n’avons encore aucune gestion des centaines et pour 101 notre programme affiche lamentablement « -zero ».

La modification du programme consiste tout d’abord à faire apparaître les centaines, ainsi qu’un second séparateur. Cependant on se rend vite compte que ce n’est pas suffisant car le cas zero dizaines oblige à faire disparaitre le chiffre des dizaines ainsi que le séparateur dizaines unités. Un cas comme 121 aurait sans doute été plus simple. Une autre condition similaire est également nécessaire pour cacher le chiffre des centaines et le séparateur centaines unités qui n’existent pas pour les cas précédents. L’option la plus simple aurait donc probablement consisté à choisir 121 et dans le programme à prévoir une branche conditionnelle complète pour les nombres supérieurs à cent. Tant pis, on obtient tout de même après quelques tentatives le code ci-dessous (mais nous rajouterons le cas 121 aux tests).

sub nombres_en_lettres {
    my $p = pop;
    my %nombres = (
         0 => 'zero',
         1 => 'un',
         2 => 'deux',
         3 => 'trois',
         4 => 'quatre',
         5 => 'cinq',
         6 => 'six',
         7 => 'sept',
         8 => 'huit',
         9 => 'neuf',
        10 => 'dix',
        11 => 'onze',
        12 => 'douze',
        13 => 'treize',
        14 => 'quatorze',
        15 => 'quinze',
        16 => 'seize',
        20 => 'vingt',
        30 => 'trente',
        40 => 'quarante',
        50 => 'cinquante',
        60 => 'soixante',
        80 => 'quatre-vingt',
       100 => 'cent',
      1000 => 'mille',
    );
    if (defined($nombres{$p})){
            return $nombres{$p};
    }
    else {
        my $centaines = int($p/100);
        my $dizaines = int($p/10)%10;
        my $unites = $p%10;
        if ($dizaines > 6){
            $unites += 10;
            $dizaines -= 1;
        }

        my $separateur_dizaines_unites = "-";
        if ($unites == 1){
            $separateur_dizaines_unites = "-et-";
        }
        if ($dizaines == 0 or $unites == 0) {
            $separateur_dizaines_unites = "";
        }
        my $separateur_centaines_dizaines = "-";
        return (($centaines>0)?$nombres{$centaines*100}:"")
              .(($centaines>0)?$separateur_centaines_dizaines:"")
              .(($dizaines>0) ?$nombres{$dizaines*10}:"")
              .$separateur_dizaines_unites
              .$nombres{$unites};

    }
}

Avec des modifications similaires on obtient le code suivant capable de traiter tous les nombres jusqu’à 999

sub nombres_en_lettres {
    my $p = pop;
    my %nombres = (
         0 => 'zero',
         1 => 'un',
         2 => 'deux',
         3 => 'trois',
         4 => 'quatre',
         5 => 'cinq',
         6 => 'six',
         7 => 'sept',
         8 => 'huit',
         9 => 'neuf',
        10 => 'dix',
        11 => 'onze',
        12 => 'douze',
        13 => 'treize',
        14 => 'quatorze',
        15 => 'quinze',
        16 => 'seize',
        17 => 'dix-sept',
        18 => 'dix-huit',
        19 => 'dix-neuf',
        20 => 'vingt',
        30 => 'trente',
        40 => 'quarante',
        50 => 'cinquante',
        60 => 'soixante',
        80 => 'quatre-vingt',
       100 => 'cent',
      1000 => 'mille',
    );
    if (defined($nombres{$p})){
            return $nombres{$p};
    }
    else {
        my $centaines = int($p/100);
        my $dizaines = int($p/10)%10;
        my $unites = $p%10;
        if ($dizaines > 6){
            $unites += 10;
            $dizaines -= 1;#!perl
use Test::More tests => 48;

unshift @INC, '.';
require_ok 'NombresEnLettres.pl';

is nombres_en_lettres(0), 'zero'      , 'zero';
is nombres_en_lettres(1), 'un'        , 'un';
is nombres_en_lettres(2), 'deux'      , 'deux';
is nombres_en_lettres(3), 'trois'     , 'trois';
is nombres_en_lettres(4), 'quatre'    , 'quatre';
is nombres_en_lettres(5), 'cinq'      , 'cinq';
is nombres_en_lettres(6), 'six'       , 'six';
is nombres_en_lettres(7), 'sept'      , 'sept';
is nombres_en_lettres(8), 'huit'      , 'huit';
is nombres_en_lettres(9), 'neuf'      , 'neuf';
is nombres_en_lettres(10), 'dix'      , 'dix';
is nombres_en_lettres(11), 'onze'     , 'onze';
is nombres_en_lettres(12), 'douze'    , 'douze';
is nombres_en_lettres(13), 'treize'   , 'treize';
is nombres_en_lettres(14), 'quatorze' , 'quatorze';
is nombres_en_lettres(15), 'quinze'   , 'quinze';
is nombres_en_lettres(16), 'seize'    , 'seize';
is nombres_en_lettres(17), 'dix-sept' , 'dix-sept';
is nombres_en_lettres(20), 'vingt'    , 'vingt';
is nombres_en_lettres(30), 'trente'   , 'trente';
is nombres_en_lettres(40), 'quarante' , 'quarante';
is nombres_en_lettres(50), 'cinquante', 'cinquante';
is nombres_en_lettres(60), 'soixante' , 'soixante';
is nombres_en_lettres(100), 'cent'    , 'cent';
is nombres_en_lettres(1000), 'mille'  , 'mille';
is nombres_en_lettres(22), 'vingt-deux', 'vingt-deux';
is nombres_en_lettres(21), 'vingt-et-un', 'vingt-et-un';
is nombres_en_lettres(70), 'soixante-dix', 'soixante-dix';
is nombres_en_lettres(79), 'soixante-dix-neuf' , 'soixante-dix-neuf';
is nombres_en_lettres(80), 'quatre-vingt', 'quatre-vingt';
is nombres_en_lettres(81), 'quatre-vingt-un', 'quatre-vingt-un';
is nombres_en_lettres(91), 'quatre-vingt-onze', 'quatre-vingt-onze';
is nombres_en_lettres(99), 'quatre-vingt-dix-neuf' , 'quatre-vingt-dix-neuf';
is nombres_en_lettres(101), 'cent-un', 'cent-un';
is nombres_en_lettres(121), 'cent-vingt-et-un', 'cent-vingt-et-un';
is nombres_en_lettres(118), 'cent-dix-huit', 'cent-dix-huit';
is nombres_en_lettres(132), 'cent-trente-deux', 'cent-trente-deux';
is nombres_en_lettres(200), 'deux-cents', 'deux-cents';
is nombres_en_lettres(237), 'deux-cent-trente-sept', 'deux-cent-trente-sept';
is nombres_en_lettres(951), 'neuf-cent-cinquante-et-un', 'neuf-cent-cinquante-et-un';
is nombres_en_lettres(999), 'neuf-cent-quatre-vingt-dix-neuf', 'neuf-cent-quatre-vingt-dix-neuf';
is nombres_en_lettres(9999), 'neuf-mille-neuf-cent-quatre-vingt-dix-neuf', 'neuf-mille-neuf-cent-quatre-vingt-dix-neuf';
is nombres_en_lettres(999999), 'neuf-cent-quatre-vingt-dix-neuf-mille-neuf-cent-quatre-vingt-dix-neuf', 'neuf-cent-quatre-vingt-dix-neuf-mille-neuf-cent-quatre-vingt-dix-neuf';
is nombres_en_lettres(999000), 'neuf-cent-quatre-vingt-dix-neuf-mille', 'neuf-cent-quatre-vingt-dix-neuf-mille';
is nombres_en_lettres(17000000), 'dix-sept millions', 'dix-sept millions';
is nombres_en_lettres(1000000), 'un million', 'un million';
is nombres_en_lettres(5000000000), 'cinq milliards', 'cinq milliards';
is nombres_en_lettres(1000000000), 'un milliard', 'un milliards';
is nombres_en_lettres(921018923111), 'neuf-cent-vingt-et-un milliards dix-huit millions neuf-cent-vingt-trois-mille-cent-onze', 'neuf-cent-vingt-et-un milliards dix-huit millions neuf-cent-vingt-trois-mille-cent-onze'
        }

        my $separateur_dizaines_unites = ($unites == 1)?" et ":"-";
        if ($dizaines == 0 or $unites == 0) {
            $separateur_dizaines_unites = "";
        }
        my $chiffre_centaines = $nombres{$centaines};
        my $separateur_centaines_u_centaines = " ";
        my $u_centaines = 'cent';
        my $separateur_centaines_dizaines = " ";

        if ($centaines == 0){
            $separateur_centaines_u_centaines = "";
            $chiffre_centaines = "";
            $u_centaines = "";
            $separateur_centaines_dizaines = "";
        }

        if ($centaines == 1){
            $separateur_centaines_u_centaines = "";
            $chiffre_centaines = "";
            $separateur_centaines_dizaines = '-';
        }

        if ($dizaines == 0 and $unites == 0){
            $separateur_centaines_dizaines = "";
        }

        return $chiffre_centaines.$separateur_centaines_u_centaines
               .$u_centaines.$separateur_centaines_dizaines
              .(($dizaines>0) ?$nombres{$dizaines*10}:"")
              .$separateur_dizaines_unites
              .(($unites>0)?$nombres{$unites}:"");

    }
}

Le problème est que le résultat est bien trop complexe et comporte de nombreuses conditions. Un refactoring s’impose.

En pratique le refactoring a necessité différentes étapes, tous les tests passants à chaque phase intermédiaire. Je vous livre le résultat final.

sub nel999 {
    my $p = pop;
    my @u = ('zero', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept',
             'huit', 'neuf', 'dix', 'onze', 'douze', 'treize', 'quatorze',
             'quinze','seize');

    my $cu = $p%10;          # cu=chiffre des unites
    my $cd = int($p/10)%10;  # cd=chiffre des dizaines
    my $cc = int($p/100);    # cc=chiffre des centaines

    if ($cd == 7 or $cd == 9 or $cd == 1){
        $cu += 10;
        $cd -= 1;
    }

    my @res;

    push @res, "cent" if $cc == 1;
    push @res, $u[$cc]."-cent".(($cd + $cu) > 0?"":"s") if $cc > 1;

    if ($cd > 0){
        my %d = (
            2 => 'vingt',
            3 => 'trente',
            4 => 'quarante',
            5 => 'cinquante',
            6 => 'soixante',
            8 => 'quatre-vingt',
        );
        push @res, $d{$cd};
    }

    push @res, "et" if $cu==1 && $cd < 8 && $cd > 1;
    push @res, ($cu < 17)?$u[$cu]:"dix-".$u[$cu-10] if $cu > 0;

    return join "-", @res;
}

On s’arrètera la dans le cadre de ce Kata. Pour ceux qui sont intéressés je
vous livre la version complète, après encore un peu de refactoring avec support
des milliards et des millions jusqu’à 999 milliards. Même avec une forte
inflation cela devrait suffire pour une machine à rédiger les chèques.

#!perl
use strict;
use warnings;

sub nel999 {
    my $p = pop;
    my @u = ('zero', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept',
             'huit', 'neuf', 'dix', 'onze', 'douze', 'treize', 'quatorze',
             'quinze','seize');
    my $cu = $p%10;          # chiffre des unites
    my $cd = int($p/10)%10;  # chiffre des dizaines
    my $cc = int($p/100);    # chiffre des centaines

    if ($cd == 7 or $cd == 9 or $cd == 1){
        $cu += 10;
        $cd -= 1;
    }

    my @res;
    push @res, "cent" if $cc == 1;
    push @res, $u[$cc]."-cent".(($cd + $cu) > 0?"":"s") if $cc > 1;
    push @res, ('vingt', 'trente', 'quarante',
                'cinquante', 'soixante', '', 'quatre-vingt')[$cd-2] if $cd > 0;
    push @res, "et" if $cu==1 && $cd < 8 && $cd > 1;
    push @res, ($cu < 17)?$u[$cu]:"dix-".$u[$cu-10] if $cu > 0;

    return join "-", @res;
}

sub nombres_en_lettres {
    my $p = pop;

    return 'zero' if $p == 0;

    my $centaines = $p % 1000;
    my $milliers = ($p/1000) % 1000;
    my $millions = ($p/1000000) % 1000;
    my $milliards = ($p/1000000000) % 1000;

    my @res = ();

    push @res, "un milliard" if $milliards == 1;
    push @res, nel999($milliards)." milliards" if $milliards > 1;

    push @res, "un million" if $millions == 1;
    push @res, nel999($millions)." millions" if $millions > 1;

    if ($centaines + $milliers > 0){
        my @m = ();
        push @m, nel999($milliers) if $milliers > 1;
        push @m, "mille" if $milliers > 0;
        push @m, nel999($centaines) if $centaines > 0;
        push @res, join "-", @m;
    }

    return join " ", @res;
}

1;

Et bien entendu le jeu de tests correspondant:

#!perl
use Test::More tests => 48;

unshift @INC, '.';
require_ok 'NombresEnLettres.pl';

is nombres_en_lettres(0), 'zero'      , 'zero';
is nombres_en_lettres(1), 'un'        , 'un';
is nombres_en_lettres(2), 'deux'      , 'deux';
is nombres_en_lettres(3), 'trois'     , 'trois';
is nombres_en_lettres(4), 'quatre'    , 'quatre';
is nombres_en_lettres(5), 'cinq'      , 'cinq';
is nombres_en_lettres(6), 'six'       , 'six';
is nombres_en_lettres(7), 'sept'      , 'sept';
is nombres_en_lettres(8), 'huit'      , 'huit';
is nombres_en_lettres(9), 'neuf'      , 'neuf';
is nombres_en_lettres(10), 'dix'      , 'dix';
is nombres_en_lettres(11), 'onze'     , 'onze';
is nombres_en_lettres(12), 'douze'    , 'douze';
is nombres_en_lettres(13), 'treize'   , 'treize';
is nombres_en_lettres(14), 'quatorze' , 'quatorze';
is nombres_en_lettres(15), 'quinze'   , 'quinze';
is nombres_en_lettres(16), 'seize'    , 'seize';
is nombres_en_lettres(17), 'dix-sept' , 'dix-sept';
is nombres_en_lettres(20), 'vingt'    , 'vingt';
is nombres_en_lettres(30), 'trente'   , 'trente';
is nombres_en_lettres(40), 'quarante' , 'quarante';
is nombres_en_lettres(50), 'cinquante', 'cinquante';
is nombres_en_lettres(60), 'soixante' , 'soixante';
is nombres_en_lettres(100), 'cent'    , 'cent';
is nombres_en_lettres(1000), 'mille'  , 'mille';
is nombres_en_lettres(22), 'vingt-deux', 'vingt-deux';
is nombres_en_lettres(21), 'vingt-et-un', 'vingt-et-un';
is nombres_en_lettres(70), 'soixante-dix', 'soixante-dix';
is nombres_en_lettres(79), 'soixante-dix-neuf' , 'soixante-dix-neuf';
is nombres_en_lettres(80), 'quatre-vingt', 'quatre-vingt';
is nombres_en_lettres(81), 'quatre-vingt-un', 'quatre-vingt-un';
is nombres_en_lettres(91), 'quatre-vingt-onze', 'quatre-vingt-onze';
is nombres_en_lettres(99), 'quatre-vingt-dix-neuf' , 'quatre-vingt-dix-neuf';
is nombres_en_lettres(101), 'cent-un', 'cent-un';
is nombres_en_lettres(121), 'cent-vingt-et-un', 'cent-vingt-et-un';
is nombres_en_lettres(118), 'cent-dix-huit', 'cent-dix-huit';
is nombres_en_lettres(132), 'cent-trente-deux', 'cent-trente-deux';
is nombres_en_lettres(200), 'deux-cents', 'deux-cents';
is nombres_en_lettres(237), 'deux-cent-trente-sept', 'deux-cent-trente-sept';
is nombres_en_lettres(951), 'neuf-cent-cinquante-et-un', 'neuf-cent-cinquante-et-un';
is nombres_en_lettres(999), 'neuf-cent-quatre-vingt-dix-neuf', 'neuf-cent-quatre-vingt-dix-neuf';
is nombres_en_lettres(9999), 'neuf-mille-neuf-cent-quatre-vingt-dix-neuf', 'neuf-mille-neuf-cent-quatre-vingt-dix-neuf';
is nombres_en_lettres(999999), 'neuf-cent-quatre-vingt-dix-neuf-mille-neuf-cent-quatre-vingt-dix-neuf', 'neuf-cent-quatre-vingt-dix-neuf-mille-neuf-cent-quatre-vingt-dix-neuf';
is nombres_en_lettres(999000), 'neuf-cent-quatre-vingt-dix-neuf-mille', 'neuf-cent-quatre-vingt-dix-neuf-mille';
is nombres_en_lettres(17000000), 'dix-sept millions', 'dix-sept millions';
is nombres_en_lettres(1000000), 'un million', 'un million';
is nombres_en_lettres(5000000000), 'cinq milliards', 'cinq milliards';
is nombres_en_lettres(1000000000), 'un milliard', 'un milliards';
is nombres_en_lettres(921018923111), 'neuf-cent-vingt-et-un milliards dix-huit millions neuf-cent-vingt-trois-mille-cent-onze', 'neuf-cent-vingt-et-un milliards dix-huit millions neuf-cent-vingt-trois-mille-cent-onze'
Publicités

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s