Übung Zahlworte

[jmoerni]

Hallo an alle,

Da ich Quereinsteiger bin (kein Studium) versuche ich mich an div. Übungsaufgaben in Java und bin bei der Uni Koblenz fündig geworden.

Die Aufgabe: Erzeugen Sie Zahlworte für die Zahlen 0...999.999.999.
Beispiel: 123 hundertdreiundzwanzig.

Ich habe mich daran gewagt und mein Ansatz war folgender:

public class C3 {
    private static String[] zw1_9 = {
        "eins","zwei","drei","vier","fuenf","sechs","sieben","acht","neun",   
    };
    private static String[] zw10_12= {
            "zehn","elf","zwoelf"
            
    };
    private static String[] zw20_90 = {
            "zwanzig","dreizig","vierzig","fuenfzig","sechzig","siebzig","achtzig","neunzig",   
        };
    
    private static String zw100 = "hundert";
    private static String zw1000 = "tausend";
    private static String zw1000000 = "millionen";

    private static String und = "und";

    private static int eingabewert = 999000000;
    
    
    public static void main(String[] args) {
        
        int zahl = eingabewert;
        String buf = Integer.toString(zahl);
        int[] array = new int[buf.length()];
        for( int i=0; i < buf.length(); i++ ) {
          array[i] = Character.getNumericValue(buf.charAt(i));
        }
        for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                        (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));
                        
                break;
                }
            
        
        
}}

Schön und gut aber ich bin dann auf die ersten ausnahmen gestoßen wie zum Beispiel 11,12,13 oder glatte endungen z.b. 900000000...
Ich bin also dabei alle Ausnahmen mit if abfragen einzeln zu betrachten.

package Übungen;

public class C3 {
    private static String[] zw1_9 = {
        "eins","zwei","drei","vier","fuenf","sechs","sieben","acht","neun",   
    };
    private static String[] zw10_12= {
            "zehn","elf","zwoelf"
            
    };
    private static String[] zw20_90 = {
            "zwanzig","dreizig","vierzig","fuenfzig","sechzig","siebzig","achtzig","neunzig",   
        };
    
    private static String zw100 = "hundert";
    private static String zw1000 = "tausend";
    private static String zw1000000 = "millionen";

    private static String und = "und";

    private static int eingabewert = 999000000;
    
    
    public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
    
        
        int zahl = eingabewert;
        String buf = Integer.toString(zahl);
        int[] array = new int[buf.length()];
        for( int i=0; i < buf.length(); i++ ) {
          array[i] = Character.getNumericValue(buf.charAt(i));
        }
        //Ausnahme für einhundertmillionen
        if(array[0]==1) {
            zw1_9[0] = "ein";
        }
        //Ausnahme für 10,11,12 im 10er Bereich
        if(array[7]==1 && array[8]==0 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                        (zw1_9[array[6]-1]+zw100) + zw10_12[0]);   
                break;
                }
            
        }else if(array[7]==1 && array[8]==1 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                        (zw1_9[array[6]-1]+zw100) + zw10_12[1]);
                break;
                }
            
        }else if(array[7]==1 && array[8]==2 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                        (zw1_9[array[6]-1]+zw100) + zw10_12[2]);   
                break;
                }
        //Ausnahme für 10,11,12 im 1000er Bereich   
        }else if(array[4]==1 && array[5]==0 ) {
                for (int i=0; i < array[i]; i++) {
                    System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                            (zw1_9[array[3]-1]+zw100) + zw10_12[0] + zw1000 +
                            (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));
                    break;
                }
        }else if(array[4]==1 && array[5]==1 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + zw10_12[1] + zw1000 +
                        (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));
                break;
            }
        }else if(array[4]==1 && array[5]==2 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + zw10_12[2] + zw1000 +
                        (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));   
                break;
            }   
            //Ausnahme für 10,11,12 im Millionen Bereich
        }else if(array[1]==1 && array[2]==0 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + zw10_12[0] + zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                        (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));
                break;
            }
    }else if(array[1]==1 && array[2]==1 ) {
        for (int i=0; i < array[i]; i++) {
            System.out.println((zw1_9[array[0]-1]+zw100) + zw10_12[1] + zw1000000 +
                    (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                    (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));
            break;
        }
    }else if(array[1]==1 && array[2]==2 ) {
        for (int i=0; i < array[i]; i++) {
            System.out.println((zw1_9[array[0]-1]+zw100) + zw10_12[2] + zw1000000 +
                    (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                    (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));   
            break;
        }
        //Ausnahme für Hundermillionen 000...
    }else if(array[1]==0 && array[2]==0 && array[3]==0 && array[4]==0 && array[5]==0 && array[6]==0 && array[7]==0 && array[8]==0 ) {
        for (int i=0; i < array[i]; i++) {
            System.out.println((zw1_9[array[0]-1]+zw100) + zw1000000 );
                        
            break;
        }
        //Ausnahme für Hundermillionen+10er Rest 000..
    }else if(array[2]==0 && array[3]==0 && array[4]==0 && array[5]==0 && array[6]==0 && array[7]==0 && array[8]==0 ) {
        for (int i=0; i < array[i]; i++) {
            System.out.println((zw1_9[array[0]-1]+zw100)+(zw20_90[array[1]-2]) + zw1000000 );
                        
            break;
        }   
        
    }else if(array[3]==0 && array[4]==0 && array[5]==0 && array[6]==0 && array[7]==0 && array[8]==0 ) {
        for (int i=0; i < array[i]; i++) {
            System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2]) + zw1000000 );
                        
            break;
        }   
        
        // restliche Ausgabe
        }else
            for (int i=0; i < array[i]; i++) {
                System.out.println((zw1_9[array[0]-1]+zw100) + (zw1_9[array[2]-1])+ und +(zw20_90[array[1]-2])+ zw1000000 +
                        (zw1_9[array[3]-1]+zw100) + (zw1_9[array[5]-1])+ und +(zw20_90[array[4]-2])+ zw1000 +
                        (zw1_9[array[6]-1]+zw100) + (zw1_9[array[8]-1])+ und +(zw20_90[array[7]-2]));
                        
                break;
                }
            
        
        
}}

Verrenne ich mich grade in etwas oder komme ich nicht drumherum?

 

[httpdigest]

Ich würde sagen, da verrennst du dich. Du bräuchtest da ja noch viel mehr Ausnahmen/if-Bedingungen, wenn du immer größere Zahlen (also Tausender-Potenzen) ausgeben möchtest.
Ich denke, der richtige Weg hier ist, erstmal zu schauen, was die größte Tausenderpotenz ist, die in der Zahl vorkommt, das dann ausgeben, die Zahl um diese Tausenderpotenz subtrahieren/verkleinern und dann rekursiv weitermachen.
Oder andersherum: Von der kleinsten Tausenderpotenz anfangen und den Rest rechts anhängen.

 

[jmoerni]

Im oberen auszug des Codes klappt es bei z.b. 355.273.888 oder auch 999.999.999 (um bei deinem Beispiel zu bleiben) da reichte die eine for schleife aus.

 

[jmoerni]

Ich dachte an eine elgantere Lösung grade für den Fall 900.000.000.
Die 3 Blöcke für 10, 11, 12 finde ich nicht so problematisch.

 

[httpdigest]

Es geht seeeehr viel eleganter. Du solltest das Problem in Teilprobleme aufteilen. Z.B. erstmal eine Methode schreiben, die Zehner korrekt ausgibt, also alle Zahlen zwischen 0 <= x <= 99.
Dann eine Methode, die Hunderter korrekt ausgibt, also alles zwischen 0 <= x <= 999 (und diese benutzt intern die zehner() Methode).
Und dann kannst du eine Schleife verwenden für die Tausenderpotenzen.

 

[jmoerni]

Ah ok, ich sehe gradeerst das Problem.. danke

 

[httpdigest]

Hab mal als kleine Fingerübung eine eigene Implementierung geschrieben:

Spoiler

public class Zahlenwort {
  // Alle Tausenderpotenzen als Wörter (Einzahl und Mehrzahl)
  private static final String[][] P = {
          {"", "tausend", " Million ", " Milliarde ", " Billion ", " Billiarde ", " Trillion ", " Trilliarde "},
          {"", "tausend", " Millionen ", " Milliarden ", " Billionen ", " Billiarden ", " Trillionen ", " Trilliarden "},
  };
  // Alle "Einer" für die verschiedenen Fälle von "Einsen", z.B. "1 = eins", "1.000 = ein", "1.000.000 = eine"
  // zusammen mit den Spezialfällen elf und zwölf (und um es einfach zu halten, ist die zehn hier auch drin)
  private static final String[][] E = {
          {"eins", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
          {"ein", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
          {"eine", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
  };
  // Volle Zehner ab zwanzig
  private static final String[] Z = {"zwanzig", "dreißig", "vierzig", "fünfzig", "sechzig", "siebzig", "achtzig", "neunzig"};

  public static String zahlenwort(long n) {
    if (n == 0L) return "null"; // <- Spezialfall n = 0
    return zahlenwort(n, 0);
  }

  // n ist die Zahl und p die aktuelle Tausenderpotenz, bei der wir gerade sind
  // denn basierend darauf ändert sich, wie wir die "Eins" angeben wollen.
  private static String zahlenwort(long n, int p) {
    if (n <= 0) return "";
    String h = hunderter((int) (n % 1000), p);
    if (!h.isEmpty()) return zahlenwort(n / 1000L, p + 1) + h + P[h.equals("eine") ? 0 : 1][p];
    return zahlenwort(n / 1000L, p + 1);
  }

  private static String hunderter(int n, int p) {
    if (n >= 100) return E[1][n / 100 - 1] + "hundert" + zehner(n % 100, p);
    return zehner(n % 100, p);
  }

  private static String zehner(int n, int p) {
    if (n == 0) return ""; // <- nichts, wenn 0
    if (n >= 1 && n <= 12) return E[Math.min(p, 2)][n - 1];
    // die 1 bei den Einern oben ist speziell, weil wir manchmal "eins", manchmal "ein" und manchmal "eine" wollen
    if (n % 10 != 0) return E[1][n % 10 - 1] + "und" + Z[n / 10 - 2]; // <- alle nicht vollen Zehner
    return Z[n / 10 - 2]; // alle (vollen) Zehner
  }

  public static void main(String[] args) {
    System.out.println(zahlenwort(1_010_001_021L));
    // "eine Milliarde zehn Millionen eintausendeinundzwanzig"
  }
}

 

[jmoerni]

package Übungen;

public class C3 {
    private static String[] zw1_9 = {
        "ein","zwei","drei","vier","fuenf","sechs","sieben","acht","neun",   
    };
    private static String[] zw10_12= {
            "zehn","elf","zwoelf"
            
    };
    private static String[] zw20_90 = {
            "zwanzig","dreizig","vierzig","fuenfzig","sechzig","siebzig","achtzig","neunzig",   
        };
    
    private static String zw100 = "hundert";
    private static String zw1000 = "tausend";
    private static String zw1000000 = "millionen";

    private static String und = "und";

    private static int eingabewert = 20;
    
    
    public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
    
        
        int zahl = eingabewert;
        String buf = Integer.toString(zahl);
        int[] array = new int[buf.length()];
        for( int i=0; i < buf.length(); i++ ) {
          array[i] = Character.getNumericValue(buf.charAt(i));
        }
        int ArrLength = 0;
        for(int Elements : array)
            ArrLength++;
        //1-99*********************************************************************************************
        if(ArrLength == 1) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw1_9[array[0]-1]));   
                break;
        }
        }else if(ArrLength == 2 && array[0]==1 && array[1]==0) {
                for (int i=0; i < array[i]; i++) {
                    System.out.println(
                            (zw10_12[array[0]-1]));   
                    break;
                }
        }else if(ArrLength == 2 && array[0]>1 && array[1]==0) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw20_90[array[0]-2]));   
                break;
            }       
                
        }else if(ArrLength == 2 && array[0]==1 && array[1]==1) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw10_12[array[1]]));       
                break;
            }
        }else if(ArrLength == 2 && array[0]==1 && array[1]==2) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw10_12[array[1]]));       
                break;
            }
            
        }else if(ArrLength == 2 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw1_9[array[1]-1])+ und + (zw20_90[array[0]-2]) );       
                break;
            }
            
            
        
        }
}}

Das hab ich jetzt erstmal für 1-99 gebastellt.

 

[jmoerni]

Schluck..
Da bin ich aber noch weit entfernt
🤣

 

[jmoerni]

Hab mal als kleine Fingerübung eine eigene Implementierung geschrieben:

Spoiler

public class Zahlenwort {
  // Alle Tausenderpotenzen als Wörter (Einzahl und Mehrzahl)
  private static final String[][] P = {
          {"", "tausend", " Million ", " Milliarde ", " Billion ", " Billiarde ", " Trillion ", " Trilliarde "},
          {"", "tausend", " Millionen ", " Milliarden ", " Billionen ", " Billiarden ", " Trillionen ", " Trilliarden "},
  };
  // Alle "Einer" für die verschiedenen Fälle von "Einsen", z.B. "1 = eins", "1.000 = ein", "1.000.000 = eine"
  // zusammen mit den Spezialfällen elf und zwölf (und um es einfach zu halten, ist die zehn hier auch drin)
  private static final String[][] E = {
          {"eins", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
          {"ein", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
          {"eine", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
  };
  // Volle Zehner ab zwanzig
  private static final String[] Z = {"zwanzig", "dreißig", "vierzig", "fünfzig", "sechzig", "siebzig", "achtzig", "neunzig"};

  public static String zahlenwort(long n) {
    if (n == 0L) return "null"; // <- Spezialfall n = 0
    return zahlenwort(n, 0);
  }

  // n ist die Zahl und p die aktuelle Tausenderpotenz, bei der wir gerade sind
  // denn basierend darauf ändert sich, wie wir die "Eins" angeben wollen.
  private static String zahlenwort(long n, int p) {
    if (n <= 0) return "";
    String h = hunderter((int) (n % 1000), p);
    if (!h.isEmpty()) return zahlenwort(n / 1000L, p + 1) + h + P[h.equals("eine") ? 0 : 1][p];
    return zahlenwort(n / 1000L, p + 1);
  }

  private static String hunderter(int n, int p) {
    if (n >= 100) return E[1][n / 100 - 1] + "hundert" + zehner(n % 100, p);
    return zehner(n % 100, p);
  }

  private static String zehner(int n, int p) {
    if (n == 0) return ""; // <- nichts, wenn 0
    if (n >= 1 && n <= 12) return E[Math.min(p, 2)][n - 1];
    // die 1 bei den Einern oben ist speziell, weil wir manchmal "eins", manchmal "ein" und manchmal "eine" wollen
    if (n % 10 != 0) return E[1][n % 10 - 1] + "und" + Z[n / 10 - 2]; // <- alle nicht vollen Zehner
    return Z[n / 10 - 2]; // alle (vollen) Zehner
  }

  public static void main(String[] args) {
    System.out.println(zahlenwort(1_010_001_021L));
    // "eine Milliarde zehn Millionen eintausendeinundzwanzig"
  }
}

Nicht das ich mich in der Position sehe Kretik üben zu können aber wenn ich das jetzt ohne "_ "als Platzhalter schreiben wollte müsste ich doch die Länge der Zahl auslesen oder?
Das war zumindestens grade mein Ansatz.
lieben Gruß

 

[jmoerni]

Mir war grade noch ein Fehler bei mir aufgefallen..habe einen Block ausgelassen >12-20

package Übungen;

public class C3 {
    private static String[] zw1_9 = {
        "ein","zwei","drei","vier","fuenf","sechs","sieben","acht","neun",   
    };
    private static String[] zw10_12= {
            "zehn","elf","zwoelf"
            
    };
    private static String[] zw20_90 = {
            "zwanzig","dreizig","vierzig","fuenfzig","sechzig","siebzig","achtzig","neunzig",   
        };
    
    private static String zw100 = "hundert";
    private static String zw1000 = "tausend";
    private static String zw1000000 = "millionen";

    private static String und = "und";

    private static int eingabewert = 15;
    
    
    public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
    
        
        int zahl = eingabewert;
        String buf = Integer.toString(zahl);
        int[] array = new int[buf.length()];
        for( int i=0; i < buf.length(); i++ ) {
          array[i] = Character.getNumericValue(buf.charAt(i));
        }
        int ArrLength = 0;
        for(int Elements : array)
            ArrLength++;
        //1-99*********************************************************************************************
        if(ArrLength == 1) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw1_9[array[0]-1]));   
                break;
        }
        }else if(ArrLength == 2 && array[0]==1 && array[1]==0) {
                for (int i=0; i < array[i]; i++) {
                    System.out.println(
                            (zw10_12[array[0]-1]));   
                    break;
                }
        }else if(ArrLength == 2 && array[0]==1 && array[1]>2) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw1_9[array[1]-1])+(zw10_12[array[0]-1]));   
                break;
            }
        }else if(ArrLength == 2 && array[0]>1 && array[1]==0) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw20_90[array[0]-2]));   
                break;
            }       
                
        }else if(ArrLength == 2 && array[0]==1 && array[1]==1) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw10_12[array[1]]));       
                break;
            }
        }else if(ArrLength == 2 && array[0]==1 && array[1]==2) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw10_12[array[1]]));       
                break;
            }
            
        }else if(ArrLength == 2 ) {
            for (int i=0; i < array[i]; i++) {
                System.out.println(
                        (zw1_9[array[1]-1])+ und + (zw20_90[array[0]-2]) );       
                break;
            }
            
            
        
        }
}}

 

[jmoerni]

Hab mal als kleine Fingerübung eine eigene Implementierung geschrieben:

Spoiler

public class Zahlenwort {
  // Alle Tausenderpotenzen als Wörter (Einzahl und Mehrzahl)
  private static final String[][] P = {
          {"", "tausend", " Million ", " Milliarde ", " Billion ", " Billiarde ", " Trillion ", " Trilliarde "},
          {"", "tausend", " Millionen ", " Milliarden ", " Billionen ", " Billiarden ", " Trillionen ", " Trilliarden "},
  };
  // Alle "Einer" für die verschiedenen Fälle von "Einsen", z.B. "1 = eins", "1.000 = ein", "1.000.000 = eine"
  // zusammen mit den Spezialfällen elf und zwölf (und um es einfach zu halten, ist die zehn hier auch drin)
  private static final String[][] E = {
          {"eins", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
          {"ein", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
          {"eine", "zwei", "drei", "vier", "fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", "zwölf"},
  };
  // Volle Zehner ab zwanzig
  private static final String[] Z = {"zwanzig", "dreißig", "vierzig", "fünfzig", "sechzig", "siebzig", "achtzig", "neunzig"};

  public static String zahlenwort(long n) {
    if (n == 0L) return "null"; // <- Spezialfall n = 0
    return zahlenwort(n, 0);
  }

  // n ist die Zahl und p die aktuelle Tausenderpotenz, bei der wir gerade sind
  // denn basierend darauf ändert sich, wie wir die "Eins" angeben wollen.
  private static String zahlenwort(long n, int p) {
    if (n <= 0) return "";
    String h = hunderter((int) (n % 1000), p);
    if (!h.isEmpty()) return zahlenwort(n / 1000L, p + 1) + h + P[h.equals("eine") ? 0 : 1][p];
    return zahlenwort(n / 1000L, p + 1);
  }

  private static String hunderter(int n, int p) {
    if (n >= 100) return E[1][n / 100 - 1] + "hundert" + zehner(n % 100, p);
    return zehner(n % 100, p);
  }

  private static String zehner(int n, int p) {
    if (n == 0) return ""; // <- nichts, wenn 0
    if (n >= 1 && n <= 12) return E[Math.min(p, 2)][n - 1];
    // die 1 bei den Einern oben ist speziell, weil wir manchmal "eins", manchmal "ein" und manchmal "eine" wollen
    if (n % 10 != 0) return E[1][n % 10 - 1] + "und" + Z[n / 10 - 2]; // <- alle nicht vollen Zehner
    return Z[n / 10 - 2]; // alle (vollen) Zehner
  }

  public static void main(String[] args) {
    System.out.println(zahlenwort(1_010_001_021L));
    // "eine Milliarde zehn Millionen eintausendeinundzwanzig"
  }
}

OK, hab es jetzt verstanden und muss sagen...
deutlich effizienter. Hut ab wäre ich so nicht drauf gekommen.

 

[mihe7]

Nicht das ich mich in der Position sehe Kretik üben zu können aber wenn ich das jetzt ohne "_ "als Platzhalter schreiben wollte müsste ich doch die Länge der Zahl auslesen oder?

Du meinst die Stelle System.out.println(zahlenwort(1_010_001_021L));? Der Underscore dient hier einfach der Formatierung des Literals im Quelltext zur besseren Lesbarkeit. Dem Compiler ist es egal, ob Du 1010001021L oder 1_010_001_021L schreibst. Du kannst auch 1_0_1_0_0_0_1_0_2_1L schreiben, aber das erhöht jetzt die Lesbarkeit nicht wirklich.

 

[jmoerni]

Du meinst die Stelle System.out.println(zahlenwort(1_010_001_021L));? Der Underscore dient hier einfach der Formatierung des Literals im Quelltext zur besseren Lesbarkeit. Dem Compiler ist es egal, ob Du 1010001021L oder 1_010_001_021L schreibst. Du kannst auch 1_0_1_0_0_0_1_0_2_1L schreiben, aber das erhöht jetzt die Lesbarkeit nicht wirklich.

Das hab ich gestern direkt ausprobiert und dann auch gesehen. Danke nochmal für deine Hilfe!

 

[berndoa]

An und für sich unterscheiden sich Zahlen ja immer in 1000er Schritten, will sagen bei der Zahl
123.456.789
muss man sprachlich 123 , die 456 und die 789 separat behandeln.

ist ja nur vom Muster
dreistellige Zahl Millionen dreistellige Zahl Tausend dreistellige Zahl

Wie bspw. die 123 ausgesprochen wird, macht keinen Unterschied, wenn sie nun vorne, mitte oder hinten steht.

Kurzum, egal welche zahl gegeben ist, sie muss erst mal in ihre Tausenderpotenzen zerlegt werden.


dann muss man sich mal angucken wie dreistellige zahlen ausgesprochen werden:


123, 456, 789
bei jeder der dreien gilt:
"erste ziffer" hundert "2stellige zahl"

also ein hundert dreiundzwanzig
usw.

wie wiederum spricht man eine 2stellige zahl aus?
die wörter der 2 ziffern in umgekehrter reihenfolge und ein "und" dazwischen.

Alles zusammenbauen halt.

Muss man sich nur noch hardcoden für welche tausenderpotenz welches zahlwort (tausend, millionen, milliarden, etc.) benutzt wird.

Und noch den sonderfall beachten wo wir bspw. 1.234.567 haben, also die vorderste dreistellige zahl nur aus einer 1 besteht.
weil da sagt man dann nicht millionen, sondern nur "eine million". weil singular halt