Römische Zahlen

Code:
#include <iostream>

using namespace std;

const int roemi[] = {5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
const char roemc[][3]={"A", "MA", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
const int arraynum = 15;
const int maxnum = 8888;

int main(int argc, char *argv[])
{
	int tmp;
	cout << "arabisch => roemisch" << endl;
	cout << "unter Anwendung der \"Subtraktionsregel\" (1..." << maxnum << ")" << endl;
	for(;;) {
		cout << "Zahl: " << flush;
		cin >> tmp;
		if(!tmp)
			break;
		if(tmp < 1 || tmp > maxnum)
			cout << "Ungueltige Zahl" << endl;
		else {
			cout << "roemisch: ";
			for(int i = 0 ; i < arraynum ; i++) {
				while(tmp >= roemi[i]) {
					tmp -= roemi[i];
					cout << roemc[i];
				}
			}
			cout << endl;
		}
	}
	return(0);
}
 
PHP:
<?php
$zahl_dez = $zahl_dez_backup = 1999;
$zahl_rom = '';

$arrRoemisch = array('A' => 5000,
                     'M' => 1000,
                     'CM'=>  900,
                     'D' =>  500,
                     'CD'=>  400,
                     'C' =>  100,
                     'XC'=>   90,
                     'L' =>   50,
                     'XL'=>   40,
                     'X' =>   10,
                     'IX'=>    9,
                     'V' =>    5,
                     'IV'=>    4,
                     'I' =>    1
                    );
                    
$arrRomLetter = array_keys($arrRoemisch);
$arrRomNumber = array_values($arrRoemisch);

$i = 0;
$multipl = 1;
$firstrun = true;
while($zahl_dez > 0) {
   if($zahl_dez >= 100000) { // Schreibweise mit Rahmen, siehe Wikipedia
      $multipl = 100000;
      if($firstrun) {$zahl_rom .= '|';}
   }elseif($multipl == 100000) {
      $multipl = 1;
      $zahl_rom .= '|';
      $i = 0;
   }
   
   if($zahl_dez >= ($arrRomNumber[$i]*$multipl)) {
      $zahl_rom .= $arrRomLetter[$i];
      $zahl_dez -= $arrRomNumber[$i]*$multipl;
   }
   if($zahl_dez < $arrRomNumber[$i]*$multipl) {
      $i++;
   }
   $firstrun = false;
}
if($multipl == 100000) { // Beseitigt Fehler: Am Ende kein Rahmen
   $zahl_rom .= '|';
}
echo $zahl_dez_backup.' ist in römischen Zahlen '.$zahl_rom;
?>
 
Meine Lösung in VBA, berücksichtigt die Subtraktionsregel

(Allerdings werden bei Zahlen über 19999 einfach noch mehr "A" eingefügt)


Code:
 Public Sub numbers()


MsgBox "Römische Zahl:" & vbCrLf & vbCrLf & convert((InputBox("Dezimalzahl:", "Dez > Röm Converter";)))

End Sub


Public Function convert(value As Integer)

Dim result, roman(14) As String
roman(0) = "A"
roman(1) = "MA"
roman(2) = "M"
roman(3) = "CM"
roman(4) = "D"
roman(5) = "CD"
roman(6) = "C"
roman(7) = "XC"
roman(8) = "L"
roman(9) = "XL"
roman(10) = "X"
roman(11) = "IX"
roman(12) = "V"
roman(13) = "IV"
roman(14) = "I"

Dim dez(14) As Integer
dez(0) = 5000
dez(1) = 4000
dez(2) = 1000
dez(3) = 900
dez(4) = 500
dez(5) = 400
dez(6) = 100
dez(7) = 90
dez(8) = 50
dez(9) = 40
dez(10) = 10
dez(11) = 9
dez(12) = 5
dez(13) = 4
dez(14) = 1

For i = 0 To 14
While (value / dez(i)) >= 1
result = result & roman(i)
value = value - dez(i)
Wend
Next

convert = result
End Function
 
Habe das ganz mla in C++ gezaubert:
#include <iostream>

using namespace std;
int main() {
/*Dieses Programm soll eine normale Zahl in eine römische Zahl umwandeln*/
int zahl;
cin >> zahl;
cout << "Römsiche zahl von: " << zahl << endl;
string romzahl;
for(int i =1;zahl>=1000;i++)
{
if(i == 3)
{
break;
}
romzahl = romzahl + 'M';
zahl = zahl - 1000;
}
for(int j=1;zahl>=500;j++)
{
if(j == 3)
{
break;
}
romzahl = romzahl + 'D';
zahl = zahl - 500;
}
for(int k=1;zahl>=100;k++)
{
if(k == 3)
{
break;
}
romzahl = romzahl + 'C';
zahl = zahl - 100;
}
for(int l=1;zahl>=50;l++)
{
if(l == 3)
{
break;
}
romzahl = romzahl + 'L';
zahl = zahl - 50;
}
for(int m=1;zahl>=10;m++)
{
if(m == 3)
{
break;
}
romzahl = romzahl + 'X';
zahl = zahl - 10;
}
for(int n=1;zahl>=5;n++)
{
if( n== 3)
{
break;
}
romzahl = romzahl + 'V';
zahl = zahl - 5;
}
for(int o=1;zahl>=1;o++)
{
if(o == 3)
{
break;
}
romzahl = romzahl + 'I';
zahl = zahl - 1;
}
cout << romzahl << endl;
}

Das mit den break, kann man zwar auch durch
for(int o=1;zahl>=1 && i<=3;o++)
, aber ich wollte schon immer mla break ausprobieren.

gruß stein
 
Hier meine Version in PVX:

Code:
PRINT "Bitte geben Sie eine ganze Dezimalzahl ein,"
PRINT "f",CHR(252),"r die berechnung ins R",CHR(246),"mische Zahlensystem."
INPUT "Eingabe: ",E
E=INT(E)

Dim rz$(29),dez(29)
rz$(1) = "A"
rz$(2) = "MA"
rz$(5) = "M"
rz$(6) = "CM"
rz$(9) = "D"
rz$(10) = "CD"
rz$(13) = "C"
rz$(14) = "XC"
rz$(17) = "L"
rz$(18) = "XL"
rz$(21) = "X"
rz$(22) = "IX"
rz$(25) = "V"
rz$(26) = "IV"
rz$(29) = "I"

dez(1) = 5000
dez(2) = 4000
dez(5) = 1000
dez(6) = 900
dez(9) = 500
dez(10) = 400
dez(13) = 100
dez(14) = 90
dez(17) = 50
dez(18) = 40
dez(21) = 10
dez(22) = 9
dez(25) = 5
dez(26) = 4
dez(29) = 1

result$=""
I=1
WHILE I<>29
WHILE E-dez(I)>=0.0000
IF MOD(I,2)=1 THEN {
	result$ = result$+rz$(I,1)
} ELSE {
	result$ = result$+rz$(I,2)
}
E = E - dez(I)
WEND
IF MOD(I,2)=0 THEN {
	I+=3
} ELSE {
	I++
}
WEND

PRINT result$

Diese Aufgabe ist mit der Subtraktion, allerdings werden bei zahlen höher als "19999" das A öfter als 4 mal hintereinander eingesetzt also zum beispiel
20000 = AAAA
 
Gibt es hier eigentlich jemanden, der sich mit der Programmiersprache Oberon 2 auskennt und dazu ein entsprechendes Programm zum Umrechnen ins römische Zahlensystem schreiben kann?
 
Dein Link zeigt auf eine Entwicklungsumgebung für Oberon-2/Java/C++, keine eigentständige Programmiersprache.
 
Obwohl der letzte Post schon ziehmlich lange her ist dachte ich mir ich veröffentliche auch mal meine Variante. Man möge es mir verzeihen.

Ich habe es in Java geschrieben. Zusätzlich habe ich auch noch die Möglichkeit eingebaut römische Ziffern in Dezimalzahlen umzuwandeln.
Bei der Umrechnung dezimal auf römisch wird die Subtraktionsregel beachtet, nicht aber bei der Umrechnung von römisch auf dezimal. Falls jemand eine einfache Möglichkeit gefunden hat auch bei römisch-dezimal die Subtraktionsregel zu berücksichtigen, möge es mir dieser bitte mitteilen.

Code:
/*Wandelt eingegebene Zahlen in
 roemische Zahlen um*/
 
import java.util.Scanner;

public class romZa
{
[	public static void main(String[] args){
		
		Scanner input=new Scanner(System.in);
		
		
		System.out.println("Please enter number: ");
		int z=input.nextInt();
		
		converter c=new converter(z);
		
		System.out.println(c.convert());
		
		
		System.out.println("Please enter roman number: ");
		input.nextLine();
		String y=input.nextLine();
		
		backConverter b=new backConverter(y);
		
		System.out.println(b.convert());
	}
}

Code:
/*
Zeichen 	I 	V 	X 	L 	C 	D 	M
Wert 		1 	5 	10 	50 	100 	500 	1000
    IV = 4 (statt IIII)
    IX = 9 (statt VIIII)
    XL = 40 (statt XXXX)
    XC = 90 (statt LXXXX)
    CD = 400 (statt CCCC)
    CM = 900 (statt DCCCC) 
*/


public class converter{
	private int number;
	private String rom="";
	
	public converter(int z){
		number=z;
	}
	
	public String convert(){
	
		while(number>0){
			
			if(number>=1000){
				rom=rom+"M";
				number-=1000;
			}
			else if(number==900){
				rom+="CM";
				number-=900;
			}
			else if(number>=500&&number<1000){
				rom+="D";
				number-=500;
			}
			else if(number==400){
				rom+="CD";
				number-=400;
			}
			else if(number>=100&&number<500){
				rom+="C";
				number-=100;
			}
			else if(number==90){
				rom+="XC";
				number-=90;
			}
			else if(number>=50&&number<100){
				rom+="L";
				number-=50;
			}
			else if(number==40){
				rom+="XL";
				number-=40;
			}
			else if(number>=10&&number<50){
				rom+="X";
				number-=10;
			}
			else if(number==9){
				rom+="IX";
				number-=9;
			}
			else if(number>=5&&number<9){
				rom+="V";
				number-=5;
			}
			else if(number==4){
				rom+="IV";
				number-=4;
			}
			else if(number>=1&&number<4){
				rom+="I";
				number-=1;
			}
		}
		return rom;
	}
}

Code:
/*
Zeichen 	I 	V 	X 	L 	C 	D 	M
Wert 		1 	5 	10 	50 	100 	500 	1000
*/

public class backConverter{

	private int number;
	private String rom;
	private int len;
	
	public backConverter(String rom){
		this.rom=rom;
		len=rom.length();
	
	}
	
	public int convert(){
		
		char[] sign=new char[len];
		
		
		for(int i=len-1;i>=0;i--){
			sign[i]=rom.charAt(i);
			
					
		}
		
		while(len>0){
		
			if(sign[len-1]=='I'){
				number+=1;
			}
			else if(sign[len-1]=='V'){
				number+=5;
			}
			else if(sign[len-1]=='X'){
				number+=10;
			}
			else if(sign[len-1]=='L'){
				number+=50;
			}
			else if(sign[len-1]=='C'){
				number+=100;
			}
			else if(sign[len-1]=='D'){
				number+=500;
			}
			else if(sign[len-1]=='M'){
				number+=1000;
			}
		
		
		len--;
		}
		return number;
		
	}
}
 
Bevor ich die Java-Lösungen hier gelesen habe, hab ich selber eine gschrieben, die etwas anders aussieht...

vielleicht denke ich ja anders als die meisten Menschen ;-)

für xyz kann man eine beliebige Dezimal-Zahl eingeben

Code:
public class RömischeZahlen {
	
	public static void main(String[] args) {
		
		int Zahl = xyz;
		
		String Ausgabe = "";
		
		while ((Zahl / 5000) > 0) {
			Ausgabe = Ausgabe + "A";
			Zahl -= 5000;
		}
		while ((Zahl / 1000) > 0) {
			Ausgabe = Ausgabe + "M";
			Zahl -= 1000;
		}		
		while ((Zahl / 500) == 1 && (Zahl / 100) != 9) {
			Ausgabe = Ausgabe + "D";
			Zahl -= 500;
		}
		if ((Zahl / 100) > 0) {
			if ((Zahl / 100) == 9) {
				Ausgabe = Ausgabe + "CM";
				Zahl -= 900;
			}
			else if ((Zahl / 100) == 4) {
				Ausgabe = Ausgabe + "CD";
				Zahl -= 400;
			}
			else {
				while ((Zahl /100) > 0) {
					Ausgabe += "C";
					Zahl -= 100;
				}
			}
		}	
		while ((Zahl / 50) == 1 && (Zahl / 10) != 9) {
			Ausgabe = Ausgabe + "L";
			Zahl -= 50;
		}
		if ((Zahl / 10) > 0) {
			if ((Zahl / 10) == 9) {
				Ausgabe = Ausgabe + "XC";
				Zahl -= 90;
			}
			else if ((Zahl / 10) == 4) {
				Ausgabe = Ausgabe + "XL";
				Zahl -= 40;
			}
			else {
				while ((Zahl /10) > 0) {
					Ausgabe += "X";
					Zahl -= 10;
				}
			}
		}
		while ((Zahl / 5) == 1 && (Zahl / 1) != 9) {
			Ausgabe = Ausgabe + "V";
			Zahl -= 5;
		}
		if ((Zahl / 1) > 0) {
			if ((Zahl / 1) == 9) {
				Ausgabe = Ausgabe + "IX";
				Zahl -= 9;
			}
			else if ((Zahl / 1) == 4) {
				Ausgabe = Ausgabe + "IV";
				Zahl -= 4;
			}
			else {
				while ((Zahl /1) > 0) {
					Ausgabe += "I";
					Zahl -= 1;
				}
			}
		}
		if (Zahl == 0) {
			System.out.println(Ausgabe);	
		}
	}
}
 
Hallo!

Meine Java Lösung

Main.java
Code:
public class Main {

	public static void main(String[] args) {
		RoemNums roem = new RoemNums();
		
		System.out.println(roem.getRoemNum(5));
		System.out.println(roem.getRoemNum(19));
		System.out.println(roem.getRoemNum(21));
		System.out.println(roem.getRoemNum(347));
		System.out.println(roem.getRoemNum(1234));
	}

}

RoemNums.java
Code:
public class RoemNums {
	
	private RoemDigit[] roemArray = null;
	
	public RoemNums() {
		this.roemArray = new RoemDigit[15];
		this.init();
	}
	
	private void init() {
		this.roemArray[0] = new RoemDigit(5000, "A");
		this.roemArray[1] = new RoemDigit(4000, "MA");
		this.roemArray[2] = new RoemDigit(1000, "M");
		this.roemArray[3] = new RoemDigit(900, "CM");
		this.roemArray[4] = new RoemDigit(500, "D");
		this.roemArray[5] = new RoemDigit(400, "CD");
		this.roemArray[6] = new RoemDigit(100, "C");
		this.roemArray[7] = new RoemDigit(90, "XC");
		this.roemArray[8] = new RoemDigit(50, "L");
		this.roemArray[9] = new RoemDigit(40, "XL");
		this.roemArray[10] = new RoemDigit(10, "X");
		this.roemArray[11] = new RoemDigit(9, "IX");
		this.roemArray[12] = new RoemDigit(5, "V");
		this.roemArray[13] = new RoemDigit(4, "IV");
		this.roemArray[14] = new RoemDigit(1, "I");
	}
	
	public String getRoemNum(int num) {
		String roem = "";
		
		for(int idx=0; idx<roemArray.length; idx++) {
			while(num >= roemArray[idx].getNum()) {
				num -= roemArray[idx].getNum();
				roem += roemArray[idx].getDigit();
			}
		}
		return roem;
	}
	
}

RoemDigit.java
Code:
public class RoemDigit {

	private int num = 0;
	private String digit = null;
	
	public RoemDigit(int num, String digit) {
		this.num = num;
		this.digit = digit;
	}
	
	public int getNum() {
		return num;
	}
	
	public String getDigit() {
		return digit;
	}
	
}

Gruß
Felix
 
Ich habe da auch eine Idee, von arabisch ins römische. Wir mussten sowas für die Schule erstellen. Die gegeben Programme haben mir da auch sehr geholfen. Danke. Ihr könnt euch ja mal melden, falls es da noch Probleme gibt.
Code:
public class rom {
  public static void main(String [] args) {
    System.out.println("Herzlich Willkommen");
    System.out.println("Dieses Programm erfüllt die Umrechnung arabischer in römische Zahlen");
    int eingabe = IOTools.readInteger("Geben sie eine Zahl von 1 bis 3999 an: ");  //Eingabe der Zahl
    if (eingabe<4000 && eingabe>0)
      eingabe = eingabe;
    else
      eingabe = IOTools.readInteger("Geben sie erneut eine Zahl von 1 bis 3999 an: ");
    abfrage(eingabe,false); //Einfache Umrechnung
    abfrage(eingabe,true);  //Subtraktionsregel
  }

  public static void abfrage (int eingabe2,boolean b){
    String sub = "";          //setzt die römische Zahl auf 0
    boolean a = true;         //Einfache Umrechnung wird festgelegt
    while(a){                 //Schleife mit der Berechnung startet
      if(eingabe2 >= 1000) {
        eingabe2 = eingabe2 - 1000;
        sub = sub + 'M';
      }
      else if(eingabe2 >=900 && b){
        eingabe2 = eingabe2 - 900;
        sub = sub+"CM";
      }
      else if(eingabe2 >= 500) {
        eingabe2 = eingabe2 - 500;
        sub = sub + 'D';
      }
      else if(eingabe2 >=400 && b){
        eingabe2 = eingabe2 - 400;
        sub =sub+"CD";
      }
      else if(eingabe2 >= 100) {
        eingabe2=eingabe2 - 100;
        sub = sub + 'C';
      }
      else if(eingabe2 >=90 && b){
        eingabe2 = eingabe2 - 90;
        sub = sub+"XC";
      }
      else if(eingabe2 >= 50) {
        eingabe2=eingabe2 - 50;
        sub = sub + 'L';
      }
      else if(eingabe2 >=40 && b){
        eingabe2 = eingabe2 - 40;
        sub = sub+"XL";
      }
      else if(eingabe2 >= 10) {
        eingabe2=eingabe2 - 10;
        sub = sub + 'X';
      }
      else if(eingabe2 >=9 && b){
        eingabe2 = eingabe2 - 9;
        sub = sub+"IX";
      }
      else if(eingabe2 >= 5) {
        eingabe2=eingabe2 - 5;
        sub = sub + 'V';
      }
      else if(eingabe2 >=4 && b){
        eingabe2 = eingabe2 - 4;
        sub = sub+"IV";
      }
      else if(eingabe2 >= 1) {
        eingabe2=eingabe2 - 1;
        sub = sub + 'I';
      }
      else if(eingabe2 == 0){
        System.out.println("Die römische Zeichenkette lautet: "+sub);     //gibt die Reihenfolge der römischen Buchstaben aus
        a = false;                   //ändert es auf die Subtraktionsregel; die Schleife wird erneut durchgeführt und mit der korrekten Ausgabe der Buchstaben ausgegeben
      }
    }
  }
}

Das geht doch als Programm, oder? Also bei mir funktioniert es.

Editiert von CDW -> CODE-Tags nutzen!
 
mit[/b] Subtraktionsregel]
Code:
zahl(5000,a).
zahl(1000,m).
zahl(900,cm).
zahl(500,d).
zahl(400,cd).
zahl(100,c).
zahl(90,xc).
zahl(50,l).
zahl(40,xl).
zahl(10,x).
zahl(9,ix).
zahl(5,v).
zahl(4,iv).
zahl(1,i).
                             %für dez. 0 ist die röm. Darstellung trivial :)
rom(0,[]).
                             %sonst: sofern die Zahl positiv ist
rom(Dec,Erg):-  Dec>0,        %gibt es bestimmt eine Zahl X,
    zahl(X,Zeichen),         %der direkt eine röm. Zahl entspricht und ein Y
    Y is Dec-X,              % welches sich in eine römische Zahl  "zerlegen"
    rom(Y,Rest),             % lässt.   Daher ist Ergebnis= die Entsprechung für
    Erg=[Zeichen|Rest],!.    % X samt der Entsprechung für Y (welche noch gefunden
                             % werden muss ;) )
                             
dec([],0).                    %fertig, wenn keine röm. Ziffer vorhanden ist
dec([Rom|Restliste],Erg):-
    zahl(X,Rom),              % sonst gibt es eine Entsprechung X für eine röm. Zahl
    dec(Restliste,Teil_erg),   % und für den Rest existiert ein Teilergebnis
    Erg is Teil_erg+X.         % so dass Ergebnis sich aus X und Teilergebnis
                               %zusammensetzt.
Ausgabe:
Code:
?- rom(2008,Jahr).
Jahr = [m, m, v, i, i, i].
?- dec([m,m,m,cm,xc,ix],Jahr).
Jahr = 3999
 
Code:
module Rom
where 
 import Hackish
 main = runHackish entry
 dez = newInt 0
 rom = newString ""

 entry = do
      repeatUntil $$ 
      do
         rom=:""
         writeLn("Zahl zum Umrechnen oder 0 zum aufhören:");
         getInt dez
         ifThen(dez==0) $$
           exit 0
         umrechnen
         writeLn(rom)
      $$(false) 
 
 umrechnen=do
     while(dez>=5000) $$ do
        dez=:dez-5000
        rom=:rom++"A"
     while(dez>=1000) $$ do
        dez=:dez-1000
        rom=:rom++"M"
     while(dez>=500) $$ do
        dez=:dez-500
        rom=:rom++"D"      
     while(dez>=100) $$ do
        dez=:dez-100
        rom=:rom++"C"
     while(dez>=50) $$ do
        dez=:dez-50
        rom=:rom++"L"
     while(dez>=10) $$ do
        dez=:dez-10
        rom=:rom++"X"
     while(dez>=5) $$ do
        dez=:dez-5
        rom=:rom++"V"
     while(dez>=1) $$ do
        dez=:dez-1
        rom=:rom++"I"
Im Anhang gibts erstmal nur CLASS Dateien (die "Sprache" wird zu Java-Bytecode compiliert)
RTS und IRTS sind "runtime system" (zum einlesen/ausgeben - sollten nur im selben Ordner wie das Hauptprogramm liegen). Den Compiler kann ich erst nach dem 7.7.08 freigeben ;)
Laufen lassen kann man das Ganze per "java Rom"
 
Hier noch meine Lösung in C++, ich hoffe sie funktioniert wie sie soll,
also die Beispiele bei wikipedia hab ich getestet die habn funktioniert.
Ist vielleicht nicht ganz so optimal programiert, aber ich bin für Verbesserungsvorschläge offen ;)
Code:
#include <cstdlib>
#include <iostream>

using namespace std;

int umrechnung ( int dezimal );

int main(void)
{
    int dezimal;
    cout << "Hallo bitte geben sie die Zahl ein " << endl;
    if (!(cin >> dezimal)) {
              cout << "Falsche Eingabe! " << endl;
              system("pause");
              return 0;
              }
    umrechnung ( dezimal );
    system("pause");
    return 0;
}

int umrechnung( int dezimal ) {
    int var1=0;
    int array1[16] = {5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };
    char array2[16][3] = { "A", "MA", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" };     
    for (int i=0;dezimal>0;) {
        if ( !((dezimal-array1[i])>-1) ) {
             i++;
             continue;
             }
        cout << array2[i];  
        dezimal = dezimal-array1[i];
        var1++;
        }
    cout << endl;
    return 0;
    }

Gruß Virus
 
Hier noch eine Lösung in Lisp:
Code:
(defparameter mapping '(("I" 1)	("IV" 4) ("V" 5) ("IX" 9) ("X" 10) ("XL" 40)
			("L" 50) ("XC" 90) ("C" 100) ("CD" 400) ("D" 500)
			("CM" 900) ("M" 1000) ("MA" 4000) ("A" 5000)))

(defun get-highest-match (number)
  (find-if (lambda (x)
	     (<= x number))
	   mapping
	   :key #'second
	   :from-end t))
;decimal to roman
(defun toroem (number)
  (if (= number 0)
      ""
      (let ((match (get-highest-match number)))
	(string-concat (car match)
		       (toroem (- number (second match)))))))

(defun get-string-match (string)
  ;sort first to catch IV,IX,XL....
  (let ((sorted-mapping (sort mapping #'>
			      :key (lambda (x) (length (car x))))))
    (dolist (el sorted-mapping)
      ;check for long enough 'string' before subseq'ing
      (if (and (<= (length (car el)) (length string))
	       (string= (car el)
			(subseq string 0 (length (car el)))))
	  (return el)))))
;roman to decimal, no error checking
(defun todec (string)
  (let ((match (get-string-match string)))
    (if (string= "" string)
	0
	(+ (second match) (todec (subseq string (length (car match))))))))
 
Meine recht kurze C++-Variante: Unterstützt auch IV, IX, XL, etc
Code:
#include <iostream>
#include <string>
using namespace std;

int main(int argc, char *argv[]) {

if(argc < 2) {
	cout << "Usage: a.out <arabische Zahl>" << endl;
	return -1;
}
int zahl = atoi(argv[1]);

string rom[] = {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
int romval[] = {1,4,5,9,10,40,50,90,100,400,500,900,1000};

for(int i=(sizeof(rom)/sizeof(rom[0])); i>=0; i--) {
	while((zahl-=romval[i])>0)
		cout << rom[i];
	if(zahl < 0)
		zahl += romval[i];		
	if(zahl == 0) 
		{cout << rom[i]; cout << endl; return  0;}	
}

}

./a.out 1439
Code:
MCDXXXIX
 
hier mal ne python lösung:

Code:
def roemisch(n):
    try:        
        x = n/5000
        summe = x*"A"
        n = n - x * 5000

        x = n/4000
        summe = summe+x*"MA"
        n = n - x * 4000

        x = n/1000
        summe = summe+x*"M"
        n = n - x * 1000

        x = n/900
        summe = summe+x*"CM"
        n = n - x * 900

        x = n/500
        summe = summe+x*"D"
        n = n - x * 500

        x = n/400
        summe = summe+x*"CD"
        n = n - x * 400

        x = n/100
        summe = summe+x*"C"
        n = n - x * 100

        x = n/90
        summe = summe+x*"XC"
        n = n - x * 90

        x = n/50
        summe = summe+x*"L"
        n = n - x * 50

        x = n/40
        summe = summe+x*"XL"
        n = n - x * 40

        x = n/10
        summe = summe+x*"X"
        n = n - x * 10

        x = n/9
        summe = summe+x*"IX"
        n = n - x * 9

        x = n/5
        summe = summe+x*"V"
        n = n - x * 5

        x = n/4
        summe = summe+x*"IV"
        n = n - x * 4

        x = n/1
        summe = summe+x*"I"

        return summe

    except:
            print "Es trat leider ein Fehler auf"
 
Nochmal als Haskell-Programm:
Code:
rome num pos s = do
    let myVal = rv !! pos
    if myVal <= num
        then do
            rome (num - myVal) pos (s ++ (rc !! pos))
        else if num > 0
            then rome num (pos + 1) s
            else putStrLn s
    where
        rc = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
        rv = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]

main = do
    putStrLn "Zahl: "
    n <- getLine
    rome (read n) 0 "Ergebnis: "
Wenn ich wieder Unsinn gebaut habe: Über konstruktive Verbesserungsvorschläge freue ich mich immer!
 
Zurück
Oben