Dezimal in römische Zahlen mit Turbo oder Dev-Pascal

Ich kann nicht so gut Pascal, daher mal in Java (jedenfalls fast):

// Hilfsstruktur zum Ablegen der röm. Zahlen
class myPair{
    int m_arab;
    String m_rom;
    myPair( int arab, String rom ) {
        m_arab = arab;
        m_rom  = rom;
    }
}

String arab2rom( int number ) {

    // Liste mit Zuordnungen von arab. zu röm. Zahlen
    // incl. Sonderfällen (z.B. IX = 9)
    ArrayList<myPair> list = new ArrayList();
    list.add( new myPair( 1000, "M" ) );
    list.add( new myPair(  900, "CM" ) );
    list.add( new myPair(  500, "D" ) );
    list.add( new myPair(  400, "CD" ) );
    list.add( new myPair(  100, "C" ) );
    list.add( new myPair(   90, "XC" ) );
    list.add( new myPair(   50, "L" ) );
    list.add( new myPair(   40, "XL" ) );
    list.add( new myPair(   10, "X" ) );
    list.add( new myPair(    9, "IX" ) );
    list.add( new myPair(    5, "V" ) );
    list.add( new myPair(    4, "IV" ) );
    list.add( new myPair(    1, "I" ) );

    String result = "";

    int div = 0;
    // loop über die Liste
    for( myPair cur : list ) {
        // Ganzzahlige Division mit der akt. arab. Zahl
        // Beisp. 15 / 10 = 1
        div = number / cur.m_arab;

        if( div > 0 ) {
            // Hänge die röm. Zahl an das Ergebnis an
            // "so oft wie sie reinpasst"
            // Beisp. 15 / 10 = 1 -> hänge 1* "X" an
            for( int i = 0; i < div; i++ ) {
                result += cur.m_rom;
            }
        }
        // Mit dem Rest weiterrechnen (%=modulo)
        // Beisp. 15 % 10 = 5 (Rest)
        number = number % cur.m_arab;
    }

    return result;
}

Was einfacheres ist mir nicht eingefallen, ich hoffe du verstehst den grundlegenden Algorithmus?

hm... naja, ich habe jetzt eine vorstellung von dem zuordnen und deklarieren der röm. zahlen... doch wie das konkret im programm aussieht ??? ??? hm
aber danke erstmal , ich werde das auf jedenfall mal meiner partnerin zeigen...
ich hoffe, mir können noch weitere user helfen...

Die Idee ist halt, dass du die Zahl nacheinander durch die römischen teilst (angefangen mit der größten) und immer mit dem Rest weiterrechnest.
Beispiel: 939
939 / 1000 = 0, Rest 939 -> Hänge 0 M an das Ergebnis an.  Ergebnis: ""
939 / 900 = 1 Rest 39 -> Hänge ein CM an das Ergebnis an. Ergebnis: "CM"
39 / 500 = 0 Rest 39 -> Hänge 0 D an das Ergebnis an. Ergebnis "CM"
...
39 / 10 = 3 Rest 9 -> Hänge drei X an das Ergebnis an. Ergebnis : "CMXXX"
9 / 9 = 1 Rest 0 -> Hänge ein IX an das Ergebnis an. Ergebnis: "CMXXXIX"
Fertig. Müsst euch bloss noch ne geeignete Struktur zur Abbildung der arabischen auf die römischen Zahlen einfallen lassen. Am besten so, dass man da automatisch drüberiterieren kann. Ansonsten kann man das natürlich auch "zu Fuss" machen, d.h. wie im Beispiel oben. Ist aber nicht so elegant...

hallo.
kann mir noch jemand speziell zu Dev Pascal / Turbo Pascal helfen und mir das sagen, was ich genau in das Programm eingeben muss?
Ich weiß zwar, wie ich vorgehen muss, jedenfalls generell, kann mir das aber nicht in der Programmiersprache vorstellen. ??? ???
Danke euch schon einmal 

Ist doch gar nicht so schwer. Einfach den Algorithmus von oben nach Pascal übersetzen. Könnte dann z.B. so aussehen:

PROGRAM Arab2Rom;

    TYPE myPair = RECORD
        arab: INTEGER;
        rom : STRING;
    END;

    VAR divi, number, i, j : INTEGER;
    VAR result : STRING;
    VAR ende : BOOLEAN;

    CONST list : ARRAY[1..13] OF myPair = ( (arab:1000; rom:'M'),
                                            (arab:900; rom:'CM'),
                                            (arab:500; rom:'D'),
                                            (arab:400; rom:'CD'),
                                            (arab:100; rom:'C'),
                                            (arab:90; rom:'XC'),
                                            (arab:50; rom:'L'),
                                            (arab:40; rom:'XL'),
                                            (arab:10; rom:'X'),
                                            (arab:9; rom:'IX'),
                                            (arab:5; rom:'V'),
                                            (arab:4; rom:'IV'),
                                            (arab:1; rom:'I'));

    FUNCTION transform( numb : INTEGER ) : STRING;
    BEGIN
        result := '';
        FOR i:=1 TO 13 DO
        BEGIN
            divi := numb DIV list[i].arab;
            IF divi > 0 THEN
            BEGIN
                FOR j:=1 TO divi DO
                BEGIN
                     result := result + list[i].rom;
                END;
            END;
            numb := numb MOD list[i].arab;
        END;
        transform := result;
    END;

BEGIN
    ende := False;
    REPEAT
        Writeln( 'Bitte Zahl eigeben (0 zum Beenden): ');
        Readln( number );
        IF number = 0 THEN ende := True
        ELSE
        BEGIN
            Writeln( 'Ergebnis: ', transform( number ) );
            Writeln( '' );
        END;
    UNTIL ende;
END.


hey..

ich hab gerade das programm entdeckt. heute in der schule hab ich so ein ähnliches programm aufbekommen.

hab gesehen das du das programm geschrieben hast @ lisa !

könntest du es mir vielleicht wieder ein bisschen erklären ?. wäre echt fein.

danke.

bloodstain

TYPE myPair = RECORD
    arab: INTEGER;
    rom : STRING;
END;
Hilfsstruktur zum Ablegen der röm. Zahlen. Halt einfach ein Paar, das eine römische auf die entsprechende arabische Zahl mappen soll.

CONST list : ARRAY[1..13] OF myPair = ( (arab:1000; rom:'M'),
[...]
Liste mit Zuordnungen von arab. zu röm. Zahlen. Das ist nötig, weil es auch so Sonderfälle gibt, wie z.B. IX = 9. Es ist möglich, weil die Anzahl der röm. Zahlen nicht so groß ist, sonst hätte man sich da was anderes einfallen lassen müssen.

FOR i:=1 TO 13 DO
Schleife über die obige Liste

divi := numb DIV list[i].arab;
Ganzzahlige Division mit der aktuellen arab. Zahl; z.B. 15 DIV 10 = 1

FOR j:=1 TO divi DO
BEGIN
    result := result + list[i].rom;
END;
Hänge die röm. Zahl an das Ergebnis an "so oft wie sie reinpasst"

numb := numb MOD list[i].arab;
Mit dem Rest weiterrechnen; z.B. 15 MOD 10 = 5 (Rest)

Die Idee ist halt, dass du die Zahl nacheinander durch die römischen teilst (angefangen mit der größten) und immer mit dem Rest weiterrechnest.
Beispiel: 939
939 / 1000 = 0, Rest 939 -> Hänge 0 M an das Ergebnis an.  Ergebnis: ""
939 / 900 = 1 Rest 39 -> Hänge ein CM an das Ergebnis an. Ergebnis: "CM"
39 / 500 = 0 Rest 39 -> Hänge 0 D an das Ergebnis an. Ergebnis "CM"
[...]
39 / 10 = 3 Rest 9 -> Hänge drei X an das Ergebnis an. Ergebnis : "CMXXX"
9 / 9 = 1 Rest 0 -> Hänge ein IX an das Ergebnis an. Ergebnis: "CMXXXIX"

Übrigens: Am meisten lernt man, wenn man sowas erstmal selbst versucht...