Enum Römische Zahlen

[Karlter]

Moin Leute,

icn bastle mometan aufgrund einer Uniaufgabe an einer Klasse, welche eine Römische Zahl darstellen soll. Hierfür benutze ich Enums. Ich habe die Funktionalität der Klasse soweit ganz gut implementieren können, scheitere aber nun bei der Umsetzung der Anwendung der Subtraktionsregel in meiner toString() Methode. Mir ist es zu stumpf die KI zu fragen, daher wende ich mich erstmal an Euch - Hättet Ihr einen Denkanstoß, welche Logik man nutzen könnte, um die Suntraktionsregel zu beachten? Meinen Code füge ich Euch ein, ich hatte jetzt erstmal daran gedacht, die Paare bei denen es relevant ist (also IV für 4 (statt 5 - 1), IX für 9 (statt 10 - 1), XL für 40 (statt 50 - 10), XC für 90 (statt 100 - 10), CD für 400 (statt 500 - 100), CM für 900 (statt 1000 - 100)) zu identifizieren und dann eine bestimmte Ausnahme zu fomulieren. Aber bei der Umestzung scheitert es aktuell noch...

public enum Roman {
    I(1, '\u2160'),
    V(5,'\u2164'),
    X(10,'\u2169'),
    L(50,'\u216C'),
    C(100,'\u216D'),
    D(500,'\u216E'),
    M(1000,'\u216F');

    private final int value;
    private final char literal;

    Roman(int value, char literal) { // eigener Konstruktor
        this.value = value;
        this.literal = literal;
    }

    public int getValue() { // Methode
        return value;
    }

    public char getLiteral() {
        return literal;
    }
    
}



public class RomanNumber {

    int value;

    public RomanNumber(int i) {
        assert i > 0;
        value = i;
    }

    public RomanNumber(String s) {
        assert s != null;
        assert !s.isEmpty();

        int value = 0;

        for (char c : s.toCharArray()) {
            Roman r = Roman.valueOf(c + "");
            value += r.getValue();

        }
        this.value = value;

    }

    public int getValue() {
        return value;
    }

    public String toString() {
        StringBuilder b = new StringBuilder();

        Roman[] r = Roman.values();

        int rest = value;

        for (int i = r.length - 1; i >= 0; i--) {  // Hier ggf. Anwendnug der Subtraktionsregel
            while (r[i].getValue() <= rest) {
                b.append(r[i].getLiteral());
                rest -= r[i].getValue();
            }
        }

        return b.toString();
    }
}

Danke für Eure Zeit!

 

[Oneixee5]

kannst du nicht einfach bspw. IV in dein Enum aufnehmen?

 

[Karlter]

Da wir mit dem speziellen Unicode-Zeichen arbeiten sollen, gibs ab der XL(40) keinen Unicode mehr. Ab dann wirds eng...

 

[Oneixee5]

Ein Enum kann doch aus mehreren Zeichen bestehen.

XL(10,"u2169\u216C"),

Die Antwort verstehe ich nicht.

 

[Karlter]

Klar, aber dann ist es ja kein char mehr, es muss zwingend ein einzelnes Zeichen bleiben :/

 

[KonradN]

Wenn Du das enum Roman nicht anpassen willst (Was ok ist, denn da geht es ja um römische Zeichen und es geht ja um Combos aus römischen Zeichen), dann musst Du das halt in RomanNumber berücksichtigen.

Damit es verständlicher wird, kannst Du eine Liste mit Umwandlungs-Werten pflegen. Da kommen dann halt alle römischen Ziffer rein aber auch alle Ziffern Kombinationen. Dann hast du das als Basis zur Umwandlung, sprich: Wenn Du etwas wie IX hast, dann weisst Du: Das ist 9. Oder wenn Du eine 9 umwandeln willst, dann kannst Du schauen, was da der nächste mögliche Wert ist ...


Du kannst aber auch prüfen, ob ein Algorithmus möglich ist. Das ist auch nicht wirklich komplex.
Ich will Dir da nicht zu viel vorgeben, aber was für Regeln gelten denn da?

Wenn man die römischen Ziffern betrachtet, dann haben wir da sozusagen Hauptwerte und Zwischenwerte. Zwischenwerte sind die Werte, die doppelt genommen das Folgeelement ergeben. Zwischenwerte kommen immer einzeln vor und nie vor einem größeren Wert.
Eine kleinere Ziffer vor einer größeren Ziffer wird nicht addiert sondern abgezogen. Bei IV wird also der Wert vom I nicht addiert sondern abgezogen, so dass Du -1 + 5 erhältst.

Damit kannst Du schon gut umwandeln von römisch nach dezimal, aber es werden auch ungültige Zahlen umgewandelt. Da kann man also noch mehr bewerten: Bei zwei Ziffern muss gelten:

• die erste ist größer wie die zweite (XI - beide werden addiert)
• die erste ist kleiner wie die zweite: Dann darf die erste kein Zwischenwert sein und die zweite Ziffer muss die nächste oder übernächste Ziffer sein. Also kein IL oder so sondern nur IV und IX

Wenn Du in die andere Richtung umwandeln willst, dann musst Du halt für jeden Wert prüfen: Gibt es Kombinationen und wenn ja: passen diese?

Da wir die Regeln für Kombinationen aufgestellt haben (Dies ggf. noch einmal prüfen) ist das ja problemlos auch im Code aufstellbar.

 

[Blender3D]

Meinen Code füge ich Euch ein, ich hatte jetzt erstmal daran gedacht, die Paare bei denen es relevant ist (also IV für 4 (statt 5 - 1), IX für 9 (statt 10 - 1), XL für 40 (statt 50 - 10), XC für 90 (statt 100 - 10), CD für 400 (statt 500 - 100), CM für 900 (statt 1000 - 100)) zu identifizieren und dann eine bestimmte Ausnahme zu fomulieren. Aber bei der Umestzung scheitert es aktuell noch...

Ich habe deine toString Methode etwas angepasst und der Klasse Roman eine Methode isBasisNumber (I,X,C,M) hinzugefügt.

public class StartRomanNumber {
    public static void main(String[] args) {
        for (int i = 1; i <= 1984; i++)
            System.out.println(i + "\t= " + new RomanNumber(i));
    }
}

public class RomanNumber {

    private int value;

    public RomanNumber(int value) {
        assert value > 0;
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public String toString() {
        StringBuilder str = new StringBuilder();
        Roman[] r = Roman.values();
        int rest = value;
        for (int i = r.length - 1; i >= 0; i--) {
            int val = 0;
            while ((val = r[i].getValue()) <= rest) {
                if (rest == 4) { // 4 -> IV
                    str.append(r[0] + "" + r[1]);
                    rest = 0;
                } else {
                    int diff = val;
                    if (!r[i].isBasisNumber()) {
                        diff = r[i + 1].getValue() - r[i - 1].getValue();
                        if (diff <= rest) // 90 -> XC
                            str.append(r[i - 1] + "" + r[i + 1]);
                        else { // 70 or 80 -> V only
                            str.append(r[i]);
                            diff = r[i].getValue();
                        }
                    } else
                        str.append(r[i]);
                    rest -= diff;
                }
            }
        }
        return str.toString();
    }
}