Eingang:

Eine ganze Zahl.

Ausgabe:

1. Konvertieren Sie zuerst die Ganzzahl in die entsprechende römische Zahl.
2. Konvertieren Sie dann jeden Großbuchstaben dieser römischen Ziffer in ihren ASCII / UNICODE-Dezimalwert.
3. Und die Summe davon ausgeben.

Beispiel:

1991 -> MCMXCI -> 77+67+77+88+67+73 -> 449
^ input                                ^ output

Römische Ziffern: Hier ist ein vielleicht nützlicher Umrechner für römische Ziffern .

Herausforderungsregeln:

• Standardregeln für römische Zahlen werden angewendet, daher gibt es keine alternativen Formen wie IIIIoder VIIIIanstelle von IVund IX. *
• Die Macron-Linien über den römischen Ziffern nach 1.000 sind ¯(UNICODE Nr. 175). Eine Zeile zählt also als +175und zwei als +350.
• Sie können einen beliebigen Eingabe- und Ausgabetyp verwenden, sofern dieser die ganzen Zahlen darstellt.
• Die Testfälle liegen im Bereich von 1 - 2,147,483,647.

* Regeln für römische Ziffern (Zitat aus Wikipedia):

Zahlen werden durch Kombinieren von Symbolen und Addieren der Werte gebildet, also IIzwei (zwei Einsen) und XIIIdreizehn (zehn und drei Einsen). Da jede Zahl einen festen Wert hat, anstatt ein Vielfaches von zehn, einhundert usw. zu repräsentieren, besteht keine Notwendigkeit, Nullen zu "platzieren", wie dies bei Zahlen wie 207 oder 1066 der Fall ist. Diese Zahlen sind geschrieben als CCVII(zweihundert, fünf und zwei Einsen) und MLXVI(tausend, fünfzig, zehn, fünf und eins).

Die Symbole werden von links nach rechts in der Reihenfolge ihres Werts angeordnet, beginnend mit dem größten. In einigen speziellen Fällen wird die subtraktive Notation jedoch häufig wie folgt verwendet , um zu vermeiden, dass vier Zeichen nacheinander wiederholt werden (z. B. IIIIoder XXXX):

• Isteht vor Voder Xgibt eins weniger an, also vier ist IV(eins weniger als fünf) und neun ist IX(eins weniger als zehn)
• Xplatziert vor Loder Czeigt zehn weniger an, also sind vierzig XL(zehn weniger als fünfzig) und neunzig XC(zehn weniger als hundert)
• Cplatziert vor Doder Mzeigt hundert weniger an, also vierhundert ist CD(hundert weniger als fünfhundert) und neunhundert ist CM(hundert weniger als tausend)
  Zum Beispiel MCMIVist eintausendneunhundertvier, 1904 ( Mist eintausend, CMist neunhundert und IVist vier).

Einige Beispiele für die moderne Verwendung römischer Ziffern sind:
1954 als MCMLIV; 1990 als MCMXC; 2014 als MMXIV
QUELLE

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

100          ->   67
1            ->   73
4            ->   159
22           ->   322
5000         ->   261
2016         ->   401
1000000000   ->   427
1991         ->   449
9999         ->   800
1111111111   ->   2344
2147483647   ->   5362

Mathematica, 181 173 166 151 Bytes

Golf gespielt

(q=Select[ToCharacterCode@#,64<#<99&]&/@StringSplit[RomanNumeral[#],"_"];p=PadLeft;l=Length;Total[p[q,4]+p[{350,350*Mod[l@q,2],175,0}[[-l@q;;]],4],2])&

Ungolfed

(
q = Select[
     ToCharacterCode@#,
     64<#<99&
    ]&/@StringSplit[RomanNumeral@#,"_"];
p=PadLeft;
l=Length;
Total[
   p[q,4]+
   p[{350,350*Mod[l@q,2],175,0}[[-l@q;;]],4]
   ,2]
)&

Die RomanNumeralImplementierung von Mathematica liefert (IX) CMXCIX für 9999, und das Programm gibt 971 für diese Zahl zurück.

Wie geschrieben gibt eine römische Ziffer vom Typ ((...)) (...) ... eine verschachtelte Liste der ASCII-Codes für die römischen Ziffern der Länge 4, ((...)) ... zurück. gibt eine Liste der Länge 3 zurück, (...) ... gibt eine Liste der Länge 2 zurück und ... gibt eine Liste der Länge 1 zurück. Die letzte Zeile konvertiert diese Regeln in die entsprechende Anzahl von Makros für jeden Abschnitt der list, fügt diese Makros hinzu und summiert dann die gesamte verschachtelte Liste, um die Ausgabe zurückzugeben.

Python 3, 281 278 273 269 ​​Bytes

Mein erster Versuch mit Codegolf, los geht's. Versucht es zu tun, ohne auf die verknüpfte Frage zu schauen, also ist es wahrscheinlich schrecklich :)

def f(n):d=len(str(n))-1;l=10**d;return 0if n<1else(n<l*4and[73,88,67,77,263,242,252,438,417,427][d]+f(n-l))or(l<=n//9and[161,155,144,340,505,494,690,855,844][d]+f(n-9*l))or(n<l*5and[159,164,135,338,514,485,688,864,835][d]+f(n-4*l))or[86,76,68][d%3]+(d//3*175)+f(n-5*l)

8 Bytes kleiner dank Gábor Fekete

Ungolfed:

def f(n):
d = len(str(n)) - 1 # number of digits minus one
l = 10 ** d         # largest power of 10 that is not larger than parameter
if n == 0:
    return 0
elif n < 4 * l: # starts with X, C, M, ...
    return [
        ord('I'),
        ord('X'),
        ord('C'),
        ord('M'),
        ord('X') + 175, 
        ord('C') + 175, 
        ord('M') + 175, 
        ord('X') + 350, 
        ord('C') + 350, 
        ord('M') + 350
    ][d] + f(n - l)
elif n // 9 * 10 >= 10 * l: # starts with IX, XC, ...
    return [
        ord('I') + ord('X'), 
        ord('X') + ord('C'), 
        ord('C') + ord('M'),
        ord('M') + ord('X') + 175,
        ord('X') + ord('C') + 350,
        ord('C') + ord('M') + 350,
        ord('M') + ord('X') + 525,
        ord('X') + ord('C') + 700,
        ord('C') + ord('M') + 700
    ][d] + f(n - 9*l)
elif n < 5 * l: # starts with IV, XL, CD, ... 
    return [
        ord('I') + ord('V'),
        ord('X') + ord('L'),
        ord('C') + ord('D'),
        ord('M') + ord('V') + 175,
        ord('X') + ord('L') + 350,
        ord('C') + ord('D') + 350,
        ord('M') + ord('V') + 525,
        ord('X') + ord('L') + 700,
        ord('C') + ord('D') + 700
    ][d] + f(n - 4 * l)
else: # starts with V, L, D, ...
    return [
        ord('V'), 
        ord('L'), 
        ord('D'),
        ord('V') + 175, 
        ord('L') + 175, 
        ord('D') + 175,
        ord('V') + 350, 
        ord('L') + 350, 
        ord('D') + 350
    ][d] + f(n - 5 * l)

Ruby, 188 Bytes

Eine Anpassung, die auf meiner alten Ruby-Antwort für die Umrechnung von römischen Zahlen basiert . Probieren Sie es online!

f=->x,i=0{k=0;(x<t=1e3)?"CM900D500CD400C100XC90L50XL40X10IX9V5IV4I1".gsub(/(\D+)(\d+)/){v=$2.to_i;s=x/v;x%=v;($1*s).bytes.map{|c|k+=c==73&&i>0?77+175*~-i:c+175*i}}:k=f[x/t,i+1]+f[x%t,i];k}

Mathematica, 198 Bytes

Tr[Tr@Flatten[ToCharacterCode/@#]+Length@#*Tr@#2&@@#&/@Partition[Join[SplitBy[Select[Characters@#/."\&"->1,MemberQ[Join["A"~CharacterRange~"Z",{1}],#]&],LetterQ]/. 1->175,{{0}}],2]]&@RomanNumeral@#&

Leider hilft das eingebaute hier nicht viel, obwohl ich mir sicher bin, dass dies weitaus mehr golfen kann.

Hinweis: Bewertet 9999 -> 971wie hier .

Batch, 373 Bytes

@echo off
set/an=%1,t=0,p=1
call:l 73 159 86 161
call:l 88 164 76 155
call:l 67 135 68 144
call:l 77 338 261 340
call:l 263 514 251 505
call:l 242 485 243 494
call:l 252 688 436 690
call:l 438 864 426 855
call:l 417 835 418 844
call:l 427 0 0 0
echo %t%
exit/b
:l
set/ad=n/p%%10,p*=10,c=d+7^>^>4,d-=9*c,t+=%4*c,c=d+3^>^>3,d-=5*c,t+=%3*c+%2*(d^>^>2)+%1*(d^&3)

Arbeitet , indem jede Ziffer der Zahl entsprechend eine Nachschlagtabelle für die Werte übersetzen 1, 4, 5 und 9. Uses M(V), M(X), (M(V))und (M(X)). Wenn Sie es vorziehen (IV), (IX), ((IV))und ((IX))dann verwenden call:l 77 509 261 511und call:l 252 859 436 861jeweils.

JavaScript (ES6), 183 Byte

f=(n,a=0)=>n<4e3?[256077,230544,128068,102535,25667,23195,12876,10404,2648,2465,1366,1183,329].map((e,i)=>(d=e>>8,c=n/d|0,n-=c*d,r+=c*(e%256+a*-~(i&1))),r=0)|r:f(n/1e3,a+175)+f(n%1e3)

Hinweis: nicht nur bevorzugt (IV)zu M(V), sondern auch bevorzugt (VI)zu (V)M; Tatsächlich wird M nur am Anfang der Zahl verwendet.

Python, 263 Bytes

def g(m):x=0;r=[73,86,88,76,67,68,77,261,263,251,242,243,252,436,438,426,417,418,427,0,0];return sum([b%5%4*r[i+(i*1)]+((b==9)*(r[i+(i*1)]+r[(i+1)*2]))+((b==4)*(r[i+(i*1)]+r[i+1+(i*1)]))+((b in [5,6,7,8])*r[i+1+(i*1)])for i,b in enumerate(map(int,str(m)[::-1]))])

R, 115 Bytes

Also ... ich poste meine Lösung, weil ich die Frage ziemlich interessant finde. Ich habe mein Bestes mit R ‚Kapazitäten s ohne Pakete mit römischen Zahlen umgehen: Sie können nur Eingabe von Zahlen zwischen 1und 3899, wie die as.roman‘ s - Dokumentation erklärt.

Deshalb habe ich ein bisschen geschummelt, indem ich den Bereich dazwischen gegeben 1habe11 14 in der forSchleife angegeben habe: Es ist die Länge der as.roman(3899)Ausgabe ( MMMDCCCXCIX) .
Tatsächlich ist laut dieser Website die längste römische Zahl MMDCCCLXXXVIII(14 Zeichen), was entspricht 2888.

Außerdem können Sie lengthdie Ausgabe dieser Funktion nicht berechnen .

a=scan();v=0;for(i in 1:14){v=c(v,as.numeric(charToRaw(substring(as.character(as.roman(a)),1:14,1:14)[i])))};sum(v)

Wenn jemand eine Lösung für die oben genannten Probleme findet, kann er dies gerne kommentieren.

Python 3, 315 Bytes

def p(n=int(input()),r=range):return sum([f*g for f,g in zip([abs(((n-4)%5)-1)]+[t for T in zip([((n+10**g)//(10**g*5))%2for g in r(10)],[(n%(10**g*5))//(10**g*4)+max((n%(10**g*5)%(10**g*4)+10**(g-1))//(10**g),0)for g in r(1,10)])for t in T],[73,86,88,76,67,68,77,261,263,251,242,243,252,436,438,426,417,418,427])])

Ungolfed-Version:

def p(n=int(input()),r=range):
    return sum([f*g for f,g in zip(
        [abs(((n-4)%5)-1)]+
        [t for T in zip(
            [((n+10**g)//(10**g*5))%2for g in r(10)],
            [(n%(10**g*5))//(10**g*4)+max((n%(10**g*5)%(10**g*4)+10**(g-1))//(10**g),0)for g in r(1,10)]
        )for t in T],
        [73,86,88,76,67,68,77,261,263,251,242,243,252,436,438,426,417,418,427])])

Erläuterung: Diese Version verwendet einen anderen Ansatz. Sie zählt römische Ziffern in der Zahl.

[abs(((n-4)%5)-1)] ist die Anzahl der I s in der römischen Zahl.

[((n+10**g)//(10**g*5))%2for g in r(10)] ist die Anzahl der V,L,D,(V),(L),(D),((V)),((L)),((D)) s in der Zahl.

[(n%(10**g*5))//(10**g*4)+max((n%(10**g*5)%(10**g*4)+10**(g-1))//(10**g),0)for g in r(1,10)] ist die Nummer der X,C,M,(X),(C),(M),((X)),((C)),((M)) s in der Nummer.

Dann multipliziert es die Vorkommen mit dem Wert des Zeichens und gibt dessen Summe zurück.