Zahlen in Wörter umwandeln

[faux]

Mit dieser Unit kann man Zahlen (0 <= n < 10^240) in Wört umwandeln:

Delphi-Quellcode:

(***************************************************************************
 *                                NumUnit.pas
 *                            -------------------
 *   begin                : Wednesday, July 19, 2006
 *   copyright            : (C) 2006 Manuel Faux
 *   email                : [email][e-mail][/email]
 *   website              : [url]www.e-faux.com[/url]
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   about this file:
 *   Wandelt Zahlen (0 <= n < 10^240) in deren deutsche Namen um.
 *
 ***************************************************************************)
unit NumUnit;

interface

uses
  SysUtils, Classes;

type
  // Ziffer
  TDigit = 0..9;
  // Beliebig große Zahl
  TBigNum = array of TDigit;

const
  // Die kleinste Potenz, bei der ein Fehler auftreten würde, da der
  // Zahlennamenumfang (_Names) zu klein ist.
  // (Am besten mit <Eingabe> < Max überprüfen.)
  Max = 240;

function BuildList(Zahl: TBigNum; Full: Boolean = True;
  ShowEmpty: Boolean = True): TStrings;
function GetName(Index: Byte; Plural: Boolean = False): string;
function ConvertString(const Input: string): string;

implementation

const
  _Names: array [0..79] of string = (
    '', 'Tausend', 'Million', 'Milliarde', 'Billion', 'Billiarde', 'Trillion',
    'Trilliarde', 'Quadrillion', 'Quadrilliarde', 'Quintrillion',
    'Quintrilliarde', 'Sextillion', 'Sextilliarde', 'Septillion',
    'Septilliarde', 'Oktillion', 'Oktilliarde', 'Nonilion', 'Nonilliarde',
    'Dezillion', 'Dezilliarde', 'Undezillion', 'Undezilliarde',
    'Duodezillion', 'Duodezilliarde', 'Tredezillion', 'Tredezilliarde',
    'Quattourdezillion', 'Quattourdezilliarde', 'Quindezillion',
    'Quindezilliarde', 'Sexdezillion', 'Sexdezilliarde', 'Septendezillion',
    'Septendezilliarde', 'Octodezillion', 'Octodezilliarde', 'Novemdezillion',
    'Novemdezilliarde', 'Vingtillion', 'Vingtilliarde', 'Unvingtillion',
    'Unvingtilliarde', 'Duovingtillion', 'Duovingtilliarde', 'Trevingtillion',
    'Trevingtilliarde', 'Quattourvingtillion', 'Quattourvingtilliarde',
    'Quinvingtillion', 'Quinvingtilliarde', 'Sexvingtillion',
    'Sexvingtilliarde', 'Septenvingtillion', 'Septenvingtilliarde',
    'Octovingtillion', 'Octovingtilliarde', 'Novemvingtillion',
    'Novemvingtilliarde', 'Trigintillion', 'Trigintilliarde',
    'Untrigintillion', 'Untrigintilliarde', 'Duotrigintillion',
    'Duotrigintilliarde', 'Tretrigintillion', 'Tretrigintilliarde',
    'Quattourtrigintillion', 'Quattourtrigintilliarde', 'Quintrigintillion',
    'Quintrigintilliarde', 'Sextrigintillion', 'Sextrigintilliarde',
    'Septentrigingtillion', 'Septentrigingtilliarde', 'Octotrigintillion',
    'Octotrigintilliarde', 'Novemtrigintillion', 'Novemtrigintilliarde'
  );

(**
 * Gibt den Zahlenname für durch 3 dividierbare Potenzen aus.
 * 
 * Index - Ein drittel der Potenz deren Name ausgegeben werden soll.
 *         1 würde 'Tausend' (1 * 3 = 3), 2 'Million' (2 * 3 = 6) und
 *         7 'Trilliarde' (7 * 3 = 21) liefern.
 * Plural - Wenn True, wird das Pluralwort zurückgegeben, wenn False,
 *          das Singularwort (False: Million, True: Millionen).
 *)
function GetName(Index: Byte; Plural: Boolean = False): string; // Public
begin
  // Überprüfung, ob Index die größte Zahlendarstellungsmöglichkeit nicht
  // überschreitet.
  if Index >= Max div 3 then
    Exit;
  Result := _Names[Index];
  if (Plural) and (Result <> '') then
    case Copy(Result, Length(Result), 1)[1] of
     'n': Result := Result + 'en';
      'e': Result := Result + 'n';
    end;
end;

(**
 * Gibt den Zahlenname für Zahlen kleiner Tausend aus.
 * 
 * Zahl - Die Zahl die konvertiert werden soll.
 * Tousand - Wenn True, wird 1 als 'ein' ausgegeben, sonst als 'eine' (man
 *           sagt "eine Million/Milliarde", aber "ein Tausend").
 *)
function GetShortName(Zahl: Integer; Tousand: Boolean;
    Last: Boolean = False): string; // Private
  (**
   * Gibt den Zahlenname für Ziffern größer 1 zurück.
   *
   * AddAnd - Wenn True, wird ein 'und' am Ende angefügt.
   * Last - Gibt an, dass es sich um die letzte Ziffer eines Segments handelt.
   * Wenn True und Zahl = 1, dann wird 'eins' zurückgegeben, wenn False und
   * Zahl = 1, dann 'ein'.
   *)
  function Short(Zahl: TDigit; AddAnd: Boolean = False;
    Last: Boolean = False): string;
  begin
    case Zahl of
      1:
      begin
        if Last then
          Result := 'eins'
        else
          Result := 'ein';
      end;
      2: Result := 'zwei';
      3: Result := 'drei';
      4: Result := 'vier';
      5: Result := 'fünf';
      6: Result := 'sechs';
      7: Result := 'sieben';
      8: Result := 'acht';
      9: Result := 'neun';
    else
      Result := '';
    end;
    if (AddAnd) and (Zahl <> 0) then
      Result := Result + 'und';
  end;
var
  Temp: Byte;
begin
  Result := '';
  if Zahl >= 100 then
  begin
    case Zahl div 100 of
      1: Result := 'hundert';
    else
      Result := Short(Zahl div 100) + 'hundert';
    end;
  end;

  if Zahl >= 10 then
  begin
    Temp := Zahl - Zahl div 10 * 10;
    case (Zahl - Zahl div 100 * 100) div 10 of
      1:
      begin
        case Zahl - Zahl div 100 * 100 of
          11: Result := Result + 'elf';
          12: Result := Result + 'zwölf';
          else
            Result := Result + Short(Temp) + 'zehn';
        end;
      end;
      2: Result := Result + Short(Temp, True) + 'zwanzig';
      3: Result := Result + Short(Temp, True) + 'dreißig';
      4: Result := Result + Short(Temp, True) + 'vierzig';
      5: Result := Result + Short(Temp, True) + 'fünfzig';
      6: Result := Result + Short(Temp, True) + 'sechzig';
      7: Result := Result + Short(Temp, True) + 'siebzig';
      8: Result := Result + Short(Temp, True) + 'achzig';
      9: Result := Result + Short(Temp, True) + 'neunzig';
      0: Result := Result + Short(Temp, False, True);
    end;
  end
  else if Zahl > 0 then
  begin
    case Zahl of
      1:
      begin
        if Last then
          Result := 'eins'
        else if Tousand then
          Result := 'ein'
        else
          Result := 'eine';
      end;
    else
      Result := Short(Zahl);
    end;
  end
  else
  begin
    Result := 'null';
  end;
end;

(**
 * Der eigentliche Konverierungsvorgang. Gibt den vollen Zahlenname als
 * TStrings zurück.
 * 
 * Zahl - Die Zahl als TBigNum.
 * Full - Wenn True, wird die Anzahl der Potenzen die durch 3 teilbar sind
 *        ausgeschrieben, wenn False, werden diese in Zahlen angeschrieben
 *        (True: dreihundertsiebzehn Millionen; False: 317 Millionen)
 * ShowEmpty - Wenn False, werden Potenzen die durch 3 teilbar sind nicht
 *             ausgegeben.
 *)
function BuildList(Zahl: TBigNum; Full: Boolean = True;
  ShowEmpty: Boolean = True): TStrings; // Public
var
  i, Max, iTemp: Integer;
  Temp: string;
begin
  Temp := '';
  Result := TStringList.Create;
  Max := Length(Zahl) - 1;
  for i := Max downto 0 do
  begin
    if ((Max - i + 1) mod 3 <> 0) and (i <> 0) then
    begin
      Temp := IntToStr(Zahl[i]) + Temp;
    end
    else
    begin
      Temp := IntToStr(Zahl[i]) + Temp;
      iTemp := StrToInt(Temp);
      if (ShowEmpty) or (iTemp <> 0) or (Result.Count = 0) then
      begin
        if Full then
           Result.Add(GetShortName(iTemp, (Max - i) div 3 = 1, i >= Max - 2) +
            ' ' + GetName((Max - i) div 3, Temp <> '1'))
        else
          Result.Add(IntToStr(iTemp) + ' ' + GetName((Max - i) div 3, Temp <> '1'))
      end;
      Temp := '';
    end;
  end;
  for i := Result.Count - 1 downto 1 do
    Result.Move(0, i);
end;

(**
 * Konvertiert einen String mit der Zahl in Ziffern, in einen String mit der
 * ausgeschrieben Zahl.
 * 
 * Input - Die Zahl in Ziffern.
 *)
function ConvertString(const Input: string): string; // Public
var
  Zahl: TBigNum;
  i, Temp, Code: Integer;
  List: TStrings;
begin
  SetLength(Zahl, Length(Input));
  for i := 0 to Length(Input) - 1 do
  begin
    Val(Input[i + 1], Temp, Code);
    if Code = 0 then
      Zahl[i] := Temp
    else
      Exit;
  end;
  List := BuildList(Zahl, True, False);
  try
    Result := '';
    for i := 0 to List.Count - 1 do
      Result := Result + List[i] + ' ';
  finally
    List.Free;
end;

end.

Anwendungsbeispiel:

Delphi-Quellcode:

ShowMessage(ConvertString('23491824379127364672512543234805794095738970387623156147056320465'));
//Gibt 'dreiundzwanzig Dezilliarden vierhunderteinundneunzig Dezillionen achthundertvierundzwanzig Nonilliarden dreihundertneunundsiebzig Nonilionen hundertsiebenundzwanzig Oktilliarden dreihundertvierundsechzig Oktillionen sechshundertzweiundsiebzig Septilliarden fünfhundertzwölf Septillionen fünfhundertdreiundvierzig Sextilliarden zweihundertvierunddreißig Sextillionen achthundert Quintrilliarden siebenhundertvierundneunzig Quintrillionen fünfundneunzig Quadrilliarden siebenhundertachtunddreißig Quadrillionen neunhundertsiebzig Trilliarden dreihundertsiebenundachzig Trillionen sechshundertdreiundzwanzig Billiarden hundertsechsundfünfzig Billionen hundertsiebenundvierzig Milliarden sechsundfünfzig Millionen dreihundertzwanzig Tausend vierhundertfünfundsechzig' aus.

Grüße
Faux