SuperStrict
' Römische Zahlen mittels der Einfachen Umrechnung:
Const M:Int = 1000, D:Int = 500, C:Int = 100, L:Int = 50, X:Int = 10, V:Int = 5, I:Int = 1
   
For Local z:Int = 1 To 10
    Print(RomanNumeral(z))
Next
Print(RomanNumeral(1999))
Print(RomanNumeral(2011))

End

Function RomanNumeral:String(zahl:Int)
    '* Die Funktion muss mit einem $ versehen werden, damit sie einen String 
    '* Zurück geben kann!
    '* Es gilt: M = 1000, D = 500, C = 100, L = 50, X = 10, V = 5, I = 1
    
    
    '* Für die Einfache Umrechnung wird mit dem höchsten Wert begonnen:
    
    If zahl <= 0 Then Return "N"
    
    Local output$ = ""
    
    Local Mz% = zahl / M '* Wie oft passt 1000 in die Zahl?
    zahl = zahl - (Mz*M) '* Glatte tausender entfernen
    output:+StringRepeat("M", Mz)
    
    Local Dz% = zahl / D 
    zahl = zahl - (Dz*D) 
    output:+StringRepeat("D", Dz)
    
    Local Cz% = zahl / C 
    zahl = zahl - (Cz*C) 
    output:+StringRepeat("C", Cz)
    
    Local Lz% = zahl / L 
    zahl = zahl - (Lz*L) 
    output:+StringRepeat("L", Lz)
    
    Local Xz% = zahl / X 
    zahl = zahl - (Xz*X) 
    output:+StringRepeat("X", Xz)
    
    Local Vz% = zahl/ V 
    zahl = zahl - (Vz*V) 
    output:+StringRepeat("V", Vz)
    
    Local Iz% = zahl / I 
    zahl = zahl - (Iz*I) 
    output:+StringRepeat("I", Iz)
    
    Return output
    
    '* Funktion in Funktion    deklarieren funktioniert in BlitzMax!
    '* Auf die Funktion kann von außen nicht zugegriffen werden... 
    '* nützlich für Hilfsfunktionen die sonst nicht gebraucht werden.
    Function StringRepeat:String(_str:String, _n:Int)
        Local tmp:String
        For Local I:Int = 0 Until _N
            tmp:+_str
        Next
        Return tmp
    End Function
    
End Function

SuperStrict
' Römische Zahlen mittels der Einfachen Umrechnung:
   
For Local z:Int = 1 To 10
    Print(RomanNumeral(z))
Next
Print(RomanNumeral(1999))
Print(RomanNumeral(2011))


End

Function RomanNumeral:String(zahl:Int)
    '* Die Funktion muss mit einem $ versehen werden, damit sie einen String 
    '* Zurück geben kann!
    '* Es gilt: M = 1000, D = 500, C = 100, L = 50, X = 10, V = 5, I = 1
    
    '* Das selbe Verfahren nur etwas kondensierter:
    Local RomSymbol:String[7]
    RomSymbol[0] = "I"
    RomSymbol[1] = "V" 
    RomSymbol[2] = "X" 
    RomSymbol[3] = "L" 
    RomSymbol[4] = "C" 
    RomSymbol[5] = "D"
    RomSymbol[6] = "M" 
    Local RomNumber:Int[7]
    RomNumber[0] = 1 
    RomNumber[1] = 5 
    RomNumber[2] = 10 
    RomNumber[3] = 50
    RomNumber[4] = 100 
    RomNumber[5] = 500 
    RomNumber[6] = 1000 
    
    If zahl <= 0 Then Return "N"
    
    Local output:String = ""
    For Local z:Int = 6 To 0 Step - 1
        Local A:Int = zahl / RomNumber[z]
        zahl = zahl - (A * RomNumber[z])
        output:+StringRepeat(RomSymbol[z], A)
    Next
    
    Return output
    
    '* Funktion in Funktion    deklarieren funktioniert in BlitzMax!
    '* Auf die Funktion kann von außen nicht zugegriffen werden... 
    '* nützlich für Hilfsfunktionen die sonst nicht gebraucht werden.
    Function StringRepeat:String(_str:String, _n:Int)
        Local tmp:String
        For Local I:Int = 0 Until _N
            tmp:+_str
        Next
        Return tmp
    End Function
    
End Function

	'BM's BPS#7: Umrechnung von arabischen Zahlen in römische Zahlendarstellung (und umgekehrt):

SuperStrict

'Folgende in einem Array zusammengestellte Zahlen sollen getestet werden (beliebig erweiterbar):
Local TestArabischeZahl:Int[] = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1999, 2011, 1984, 848]
'Zwecks späterer Rückumwandlung wird ein gleich großes Array für die Ergebnisse bereitgestellt:
Local TestRoemischeZahl:String[ Len(TestArabischeZahl) ]

'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

'Gestützt auf den 'Wikipedia'-Artikel über römische Zahlendarstellung sollen drei Arten unterschieden werden.
'Zuerst soll sich der historisch ältesten, rein additiven römischen Zahlendarstellung gewidmet werden.
'Dazu werden zum einen die Zeichen und zum anderen die Werte definiert, welche die Zeichen repräsentieren:
Global Zeichen:String[] = [ "I", "V",  "X",  "L",  "C",   "D",  "M" ]
Global Wert:Int[] =            [   1,    5,    10,   50,  100,  500, 1000 ] 

'Auf diesen globalen Arrays basierend soll folgende Funktion
'ein arabisches Zahlenargument in ein römisches umwandeln:
Function  Arabisch_Roemisch:String(ArabischeZahl:Int)

	'Die folgende (noch "leere") Stringvariable wird nun Zeichen
	'für Zeichen von Links nach Rechts zusammengesetzt werden:
	Local RoemischeDarstellung:String
	
	'Ausgehend vom größten Wert wird geprüft, ob er in die Zahl hineinpasst. Dabei
	'wird das Array "von hinten aufgerollt" und mit dem letzten Wert-Eintrag gestartet:
	Local Index:Int = Len(Wert) - 1
	
	Repeat
	
		While ArabischeZahl >= Wert[Index]   'Falls dieser Wert "hineinpasst", ...
		
			'... wird das entsprechende Zeichen Rechts hinzugefügt,
			RoemischeDarstellung = RoemischeDarstellung + Zeichen[Index]
			
			'der Wert vom originalen Zahlenargument abgezogen
			ArabischeZahl = ArabischeZahl - Wert[Index]
			
		Wend   'und dies solang wiederholt, bis der Wert NICHT mehr hineinpasst.
		
		'Dann bzw. ansonsten wird im Wert-Array ein Schritt zurückgegangen,
		'um zu prüfen, ob der jeweils nächstkleinere Wert hineinpasst:
		Index = Index - 1

		'Das Ganze wird wiederholt, bis vom Zahlenargument nichts mehr übrig ist:
	Until ArabischeZahl = 0
	
	'Dann ist die Umwandlung fertig und das Ergebnis kann zurückgegeben werden:
	Return RoemischeDarstellung
	
End Function

'Nun sollen die Ergebnisse der Funktion getestet werden:
Print "1.Umwandlung in römische Zahlendarstellung (rein additiv):"
For Local i:Int = 0 Until Len(TestArabischeZahl)
	TestRoemischeZahl[i] = Arabisch_Roemisch(TestArabischeZahl[i])
	Print TestArabischeZahl[i] + " = " + TestRoemischeZahl[i]
Next

'Über die BPS-Aufgabenstellung hinausgehend soll nicht versäumt werden,
'eine entsprechende Konvertierungsfunktion zu erstellen, welche die 
'Römische Zahl wieder in die arabische Schreibweise zurück verwandelt:
Function  Roemisch_Arabisch:Int(RoemischeZahl:String)

	'Die folgende Integervariable wird gleich additiv gefüllt werden:
	Local ArabischeZahl:Int
	
	'Vom kleinsten zum größten Wert wird nun geprüft, ob eines der Zeichen
	'mit einem Teilstring am rechten Rand der römischen Zahl identisch ist:
	For Local i:Int = 0 Until Len(Zeichen)
	
		While Zeichen[i] = Right(RoemischeZahl, Len(Zeichen[i]))   'Ist dies der Fall,
		
			'dann wird der entsprechende Wert zum Ergebnis hinzugezählt
			ArabischeZahl = ArabischeZahl + Wert[i]
			
			'und der Teilstring vom rechten Rand der römischen Zahl abgeschnitten:
			RoemischeZahl = Left(RoemischeZahl, Len(RoemischeZahl) - Len(Zeichen[i]))
			
			'Falls das römische Zahlenargument bereits vollständig zerlegt worden ist,
			'kann das nun fertige Endergebnis zurückgegeben werden:
			If RoemischeZahl = "" Then Return ArabischeZahl
			
		Wend   'Dies wird solang wiederholt, bis der rechte Rand NICHT mehr identisch ist,
		
	Next   'dann bzw. ansonsten wird zum nächstgrößeren Wert bzw. Zeichen vorangeschritten.
	
End Function

'Nun folgt der Test, ob die römischen Zahlen richtig zurückkonvertiert werden:
Print "Umwandlung zurück in arabische Zahlen:"
For Local i:Int = 0 Until Len(TestArabischeZahl)
	Print TestRoemischeZahl[i] + " = " + Roemisch_Arabisch(TestRoemischeZahl[i])
Next

'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

'Nun soll die zweite Art römischer Zahlendarstellung behandelt werden, nämlich jene mit der Subtraktionsregel.
'Erfreulicher Weise können weiterhin genau die gleichen Konvertierungsfunktionen verwendet werden.
'Lediglich die Zeichen- und Wert-Arrays müssen um einige zusätzliche Einträge ergänzt werden:

Zeichen = [ "I", "IV","V",  "IX", "X",  "XL", "L",  "XC", "C", "CD",  "D",  "CM",  "M" ]
Wert =      [   1,    4,    5,      9,    10,    40,    50,    90,  100,   400,  500,   900,  1000 ]

Print "2.Umwandlung in römische Zahlendarstellung (mit Subtraktionsregel):"
For Local i:Int = 0 Until Len(TestArabischeZahl)
	TestRoemischeZahl[i] = Arabisch_Roemisch(TestArabischeZahl[i])
	Print TestArabischeZahl[i] + " = " + TestRoemischeZahl[i]
Next
Print "Und wieder zurück in arabische Zahlen:"
For Local i:Int = 0 Until Len(TestArabischeZahl)
	Print TestRoemischeZahl[i] + " = " + Roemisch_Arabisch(TestRoemischeZahl[i])
Next

'= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

'Zuletzt wird die römischen Zahlendarstellung mit erweiterten "fehlerhaften" Subtraktionsregeln behandelt.
'Die Zeichen- und Wert-Arrays müssen wie folgt um weitere Einträge ergänzt werden:

Zeichen = [ "I", "IV","V", "IIX", "IX", "X",  "XL", "IIL", "IL", "L", "XXC", "XC", "IIC", "IC", "C", "CD", "XXD", "XD", "IID", "ID",  "D", "CCM", "CM",  "XXM", "XM", "IIM", "IM",  "M" ]
Wert =      [   1,    4,    5,      8,     9,    10,    40,     48,  49,   50,     80,      90,     98,   99,  100,   400,    480,    490,   498, 499,  500,    800,     900,      980,     990,   998,  999, 1000 ]

Print "3.Umwandlung in römische Zahlendarstellung (mit erweiterten 'fehlerhaften' Subtraktionsregeln):"
For Local i:Int = 0 Until Len(TestArabischeZahl)
	TestRoemischeZahl[i] = Arabisch_Roemisch(TestArabischeZahl[i])
	Print TestArabischeZahl[i] + " = " + TestRoemischeZahl[i]
Next
Print "Und wieder zurück in arabische Zahlen:"
For Local i:Int = 0 Until Len(TestArabischeZahl)
	Print TestRoemischeZahl[i] + " = " + Roemisch_Arabisch(TestRoemischeZahl[i])
Next