Chiffres en lettres et récursivité

Télécharger le projet
Commenter

Description

Ce n'est pas la première source du genre mais juste une autre façon d'aborder la question en mettant en oeuvre la récursivité.
Facilement extensible, ce code avait, à l'origine, pour seul but de transformer sous forme littérale une année fournie en chiffres.
Limitations :
La fonction Int2Letters ne gère donc pas de décimales et ne traite que les nombres de quatre chiffres au maximum.
Mise en oeuvre de la surcharge de fonctions(voir annotations plus bas).

Source / Exemple : 


{-----------------------------------------------------------------------------
 Unit Name: ChiffresEnLettres
 Author:    delphiprog
 Purpose:   convertir un nombre entier en toutes lettres en utilisant
            la récursivité. La fonction Int2Letters n'est pas transposable
            dans d'autres langues car elle tient compte des particularités
            grammaticales de la langue française uniquement.
            C'est aussi l'occasion d'utiliser la surcharge de fonctions,
            disponible depuis Delphi 5 ou 6.
            
 History:
   02/05/2003 publication sur DelphiFr.com
-----------------------------------------------------------------------------}

unit ChiffresEnLettres;

interface
  {La fonction Int2Letters reçoit un nombre sous forme de chaine et renvoie
  son équivalent sous forme littérale.
  Exemple :
  Var
    S : string;
  begin
    S := '1971';
    S := Int2Letters(S);
    ShowMessage(S); //-> mille neuf cent soixante et onze
  end;}
  function Int2Letters(const ANumber: string): string;overload;
  {La fonction Int2Letters reçoit un paramètre sous forme d'entier et renvoie
  son équivalent sous forme littérale. Attention, seuls les entiers de
  4 chiffres maximum seront autorisés.}
  function Int2Letters(const ANumber: integer):string;overload;

implementation

uses
  SysUtils;

const
  Chiffres: array['0'..'9'] of string =
  ('', 'un ', 'deux ', 'trois ', 'quatre ',
    'cinq ', 'six ', 'sept ', 'huit ', 'neuf ');

  LaDizaine: array['0'..'9'] of string =
  ('dix', 'onze', 'douze', 'treize', 'quatorze',
    'quinze', 'seize', 'dix sept', 'dix huit', 'dix neuf');

  Dizaines: array['0'..'9'] of string =
  ('', 'dix ', 'vingt ', 'trente ', 'quarante ',
    'cinquante ', 'soixante ', 'soixante ', 'quatre vingt ',
      'quatre vingt dix ');

function Int2Letters(const ANumber: string): string;
var
  Verif: integer;
  Temp: string;
begin
  Verif := StrToIntDef(ANumber, -1);
  if Verif = -1 then
    Result := Format('%s n''est pas un Chiffres valide', [ANumber])
  else
    case Length(ANumber) of
      4: //Traitement des milliers
        begin
          case ANumber[1] of
            '1': Result := 'mille ';
          else
            Result := Chiffres[ANumber[1]] + 'mille ';
          end;
          Temp := Copy(Anumber, 2, 3);
          Result := Result + Int2Letters(Temp);
        end;
        //Fin Traitement des milliers

      3: //Traitement des centaines
        begin
          case Anumber[1] of
            '0': Result := EmptyStr;
            '1': Result := 'cent ';
          else
            Result := Chiffres[ANumber[1]] + 'cent ';
          end;
          Temp := Copy(ANumber, 2, 2);
          Result := Result + Int2Letters(Temp);
        end;
        //Fin Traitement des centaines

      2: //Traitement des dizaines
        begin
          case ANumber[1] of
            '0':
              begin
                Result := EmptyStr;
                Temp := Copy(Anumber, 2, 1);
                Result := Int2Letters(Temp);
              end;

            '1':
              case ANumber[2] of
                '1'..'6': Result := LaDizaine[ANumber[2]];
              else
                begin
                  Temp := Copy(Anumber, 2, 1);
                  Result := 'dix ' + Int2Letters(Temp);
                end;
              end;

            '2'..'6' :
              case ANumber[2] of
                '0': Result := Dizaines[ANumber[1]];
                '1':
                  begin
                    Result := Dizaines[ANumber[1]] + 'et ';
                    Temp := ANumber[2];
                    Result := Result + Int2Letters(Temp);
                  end;
              else
                begin
                  Result := Dizaines[ANumber[1]];
                  Temp := ANumber[2];
                  Result := Result + Int2Letters(Temp);
                end;
              end;

            '7':
              begin
                case ANumber[2] of
                  '1': Result := Dizaines[ANumber[1]] + 'et ';
                else
                  Result := Dizaines[ANumber[1]];
                end;
                Result := Result + LaDizaine[ANumber[2]];
              end;

            '8':
              begin
                Result := Dizaines[ANumber[1]];
                Temp := ANumber[2];
                Result := Result + Int2Letters(Temp);
              end;

            '9':
              case ANumber[2] of
                '0': Result := Dizaines[ANumber[1]];
              else
                begin
                  Result := Dizaines[pred(ANumber[1])];
                  Result := Result + LaDizaine[ANumber[2]];
                end;
              end;

          end;
        end;
        //Fin Traitement des dizaines
        
      1: //Traitement des unités
          Result := Chiffres[ANumber[1]];

    else
      Result := 'Chiffres trop grand : 4 chiffres maximum autorisés';
    end; {case Length(ANumber)}

end;

function Int2Letters(const ANumber: integer):string;
begin
  Result := Int2Letters(IntToStr(ANumber));
end;

end.

Conclusion :


Compatible D6 et + seulement du fait des directives Overload (surcharge des fonctions).
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_Delphiprog)