Zahl zu Text Umwandeln

[Victorinus]

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]

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]

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]

"zähner"? Really?

 

[Landei]

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]

"zähner"? Really?

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

 

[victorinus]

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])

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]

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]

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

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

 

[victorinus]

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]

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]

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]

int zähnerIndex

nicht dein ernst oder ?

 

[jDennis79]

nicht dein ernst oder ?

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

 

[irgendjemand]

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]

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]

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]

... 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]

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]

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]

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

 

[Numue1332]

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

 

[truesoul]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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

 

[pappawinni]

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]

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]

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]

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]

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

 

[Numue1332]

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]

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]

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]

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]

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]

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]

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]

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

 

[pappawinni]

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]

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

 

[Numue1332]

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]

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]

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)