Conversion d'un nombre compris 0 et 999999999999999999 (18 chiffres) en lettres

Soyez le premier à donner votre avis sur cette source.

Snippet vu 11 333 fois - Téléchargée 29 fois


Contenu du snippet

Unité capable de convertir un nombre compris 0 et 999999999999999999 qui peut
etre utile pour des applications de facturation ou d'autre applications de
finance ou statestiques.

Source / Exemple :


{******************************************************************************}
{Unité capable de convertir un nombre compris 0 et 999999999999999999 qui peut-}
{etre utils pour des applications de facturation ou d'autre applications de ---}
{finance ou statestiques...----------------------------------------------------}
{par HRaouf Laghouati----------------------------------------------------------}
{si'il ya des erreurs veuillez me contacter: hraoufone@yahoo.com---------------}
{******************************************************************************}
unit ConversionDeNombresEnLettres;

interface

uses
  SysUtils;

var T: array[0..90] of string;
    Ininitialise: boolean=false;
implementation
//------------------------------------------------------------------------------
Procedure InitTable();
Begin
//Initialisation du tableau avec les valeurs de base
      T[0]:='zero';T[1]:='un';T[2]:='deux';T[3]:='trois';T[4]:='quatre';
      T[5]:='cinq';T[6]:='six';T[7]:='sept';T[8]:='huit';T[9]:='neuf';
      T[10]:='dix';T[11]:='onze';T[12]:='douze';T[13]:='trieze';
      T[14]:='quatorze';T[15]:='quinze';T[16]:='seize';T[17]:='dix-sept';
      T[18]:='dix-huit';T[19]:='dix-neuf';T[20]:='vingt';T[30]:='trente';
      T[40]:='quarante';T[50]:='cinquante';T[60]:='soixante';T[70]:='soixante-dix';
      T[80]:='quatre-vingt';T[90]:='quatre-vingt-dix';
      Ininitialise:=true;
//fin de l'initialisation
end;
//Fonction responsable de verifier si la valeur et entre 0 et 9 ----------------
Function Vun(Chiffre: string):string;
Var I: integer;
Begin
if Chiffre='0' then exit
else
     for i:= 1 to 9 do
     begin
       if Chiffre = inttostr(i) then
       begin
         Vun:= T[i];
         break;
       end
     end
end;
//Fin de la fonctin Vun --------------------------------------------------------

//Fonction responsable de verifier les valeurs entre 10 et 99 ------------------
Function Vdix(Nombre: string):string;
Var I: integer;
    S1,S2: string;
    B:boolean;
Begin

if Nombre[1]='0' then
begin
   Vdix:=Vun(Nombre[2]);
end
else
begin
    B:=false;
    for i:= 10 to 90 do
    begin
      if (Nombre=inttostr(i)) and (T[I]<>'') then
      begin
       Vdix:=T[i];
       B:=true;
       break;
      end
    end;
    if B=false then
    begin
       if Nombre[1]<'7' then//moin de soixante-dix
       begin
         S1:=Nombre[1]+'0';
         S2:=Nombre[2];
         if S2='1' then
            Vdix:=Vdix(S1)+'-et-'+Vun(S2)
         else
            Vdix:=Vdix(S1)+'-'+Vun(S2)
       end//if moin de soixante-dix
       else //superieur a soixante-dix
       begin
         Case Nombre[1] of
         '7': begin
                 S1:='60';
                 S2:='1'+Nombre[2];
                 if S2='11' then
                    Vdix:=Vdix(S1)+'-et-'+Vdix(S2)
                 else
                    Vdix:=Vdix(S1)+'-'+Vdix(S2)
              end;//'7'
         '8': begin
                 S1:=Nombre[1]+'0';
                 S2:=Nombre[2];
                 if S2='1' then
                    Vdix:=Vdix(S1)+'-et-'+Vun(S2)
                 else
                    Vdix:=Vdix(S1)+'-'+Vun(S2)
              end;// '8'
         '9': begin
                 S1:='80';
                 S2:='1'+Nombre[2];
                 if S2='11' then
                    Vdix:=Vdix(S1)+'-et-'+Vdix(S2)
                 else
                    Vdix:=Vdix(S1)+'-'+Vdix(S2)
              end;// '9'
         end //case
       end //else superieur a soixante-dix
    end
end;

End;
//Fin de la Fonctiin Vdix ------------------------------------------------------

//Fonction responsable de verifier les valeurs entre 100 et 999 ----------------
Function Vcent(Nombre: string):string;
var S: string;
begin
if Nombre='100' then Vcent:='cent'
else
begin
   if Nombre[1] = '0' then
     begin
      delete(Nombre,1,1);
      Vcent:=Vdix(Nombre);
     end
   else
   if Nombre[1]='1' then
     begin
      delete(Nombre,1,1);
      Vcent:='cent ' + Vdix(Nombre);
     end
   else
   begin
      S:=Vun(Nombre[1])+' cent ';
      delete(Nombre,1,1);
      Vcent:=S+Vdix(Nombre);
   end

end
End;
//Fin de la Fonction Vcent -----------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 1000 et 9999----------------
Function Vmille(Nombre: string):string;
var S: string;
begin
if Nombre='1000' then Vmille:='mille'
else
begin
   if Nombre[1] = '0' then
     begin
      delete(Nombre,1,1);
      Vmille:=Vcent(Nombre);
     end
   else
   if Nombre[1]='1' then
     begin
      delete(Nombre,1,1);
      Vmille:='mille ' + Vcent(Nombre);
     end
   else
   begin
      S:=Vun(Nombre[1])+' mille ';
      delete(Nombre,1,1);
      Vmille:=S+Vcent(Nombre);
   end
end
End;

//Fin de la fonction Vmille ----------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 10000 et 99999--------------
Function Vdixmille(Nombre: string):string;
var S: string;
begin
 if Nombre[1]='0' then
   begin
      delete(Nombre,1,1);
      Vdixmille:=Vmille(Nombre);
   end
 else
   begin
      S:=Vdix(Nombre[1] + Nombre[2])+' mille ' ;
      delete(Nombre,1,2);
      Vdixmille:=S + Vcent(Nombre);
   end

End;

//Fin de la fonction Vdixmille -------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 100000 et 999999------------
Function Vcentmille(Nombre: string):string;
var S: string;
begin
 if Nombre[1]='0' then
   begin
    delete(Nombre,1,1);
    Vcentmille:=Vdixmille(Nombre);
   end
 else
   begin
      S:=Vcent(Nombre[1] + Nombre[2] + Nombre[3])+' mille ';
      delete(Nombre,1,3);
      Vcentmille:=S + Vcent(Nombre);
   end
End;
//Fin de la fonction Vcentmille ------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 1000000 et 9999999----------
Function Vmillion(Nombre: string):string;
var S: string;
begin

 if Nombre[1]='0' then
   begin
    delete(Nombre,1,1);
    Vmillion:=Vcentmille(Nombre);
   end
   else
   begin
    if Nombre[1]='1' then
    S:=Vun(Nombre[1])+' millioin '
    else
    S:=Vun(Nombre[1])+' millioins ';
    delete(Nombre,1,1);
    Vmillion:=S + Vcentmille(Nombre);
   end

End;
//Fin de la fonction Vmillion --------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 10000000 et 99999999--------
Function Vdixmillion(Nombre: string):string;
var S: string;
begin
 if Nombre[1]='0' then
   begin
    delete(Nombre,1,1);
    Vdixmillion:=Vmillion(Nombre);
   end
   else
   begin
    S:= Vdix(Nombre[1] + Nombre[2])+ ' millions ';
    delete(Nombre,1,2);
    Vdixmillion:= S + Vcentmille(Nombre);
   end
End;
//Fin de la fonction Vdixmillion -----------------------------------------------

//Fonctin responsable de verifier les valeurs entre 100000000 et 999999999------
Function Vcentmillion(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vcentmillion:=Vdixmillion(Nombre);
   end
   else
   begin
    S:=Vcent(Nombre[1] + Nombre[2] + Nombre[3])+ ' millions ';
    delete(Nombre,1,3);
    Vcentmillion:= S + Vcentmille(Nombre);
   end
End;
//Fin de la fonction Vcentmillion ----------------------------------------------

//Fonctin responsable de verifier les valeurs entre 1000000000 et 9999999999----
Function Vmilliard(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vmilliard:=Vcentmillion(Nombre);
   end
   else
   begin
    if Nombre[1]= '1' then
    S:= Vun(Nombre[1]) + ' milliard '
    else
    S:= Vun(Nombre[1]) + ' milliards ';
    delete(Nombre,1,1);
    Vmilliard:=S + Vcentmillion(Nombre);
   end
End;
//Fin de la fonction Vmilliard -------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 10000000000 et 99999999999--
Function Vdixmilliard(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vdixmilliard:=Vmilliard(Nombre);
   end
   else
   begin
    S:= Vdix(Nombre[1] + Nombre[2]) + ' milliards ';
    delete(Nombre,1,2);
    Vdixmilliard:=S + Vcentmillion(Nombre);
   end
End;
//Fin de la fonction Vdixmilliard ----------------------------------------------

//Fonctin responsable de verifier les valeurs entre 100000000000 et 999999999999
Function Vcentmilliard(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vcentmilliard:=Vdixmilliard(Nombre);
   end
   else
   begin
    S:= Vcent(Nombre[1] + Nombre[2] + Nombre[3]) + ' milliards ';
    delete(Nombre,1,3);
    Vcentmilliard:=S + Vcentmillion(Nombre);
   end
End;
//Fin de la fonction Vcentmilliard ---------------------------------------------

//Fonctin responsable de verifier les valeurs entre 1000000000000 et 9999999999999
Function Vbillion(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vbillion:=Vcentmilliard(Nombre);
   end
   else
   begin
    if Nombre[1] = '1' then
    S:= Vun(Nombre[1]) + ' billion '
    else
    S:= Vun(Nombre[1]) + ' billions ';
    delete(Nombre,1,1);
    Vbillion:=S + Vcentmilliard(Nombre);
   end
End;
//Fin de la fonction Vbillion --------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 10000000000000 et 99999999999999
Function Vdixbillion(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vdixbillion:=Vbillion(Nombre);
   end
   else
   begin
    S:= Vdix(Nombre[1] + Nombre[2]) + ' billions ';
    delete(Nombre,1,2);
    Vdixbillion:=S + Vcentmilliard(Nombre);
   end
End;
//Fin de la fonction Vdixbillion -----------------------------------------------

//Fonctin responsable de verifier les valeurs entre 100000000000000 et 999999999999999
Function Vcentbillion(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vcentbillion:=Vdixbillion(Nombre);
   end
   else
   begin
    S:= Vcent(Nombre[1] + Nombre[2] + Nombre[3]) + ' billions ';
    delete(Nombre,1,3);
    Vcentbillion:=S + Vcentmilliard(Nombre);
   end
End;
//Fin de la fonction Vcentbillion ----------------------------------------------

//Fonctin responsable de verifier les valeurs entre 1000000000000000 et 9999999999999999
Function Vbilliard(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vbilliard:=Vcentbillion(Nombre);
   end
   else
   begin
    if Nombre[1] = '1' then
    S:= Vun(Nombre[1]) + ' billiard '
    else
    S:= Vun(Nombre[1]) + ' billiards ';
    delete(Nombre,1,1);
    Vbilliard:=S + Vcentbillion(Nombre);
   end
End;
//Fin de la fonction Vbilliard -------------------------------------------------

//Fonctin responsable de verifier les valeurs entre 10000000000000000 et 99999999999999999
Function Vdixbilliard(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vdixbilliard:=Vbilliard(Nombre);
   end
   else
   begin
    S:= Vdix(Nombre[1] + Nombre[2]) + ' billiards ';
    delete(Nombre,1,2);
    Vdixbilliard:=S + Vcentbillion(Nombre);
   end
End;
//Fin de la fonction Vdixbilliard -----------------------------------------------

//Fonctin responsable de verifier les valeurs entre 100000000000000000 et 999999999999999999
Function Vcentbilliard(Nombre: string):string;
var S: string;
begin
 if Nombre[1] = '0' then
   begin
    delete(Nombre,1,1);
    Vcentbilliard:=Vdixbilliard(Nombre);
   end
   else
   begin
    S:= Vcent(Nombre[1] + Nombre[2] + Nombre[3]) + ' billiards ';
    delete(Nombre,1,3);
    Vcentbilliard:=S + Vcentbillion(Nombre);
   end
End;
//Fin de la fonction Vcentbilliard ---------------------------------------------
//Fonction principale de conversion
function NombreEnLettre(Nombre: string):String;
begin
if length(trim(Nombre))<>0 then
begin
  if Ininitialise = false then InitTable();
  if Nombre = '0' then NombreEnLettre:=T[0];
  if length(trim(Nombre))>18 then
  begin
   NombreEnLettre:='Nombre non supporté' ;
   exit;
  end
  else
  case length(trim(Nombre)) of
       1:     NombreEnLettre:=Vun(Nombre);
       2:     NombreEnLettre:=Vdix(Nombre);
       3:     NombreEnLettre:=Vcent(Nombre);
       4:     NombreEnLettre:=Vmille(Nombre);
       5:     NombreEnLettre:=Vdixmille(Nombre);
       6:     NombreEnLettre:=Vcentmille(Nombre);
       7:     NombreEnLettre:=Vmillion(Nombre);
       8:     NombreEnLettre:=Vdixmillion(Nombre);
       9:     NombreEnLettre:=Vcentmillion(Nombre);
      10:     NombreEnLettre:=Vmilliard(Nombre);
      11:     NombreEnLettre:=Vdixmilliard(Nombre);
      12:     NombreEnLettre:=Vcentmilliard(Nombre);
      13:     NombreEnLettre:=Vbillion(Nombre);
      14:     NombreEnLettre:=Vdixbillion(Nombre);
      15:     NombreEnLettre:=Vcentbillion(Nombre);
      16:     NombreEnLettre:=Vbilliard(Nombre);
      17:     NombreEnLettre:=Vdixbilliard(Nombre);
      18:     NombreEnLettre:=Vcentbilliard(Nombre);
  end;
end
End;
//------------------------------------------------------------------------------
end.

A voir également

Ajouter un commentaire Commentaires
Messages postés
2226
Date d'inscription
dimanche 5 octobre 2003
Statut
Modérateur
Dernière intervention
18 novembre 2010
13
Pas eu le courage de relire 18 fois le même genre de procédure. ce système à ses propres limites. Vraiment pas top, regardes les liens du premiers posts, là ok.
Messages postés
1
Date d'inscription
jeudi 6 décembre 2007
Statut
Membre
Dernière intervention
13 août 2008

[qui peut être utile pour des applications de facturation"
=> Ben dis donc ils facturent chers !!! ça vous fera 999999999999999999 €]
tu peut dir qu'ils facrurent chers !!! ça vous fera 99999999999999 € si tu utilisie les autres sources de conversion aussi, merci pour le commentaire constructif
Messages postés
4297
Date d'inscription
samedi 19 janvier 2002
Statut
Modérateur
Dernière intervention
9 janvier 2013
30
De plus, le code ne gère pas les décimales. Or, en matière de facturation, il y a une fâcheuse tendance à mettre des ",99" un peu partout. Le code est lourd mais comme il s'agit d'un niveau débutant et apparemment la première source de hror, on peut admettre quelques gaffes. On sent qu'il y a eu un travail préalable de réflexion. Néanmoins, je lui suggère d'étudier les liens indiqués par cantador, ça ne pourra que lui être bénéfique.
Personnellement je trouve que, pour un début, ce n'est pas si mal et que ça mérite des encouragements.
Messages postés
3793
Date d'inscription
samedi 22 décembre 2007
Statut
Membre
Dernière intervention
3 juin 2016
8
Bonjour,
étrange, avec "Edit1" il me balance "mille cent".
J'ai aussi dû corriger l'unité (mettre la fonction principale en déclaration dans Interface) et réécrire "millions" correctement ...
Le "vingt" pose plus de problèmes que l'on croit, car il doit se placer avec un "s" a la fin dans certains cas ...

Cordialement, Bacterius !
Messages postés
4715
Date d'inscription
dimanche 26 février 2006
Statut
Modérateur
Dernière intervention
27 mars 2018
13
Autre chose la fonction de conversion n'est pas publiée de sorte que le programme est
inutilisable en l'état...

et par ailleurs, il n'intègre pas les nombreuses règles d'accord concernant les nombres en lettres.
ex:

* quatre-vingts
* quatre cents
* quatre cent vingt et un

Ce qui fait que ce développement est beaucoup plus complexe qu'il n'y paraît.
Afficher les 6 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.