# Zahlen in Worte



## ICG (29. Nov 2009)

Hallo und zwar versuche ich ein Programm zu schreiben, welches mir eingegebene Zahlen in Worten ausgibt.
Bis 99 klappt das bisher mit meinem Programm, mein Problem ist nun wie mach ich das mit den "hundertern" genau?
Wenn ich eine dreistellige Zahl durch modulo 100 teile bekomme ich die letzten beiden Zahlen, doch irgendwie weiß ich nun nicht weiter, bei meiner Ausgabe kommt jetzt erstmal nur als Beispiel 456 vierhundert raus.

Wie müsste meine Funktion geändert werden damit der Rest auch noch ausgegeben wird (Zeile 21 denke ich muss ich irgendwie modifizieren)
schon mal Danke für Tipps

Edit: okay hab es selbst gelöst hab nun nur noch paar Probleme mit der Zwanzig und paar anderen Ausnahmen.


```
public class ZahlenAusg {
    static String[] einer = { 
        "null", "eins", "zwei", "drei", "vier", 
        "fünf", "sechs", "sieben", "acht", "neun", 
        "zehn", "elf", "zwölf", "dreizehn", "vierzehn",
        "fünfzehn", "sechzehn", "siebzehn", "achtzehn", "neunzehn"
    };

    static String[] zehner = {
         null, null, "zwanzig", "dreißig", "vierzig", "fünfzig",
        "sechzig", "siebzig", "achtzig", "neunzig"
    };
   
    static String ZahlenInWorte(int Zahl) {
        
        
        
        
        if (Zahl >= 100) {
            int z = Zahl % 100;
            int e = z % 10;
            return einer[Zahl/100]+"hundert"+einer[e]+"und"+zehner[z/10];
        }

            else if(Zahl >= 20) {
            int n = Zahl % 10;
            return (ZahlenInWorte(n)) + "und" + zehner[Zahl/10];
        }
            else return einer[Zahl];
    }
}
```


----------



## Marco13 (29. Nov 2009)

Hm... bis zu welcher Größe sollen denn solche Zahlen ausgegeben werden können? Wird es da jetzt weitergehen mit

```
if (Zahl>=1000) ...
if (Zahl>=10000) ...
if (Zahl>=100000) ...
if (Zahl>=1000000) ...
if (Zahl>=10000000) ...
if (Zahl>=100000000) ...
if (Zahl>=1000000000) ...
```
?

(Das hatte ich auch mal gebastelt

```
class NumText2 {
 public static void main(String args[]) {
  System.out.println("                  0: "+X.p(                  0L));
  System.out.println("                  1: "+X.p(                  1L));
  System.out.println("                  9: "+X.p(                  9L));
  System.out.println("                 10: "+X.p(                 10L));
  System.out.println("                 11: "+X.p(                 11L));
  System.out.println("                 12: "+X.p(                 12L));
  System.out.println("                 13: "+X.p(                 13L));
  System.out.println("                 14: "+X.p(                 14L));
  System.out.println("                 15: "+X.p(                 15L));
  System.out.println("                 16: "+X.p(                 16L));
  System.out.println("                 17: "+X.p(                 17L));
  System.out.println("                 18: "+X.p(                 18L));
  System.out.println("                 19: "+X.p(                 19L));
  System.out.println("                 20: "+X.p(                 20L));
  System.out.println("                 27: "+X.p(                 27L));
  System.out.println("                100: "+X.p(                100L));
  System.out.println("                111: "+X.p(                111L));
  System.out.println("                123: "+X.p(                123L));
  System.out.println("               1000: "+X.p(               1000L));
  System.out.println("               1002: "+X.p(               1002L));
  System.out.println("               4521: "+X.p(               4521L));
  System.out.println("              34567: "+X.p(              34567L));
  System.out.println("             230518: "+X.p(             230518L));
  System.out.println("            1000000: "+X.p(            1000000L));
  System.out.println("            2000000: "+X.p(            2000000L));
  System.out.println("            4234507: "+X.p(            4234507L));
  System.out.println("           11201514: "+X.p(           11201514L));
  System.out.println("          145234567: "+X.p(          145234567L));
  System.out.println("         1000000000: "+X.p(         1000000000L));
  System.out.println("      1000000000000: "+X.p(      1000000000000L));
  System.out.println("   1000000000000000: "+X.p(   1000000000000000L));
  System.out.println(" 987000000000000001: "+X.p( 987000000000000001L));
  System.out.println("9223372036854775807: "+X.p(9223372036854775807L));
 }
}

class X{static String _,I="zig",l="zehn",J="illi",í="m"+J,ì="b"+J,f="arde",a=
"sech",b="sieb",c="ach",î[]=new String[]{_,"ein","zwei","drei","vier","fünf",a
+"s",b+"en",c+"t","neun"},T[]=new String[]{_,l,"zwan"+I,î[3]+"ßig",î[4]+I,î[5]
+I,a+I,b+I,c+I,î[9]+I},L[]=new String[]{l,"elf","zwölf",_,_,_,a+l,b+l,c+l},$[]
=new String[]{"","tausend",í+"on",í+f,ì+"on",ì+f,"tr"+J+"on"};static String p(
long n){return(n==0?""+_:p(n,0));}static String p(long n,int k){String r="";if
(n%1000==0)return p(n/1000,k+1);int h=(int)(n%1000)/100;int t=(int)(n%100)/10;
int o=(int)(n%10);if(h>0)r+=î[h]+"hundert";if(t>0){if(t==1){if(o%6<3)r+=L[o];
else r+=î[o]+l;}else if(o==0)r+=T[t];else r+=î[o]+"und"+T[t];}else if(o>0)r+=î
[o];if(k<2)r+=$[k];else if(o==1&&t==0)r+="e"+$[k];else if(k%2==0)r+=$[k]+"en";
else r+=$[k]+"n";if(n/1000!=0)r=p(n/1000,k+1)+r;return r;}}
```
(und obfuskiert ... ich mag das irgendwie ))


----------



## javimka (29. Nov 2009)

ganz genial :lol:
Die paar if-Abfragen kannst du doch sicher noch durch ?: ersetzen


----------



## Marco13 (29. Nov 2009)

:smoke:

```
class NumText3 {
 public static void main(String args[]) {
  System.out.println("                  0: "+X.p(                  0L));
  System.out.println("                  1: "+X.p(                  1L));
  System.out.println("                  9: "+X.p(                  9L));
  System.out.println("                 10: "+X.p(                 10L));
  System.out.println("                 11: "+X.p(                 11L));
  System.out.println("                 12: "+X.p(                 12L));
  System.out.println("                 13: "+X.p(                 13L));
  System.out.println("                 14: "+X.p(                 14L));
  System.out.println("                 15: "+X.p(                 15L));
  System.out.println("                 16: "+X.p(                 16L));
  System.out.println("                 17: "+X.p(                 17L));
  System.out.println("                 18: "+X.p(                 18L));
  System.out.println("                 19: "+X.p(                 19L));
  System.out.println("                 20: "+X.p(                 20L));
  System.out.println("                 27: "+X.p(                 27L));
  System.out.println("                100: "+X.p(                100L));
  System.out.println("                111: "+X.p(                111L));
  System.out.println("                123: "+X.p(                123L));
  System.out.println("               1000: "+X.p(               1000L));
  System.out.println("               1002: "+X.p(               1002L));
  System.out.println("               4521: "+X.p(               4521L));
  System.out.println("              34567: "+X.p(              34567L));
  System.out.println("             230518: "+X.p(             230518L));
  System.out.println("            1000000: "+X.p(            1000000L));
  System.out.println("            2000000: "+X.p(            2000000L));
  System.out.println("            4234507: "+X.p(            4234507L));
  System.out.println("           11201514: "+X.p(           11201514L));
  System.out.println("          145234567: "+X.p(          145234567L));
  System.out.println("         1000000000: "+X.p(         1000000000L));
  System.out.println("      1000000000000: "+X.p(      1000000000000L));
  System.out.println("   1000000000000000: "+X.p(   1000000000000000L));
  System.out.println(" 987000000000000001: "+X.p( 987000000000000001L));
  System.out.println("9223372036854775807: "+X.p(9223372036854775807L));
 }
}

class X{String _,T="zig",m="mill",b="bill",O="ion",A="iarde",s="sieb",x="sech",
i="zwölf",y="ach",v="en",N[]={"","ein","zwei","drei","vier","fünf",x+"s",s+v,y+
"t","neun"},g="elf",u[]={"","zehn","zwan"+T,N[3]+"ßig",N[4]+T,N[5]+T,x+T,s+T,y+
T,N[9]+T},M[]={"","tausend",m+O,m+A,b+O,b+A,"trill"+O};int z=100,c=10,w=c*z;int
h(long n){return(int)((n%w)/z);}String p(long n,int k){return n%w==0?p(n/w,k+1)
:n/w!=0?p(n/w,k+1)+q(n,k):q(n,k);}String q(long n,int k){return (h(n)!=0?N[h(n)
]+"hundert":"")+(t(n)!=0?t(n)==1?o(n)==0?u[1]:o(n)==1?g:o(n)==2?i:o(n)==6?x+u[1
]:o(n)==7?s+u[1]:o(n)==8?y+u[1]:N[o(n)]+u[1]:o(n)==0?u[t(n)]:N[o(n)]+"und"+u[t(
n)]:N[o(n)])+(k<=1?M[k]:o(n)==1&&t(n)==0?"e"+M[k]:k%2==0?M[k]+v:M[k]+"n");}int
t(long n){return(int)((n%z)/c);}int o(long n){return(int)(n%c);}static String p
(long n){return new X().P(n);}String P(long n){return(n==0?_:p(n,0));}}
```


----------



## ICG (30. Nov 2009)

Also es soll von -999999 bis 999999 gehen.

Habe nun aber erstmal ein Problem mit den Zehner, da ich momentan wenn ich 50 eingebe, als Ausgabe "undfünfzig" bekomme. Habe nun eine weiter Schleife in der Schleife geschrieben für die Zehner schritte, aber irgendwie hab ich wohl ein Fehler bei meinen Klammern oder so da er ständig meckert grr.


----------



## Marco13 (30. Nov 2009)

```
int n = Zahl % 10;
if (n==0)
{
    return zehner[Zahl/10];
}
else
{
    return (ZahlenInWorte(n)) + "und" + zehner[Zahl/10];
}
```


----------



## ICG (30. Nov 2009)

Jo, danke hab es so ähnlich gelöst, also mein jetziger Programm-Code sieht so aus.

Habe nun die Tausender drin, habe aber hier wieder das Problem mit verschiedenen Zahlen wie 5000.
Irgendwie muss es da doch eine gescheite Lösung geben, dass er nur, in die 5000er Schleife geht und sich die erste Zahl schnappt und dann weiter runter in die nächste Schleife, weil so muss ich wieder Schleifen in Schleifen schreiben für die speziellen Fälle...
Als blutiger Anfänger ist das alles nicht leicht, macht aber Laune wenn es dann funktioniert wie es soll 


```
public class ZahlenAusg {
    static String[] einer = { 
        "", "eins", "zwei", "drei", "vier", 
        "fünf", "sechs", "sieben", "acht", "neun", 
        "zehn", "elf", "zwölf", "dreizehn", "vierzehn",
        "fünfzehn", "sechzehn", "siebzehn", "achtzehn", "neunzehn"
    };

    static String[] zehner = {
         null, null, "zwanzig", "dreißig", "vierzig", "fünfzig",
        "sechzig", "siebzig", "achtzig", "neunzig"
    };
   
    static String ZahlenInWorte(int Zahl) {
        
        if (Zahl == 0) {
            return "null";
        } 
       
        if (Zahl >= 1000) {
            int t = Zahl % 1000;
            int z = t % 100;
            int e = z % 10;
            return einer[Zahl/1000] + "tausend" + einer[t/100] + "hundert" + einer[e] + "und" + zehner[z/10];
        }
        
        if (Zahl >= 100) {
            int z = Zahl % 100;
            int e = z % 10;
            return einer[Zahl/100] + "hundert" + einer[e] + "und" + zehner[z/10];
        }    
        
        if (Zahl >= 20) {
            int x=0;
            x = Zahl % 10;
            
            if (x == 0) {
            return zehner[Zahl/10];
        }    
            else{
              int e = Zahl % 10;
              return einer[e] + "und" + zehner[Zahl/10];
            }
        }
        return einer[Zahl];
    }
}
```


----------



## Marco13 (30. Nov 2009)

Das gleiche wie oben:
einer[Zahl/1000] + "tausend" + einer[t/100] + "hundert" + einer[e] + "und" + zehner[z/10];
wird in einer if-Abfrage aufgeteilt werden müssen, damit Zahlen, die keine 100er, 10er oder 1er enthalten richtig behandelt werden....


----------



## ICG (30. Nov 2009)

So ich schreibe gerade mein ganzes Programm um, gibt es denn eine Möglichkeit eine Schleife sofort zu beenden, wenn die eingegebene Zahl in der Schleife geteilt wird und als Ergebnis 0 rauskommt?
Habe bischen rum probiert, aber wüsste jetzt nicht, wie ich das aufschreiben könnte, vielleicht hat ja jemand mehr Ahnung und mag mir helfen, wie ich das in der Schleife schreiben müsste, habe mal was in einem anderen Programm mit "break" gesehen, aber so klappt das nicht wie ich es gemacht habe...


```
if (Zahl < 1000000) {
            Zahlen = einer[Zahl/100000]+"hunderttausend";
            Zahl = Zahl % 100000;
            if (Zahl == 0); break;
```


----------



## Marco13 (30. Nov 2009)

Wenn dann ohne Semikolon hinter der ")"
if (Zahl == 0) break;
Aber in deinem Programm kam bisher keine Schleife vor (außer den if-Schleifen  ), deswegen gehe ich davon aus, dass du etwas anderes meinst.


----------

