Bei einer streng positiven Ganzzahl geben Sie die kürzestmögliche römische Zahl nur mit der additiven Regel zurück. Die Ausgabe muss aus null oder mehr Zeichen MDCLXVIin dieser Reihenfolge bestehen. Die Nummer 14muss also XIIIIeher geben als XIV.

Die numerischen Werte der Zeichen sind M= 1000, D= 500, C= 100, L= 50, X= 10, V= 5, I= 1.

Beispiele

3 → III

4 → IIII

9 → VIIII

42 → XXXXII

796 → DCCLXXXXVI

2017 → MMXVII

16807 → MMMMMMMMMMMMMMMMDCCCVII

Plain English , 1059 1025 678 641 451 399 Bytes

34 Byte durch Entfernen einer Fehlerfalle eingespart. Dann werden 384 Bytes durch Golfen eingespart. Dann werden 190 Bytes gespart, indem die Divisionsoperation mit der Anfügungsoperation ("z") zu einer neuen Operation ("p") kombiniert wird. Dann wurden durch Golfen 52 Bytes gespart.

A s is a string.
To p a r remainder a s a x string a n number:
If the x is "", exit.
Divide the r by the n giving a q quotient and the r.
Fill a t s with the x's first's target given the q.
Append the t to the s.
To convert a r number to a s:
p the r the s "M" 1000.
p the r the s "D" 500.
p the r the s "C" 100.
p the r the s "L" 50.
p the r the s "X" 10.
p the r the s "V" 5.
p the r the s "I" 1.

Hier ist die unbenutzte Version des endgültigen Codes sowie eine Fehlerfalle für eine negative Zahl:

A roman numeral is a string.

To process a remainder given a roman numeral and a letter string is a number:
  If the letter is "", exit.
  Divide the remainder by the number giving a quotient and the remainder.
  Fill a temp string with the letter's first's target given the quotient.
  Append the temp string to the roman numeral.

To convert a number to a roman numeral:
  If the number is negative, exit.
  Put the number in a remainder.
  Process the remainder given the roman numeral and "M" is 1000.
  Process the remainder given the roman numeral and "D" is  500.
  Process the remainder given the roman numeral and "C" is  100.
  Process the remainder given the roman numeral and "L" is   50.
  Process the remainder given the roman numeral and "X" is   10.
  Process the remainder given the roman numeral and "V" is    5.
  Process the remainder given the roman numeral and "I" is    1.

APL (Dyalog) , 25 22 Bytes

'MDCLXVI'/⍨(0,6⍴2 5)∘⊤

Probieren Sie es online!

Retina , 57-42 Bytes

Konvertiert zu Unary und ersetzt gierig Bündel von Is durch die höheren Konfessionen in der angegebenen Reihenfolge.

.*
$*I
I{5}
V
VV
X
X{5}
L
LL
C
C{5}
D
DD
M

Probieren Sie es online aus

_{Dank Martin 15 Bytes gespart}

Python 2 , 64 Bytes

f=lambda n,d=5,r='IVXLCD':r and f(n/d,7-d,r[1:])+n%d*r[0]or'M'*n

Probieren Sie es online!

Anstatt die Ausgabezeichenfolge von Anfang an zu erstellen, indem der größte Teil gierig übernommen wird, wird sie vom Ende an erstellt. Zum Beispiel ist die Anzahl von I's n%5, dann ist die Anzahl von V' s n/5%2und so weiter. Dies ist eine gemischte Basenumwandlung mit aufeinanderfolgenden Verhältnissen von 5 und 2 abwechselnd.

Hier ist ein iteratives Äquivalent:

Python 2 , 68 Bytes

n=input();s='';d=5
for c in'IVXLCD':s=n%d*c+s;n/=d;d^=7
print'M'*n+s

Probieren Sie es online!

Die Mmüssen separat behandelt werden, da eine beliebige Anzahl von ihnen vorhanden sein kann, da es keine größere Ziffer gibt. Nachdem die anderen Platzwerte zugewiesen wurden, wird der verbleibende Wert in M's umgewandelt.

Zum Vergleich eine gierige Strategie (69 Bytes):

Python 2 , 69 Bytes

f=lambda n,d=1000,r='MDCLXVI':r and n/d*r[0]+f(n%d,d/(d%3*3-1),r[1:])

Probieren Sie es online!

Der aktuelle Ziffernwert dwird durch 2 oder 5 geteilt, um die nächste Ziffer zu erhalten. Der Wert von d%3sag uns welches: wenn d%3==1, dividiere durch 2; und wenn d%3==2, durch 5 teilen.

Mathematica, 81 Bytes

Table@@@Thread@{r=Characters@"MDCLXVI",#~NumberDecompose~FromRomanNumeral@r}<>""&

Die explizite Verwendung der Werte und die Ableitung der entsprechenden Ziffern scheint ein Byte länger zu sein:

Table@@@Thread@{RomanNumeral[n={1000,500,100,50,10,5,1}],#~NumberDecompose~n}<>""&

Excel, 236 193 161 Bytes

43 Bytes gespart dank @ BradC

Zu diesem Zeitpunkt gehört die Antwort wirklich ganz @ BradC . Weitere 32 Bytes gespeichert.

=REPT("M",A1/1E3)&REPT("D",MOD(A1,1E3)/500)&REPT("C",MOD(A1,500)/100)&REPT("L",MOD(A1,100)/50)&REPT("X",MOD(A1,50)/10)&REPT("V",MOD(A1,10)/5)&REPT("I",MOD(A1,5))

Formatiert:

=REPT("M",A1/1E3)
    &REPT("D",MOD(A1,1E3)/500)
    &REPT("C",MOD(A1,500)/100)
    &REPT("L",MOD(A1,100)/50)
    &REPT("X",MOD(A1,50)/10)
    &REPT("V",MOD(A1,10)/5)
    &REPT("I",MOD(A1,5))

Perl 5 , 66 Bytes

65 Byte Code + -pFlag.

$s=1e3;for$@(MDCLXVI=~/./g){$\.=$@x($_/$s);$_%=$s;$s/=--$|?2:5}}{

Probieren Sie es online!

MDCLXVI=~/./gKann ohne Änderung der Byteanzahl durch ersetzt werden M,D,C,L,X,V,I. und --$|?2:5von $|--*3+2.

Viel länger ( 99 Bytes ) gibt es:

$_=M x($_/1e3).D x($_%1e3/500).C x($_%500/100).L x($_%100/50).X x($_%50/10).V x($_%10/5).I x($_%5)

CJam , 35 28 Bytes

-7 Bytes dank Martin Ender

q~{5md\2md\}3*]W%"MDCLXVI".*

Probieren Sie es online!

Erläuterung

q~         e# Read and eval input (push the input as an integer).
{          e# Open a block:
 5md\      e#  Divmod the top value by 5, and bring the quotient to the top.
 2md\      e#  Divmod that by 2, and bring the quotient to the top.
}3*        e# Run this block 3 times.
]W%        e# Wrap the stack in an array and reverse it. Now we've performed the mixed-base
           e# conversion.
"MDCLXVI"  e# Push this string.
.*         e# Element-wise repetition of each character by the numbers in the other array.
           e# Implicitly join and print.

C #, 127 Bytes

f=n=>n>999?"M"+f(n-1000):n>499?"D"+f(n-500):n>99?"C"+f(n-100):n>49?"L"+f(n-50):n>9?"X"+f(n-10):n>4?"V"+f(n-5):n>0?"I"+f(n-1):""

Eine rein hartcodierte ternäre Anweisung mit Rekursion.

Voll / Formatierte Version:

using System;

class P
{
    static void Main()
    {
        Func<int, string> f = null;
        f = n => n > 999 ? "M" + f(n - 1000)
                         : n > 499 ? "D" + f(n - 500)
                                   : n > 99 ? "C" + f(n - 100)
                                            : n > 49 ? "L" + f(n - 50)
                                                     : n > 9 ? "X" + f(n - 10)
                                                             : n > 4 ? "V" + f(n - 5)
                                                                     : n > 0 ? "I" + f(n - 1)
                                                                             : "";

        Console.WriteLine(f(3));
        Console.WriteLine(f(4));
        Console.WriteLine(f(42));
        Console.WriteLine(f(796));
        Console.WriteLine(f(2017));
        Console.WriteLine(f(16807));

        Console.ReadLine();
    }
}

05AB1E , 29 26 25 Bytes

¸5n3×Rvćy‰ì}"MDCLXVI"Ss×J

Probieren Sie es online!

Erläuterung

¸                           # wrap input in a list
 5n                         # push 5**2
   3×                       # repeat it 3 times
     Rv                     # for each digit y in its reverse
       ć                    # extract the head of the list 
                            # (div result of the previous iteration, initially input)
        y‰                  # divmod with y
          ì                 # prepend to the list
           }                # end loop
            "MDCLXVI"S      # push a list of roman numerals
                      s×    # repeat each a number of times corresponding to the result
                            # of the modulus operations
                        J   # join to string

JavaScript (ES6), 81 75 69 Bytes

6 Bytes gespart dank @Neil für die Portierung der Antwort von @ Jörg Hülsermann

6 Bytes gespart dank @Shaggy

n=>'MDCLXVI'.replace(/./g,(c,i)=>c.repeat(n/a,n%=a,a/=i%2?5:‌​2),a=1e3)

Testfälle:

f=
n=>'MDCLXVI'.replace(/./g,(c,i)=>c.repeat(n/a,n%=a,a/=i%2?5:‌​2),a=1e3)

const testCases = [3, 4, 42, 796, 2017, 16807]
testCases.forEach(testCase => console.log(f(testCase)))

/// , 50 bytes

/1/I//IIIII/V//VV/X//XXXXX/L//LL/C//CCCCC/D//DD/M/

Probieren Sie es online!

Nimmt die Eingabe in unary auf, und ich verwende (ab) das Fußzeilenfeld von TIO für die Eingabe, sodass der Ausgabe eine neue Zeile vorangestellt wird.

Python 3 , 100 97 96 94 93 91 90 Bytes

• 4 + 2 Bytes gespeichert: Verwendung von def; Array als Standardparameter reduzierte einen Einrückungsraum; unerwünschte Variablendeklaration entfernt
• @shooqie 1 Byte a%=Kurzschrift gespeichert
• 2 Bytes gespart: neu angeordnet und geschweifte Klammern (a//i)entfernt
• @Wondercricket 1 Byte gespart: Verschiebt das Array vom Standardparameter in die Funktion, die []auf Kosten eines Einrückungsraums entfernt wurde, wodurch 1 Byte gespart wird.

def f(a):
 b=1000,500,100,50,10,5,1
 for i in b:print(end=a//i*'MDCLXVI'[b.index(i)]);a%=i

Probieren Sie es online!

Cubix , 69 74 80 Bytes

/.UI,..N&..0\0&/52"IVXLCDM"U,r%ws;rr3tu;pw..u;qrUosv!s.u\psq,!@Us(0;U

Probieren Sie es online!

        / . U I
        , . . N
        & . . 0
        \ 0 & /
5 2 " I V X L C D M " U , r % w
s ; r r 3 t u ; p w . . u ; q r
U o s v ! s . u \ p s q , ! @ U
s ( 0 ; U . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

Beobachten Sie es laufen

Ich habe es geschafft, es ein bisschen mehr zu komprimieren, aber es gibt immer noch einige nervige No-Ops, besonders auf der Oberseite.

• 52"IVXLCDM"ULegen Sie die erforderlichen Teiler und Zeichen auf den Stapel. Die 5 und 2 werden verwendet, um den div / mod-Wert zu verringern, und die Zeichen werden nach der Verwendung verworfen.
• UIN0/&0\&,/UWendet euch auf die Oberseite und startet eine lange Tour, um die Eingabe zu erhalten und 1000 auf den Stapel zu schieben. Eine erste Teilung wird durchgeführt und eine Kehrtwende rzum nächsten Snippet durchgeführt. In diesem Bereich wollte ich Einsparungen erzielen.
• ,r%ws;rrBeginn der Divmod-Schleife. Ganzzahl-Teilung, drehen Sie den Mod "Ergebnis weg" und ordnen Sie den oberen Bereich des Stapels neu an, um die Eingabe, den aktuellen Teiler und das Divisionsergebnis zu reduzieren.
• 3tus Bringe das aktuelle Zeichen nach oben und tausche es mit dem Divisionsergebnis aus.
• !vsoUs(0;UDies ist die Druckschleife. Wenn das Div-Ergebnis größer als 0 ist, tauschen Sie es mit der Zeichenausgabe aus, tauschen Sie es zurück, dekrementieren Sie es, drücken Sie eine 0 und lassen Sie sie fallen. Bei 0 umleiten über den Pop-Stack (Ergebnis der Teilung entfernen) und um den Würfel.
• \u;pwpsq,!@Urq;uMit ein wenig Umleitung wird der Charakter vom Stapel entfernt, die 5 und 2 werden nach oben verschoben, vertauscht und einer wird nach unten gedrückt. Der Rest wird verwendet, um den Teiler zu reduzieren. Halten Sie an, wenn es auf 0 reduziert wird, andernfalls drücken Sie die 5 oder 2 nach unten und betreten Sie die Schleife erneut.

Mathematica, 130 Bytes

(f=#~NumberDecompose~{1000,500,100,50,10,5,1};""<>{Flatten@Table[Table[{"M","D","C","L","X","V","I"}[[i]],f[[i]]],{i,Length@f}]})&

Python 2 , 109 90 Bytes

lambda n,r=[1000,500,100,50,10,5,1]:''.join(n%a/b*c for a,b,c in zip([n+1]+r,r,'MDCLXVI'))

Probieren Sie es online!

PHP , 70 Bytes

for($r=1e3;$a=&$argn;)$a/$r<1?$r/=++$i%2?2:5:$a-=$r*print MDCLXVI[$i];

Probieren Sie es online!

T-SQL, 164 Bytes

SELECT REPLICATE('M',n/1000)+IIF(n%1000>499,'D','')
      +REPLICATE('C',n%500/100)+IIF(n%100>49,'L','')
      +REPLICATE('X',n%50/10)+IIF(n%10>4,'V','')
      +REPLICATE('I',n%5)
FROM t

Zeilenumbrüche wurden nur zur besseren Lesbarkeit hinzugefügt.

Diese Version ist viel länger (230 Zeichen), fühlt sich aber viel "SQL-ähnlicher" an:

DECLARE @ INT,@r varchar(99)=''SELECT @=n FROM t
SELECT'I's,1v INTO m
INSERT m VALUES('V',5),('X',10),('L',50),('C',100),('D',500),('M',1000)
L:
    SELECT @-=v,@r+=s 
    FROM m WHERE v=(SELECT MAX(v)FROM m WHERE v<=@)
IF @>0GOTO L
SELECT @r

Erstellt eine Tabelle m mit allen Zeichenwertzuordnungen und durchläuft dann die Suche nach dem größten Wert <= der Zahl, wobei das übereinstimmende Zeichen verkettet wird.

Japt , 34 Bytes

"IVXLCD"£%(U/=Y=v *3+2Y)îXÃw i'MpU

Online testen!

"IVXLCD"£    %(U/=Y=v  *3+2Y )îXÃ w i'MpU
"IVXLCD"mXY{U%(U/=Y=Yv *3+2,Y)îX} w i'MpU : Ungolfed
                                          : Implicit: U = input number
"IVXLCD"mXY{                    }         : Map each char X and its index Y in this string to:
                  Y=Yv *3+2               :   Set Y to 5 for even indexes, 2 for odd.
               U/=                        :   Divide U by this amount.
            U%(            ,Y)            :   Modulate the old value of U by 5.
                              îX          :   Repeat the character that many times.
                                          : This returns e.g. "IIVCCCD" for 16807.
                                  w       : Reverse the entire string.
                                    i'MpU : Prepend U copies of 'M' (remember U is now the input / 1000).
                                          : Implicit: output result of last expression

JavaScript (ES6), 65 Byte

Eine rekursive Funktion.

f=(n,a=(i=0,1e3))=>n?a>n?f(n,a/=i++&1?5:2):'MDCLXVI'[i]+f(n-a):''

Wie?

Der zweite rekursive Aufruf f(n-a)sollte wirklich sein f(n-a,a). Durch den zweiten Parameter weggelassen, aund ineu initialisiert (bis 1000 bzw. 0) jedes Mal , wenn eine neue römische Ziffer wird auf das Endergebnis angehängt. Dies führt zu mehr Rekursion als erforderlich, ändert jedoch nicht das Ergebnis der Funktion und spart 2 Bytes.

Testfälle

f=(n,a=(i=0,1e3))=>n?a>n?f(n,a/=i++&1?5:2):'MDCLXVI'[i]+f(n-a):''

console.log(f(3))
console.log(f(4))
console.log(f(9))
console.log(f(42))
console.log(f(796))
console.log(f(2017))
console.log(f(16807))

J , 26-23 Bytes

3 Bytes gespart dank Adám.

'MDCLXVI'#~(_,6$2 5)&#:

Probieren Sie es online!

Ähnlich wie bei der APL antworte im Grunde das Gleiche.

'MDCLXVI'#~(_,6$2 5)&#:
           (       )&#:   mixed base conversion from decimal
              6$2 5       2 5 2 5 2 5
            _,            infinity 2 5 2 5 2 5
                          this gives us e.g. `0 0 0 0 1 0 4` for input `14`
'MDCLXVI'#~               shape each according to the number of times on the right
                          this is greedy roman numeral base conversion

Batch, 164 Bytes

@set/pn=
@set s=
@for %%a in (1000.M 500.D 100.C 50.L 10.X 5.V 1.I)do @call:c %%~na %%~xa
@echo %s:.=%
@exit/b
:c
@if %n% geq %1 set s=%s%%2&set/an-=%1&goto c

Übernimmt die Eingabe für STDIN.

Oracle SQL, 456 Byte

select listagg((select listagg(l)within group(order by 1)from dual start with trunc((n-nvl(n-mod(n,p),0))/v)>0 connect by level<=trunc((n-nvl(n-mod(n,p),0))/v)))within group(order by v desc)from (select 2849n from dual)cross join(select 1000v,null p,'m'l from dual union select 500,1000,'d'from dual union select 100,500,'c'from dual union select 50,100,'l'from dual union select 10,50,'x'from dual union select 5,10,'v'from dual union select 1,5,'i'from dual)

Ausgänge:

mmdcccxxxxviiii

Bitte beachten Sie, dass die tatsächliche Größe der Zeile 460 Byte beträgt, da sie die Eingabenummer (2849) enthält.

Ungolfed:

select listagg(
            (select listagg(l, '') within group(order by 1) 
             from dual 
             start with trunc((n-nvl(p*trunc(n/p),0))/v) > 0 
             connect by level <= trunc((n-nvl(p*trunc(n/p),0))/v) )
        ) within group(order by v desc)
from (select 2348 n
    from dual
) cross join (
    select 1000v, null p, 'm' l from dual union 
    select 500, 1000, 'd' from dual union
    select 100, 500, 'c' from dual union
    select 50, 100, 'l' from dual union
    select 10, 50, 'x' from dual union
    select 5, 10, 'v' from dual union
    select 1, 5, 'i' from dual     
)

Wie es funktioniert: Ich berechne, wie viele von jedem Buchstaben ich brauche, indem ich mit dem höheren Wert eins (unendlich für M) das Maximum errechne und dann eine ganzzahlige Division zwischen dem Wert des aktuellen Buchstabens und dem Ergebnis desselben durchführe.

ZB 2348, wie viele Cs brauche ich? trunc((2348-mod(2348,500))/100)= 3.

Dann habe ich listaggdiesen Brief 3 mal zusammen (ausnutzen CONNECT BY, um die 3 Zeilen zu generieren, die ich brauche). Zum Schluss hab ich listaggalles zusammen.

Ein bisschen sperrig, aber das meiste ist das select from duals in der Umrechnungstabelle und ich kann nicht wirklich viel dagegen tun ...

Java (OpenJDK 8) , 119 bis 118 Byte

n->{String s="";for(int v[]={1,5,10,50,100,500,1000},i=7;i-->0;)for(;n>=v[i];n-=v[i])s+="IVXLCDM".charAt(i);return s;}

Probieren Sie es online!

Dank @TheLethalCoder ein Byte gespeichert

Charcoal , 61 50 46 Bytes

ＮνＡ⁰χＷφ«Ｗ¬‹νφ«§MDCLXVIχＡ⁻νφν»Ａ⁺¹χχＡ÷φ⎇﹪χ²¦²¦⁵φ

Probieren Sie es online!

Erläuterung:

Ｎν                   Take input as number and assign it to ν
Ａ⁰χ                  Let χ=0
Ｗφ«                  While φ>0 (φ has a predefined value of 1000)
    Ｗ¬‹νφ«               While v>=φ 
        §MDCLXVIχ             Take the char from string "MDCLXVI" at position χ
        Ａ⁻νφν»               Let ν=ν-φ
    Ａ⁺¹χχ                Increment χ
    Ａ÷φ⎇﹪χ²¦²¦⁵φ        If χ is odd, divide φ by 5, else divide φ by 2

• 4 Bytes gespart dank Neil, während ich immer noch versuche herauszufinden, wie ich mit dem zweiten Teil seines Kommentars vorgehen soll.

C ++, 272 Bytes

#include <cstdio>
#include <map>
std::map<int,char> m = {{1000,'M'},{500,'D'},{100,'C'},{50,'L'},{10,'X'},{5,'V'},{1,'I'}};
int main(){unsigned long x;scanf("%d",&x);for(auto i=m.rbegin();i!=m.rend();++i)while(x>=i->first){printf("%c", i->second);x=x-i->first;}return 0;}

C 183 Bytes

#include <stdio.h>
int v[]={1000,500,100,50,10,5,1};
char*c="MDCLXVI";
int main(){int x;scanf("%d",&x);for(int i=0;i<sizeof v/sizeof(int);i++)for(;x>=v[i];x-=v[i])putc(c[i],stdout);}

Gleicher Algorithmus wie zuvor, nur mit einfachen c-Arrays anstelle einer std :: map, teilweise inspiriert von der Antwort von @ xnor, und unter Verwendung einer Zeichenfolge zum Speichern der Buchstaben.

Common Lisp, 113 Bytes

Dies ist eine anonyme Funktion, die das Ergebnis als Zeichenfolge zurückgibt.

(lambda(value)(setf(values a b)(floor v 1000))(concatenate 'string(format()"~v,,,v<~>"a #\M)(format nil"~@:r"b)))

Ungolfed, mit beschreibenden Variablennamen und Kommentaren:

(defun format-roman (value)
  ;; Get "value integer-divided by 1000" and "value mod 1000"
  (setf (values n_thousands remainder) (floor value 1000))
  (concatenate 'string
               ;; Pad the empty string n_thousands times, using "M" as the 
               ;; padding character
               (format () "~v,,,v<~>" n_thousands #\M)
               ;; Format the remainder using "old-style" Roman numerals, i.e. 
               ;; numerals with "IIII" instead of "IV"
               (format nil "~@:r" remainder)))

In CL ist ein Formatierer für römische Zahlen integriert. Leider funktioniert es nicht für Zahlen größer als 3999.

Kohle , 34 Bytes

ＮςＡ²ξＦMDCLXVI«×ι÷ςφＡ﹪ςφςＡ÷φξφＡ÷χξξ

Ursprünglich basiert auf @ CarlosAlegos Antwort. Ein Port von @ xnors Python-Lösung ist ebenfalls 34 Byte groß:

ＮθＡ⁵ξＦIVXLCD«←×ι﹪θξＡ÷θξθＡ÷χξξ»←×Mθ

Edit: Ein Port von @ xnors anderer Python-Lösung hat 33 Bytes!

ＮθＦMDCLXVI«×ι÷θφＡ﹪θφθＡ÷φ⁺׳﹪φ³±¹φ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Beachten Sie, dass ich ⁺׳﹪φ³±¹anstelle von verwendet habe, ⁻׳﹪φ³¦¹weil der Deverbosifier derzeit das Trennzeichen nicht einfügen kann.