Banken verlangen häufig, daß Zahlen nicht nur in Ziffern, sondern auch in Worten angegeben werden.

Beispiel: 42     zweiundvierzig
          425    vierhundertfünfundzwanzig
          1300   eintausenddreihundert
          24201  vierundzwanzigtausendzweihunderteins
          101000 einhunderteintausend
          400016 vierhunderttausendsechzehn

Aufgabe:
Schreibe ein Programm, welches natürliche Zahlen zwischen 1 und 999999 korrekt in Worten ausgeben kann.
Erläutere ausführlich das Konstruktionsprinzip.

Lösungsidee und Programmdokumentation:

Prinzipiell werden deutsche Zahlwörter vergleichsweise regelmäßig gebildet:
Aus 735629 wird 7 hundert 5 und 30 tausend 6 hundert 9 und 20.
Ausnahmen bilden dabei elf, zwölf, sechzehn (weil das s am Ende der 6 fehlt) und siebzehn (es heißt nicht siebenzehn). Auch bei den Zehnern gibt es diverse Ausnahmen, nämlich zwanzig, dreißig, sechzig und siebzig.
Am einfachsten geht man mit diesen Ausnahmen um, indem man die Zahlen von 1 bis 20 und alle Zehner als Konstanten vereinbart.
Schließlich muß man noch auf die 1 aufpassen, denn bei auf 01 endenden Zahlen muß es eins heißen, innerhalb der Zahlwörter jedoch ein.

Für die Konstanten von 1 bis 19 verwenden wir ein Array klein, für die Zehner ein Array zig. Dann definieren wir drei Funktionen zehner, hunderter und tausender, die für die korrekte Umwandlung der Zahlen von 0 bis 99, von 100 bis 999 und von Zahlen ab 1000 sorgen.
Am einfachsten ist dabei die Funktion tausender, da sie nur wieder die Funktion hunderter aufruft und das Wort tausend einfügt.
In der Funktion hunderter wird mittels Division durch 100 berechnet, wieviele Hunderter in der Zahl enthalten sind und dafür gesorgt, daß nur dann das Wort hundert eingefügt wird, wenn es tatsächlich gebraucht wird. Der noch nicht in Buchstaben verwandelte Teil der eingegebenen Zahl wird mittels der Modulo-Funktion ermittelt und wiederum an die Funktion hunderter übergeben.
Wenn es im Rest keine Hunderter mehr gibt, wird die Funktion zehner aufgerufen.

In der Funktion zehner wird überprüft, ob für die umzusetzende Zahl eine Konstante vereinbart wurde. Wenn ja, wird diese eingesetzt, ansonsten wird die Zahl in ihren Zehner- und ihren Einerteil aufgespaltet (wieder mittels DIV und MOD) und die Wörter für diese beiden Teile werden, falls nötig, durch und verbunden.

Die Berechnung des Wortes für die eingegebene Zahl wird gestartet durch den Aufruf der Funktionen tausender(zahl DIV 1000) und hunderter(zahl MOD 1000). Die Ergebnisse der Funktionsaufrufe werden aneinandergehängt. Schließlich wird vor der Ausgabe noch geprüft, ob das ermittelte Wort auf ein endet, und wenn ja, wird ein sangehängt.

Die Eingabe von zu großen Zahlen führt nur zur Ausgabe "zu groß!!!", danach können weitere Zahlen eingegeben werden. Beendet wird das Programm mit der Eingabe der Null. Die Eingabe von Zeichen statt Ziffern wird nicht abgefangen, sie führt zum Absturz des Programms.

Halbformale Programmbeschreibung:

Das Programm ist so kurz, daß jede halbformale Programmbeschreibung, die mehr enthält als nur
Einlesen der Zahl
Umwandeln in Zeichen
Ausgeben
nur unwesentlich kürzer wäre als das Programm. Außerdem sollte die Vorgehensweise nach der ausführlichen Erläuterung der Lösungsidee anhand des Programmtextes leicht nachvollziehbar sein.

Bildschirmausgabe:

0 <= Zahl <= 999999: 1001
eintausendeins
0 <= Zahl <= 999999: 666
sechshundertsechsundsechzig
0 <= Zahl <= 999999: 777
siebenhundertsiebenundsiebzig
0 <= Zahl <= 999999: 999999
neunhundertneunundneunzigtausendneunhundertneunundneunzig
0 <= Zahl <= 999999: 654321
sechshundertvierundfünfzigtausenddreihunderteinundzwanzig
0 <= Zahl <= 999999: 3432
dreitausendvierhundertzweiunddreißig
0 <= Zahl <= 999999: 75850
fünfundsiebzigtausendachthundertfünfzig
0 <= Zahl <= 999999: 1000000
zu groß!!!
0 <= Zahl <= 999999: 0


program zahlwoerter; (* Lothar Oppor *)

var
 klein : array[1..19] of string[10];
 zig : array[2..9] of string[10];
 zahl : longint;
 ergebnis: string;

procedure init;
begin
  klein[1] := 'ein';
  klein[2] := 'zwei';
  klein[3] := 'drei';
  klein[4] := 'vier';
  klein[5] := 'fünf';
  klein[6] := 'sechs';
  klein[7] := 'sieben';
  klein[8] := 'acht';
  klein[9] := 'neun';
  klein[10] := 'zehn';
  klein[11] := 'elf';
  klein[12] := 'zwölf';
  klein[13] := 'dreizehn';
  klein[14] := 'vierzehn';
  klein[15] := 'fünfzehn';
  klein[16] := 'sechzehn';
  klein[17] := 'siebzehn';
  klein[18] := 'achtzehn';
  klein[19] := 'neunzehn';
  zig[2] := 'zwanzig';
  zig[3] := 'dreißig';
  zig[4] := 'vierzig';
  zig[5] := 'fünfzig';
  zig[6] := 'sechzig';
  zig[7] := 'siebzig';
  zig[8] := 'achtzig';
  zig[9] := 'neunzig';
end; (* init*)


function zehner(z : longint) : string;

begin
 if z < 1 then zehner := ''
 else if z <= 19 then zehner := klein[z]
 else if (z mod 10) = 0 then
  zehner := zig[z div 10]
 else zehner := klein[z mod 10] + 'und'
       + zig[z div 10]
end; (* zehner *)


function hunderter(z: longint) : string;

begin
 if z < 1 then hunderter := ''
 else if z < 100 then hunderter := zehner(z)
 else hunderter := klein[z div 100] +
       'hundert' + hunderter(z mod 100)
end; (* hunderter *)


function tausender (z : longint) : string;

begin
 if z < 1 then tausender := ''
 else tausender := hunderter(z) + 'tausend'
end; (* tausender *)

begin
 init;
 zahl := 0;
 while zahl >= 0 do
  begin
   write('0 <= Zahl <= 999999: ');
   readln(zahl);
   if zahl <= 0 then exit
   else if zahl <= 999999 then
   begin
    ergebnis := tausender(zahl div 1000) +
       hunderter(zahl mod 1000);
    if copy(ergebnis,length(ergebnis)-2,3) =
       'ein' then
     ergebnis := ergebnis + 's';
    writeln(ergebnis)
   end
   else
    writeln('zu groß!!!')
 end (* while *)
end.



zurück     Index