# Zahl zu Text Umwandeln



## Victorinus (18. Feb 2012)

Hallo,

Ich soll für die Schule ein Java Programm schreiben welches Zahlen in Texte umwandelt.
Wir sollen dafür If/else oder switch case benutzen.

soweit so gut das kann ich alles aber es sind zahlen von 0-99 und wir sollen so wenig wie möglich if/else oder switch cases benutzen

hier Meine Frage:

Kann man das mit Arrays z.B. vereinfachen oder i-wie anders?

nicht einfach 

```
if(Integer.valueOf(zahl) == 4){
      System.out.println("Vier");
    }
```

Sondern so das man nicht nur 1 Zahl pro If anweisung hat :S

Danke im Voraus


----------



## gasssst (18. Feb 2012)

Da die deutschen Zahlen von zwanzig bis neunundneunzig alle mehr oder weniger identisch aufgebaut sind lässt sich das natürlich vereinfachen.

Arrays zu benutzen wär dafür sicher sinnvoll.


----------



## Kamil (18. Feb 2012)

1 und 10-19 würde ich auch "gesondert" abfragen. Aber für den Rest würde ich mir persönlich zwei Arrays erstellen. Sowas wie einer[] und zaehner[]. Position 0 würde ich mit null belegen und den Rest einfach entsprechend der Zahl. Beispiel:

einer[8] = "acht"
zaehner[6] = "sechzig"

Dann mit subString alle eingaben > 20 splitten und direkt als Array-Stelle übergeben.

Eingabe 68:
x = 8
y = 6

println( einer[x] + "und" + zaehner[y])


----------



## jDennis79 (18. Feb 2012)

"z*ä*hner"? Really?


----------



## Landei (18. Feb 2012)

Du kannst doch die Zahl als Array-Index verwenden:


```
private final String[] EINER = {"null","eins","zwei","drei","vier","fünf","schweinkram","sieben","acht","neun"};

public String einer(int i) {
   return EINER[i];
}
```

Bei den weiteren Werten wird es natürlich etwas schwieriger...


----------



## Kamil (18. Feb 2012)

jDennis79 hat gesagt.:


> "z*ä*hner"? Really?



Mein Gott. Kann schon mal passieren. Ich bitte aufrichtig um Värzeihung. Such' den Fehler.


----------



## victorinus (19. Feb 2012)

Kamil hat gesagt.:


> 1 und 10-19 würde ich auch "gesondert" abfragen. Aber für den Rest würde ich mir persönlich zwei Arrays erstellen. Sowas wie einer[] und zaehner[]. Position 0 würde ich mit null belegen und den Rest einfach entsprechend der Zahl. Beispiel:
> 
> einer[8] = "acht"
> zaehner[6] = "sechzig"
> ...




ok danke und wenn ich das als if habe wie kann ich das machen das wenn der 68 angibt ich nicht 68 verschiedene ifs brauche um von 1-68 zu ommen?

da liegt mein Hauptproblem wir sollen so wenige wie möglich haben und ich wüsste nicht wie ichs in Java bewerkstellige


----------



## Marco13 (19. Feb 2012)

int zahl = 68;
int zähnerIndex = zahl/10; // Ergibt 6
int einerIndex = zahl%10; // Ergibt 8

Die Indizes jetzt verwenden um auf die Arrays zuzugreifen


----------



## Landei (19. Feb 2012)

Kamil hat gesagt.:


> [c]println( einer[x] + "und" + zaehner[y])[/c]



Aha, 70 gibt dann also "nullundsiebzig"...


----------



## victorinus (19. Feb 2012)

Hm ja wie ich aus 50 fünzig mache weiß ich ja an sich aber ich kann ja mal den geasmten quelltext posten wie es nicht aussehen sollte


```
Scanner pl = new Scanner(System.in);
   int zahl;
   zahl = pl.nextInt();
    if(Integer.valueOf(zahl) == 0){
      System.out.println("null");
    }
    if(Integer.valueOf(zahl) == 1){
      System.out.println("eins");
    }
    if(Integer.valueOf(zahl) == 2){
      System.out.println("zwei");
    }
    if(Integer.valueOf(zahl) == 3){
      System.out.println("drei");
    }
    if(Integer.valueOf(zahl) == 4){
      System.out.println("vier");
    }
    if(Integer.valueOf(zahl) == 5){
      System.out.println("fünf");
    }
    if(Integer.valueOf(zahl) == 6){
      System.out.println("sechs");
    }
    if(Integer.valueOf(zahl) == 7){
      System.out.println("sieben");
    }
    if(Integer.valueOf(zahl) == 8){
      System.out.println("acht");
    }
    if(Integer.valueOf(zahl) == 9){
      System.out.println("neun");
    }
    if(Integer.valueOf(zahl) == 10){
      System.out.println("zehn");
    }
    if(Integer.valueOf(zahl) == 11){
      System.out.println("elf");
    }
    if(Integer.valueOf(zahl) == 12){
      System.out.println("zwölf");
    }
    if(Integer.valueOf(zahl) == 20){
      System.out.println("zwanzig");
    }
    if(Integer.valueOf(zahl) == 30){
      System.out.println("dreizig");
    }
    if(Integer.valueOf(zahl) == 40){
      System.out.println("vierzig");
    }
    if(Integer.valueOf(zahl) == 50){
      System.out.println("fünfzig");
    }
    if(Integer.valueOf(zahl) == 60){
      System.out.println("sechzig");
    }
    if(Integer.valueOf(zahl) == 70){
      System.out.println("siebzig");
    }
    if(Integer.valueOf(zahl) == 80){
      System.out.println("achtzig");
    }
    if(Integer.valueOf(zahl) == 90){
      System.out.println("neunzig");
    }
```

So würden es zu viele if's sein mein Problem ist lediglich das ich in wengier als 10 if abfragen alle zahlen von 0-99 also auch 66 oder 46 oder 98 oder 32 udn so haben kann und ich weiß nicht wie ich mehrere zaheln in einer if abfrage haben kann weil sich das für mich komisch anhört und arrays brauch man nicht unbedingt wurde mir egsagt aber man einer hat sie verwendet sagt bloss nicht wie


----------



## Pentalon (19. Feb 2012)

```
public class zahlalswort {

	static String nullbis19[] = {"null", "ein", "zwei", "drei", "vier", "fuenf", "sechs", "sieben",
						  "acht", "neun", "zehn", "elf", "zwoelf", "dreizehn", "vierzehn",
						  "fuenfzehn", "sechzehn", "siebzehn", "achtzehn", "neunzehn"};
	
	static String groesser[] = {"","","zwanzig", "dreissig", "vierzig", "fuenfzig", "sechzig",
						 "siebzig", "achtzig", "neunzig"};
	
	static int zahl=0;
	static int zehner = 0;
	static int einer = 0;
	
//----------------------------------------------------------	
	
	public static String Zahl2Wort(int zahl) {
		if (zahl == 1) return("Die Zahl lautet eins"); 
		
		if (zahl < 20) 
			return("Die Zahl lautet "+nullbis19[zahl]);
			
		// Zerlege die gesuchte Zahl in Zehner und einer
		zehner = zahl / 10;
		einer = zahl % 10;
			
		if (einer == 0)
			return("Die Zahl lautet "+groesser[zehner]);
		else
			return("Die Zahl lautet "+nullbis19[einer]+"und"+groesser[zehner]);
	}
	
//***********************************************************
// MAIN
//***********************************************************	
	
	public static void main (String[] args)
	{ 
		for(zahl = 0; zahl < 100; zahl++) {
			System.out.println(Zahl2Wort(zahl));
		}
	}
}
```

Schöne Grüsse


----------



## HimBromBeere (19. Feb 2012)

Mach mal erstmal einen switch da drauß, dann sieht die Sache auch schon wieder netter aus:

```
switch (Integer.valueOf(zahl)) {
    case 0: ... break;
    case 1: ... break;
    case 2: ... break;
    ....
}
```


----------



## irgendjemand (19. Feb 2012)

Marco13 hat gesagt.:


> int z*ä*hnerIndex



nicht dein ernst oder ?


----------



## jDennis79 (19. Feb 2012)

irgendjemand hat gesagt.:


> nicht dein ernst oder ?



Quatsch. Das war 'ne Anspielung auf mein "Gemecker" weiter oben.


----------



## irgendjemand (19. Feb 2012)

gut ... das hier viele neulinge auf grund ihres alters meist kein englisch können ... oder wenn dann nur schlecht ... daran haben wir uns ja gewöhnt ... aber wenigstens DEUTSCH sollte man können wenn man schon als deutscher in nem deutschen forum postet *versteht das jetzt bitte nicht rechtsradikal ... aber solche DUMMEN fehler wie zehn mit ä schreiben sind echt zu krass *wobei es mich in der heutigen zeit auch nicht gerade wundert**


----------



## HoaX (19. Feb 2012)

irgendjemand hat gesagt.:


> gut ... das hier viele neulinge auf grund ihres alters meist kein englisch können ... oder wenn dann nur schlecht ... daran haben wir uns ja gewöhnt ... aber wenigstens DEUTSCH sollte man können wenn man schon als deutscher in nem deutschen forum postet *versteht das jetzt bitte nicht rechtsradikal ... aber solche DUMMEN fehler wie zehn mit ä schreiben sind echt zu krass *wobei es mich in der heutigen zeit auch nicht gerade wundert**



Na dann sei doch mal ein gutes Vorbild und fang mal an und schreib nicht immer alles klein und gelegentlich einzelne Worte komplett groß, und lass die komischen, undeutschen * weg. Wer im Glashaus sitzt...


----------



## jDennis79 (19. Feb 2012)

irgendjemand hat gesagt.:


> gut ... das hier viele neulinge auf grund ihres alters meist kein englisch können ... oder wenn*,* dann nur schlecht ... daran haben wir uns ja gewöhnt ... aber wenigstens DEUTSCH sollte man können*,* wenn man schon als deutscher in *'*nem deutschen forum postet*.* *versteht das jetzt bitte nicht **rechtsradikal* ... aber solche DUMMEN fehler*,* wie zehn mit ä **schreiben**,* sind echt zu krass*.* *wobei es mich in der heutigen zeit auch nicht gerade wundert**



Fehler sind unterstrichen, ungrammatische Satzkonstruktionen und fehlende Satzzeichen sind in Fettschrift markiert. Jeden Satz mit drei Punkten zu beenden, ist darüber hinaus stilistisch nicht besonders einfallsreich.

Wie HoaX schon sagte, "wer im Glashaus sitzt...".


----------



## Landei (19. Feb 2012)

victorinus hat gesagt.:


> ... Code ...
> 
> So würden es zu viele if's sein mein Problem ist lediglich das ich in wengier als 10 if abfragen alle zahlen von 0-99 also auch 66 oder 46 oder 98 oder 32 udn so haben kann und ich weiß nicht wie ich mehrere zaheln in einer if abfrage haben kann weil sich das für mich komisch anhört und arrays brauch man nicht unbedingt wurde mir egsagt aber man einer hat sie verwendet sagt bloss nicht wie



Wofür haben wir die Hinweise mit dem Array oben überhaupt gegeben, wenn du sie nicht liest? Sie sind hier die mit Abstand einfachste Lösung. Damit wärst du selber auf Pentalon's Code gekommen...


----------



## Marco13 (19. Feb 2012)

Die Alternative wäre noch, mit einer Forensuche auf http://www.java-forum.org/java-basics-anfaenger-themen/101353-int-string-umwandeln.html#post645321 zu stoßen... Sind zwar viele if's, dafür nicht nur so'n Kinderkram wie 1-99, sondern bis neun Trillionen zweihundertdreiundzwanzig Milliarden dreihundertzweiundsiebzig Billionen sechsunddreißig Milliarden achthundertvierundfünfzig Millionen siebenhundertfünfundsiebzigtausend achthundertsieben


----------



## Numue1332 (21. Feb 2012)

Hab versucht den Code so umzuschreiben, dass es für zahlen von 1-9999 funktioniert. Krieg aber bloß nen "Unreachable Code" Error, weiß jemand warum der Code nicht erreicht wird an der Stelle 'if (zahl < 1000)' ? Ich find den fehler irgendwie nicht -.- ...

Auch würde mich interessiere wie man das umgekehrt hinbekommt ("eins" wird zu "1" etc.) . Mit vielen If's kann man das natürlich machen, aber wie macht man das mit möglichst wenigen if's ?


```
public class zahlzuwort {
			 
		    static String nullbis19[] = {"null", "ein", "zwei", "drei", "vier", "fuenf", "sechs", "sieben",
		                          "acht", "neun", "zehn", "elf", "zwoelf", "dreizehn", "vierzehn",
		                          "fuenfzehn", "sechzehn", "siebzehn", "achtzehn", "neunzehn"};
		    
		    static String groesser[] = {"","","zwanzig", "dreissig", "vierzig", "fuenfzig", "sechzig",
		                         "siebzig", "achtzig", "neunzig"};
		    
		    static int zahl = 0;			// wert von Textbox I (eingabewert)
		    static int einer = 0;
			static int zehner = 0;
			static int hunderter = 0;
			static int tausender = 0;
		    
		//----------------------------------------------------------    
		    
		    public static String Zahl2Wort(int zahl) {
			
				// Zahl zu groß, zu klein oder keine zahl
					if (zahl <= 0 & zahl > 9999)
						return("Zahl liegt nicht im gültigen Bereich! {1-9999}");
			
		        // Zerlege die gesuchte Zahl in Tausender, Hunderter, Zehner und einer
				if (zahl < 10000) 
					tausender = zahl / 1000;				// zahl : 1000
					hunderter = ((zahl % 1000)/100);		// zahl : 1000 ; rest : 100
					zehner = ((zahl % 100)/10);				// zahl : 100 ; rest : 10
					einer = zahl % 10;						// zahl : 10 ; rest
					
					if (einer == 0 & zehner == 0 & hunderter == 0)
						return(nullbis19[tausender]+"tausend");
					else if (einer == 0 & zehner == 0)
						return(nullbis19[tausender]+"tausend"+nullbis19[hunderter]+"hundert");
					else if (einer == 0)
						return(nullbis19[tausender]+"tausend"+nullbis19[hunderter]+"hundert"+groesser[zehner]);
					else
						return(nullbis19[tausender]+"tausend"+nullbis19[hunderter]+"hundert"+nullbis19[einer]+"und"+groesser[zehner]);
				
				// Zerlege die gesuchte Zahl in Hunderter, Zehner und Einer
				if (zahl < 1000 ) // <-- Ab hier "Unreachable Code"
					hunderter = zahl / 100;				// zahl : 100
					zehner = ((zahl % 100)/10);			// zahl : 100 ; rest : 10
					einer = zahl % 10;					// zahl : 10 ; rest
					
					if (einer == 0 & zehner == 0)
						return(nullbis19[hunderter]+"hundert");
					else if (einer == 0)
						return(nullbis19[hunderter]+"hundert"+groesser[zehner]);
					else
						return(nullbis19[hunderter]+"hundert"+nullbis19[einer]+"und"+groesser[zehner]);
		                           
		        // Zerlege die gesuchte Zahl in Zehner und Einer
		        if (zahl < 100)
					zehner = zahl / 10;		// zahl : 10
					einer = zahl % 10;		// zahl : 10 ; rest
				
					if (einer == 0)
						return(groesser[zehner]);
					else
						return(nullbis19[einer]+"und"+groesser[zehner]);
				
				if (zahl < 20) 
		            return(nullbis19[zahl]);
				
				if (zahl == 1) return("eins"); 
				
				
		    }
		    
			
		//***********************************************************
		// MAIN
		//***********************************************************   
		    
		    public static void main (String[] args)
		    { 
		        for(zahl = 0; zahl < 100000; zahl++) {
		            System.out.println(Zahl2Wort(zahl));
		        }
		    }
		}
```


----------



## truesoul (21. Feb 2012)

Die Zeile wird auch nie erreicht da du in der Zeile 38, 51 und 61 ein return hast.


----------



## Numue1332 (21. Feb 2012)

wäre es sinnvoller die 'if (zahl ...)' durch 'switch (zahl) case ...' zu ersetzen ?


----------



## truesoul (21. Feb 2012)

Naja, oder du setzt erstmal vernünftig die Klammern weil durch sowas:

```
if(isWahr)
   zahl = 1;

if(zahl1 == 1)
   return zahl1;
else
  return 0;

machWas(); // Wird nie erreicht!
```

kommt es so fehler wie bei dir im Code.
Dann lieber :

```
if(isWahr){
   zahl = 1;

   if(zahl1 == 1){
       return zahl1;
   }else{
       return 0;
   }
}
machWas(); // Wird erreicht wenn isWahr == false
```

[WR]ACHTUNG Pseudocode[/WR]


----------



## Numue1332 (21. Feb 2012)

danke, dass du mich auf diesen dummen fehler aufmerksam gemacht hast (wie konnte ich nur die klammern vergessen) ... aber hab dadurch jetzt ein neues problem "This method must return a result of type String" kommt dann bei 


```
public static String Zahl2Wort(int zahl)
```
 
und als lösung kommt dann entweder 

1.

```
// Zahl zu groß	
				if (zahl > 10000) {
					return("Zahl liegt nicht im gültigen Bereich! {1-9999}");		
				}
                                       Return = Null // <---
			        }
```

Was zu einer Endloschleife führt wenn ich das so in eclipse ausführe - und

2.

```
public static void Zahl2Wort(int zahl) {
```

Was dazu führt das alle return anweisungen für nichts sind weil "void" keine Werte zurückgeben kann.


----------



## Kamil (21. Feb 2012)

Landei hat gesagt.:


> Aha, 70 gibt dann also "nullundsiebzig"...



Okay, ich sehe den Denkfehler jetzt auch. Aber wieso kannst Du dann nicht gleich erklären wieso das so nicht funktioniert etc? Ernsthaft. Ich kann diese "..." nicht mehr sehen.


```
if( x != 0) {
println(einer[x] + "und" + zehner[y])
} else {
println(zehner[y])
}
```

Müsste dann ja passen, oder? (Auch wenn es grad nicht mehr relevant ist. )


----------



## Numue1332 (21. Feb 2012)

hättest du meinen ersten beitrag gelesen hättest du das auch schon gesehen  ... zu meinem jetztigen Fehler hast du aber nich zufällig grad ne lösung parat oder ? ...


----------



## Numue1332 (21. Feb 2012)

hab jetzt mit void probiert und die returns durch ne variable ersetzt, aber jetzt kommt gar nichts mehr ?? Wär schön wenn ich das heute noch zum laufen kriege weil ich das noch in ein swing applet übertragen muss (der variable zahl wird dann ein wert aus ner textbox übergeben und per button in text umgewandelt und in ner 2. textbox übertragen - was an sich ja nich so schwer ist ^^)


----------



## Landei (21. Feb 2012)

Du fragst nach   if (zahl < 10000)  und returnst in jedem der Zweige. Wie soll da jemals dein if (zahl < 1000 ) aufgerufen werden? Fazit: Du must die  Fälle aufsteigend prüfen, zuerst < 10, dann < 100 u.s.w.

Außerdem empfehle ich dir dringend, Klammern zu verwenden:


```
if (zahl < 1000 )
                    hunderter = zahl / 100;             // zahl : 100
                    zehner = ((zahl % 100)/10);         // zahl : 100 ; rest : 10
```

Durchs hübsche Einrücken kommt die letzte Zeile nicht in den Scope von if, wir sind hier nicht bei Python...


----------



## pappawinni (22. Feb 2012)

Ich weiss ja nicht, wonach ihr noch sucht, nachdem hier schon ein Link zu einer Lösung gepostet worden war.
Ich hätte auch eine, vielleicht etwas weniger elegenante Lösung:


```
import java.util.*;

public class CNumInWords {
  public static void main (String[] args) 
  {
   int n = Integer.parseInt(args[0]);
   for (int i = n ; i < n+20; i++)
     { 
      System.out.println(numberInWordsDE(i));
     }
  }
  public static String numberInWordsDE(int Zahl)
  {
   String strLower20[] = {"","ein","zwei","drei","vier","fünf",
            "sechs","sieben","acht","neun","zehn","elf","zwölf","dreizehn",
            "vierzehn","fünfzehn","sechzehn","siebzehn","achtzehn",
            "neunzehn"};
   String strTenth[] = {"","zehn","zwanzig","dreißig",
            "vierzig","fünfzig","sechzig","siebzig","achtzig",
            "neunzig","hundert"};
   String strOrder[] = {"","tausend","million","milliarde","billion"};
   String strExtend[] = {"s"," ",""," ","e","en ","e","n ","e","en "};
   String strOut = "";
   String strReturn = "";
   String strAppend = "";

   if (Zahl == 0) return "Null";
   if (Zahl < 0) return 
        "Zahl liegt nicht im gültigen Bereich! {0-2147483647}";

   int intRemaining = Zahl;
   int intA = 0;
   int intB = 0;
   int intOrder = 0;

   while (intRemaining > 0)
     {
       strAppend = strExtend[ intOrder*2 + 1 ];
       strOut = "";
       intA = intRemaining % 1000;
       intRemaining = intRemaining / 1000;
       if (intA > 99) strOut = strOut + strLower20[intA/100] + strTenth[10];
       intB = intA % 100;
       if (intB > 19) 
         { 
           if ((intB % 10) > 0 )
             { strOut = strOut + strLower20[intB % 10] + "und" ;
             }
           strOut = strOut + strTenth[intB / 10];
         }
       else 
         {
           if (intB > 0) strOut = strOut + strLower20[intB];
           if (intB == 1) 
             { strOut = strOut + strExtend[intOrder*2];
               strAppend = "";
             }
         }
       strOut = strOut + strOrder[intOrder] + strAppend;      
       intOrder++;
       strReturn = strOut + strReturn;
     }
   return strReturn;
   }
  }
```


----------



## Numue1332 (22. Feb 2012)

habs jetzt so zum laufen bekommen  ... 

hab da aber noch ne frage und zwar wie bekomme ich das hin,dass wenn ich "eins" eingebe "1" raus kommt - also genau umgekehrt ? Ich mach mal ein Beispiel :

Man macht 2 Arrays (oder switch?) für die Fälle (0-19) und (20, 30 ...).
Dann nimmt man die Eingabe die man macht in ne string variable und durchsucht diese (nach "tausend", "hundert", "und" - wenn alles nich vorkommt nimmt er nur die oben genannten fälle. ("tausend" und "hundert" haben dann fest die Werte '1000' und '100') Wenn z.b. "tausend" im String enthalten ist schneidet er den string rechts von "tausend" ab und speichert diesen "rest" in ne variable. Danach guckt man ob links von "tausend" noch was steht (wenn ja, links von "tausend" abschneiden und vergleicht das mit den Fällen). Danach macht er dasselbe halt mit dem "rest" usw. Und dann macht man z.b. wieder if anweisungen die dann das gewünschte ergebnis ausgeben sollen. (beispiel: "dreitausendeinhundert" = ("drei"+"tausend") + ("ein" + "hundert") = (3*1000) + (1*100) = 3100)

Wäre das so machbar ? wahrscheinlich gehts auch einfacher, aber hauptsache es funktioniert erstmal  - kann man das ganze dann auch noch in dem code hier einfügen ? Also ne große If-else anweisung und den ganzen code 


```
public static void main (String[] args)
    { 
//Try {
// --> If (Eingabe = numerisch) {

        String nullbis19[] = {"null", "ein", "zwei", "drei", "vier", "fuenf", "sechs", "sieben",
            "acht", "neun", "zehn", "elf", "zwoelf", "dreizehn", "vierzehn",
            "fuenfzehn", "sechzehn", "siebzehn", "achtzehn", "neunzehn"};

		String groesser[] = {"","","zwanzig", "dreissig", "vierzig", "fuenfzig", "sechzig",
           "siebzig", "achtzig", "neunzig"};
		   
		   
		Scanner sc = new Scanner(System.in);
		System.out.print("Bitte eine Zahl eingeben: ");
		int zahl = sc.nextInt();			// wert von Textbox I (eingabewert)
		String zahl2 = "";
		int einer = 0;
		int zehner = 0;
		int hunderter = 0;
		int tausender = 0;
		
		// Zahl zu klein
		if (zahl <= 0 ) {
                    zahl2 = "Zahl liegt nicht im gültigen Bereich! {1-9999}";
                    System.out.print(zahl2);
                    System.exit(0);
		}
                
		// Zahl = 1
		if (zahl == 1) { 
                    zahl2 = "eins"; 
                    System.out.print(zahl2);
                    System.exit(0);
		}
                
		// Zahl unter 20
		if (zahl < 20) {
                    zahl2 = nullbis19[zahl];
                    System.out.print(zahl2);
                    System.exit(0);
		}

		// Zerlege die gesuchte Zahl in Zehner und Einer
		if (zahl < 100) {
                    zehner = zahl / 10;		// zahl : 10
                    einer = zahl % 10;		// zahl : 10 ; rest

                    if (einer == 0) {
			zahl2 = groesser[zehner];
			System.out.print(zahl2);
                        System.exit(0);
                    }
                    
                    else {
			zahl2 = nullbis19[einer]+"und"+groesser[zehner];
			System.out.print(zahl2);
                        System.exit(0);
                    }
                }
                
		// Zerlege die gesuchte Zahl in Hunderter, Zehner und Einer
		if (zahl < 1000) {
                    hunderter = zahl / 100;				// zahl : 100
                    zehner = ((zahl % 100)/10);			// zahl : 100 ; rest : 10
                    einer = zahl % 10;					// zahl : 10 ; rest
                
                    if (einer == 0 & zehner == 0) {
			zahl2 = nullbis19[hunderter]+"hundert";
			System.out.print(zahl2);
                        System.exit(0);
                    }
                    
                    else if (einer == 0) {
			zahl2 = nullbis19[hunderter]+"hundert"+groesser[zehner];
			System.out.print(zahl2);
                        System.exit(0);
                    }
                    
                    else {
			zahl2 = nullbis19[hunderter]+"hundert"+nullbis19[einer]+"und"+groesser[zehner];
			System.out.print(zahl2);
                        System.exit(0);
                    }
                }
                
		// Zerlege die gesuchte Zahl in Tausender, Hunderter, Zehner und einer
		if (zahl < 10000) {
                    tausender = zahl / 1000;				// zahl : 1000
                    hunderter = ((zahl % 1000)/100);		// zahl : 1000 ; rest : 100
                    zehner = ((zahl % 100)/10);				// zahl : 100 ; rest : 10
                    einer = zahl % 10;						// zahl : 10 ; rest

                    if (einer == 0 & zehner == 0 & hunderter == 0) {
			zahl2 = nullbis19[tausender]+"tausend";
			System.out.print(zahl2);
                        System.exit(0);
                    }
                    
                    else if (einer == 0 & zehner == 0) {
			zahl2 = nullbis19[tausender]+"tausend"+nullbis19[hunderter]+"hundert";
			System.out.print(zahl2);
                        System.exit(0);
                    }
                    
                    else if (einer == 0) {
			zahl2 = nullbis19[tausender]+"tausend"+nullbis19[hunderter]+"hundert"+groesser[zehner];
			System.out.print(zahl2);
                        System.exit(0);
                    }
                    
                    else {
			zahl2 = nullbis19[tausender]+"tausend"+nullbis19[hunderter]+"hundert"+nullbis19[einer]+"und"+groesser[zehner];
			System.out.print(zahl2);
                        System.exit(0);
                    }
                }
                
		// Zahl zu groß	
		if (zahl > 10000) {
                    zahl2 = "Zahl liegt nicht im gültigen Bereich! {1-9999}";	
                    System.out.print(zahl2);
                    System.exit(0);
		}
// }
// ---> Else If (Eingabe enthält buchstaben) {
//                  Code
//       }
//


				
    }
```


----------



## HimBromBeere (22. Feb 2012)

Vom Prinzip ist deine Überlegung mit der Rücktransformation schonmal OK. Zum Glück hast du ja die benötigten Ziffern als Strings auch bereits da, kannst dir also ein zweites Neuanlegen auch sparen. Brauchst du nur noch ein String-Array für die 10er-Potenzen ("zwanzig", "dreißig", n-"zig", ..., "hundert", "tausend").


----------



## Numue1332 (22. Feb 2012)

Ein kleines bisschen Hilfe bei der Umsetzung könnt ich schon gebrauchen, hab erst vor ner woche mit java angefangen ...


----------



## pappawinni (22. Feb 2012)

Ich denk du solltest dir erst mal eine Strategie überlegen, ganz ohne Java.

Das kann z.B. so aussehen

Restzeichenkette = Zahlwortstring
Faktor3 = 10^9
Für Tausender (Milliarde, Million, Tausend) absteigend bis Restzeichenkette = ""
  Restzeichenkette nach Tausender durchsuchen
  Wenn gefunden oder Faktor3 = 1, dann
    Teilzeichenkette =  Zeichen vor dem Tausender
    Restzeichenkette = Restzeichenkette ab Stelle nach dem Tausender.
      Für Hunderter absteigend bis Teilzeichenkette =""
      ..
      usw.
  sonst 
    Faktor3 = Faktor3/1000
nächster Tausender

Überleg dir was.


----------



## Marco13 (22. Feb 2012)

Da ist sehr wichtig, zu wissen, was erlaubt sein soll. Bei Zahl->String ist's im Zweifelsfall egal, ob man für 3001 
dreitausendeins
oder
drei tausend und ein
ausgibt, aber bei der umgekehrten Richtung kommt man in die Hölle, wenn die Eingabe nicht genau spezifiziert ist und befolgt wird.


----------



## pappawinni (23. Feb 2012)

Ich hab mal versucht ne Strategie zu entwickeln...
Ich schreib es mal in Java-Tags, weil die Einrückungen sonst verschwinden.


```
Restzeichenkette = Zahlwortstring in Großbuchstaben gewandelt und von Zeichen befreit, die nicht A-Z oder Ö sind.
Faktor3 = 10^9
Zahl = 0
Für Tausender (MILLIARD, MILLION, TAUSEND, rest) absteigend bis Restzeichenkette = ""
  Tripple = 0
  Restzeichenkette nach Tausender durchsuchen
  Wenn gefunden oder Faktor3 = 1, dann
    Wenn Faktor3 = 1 dann    
      Teilzeichenkette = Restzeichenkette
      Restzeichenkette = ""
    Sonst
      Teilzeichenkette = Zeichen vor dem Tausender
      Restzeichenkette = Restzeichenkette ab Stelle nach dem Tausender.
    Hundert = 0
    Wenn "Hundert" in Teilzeichenkette
       Hundert = 1
       Vorspann = Zeichen vor dem Hunderter (ein,zwei.. ,neun)
       Nachspann = Zeichen nach dem Hunderter (Null...neunundneunzig)
    Sonst
       Vorspann = ""
       Nachspann = Teilzeichenkette
    Vorspann enthält
       "EIN": Einer = 1
       "ZWEI": Einer = 2           
       .
       .
       "NEUN": Einer = 9
        sonst: Einer = 0
       Tripple = Tripple + Hundert * Einer
    Wenn Nachspann enthält "UND"
       Zehner = Zeichen von Nachspann nach "UND"
       Rest = Zeichen von Nachspann vor "UND"
       Rest enthält:
         "EIN": Einer = 1
         "ZWEI": Einer = 2           
         .
         .
         "NEUN": Einer = 9
          sonst: Einer = 0
         Tripple = Tripple + Einer
       Zehner enthält
         "EIN": Einer = 1           
         .
         .
         "NEUN": Einer = 9
          sonst: Einer = 0
         Wenn Einer > 2 dann tripple = tripple + Einer * 10
    sonst
       Wenn Nachspann enthält "ZEHN"
          Nachspann enthält
            "EIN": Einer = 1
            .
            .
            "NEUN": Einer = 9
             sonst: Einer = 0
          Wenn Einer > 2 dann tripple = tripple + 10 + Einer
       Sonst         
          Nachspann enthält           
            "EIN": Einer = 1
             .
             .
            "NEUN": Einer = 9
             sonst: Einer = 0
          tripple = tripple + Einer
          Wenn Einer == 0 dann
            Nachspann enthält           
              "ELF": tripple = tripple + 11          
              "ZWÖLF": tripple = tripple + 12
              "ZWAN": tripple = tripple + 20
    Wenn Faktor3 > 1 und tripple = 0 dann tripple = 1
    Zahl = Zahl + Tripple * Faktor3
  sonst 
    Faktor3 = Faktor3/1000
nächster Tausender
Ergebnis: ZAHL
```

Es fällt auf, dass da ein Abschnitt mehrfach auftaucht. Dafür würde sich wohl eine eigene Methode lohnen.

Ich hoffe dass das prinzipiell einigermassen funktioniert und dann auch hinreichend Fehlertolerant ist.
Merkwürdigkeiten wie : "drei tausend und ein" gehn aber sicherlich in die Hose.


----------



## pappawinni (23. Feb 2012)

Ups..
Da hab ich doch gleich schon ein paar fehlerchen entdeckt.
Der Hunderter hat es in sich :shock:
zum Beispiel hab ich geschrieben:
Hundert = 1
Das muss aber heissen
Hundert = 100
Und man muss natürlich auch nach "HUNDERT" suchen, weil ich ja von einer Zeichenkette in Großbuchstaben ausgegangen bin.
und.. naja ich verrate mal noch nicht alles

Warum kann ich eigentlich jetzt den Originalbeitrag nicht mehr editieren?


----------



## Landei (23. Feb 2012)

Und was ist, wenn jemand "einhundert" statt "hundert" schreibt?


----------



## Numue1332 (23. Feb 2012)

Also hab mich jetzt mal dran gesetz nach der vorgeschlagenen Strategie zu programmieren. Werd aber erst heut abend weiter machen können, also poste ich wahrscheinlich morgen dann mein ergebnis.

Hab da noch nen Fehler beim zahl->wort programm gefunden. Alle zahlen zwischen xx00-xx20 geben als wort nach "hundert" "y+und" aus anstatt den gewünschten werten (xx = 01-99 ; y = "ein, zwei ..., neunzehn"). Wo liegt der fehler ? Hab schon rumprobiert und nichts hat geklappt


----------



## Ralle502 (23. Feb 2012)

Ich habe mich mal im Internet umgesehen und ein C++ Programm gefunden (Author unbekannt), das sich leicht in Java umsetzen lies. Wahrscheinlich gibt es auch hier Verbesserungen, aber es läuft.


```
import java.text.DecimalFormat;

public class ValueToWord {

	
	public  static void main(String[] args) {

		
		int wert = 532110456;
		String wort = "";
		DecimalFormat fs = new DecimalFormat(",###");
		
		wort =  holeWort(wert);
		System.out.println(fs.format( wert) + " ausgeschrieben: " + wort);
	}
	
	private static String unter20( int wert, boolean eins) 
	{ 
	  switch(wert) { 
	      case 1: 
	        if(eins) 
	          return("eins"); 
	        else 
	          return("ein"); 
	      case 2: return("zwei"); 
	      case 3: return("drei"); 
	      case 4: return("vier"); 
	      case 5: return("fuenf"); 
	      case 6: return("sechs"); 
	      case 7: return("sieben"); 
	      case 8: return("acht"); 
	      case 9: return("neun"); 
	      case 10: return("zehn"); 
	      case 11: return("elf"); 
	      case 12: return("zwoelf"); 
	      case 13: return("dreizehn"); 
	      case 14: return("vierzehn"); 
	      case 15: return("fünfzehn"); 
	      case 16: return("sechszehn"); 
	      case 17: return("siebzehn"); 
	      case 18: return("achtzehn"); 
	      case 19: return("neunzehn"); 
	      default: return("-Fehler-"); 
	    } 
	} 
	
	//******************************************************* 
	
	private static String zehner( int wert) 
	{ 
	  switch(wert/10) 
	    { 
	      case 2: return("zwanzig"); 
	      case 3: return("dreissig"); 
	      case 4: return("vierzig"); 
	      case 5: return("fünfzig"); 
	      case 6: return("sechzig"); 
	      case 7: return("siebzig"); 
	      case 8: return("achtzig"); 
	      case 9: return("neunzig"); 
	      default: return("-Fehler-"); 
	    } 
	} 
	
	//******************************************************* 
	
	private static String unter100( int wert,boolean eins) 
	{ 
	
	  if(wert<20) 
	    return unter20(wert,eins); 
	
	  if(wert % 10!=0) 
	    return unter20(wert%10,false)+"und"+zehner(wert); 
	  else 
	    return zehner(wert); 
	} 
	
	//******************************************************* 
	
	private static String unter1000( int wert, boolean eins) 
	{ 
	  if(wert<100) 
	    return unter100(wert,eins); 
	
	  if(wert % 100 != 0) 
	    return unter20(wert/100,false)+"hundert"+unter100(wert%100,eins); 
	  else 
	    return unter20(wert/100,false)+"hundert"; 
	} 
	
	//******************************************************* 
	
	private static String tausend( int wert) 
	{ 
	  String s=""; 
	  
	  if(wert>=1000) 
	    s=unter1000(wert/1000,false)+"tausend"; 

	  if(wert % 1000 != 0) 
	    s+=unter1000(wert%1000,true); 
	  return s; 
	
	} 
	
	//******************************************************* 
	
	private static String million( int wert) 
	{ 
	  String s=""; 
	  if(wert>=1000000) 
	    { 
	      int mil=wert/1000000; 
	      if(mil==1) 
	        s="einemillion"; 
	      else 
	        s=unter1000(mil,false)+"millionen"; 
	      wert %= 1000000; 
	    } 
	  return s+tausend(wert); 
	} 
	
	//******************************************************* 
	
	private static String milliarde( int wert) 
	{ 
	  String s=""; 
	  if(wert>=1000000000) 
	    { 
	      int mil=wert/1000000000; 
	      if(mil==1) 
	        s="einemilliarde"; 
	      else 
	        s=unter1000(mil,false)+"milliarden"; 
	      wert%=1000000000; 
	    } 
	
	  return(s+million(wert)); 
	} 
	
	//******************************************************* 
	
	private static String holeWort( int wert) 
	{ 
	  if(wert==0) 
	    return("Null"); 
	
	  String x=milliarde(wert); 
	  String s = x.substring(0,1).toUpperCase() + x.substring(1).toLowerCase();
	  return s; 
	} 
	
	//******************************************************* 
	
}
```


----------



## Numue1332 (23. Feb 2012)

hatte auch mal was gefunden , hab dann die überschrift bis "ist aber in c geschrieben" gelesen und dann weitergeguckt, kann ja kein c und bei java bin ich ja auch erst seit etwas über ner woche bei ...

schön und gut ne fertige lösung reinzustellen, aber ich glaub es ist besser wenn man auf seine fehler, die man beim programmieren nunmal macht, hingewiesen wird um diese dann zu verbessern. Man lernt dabei mehr, meiner meinung nach ...

was mich auch noch interessieren würde, wie man z.B. (wenn die zahl nicht fest eingegeben ist, sondern eingegeben wird) 

```
Scanner sc = new Scanner(System.in);
        System.out.print("Bitte eine Zahl eingeben: ");
        int zahl = sc.nextInt();
```
die eingabe der zahl beschränken kann (auf 4 zeichen ; nur zahlen ; nur text). Geht das mit nem Try-Catch befehl ? Und wenn ja wie ?


----------



## Ralle502 (23. Feb 2012)

Grundsätzlich stimmt es schon, dass man aus seinen Fehlern lernt. In diesem Fall war ich es als totaler Java-Anfänger, der einiges bei der Umsetzung des Codes gelernt hat. Andererseits freue ich mich auch über lauffähige Beispiele, die ich analysieren und vielleicht auch verbessern kann. So fehlt auch in meinem Beispiel noch einiges wie z. B. Eingabe, Fehlerprüfung und ...


----------



## pappawinni (23. Feb 2012)

Landei hat gesagt.:


> Und was ist, wenn jemand "einhundert" statt "hundert" schreibt?


Naja, es war doch schon recht spät (bzw. früh) als ich mich entschlossen hatte, noch etwas hierzu zu schreiben und das von Dir angesprochene Problem war eigentlich gelöst nur habe ich das im Zuge einer "Optimierung" verbösert.
Was noch nicht aufgefallen ist.
Es muss natürlich ausser A-Z und Ö auch Ü zulässig sein. (FÜNF)
Aber wie heisst es so schön:
"Wer einen Fehler findet, der darf ihn behalten" :lol:


----------



## pappawinni (24. Feb 2012)

So, jetzt hab ich mal nen ersten Versuch in Java für die Rückwandlung von Text zu Zahl.
Äh, ich hab hier beides drin, von Zahl zu Wort und zurück.
Es darf verbessert werden 


```
import java.util.*;

public class CNumInWords {
  public static void main (String[] args) 
  {
   int n = Integer.parseInt(args[0]);
   for (int i = n ; i < n+20; i++)
     { 
      System.out.println(numberInWordsDE(i));
      System.out.println( wordsToNumberDE(numberInWordsDE(i)) );    
     }
  }
  public static String numberInWordsDE(int Zahl)
  {
   String strLower20[] = {"","ein","zwei","drei","vier","fünf",
            "sechs","sieben","acht","neun","zehn","elf","zwölf","dreizehn",
            "vierzehn","fünfzehn","sechzehn","siebzehn","achtzehn",
            "neunzehn"};
   String strTenth[] = {"","zehn","zwanzig","dreißig",
            "vierzig","fünfzig","sechzig","siebzig","achtzig",
            "neunzig","hundert"};
   String strOrder[] = {"","tausend","million","milliarde","billion"};
   String strExtend[] = {"s"," ",""," ","e","en ","e","n ","e","en "};
   String strOut = "";
   String strReturn = "";
   String strAppend = "";

   if (Zahl == 0) return "Null";
   if (Zahl < 0) return 
        "Zahl liegt nicht im gültigen Bereich! {0-2147483647}";

   int intRemaining = Zahl;
   int intA = 0;
   int intB = 0;
   int intOrder = 0;

   while (intRemaining > 0)
     {
       strAppend = strExtend[ intOrder*2 + 1 ];
       strOut = "";
       intA = intRemaining % 1000;
       intRemaining = intRemaining / 1000;
       if (intA > 99) strOut = strOut + strLower20[intA/100] + strTenth[10];
       intB = intA % 100;
       if (intB > 19) 
         { 
           if ((intB % 10) > 0 )
             { strOut = strOut + strLower20[intB % 10] + "und" ;
             }
           strOut = strOut + strTenth[intB / 10];
         }
       else 
         {
           if (intB > 0) strOut = strOut + strLower20[intB];
           if (intB == 1) 
             { strOut = strOut + strExtend[intOrder*2];
               strAppend = " ";
             }
         }
       strOut = strOut + strOrder[intOrder] + strAppend;      
       intOrder++;
       strReturn = strOut + strReturn;
     }
   return strReturn;
  }
  public static int wordsToNumberDE(String zahlwort)
  {
     String strOrder[] = {"#","TAUSEND","MILLION","MILLIARDE"}; 
     String strRest = "";
     String strTeil = "";
     String strNach100 = "";
     int intfaktor = 1000000000;
     int intEiner = 0;
     int intZahl = 0;
     int inttripple = 0;
     int intO = 3;
     int intP = 0;

     String strRemain = zahlwort.toUpperCase();
     strRemain = strRemain.replaceAll("[^A-ZÖÜß]","");
     while ( ! strRemain.equals("") )
       {
        if (intO == 0) strRemain = strRemain +"#";
        inttripple = 0;
        intP = strRemain.indexOf(strOrder[intO]); 
        if (intP >= 0) 
          {
            strTeil = zeichenVor(strRemain,strOrder[intO]);
            strRemain = zeichenNach(strRemain,strOrder[intO]);
            strNach100 = strTeil;
            if (strTeil.indexOf("HUNDERT")>=0) 
              { 
                strNach100 = zeichenNach(strTeil,"HUNDERT");       
                intEiner = wordToDigitDE(zeichenVor(strTeil,"HUNDERT"));
                if (intEiner == 0) intEiner = 1;
                inttripple = inttripple + 100 * intEiner;
              }; 
            if (strNach100.indexOf("UND") >=0)
              {
                inttripple += wordToDigitDE(zeichenVor(strNach100,"UND"));
                strNach100 = zeichenNach(strNach100,"UND");                
              };
            if (strNach100.indexOf("IG") >=0)
              { 
                if (strNach100.indexOf("ZWANZIG")>=0) inttripple += 20 ;
                inttripple += 10 * wordToDigitDE(zeichenVor(strNach100,"IG"));
                strNach100 = zeichenNach(strNach100,"IG");
              };      
            if (strNach100.indexOf("ZEHN") >=0)
              { 
                inttripple += 10;
                intEiner = wordToDigitDE(zeichenVor(strNach100,"ZEHN"));
                if (intEiner > 2) inttripple += intEiner;                
              }
            else
              {
                inttripple += wordToDigitDE(strNach100);
                if (strNach100.indexOf("ELF")>=0) inttripple += 11 ;
                if (strNach100.indexOf("ZWÖLF")>=0) inttripple += 12 ;
              }
            if (intfaktor > 1 && inttripple == 0) inttripple = 1;  
          };
        intZahl += inttripple * intfaktor;
        intfaktor = intfaktor/1000;
        intO -= 1;
        }       
     return intZahl;  

  }
  private static int wordToDigitDE(String einerzahlwort)
  {
     if (einerzahlwort.indexOf("EIN") >= 0) return 1;
     if (einerzahlwort.indexOf("ZWEI") >= 0) return 2;
     if (einerzahlwort.indexOf("DREI") >= 0) return 3;
     if (einerzahlwort.indexOf("VIER") >= 0) return 4;
     if (einerzahlwort.indexOf("FÜNF") >= 0) return 5;
     if (einerzahlwort.indexOf("SECH") >= 0) return 6;
     if (einerzahlwort.indexOf("SIEB") >= 0) return 7;
     if (einerzahlwort.indexOf("ACHT") >= 0) return 8;
     if (einerzahlwort.indexOf("NEUN") >= 0) return 9;
     return 0;
  }
  private static String zeichenVor(String zeile,String trennwort)
  {
    String strOut = "";
    int intP = zeile.indexOf(trennwort);
    if (intP >= 0) strOut = zeile.substring(0,intP);
    return strOut; 
  }
  private static String zeichenNach(String zeile,String trennwort)
  {
    String strOut = "";
    int intP = zeile.indexOf(trennwort) + trennwort.length();
    if (intP < zeile.length())
      strOut = zeile.substring(intP,zeile.length());
    return strOut; 
  }
}
```


----------



## Numue1332 (27. Feb 2012)

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
	at CNumInWords.main(CNumInWords.java:6)
Java Result: 1

Das kommt wenn ich deinen Code ausführe, schon bei der ersten zeile des Codes ...

```
int n = Integer.parseInt(args[0]);
```


----------



## jgh (27. Feb 2012)

dann erwartet das Programm wohl beim Start eine Zahl, die in ein double geparst werden kann....


----------



## pappawinni (27. Feb 2012)

Numue1332 hat gesagt.:


> Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
> at CNumInWords.main(CNumInWords.java:6)
> Java Result: 1



ok... ich war mal wieder schlampig.
Wenn du das Programm ohne Argument aufrufst, dann geht es in die Hose.
Probiers halt mal mit:
Java CNumInWords 234
aufzurufen, dann klappt das schon.
Alternativ kannst du natürlich die Eingabe auch anders realisieren.


----------



## Landei (27. Feb 2012)

In solchen Fällen einfach einen Default einbauen: [c]int n = args.length == 0 ? 42 : Integer.parseInt(args[0]);[/c]


----------



## Numue1332 (28. Feb 2012)

Die Zahl bekommt das Programm bei mir jetzt per Eingabe mit dem Scanner : 


```
public static void main (String[] args) 
		  {
                    Scanner sc = new Scanner (System.in);
                    System.out.println("Bitte Zahl oder Wort eingeben");
                    int n = sc.nextInt();

                    System.out.println(numberInWordsDE(n));
                    System.out.println( wordsToNumberDE(numberInWordsDE(n)) );    
                        
                    }
```

Hab jetzt ne Frage und zwar :
Ich würde gerne die Eingabe abfragen lassen (NumberFormat, TextFormat) und wenn die Eingabe nur Zahlen beinhaltet, dann soll er die eingegebene Zahl in den Zahlennamen umwandeln, bei nur text halt umgekehrt und bei allen anderen eingaben soll er mir nen Message ausspucken ("Ungültige Eingabe" oder so). Wie kann ich das am besten machen ?

Edit: Die Frage hat sich erübrigt . Sobald ich fertig bin poste ich den Code hier ...


----------



## Numue1332 (28. Feb 2012)

hier dann mal der Code :

[JAVA=5]public static void main (String[] args) 
		  {

                    Scanner scan_verf = new Scanner (System.in);                                                
                    int verfahren;
                    String eingabe ;
                    int zahl;

                    do{
                        System.out.println("Gib das Verfahren an!");
                        System.out.println("[1] = Zahl zu Text ; [2] = Text zu Zahl"); 

                        while (!scan_verf.hasNextInt()) {
                            System.out.println("nur '1' oder '2' als eingabe erlaubt!");
                            scan_verf.next();
                        }                        
                        verfahren = scan_verf.nextInt();                        
                        if (verfahren == 1) {
                            Scanner scan_int = new Scanner (System.in);
                            do {
                                System.out.println("Gib eine positive Zahl kleiner 9999 ein!");
                                while (!scan_int.hasNextInt()) {
                                    System.out.println("Das ist keine Zahl!");
                                    scan_int.next(); 
                                }
                                zahl = scan_int.nextInt();
                                System.out.println(numberInWordsDE(zahl));
                            } while (zahl <= 0);	
                        }
                        else if (verfahren == 2) {
                            Scanner scan_str = new Scanner (System.in);
                            do {
                                System.out.println("Gib einen Zahlennamen in Großbuchstaben ein!");
                                while (!scan_str.hasNext("[A-Z]+")) {
                                     System.out.println("Das ist kein großgeschriebener Zahlenname!");
                                     scan_str.next(); 
                             }
                             eingabe = scan_str.next();
                             System.out.println(wordsToNumberDE(eingabe));
                            } while (eingabe == "");	
                        }                       
                        else {
                            System.out.println("nur '1' oder '2' als eingabe erlaubt!");
                            scan_verf.next();
                        }
                    } while (verfahren != 1 & verfahren != 2);
                    }

		  public static String numberInWordsDE(int Zahl)
		  {
		   String strLower20[] = {"","ein","zwei","drei","vier","fünf",
		            "sechs","sieben","acht","neun","zehn","elf","zwölf","dreizehn",
		            "vierzehn","fünfzehn","sechzehn","siebzehn","achtzehn",
		            "neunzehn"};
		   String strTenth[] = {"","zehn","zwanzig","dreißig",
		            "vierzig","fünfzig","sechzig","siebzig","achtzig",
		            "neunzig","hundert"};
		   String strOrder[] = {"","tausend","million","milliarde","billion"};
		   String strExtend[] = {"s"," ",""," ","e","en ","e","n ","e","en "};
		   String strOut = "";
		   String strReturn = "";
		   String strAppend = "";           

		   if (Zahl == 0) { 
                       return "Null";
                   }
		   if (Zahl < 0) { 
                       return "Zahl liegt nicht im gültigen Bereich! {0-9999}"; 
                   }
                   if (Zahl > 9999) {
                       return "Zahl liegt nicht im gültigen Bereich! {0-9999}";
                   }

		   int intRemaining = Zahl;
		   int intA = 0;
		   int intB = 0;
		   int intOrder = 0;

		   while (intRemaining > 0)
		     {
		       strAppend = strExtend[ intOrder*2 + 1 ];
		       strOut = "";
		       intA = intRemaining % 1000;
		       intRemaining = intRemaining / 1000;
		       if (intA > 99) strOut = strOut + strLower20[intA/100] + strTenth[10];
		       intB = intA % 100;
		       if (intB > 19) 
		         { 
		           if ((intB % 10) > 0 )
		             { strOut = strOut + strLower20[intB % 10] + "und" ;
		             }
		           strOut = strOut + strTenth[intB / 10];
		         }
		       else 
		         {
		           if (intB > 0) strOut = strOut + strLower20[intB];
		           if (intB == 1) 
		             { strOut = strOut + strExtend[intOrder*2];
		               strAppend = " ";
		             }
		         }
		       strOut = strOut + strOrder[intOrder] + strAppend;      
		       intOrder++;
		       strReturn = strOut + strReturn;
		     }
		   return strReturn;
		  }
		  public static int wordsToNumberDE(String zahlwort)
		  {
		     String strOrder[] = {"#","TAUSEND","MILLION","MILLIARDE"}; 
		    // String strRest = "";
		     String strTeil = "";
		     String strNach100 = "";
		     int intfaktor = 1000000000;
		     int intEiner = 0;
		     int intZahl = 0;
		     int inttripple = 0;
		     int intO = 3;
		     int intP = 0;

		     String strRemain = zahlwort.toUpperCase();
		     strRemain = strRemain.replaceAll("[^A-ZÖÜß]","");
		     while ( ! strRemain.equals("") )
		       {
		        if (intO == 0) strRemain = strRemain +"#";
		        inttripple = 0;
		        intP = strRemain.indexOf(strOrder[intO]); 
		        if (intP >= 0) 
		          {
		            strTeil = zeichenVor(strRemain,strOrder[intO]);
		            strRemain = zeichenNach(strRemain,strOrder[intO]);
		            strNach100 = strTeil;
		            if (strTeil.indexOf("HUNDERT")>=0) 
		              { 
		                strNach100 = zeichenNach(strTeil,"HUNDERT");       
		                intEiner = wordToDigitDE(zeichenVor(strTeil,"HUNDERT"));
		                if (intEiner == 0) intEiner = 1;
		                inttripple = inttripple + 100 * intEiner;
		              }; 
		            if (strNach100.indexOf("UND") >=0)
		              {
		                inttripple += wordToDigitDE(zeichenVor(strNach100,"UND"));
		                strNach100 = zeichenNach(strNach100,"UND");                
		              };
		            if (strNach100.indexOf("IG") >=0)
		              { 
		                if (strNach100.indexOf("ZWANZIG")>=0) inttripple += 20 ;
		                inttripple += 10 * wordToDigitDE(zeichenVor(strNach100,"IG"));
		                strNach100 = zeichenNach(strNach100,"IG");
		              };      
		            if (strNach100.indexOf("ZEHN") >=0)
		              { 
		                inttripple += 10;
		                intEiner = wordToDigitDE(zeichenVor(strNach100,"ZEHN"));
		                if (intEiner > 2) inttripple += intEiner;                
		              }
		            else
		              {
		                inttripple += wordToDigitDE(strNach100);
		                if (strNach100.indexOf("ELF")>=0) inttripple += 11 ;
		                if (strNach100.indexOf("ZWÖLF")>=0) inttripple += 12 ;
		              }
		            if (intfaktor > 1 && inttripple == 0) inttripple = 1;  
		          };
		        intZahl += inttripple * intfaktor;
		        intfaktor = intfaktor/1000;
		        intO -= 1;
		        }       
		     return intZahl;  

		  }
		  private static int wordToDigitDE(String einerzahlwort)
		  {
		     if (einerzahlwort.indexOf("EIN") >= 0) return 1;
		     if (einerzahlwort.indexOf("ZWEI") >= 0) return 2;
		     if (einerzahlwort.indexOf("DREI") >= 0) return 3;
		     if (einerzahlwort.indexOf("VIER") >= 0) return 4;
		     if (einerzahlwort.indexOf("FÜNF") >= 0) return 5;
		     if (einerzahlwort.indexOf("SECH") >= 0) return 6;
		     if (einerzahlwort.indexOf("SIEB") >= 0) return 7;
		     if (einerzahlwort.indexOf("ACHT") >= 0) return 8;
		     if (einerzahlwort.indexOf("NEUN") >= 0) return 9;
		     return 0;
		  }
		  private static String zeichenVor(String zeile,String trennwort)
		  {
		    String strOut = "";
		    int intP = zeile.indexOf(trennwort);
		    if (intP >= 0) strOut = zeile.substring(0,intP);
		    return strOut; 
		  }
		  private static String zeichenNach(String zeile,String trennwort)
		  {
		    String strOut = "";
		    int intP = zeile.indexOf(trennwort) + trennwort.length();
		    if (intP < zeile.length())
		      strOut = zeile.substring(intP,zeile.length());
		    return strOut; 
		  }[/code]


----------



## x22 (28. Feb 2012)

Wieso benutzt du keine enumeration? (enum.)
Wäre evtl. gut es damit mal zu versuchen, bin mir nicht sicher ob das klappt, aber wäre besser.

Das ist wie eine eigenen Klasse.. wäre interessanter und du würdest diese "Klasse" zusätzlich kennen lernen..

Enum (Java 2 Platform SE 5.0)


----------



## Numue1332 (28. Feb 2012)

Weil ich die bis jetzt nich kannte, deswegen hab ich die nicht benutzt, bin ja erst seit kurzem am Java programmieren (hatte vorher viel vb.net und n bisschen C# gemacht). Aber ein interessanter vorschlag, vielleicht schreib ich das Programm mal um, wenn ich dafür zeit hab. Hab momentan noch 3 Java-Projekte am laufen die in der nächsten Zeit fertig müssen, von daher ist die zeit für sowas wie enum ein bisschen begrenzt  .

Edit: Wie kann man die Eingabe vom Text so einschränken, dass er nur die eingabe annimmt, die auch zu nem Ergebnis führt ? nicht -> (Eingabe = "D" - Ausgabe = 0) sondern (Eingabe = "D" - Ausgabe = "Das ist kein großgeschriebener Zahlenname!") und man muss erneut nen Text eingeben ? ???:L


----------



## pappawinni (28. Feb 2012)

Numue1332 hat gesagt.:


> .. Wie kann man die Eingabe vom Text so einschränken, dass er nur die eingabe annimmt, die auch zu nem Ergebnis führt ? nicht -> (Eingabe = "D" - Ausgabe = 0) sondern (Eingabe = "D" - Ausgabe = "Das ist kein großgeschriebener Zahlenname!") und man muss erneut nen Text eingeben ? ???:L



Du könntest das Ergebnis der Wandlung des Zahlwortes in eine Zahl mit Hilfe von numberInWordsDE wieder zurück in Text wandeln. Diesen Text kannst du dann z.B. in Großbuchstaben umsetzen und von Leerzeichen befreien und dann mit dem eingegebenen Zahlwort vergleichen.
D.h. aber,  dass die Eingabe exakt der durch die Methode numberInWordsDE vorgebenen Struktur entsprechen müsste.
So wäre beispielsweise die Eingabe *EIN*TAUSDEND gültig, während die Eingabe TAUSEND ungültig wäre.
DREITAUSENDEINS wäre gültig, DREITAUSEND*UND*EINS ungültig.


----------



## pappawinni (29. Feb 2012)

Autsch..
hab einen [WR]FEHLER [/WR] gefunden und will ihn nicht behalten

In der Methode numberInWordsDE hätte es heissen müssen:

[JAVA=106]
     if (intA > 0 )
          strOut = strOut + strOrder[intOrder] + strAppend;
[/code]

dort steht aber nur:
[JAVA=106]
     strOut = strOut + strOrder[intOrder] + strAppend;
[/code]


----------

