Schreiben Sie ein Programm, das in römischen Ziffern von 1 bis 100 zählt, und drucken Sie diese Zahlen als Standardausgabe. Jede der Zahlen muss durch ein Leerzeichen getrennt werden.

Sie können keine eingebaute Funktion zum Umwandeln in römische Ziffern oder eine externe Anwendung oder Bibliothek verwenden, um dies zu tun.

Das gewünschte Ergebnis ist

I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI XVII XVIII XIX XX XXI XXII XXIII XXIV XXV XXVI XXVII XXVIII XXIX XXX XXXI XXXII XXXIII XXXIV XXXV XXXVI XXXVII XXXVIII XXXIX XL XLI XLII XLIII XLIV XLV XLVI XLVII XLVIII XLIX L LI LII LIII LIV LV LVI LVII LVIII LIX LX LXI LXII LXIII LXIV LXV LXVI LXVII LXVIII LXIX LXX LXXI LXXII LXXIII LXXIV LXXV LXXVI LXXVII LXXVIII LXXIX LXXX LXXXI LXXXII LXXXIII LXXXIV LXXXV LXXXVI LXXXVII LXXXVIII LXXXIX XC XCI XCII XCIII XCIV XCV XCVI XCVII XCVIII XCIX C

Da es sich um eine Code-Golf-Herausforderung handelt, gewinnt der kürzeste Code .

Perl 69 Bytes

s;.;y/XVI60-9/CLXVIX/dfor$a[$_].="32e$&"%72726;gefor 1..100;print"@a"

Arbeitet nach einer magischen Formel. Der Ausdruck "32e$&"%72726transformiert jede Ziffer auf folgende Weise:
0⇒32, 1⇒320, 2⇒3200, 3⇒32000, 4⇒29096, 5⇒56, 6⇒560, 7⇒5600, 8⇒56000, 9⇒50918

Nach Anwenden der Übersetzung y/016/IXV/haben wir stattdessen Folgendes :
0⇒32, 1⇒32 I , 2⇒32 II , 3⇒32 III , 4⇒29 I 9 V , 5⇒5 V , 6⇒5 VI , 7⇒5 VII , 8 ⇒ 5 VIII , 9 ⇒ 5 I 9 X 8

Die restlichen Ziffern ( 2-57-9) werden entfernt. Beachten Sie, dass diese durch einen Byte verbessert werden könnte eine Formel unter Verwendung der übersetzt 012statt 016, die Vereinfachung /XVI60-9/zu /XVI0-9/. Ich konnte keinen finden, aber vielleicht hast du mehr Glück.

Sobald eine Ziffer auf diese Weise transformiert wurde, wird der Vorgang für die nächste Ziffer wiederholt, wobei das Ergebnis angehängt und die vorherigen XVIs zur CLXgleichen Zeit übersetzt werden, zu der die Übersetzung für die neue Ziffer erfolgt.

Update Die
ausführliche Suche ergab keine kürzeren Ergebnisse. Ich habe jedoch eine alternative 69-Byte-Lösung gefunden:

s;.;y/XVI0-9/CLXIXV/dfor$a[$_].="57e$&"%474976;gefor 1..100;print"@a"

Dieser verwendet eine 0-2Substitution für IXV, hat aber ein Modulo, das eine Ziffer länger ist.

Update: 66 65 Bytes

Diese Version unterscheidet sich erheblich, daher sollte ich wahrscheinlich ein paar Worte dazu sagen. Die verwendete Formel ist tatsächlich ein Byte länger!

Da ich die Formel nicht mehr verkürzen konnte, entschied ich mich, das, was ich hatte, herunterzuspielen. Es dauerte nicht lange, bis ich mich an meinen alten Freund erinnerte $\. Wenn eine printAnweisung ausgegeben wird, $\wird sie automatisch an das Ende der Ausgabe angehängt. Ich konnte die umständliche $a[$_]Konstruktion für eine Zwei-Byte-Verbesserung loswerden :

s;.;y/XVI60-9/CLXVIX/dfor$\.="32e$&"%72726;ge,$\=!print$"for 1..100

Viel besser, aber das $\=!print$"sah immer noch ein bisschen wortreich aus. Ich erinnerte mich dann an eine alternative Formel gleicher Länge, die ich gefunden hatte und die die Zahl 3in keiner ihrer Zifferntransformationen enthielt . Daher sollte es möglich sein, $\=2+printstattdessen Folgendes zu verwenden und das Ergebnis 3durch ein Leerzeichen zu ersetzen :

s;.;y/XVI0-9/CLXIIX V/dfor$\.="8e$&"%61535;ge,$\=2+print for 1..100

Auch 67 Bytes, aufgrund des notwendigen Leerzeichens zwischen printund for.

Bearbeiten : Dies kann um ein Byte verbessert werden, indem das printnach vorne verschoben wird:

$\=2+print!s;.;y/XVI0-9/CLXIIX V/dfor$\.="8e$&"%61535;gefor 1..100

Da die Substitution vor dem vollständig ausgewertet werden muss print, wird die Zuweisung zu $\immer noch als letztes erfolgen. Wenn Sie das Leerzeichen zwischen geund entfernen, forwird eine Warnung angezeigt, die jedoch ansonsten gültig ist.

Aber wenn es eine Formel gäbe, die 1nirgendwo eine verwendet, würden $\=2+printsich $\=printfür weitere zwei Bytes Einsparungen ergeben. Selbst wenn es ein Byte länger wäre, wäre es immer noch eine Verbesserung.

Wie sich herausstellt, gibt es eine solche Formel, die jedoch ein Byte länger ist als das Original, was zu einer Endbewertung von 65 Bytes führt :

$\=print!s;.;y/XVI60-9/CLXXI V/dfor$\.="37e$&"%97366;gefor 1..100

Methodik

Die Frage wurde gestellt, wie man eine solche Formel finden könnte. Im Allgemeinen ist es eine Frage der Wahrscheinlichkeit, eine Zauberformel zur Verallgemeinerung eines beliebigen Datensatzes zu finden. Das heißt, Sie möchten eine Form auswählen, die mit größter Wahrscheinlichkeit zu einem ähnlichen Ergebnis wie das gewünschte führt.

Prüfung der ersten römischen Ziffern:

0:
1: I
2: II
3: III
4: IV
5: V
6: VI
7: VII
8: VIII
9: IX

Es gibt eine gewisse Regelmäßigkeit zu sehen. Insbesondere von 0 bis 3 und dann wieder von 5 bis 8 wird jeder aufeinanderfolgende Term um eine Ziffer länger. Wenn wir eine Zuordnung von Ziffern zu Zahlen schaffen wollten, würden wir einen Ausdruck haben , die auch durch eine Ziffer für jeden folgenden Ausdruck in der Länge zunimmt. Eine logische Wahl ist k · 10 ^d, wobei d die entsprechende Ziffer ist und k eine beliebige Ganzzahlkonstante ist.

Dies funktioniert für 0-3 , aber 4 muss das Muster brechen. Was wir hier tun können, ist ein Modulo anzuheften:
k · 10 ^d % m , wobei m irgendwo zwischen k · 10 ³ und k · 10 ^{4 liegt} . Dadurch bleibt der Bereich 0-3 unverändert, und 4 wird so geändert, dass er keine vier ISekunden enthält. Wenn wir unseren Suchalgorithmus zusätzlich so einschränken, dass der modulare Rest von 5 , nennen wir es j , kleiner als m / 1000 ist , wird sichergestellt, dass wir auch eine Regelmäßigkeit von 5-8 haben . Das Ergebnis ist ungefähr so:

0: k
1: k0
2: k00
3: k000
4: ????
5: j
6: j0
7: j00
8: j000
9: ????

Wie Sie sehen können, wenn wir ersetzen 0mit I, 0-3 und 5-8 sind alle garantiert korrekt abgebildet werden! Die Werte für 4 und 9 müssen allerdings brachial erzwungen werden. Insbesondere muss 4 eins 0und eins j(in dieser Reihenfolge) enthalten, und 9 muss eins enthalten 0, gefolgt von einer anderen Ziffer, die an keiner anderen Stelle erscheint. Sicher gibt es eine Reihe anderer Formeln, die durch einen Zufall das gewünschte Ergebnis erzielen könnten. Einige von ihnen können sogar kürzer sein. Aber ich glaube nicht, dass es welche gibt, die genauso erfolgreich sind wie diese.

Ich experimentierte auch mit mehrfachem Ersatz für Iund / oder Vmit einigem Erfolg. Aber leider nichts kürzer als das, was ich schon hatte. Hier ist eine Liste der kürzesten Lösungen, die ich gefunden habe (die Anzahl der 1-2 Bytes schwereren Lösungen ist zu groß, um sie aufzulisten):

y/XVI60-9/CLXVIX/dfor$\.="32e$&"%72726
y/XVI0-9/CLXIXV/dfor$\.="57e$&"%474976
y/XVI0-9/CLXIVXI/dfor$\.="49e$&"%87971

y/XVI0-9/CLXIIXIV/dfor$\.="7e$&"%10606  #
y/XVI0-9/CLXIIXIV/dfor$\.="7e$&"%15909  # These are all essentially the same
y/XVI0-9/CLXIIXIV/dfor$\.="7e$&"%31818  #

y/XVI0-9/CLXIIX V/dfor$\.="8e$&"%61535  # Doesn't contain 3 anywhere

y/XVI60-9/CLXXI V/dfor$\.="37e$&"%97366 # Doesn't contain 1 anywhere

HTML + JavaScript + CSS (137)

HTML (9)

<ol></ol>

JavaScript (101)

for(i=1;i<=100;i++){document.getElementsByTagName('ol')[0].appendChild(document.createElement('li'))}

CSS (27)

ol{list-style:upper-roman​}

Ausgabe

...

Demo auf JSBin

Python 116

Besserer Golf-Code für die Antwort von Scleaver:

r=lambda a,b,c:('',a,2*a,3*a,a+b,b,b+a,b+a+a,b+3*a,a+c);print' '.join(i+j for i in r(*'XLC')for j in r(*'IVX'))+' C'

Python, 139

print' '.join(' '.join(i+j for  j in ' _I_II_III_IV_V_VI_VII_VIII_IX'.split('_'))for i in ' _X_XX_XXX_XL_L_LX_LXX_LXXX_XC'.split('_'))+' C'

C 177 160 147 Zeichen

Es gibt kürzere Lösungen, aber keine in C, also hier ist mein Versuch.

Neue Lösung, völlig anders als meine vorherige:

char*c;
f(n){
    printf("%.*s",n%5>3?2:n%5+n/5,c+=n%5>3?n%4*4:2-n/5);
}
main(i){
        for(;i<100;putchar(32))
                c="XLXXXC",f(i/10),
                c="IVIIIX",f(i++%10);
        puts("C");
}

Vorherige Lösung (160 Zeichen):

Logik:
1. fGibt eine Zahl von 1 bis 10 aus. cDie verwendeten Ziffern können IVXoder sein XLC. Einmal für die Zehn, einmal für die Einen.
2. Wenn n%5==0- print nichts oder c[n/5]die ist Ioder V(oder Loder C).
3. Wenn n%4==4- 4oder 9- I(oder X) drucken , durch n+1.
4. Wenn n>4- dann drucken 5(dh Voder L) n-5.
5. Wenn n<4- Idann drucken n-1(dh nmal I).

char*c;
p(c){putchar(c);}
f(n){
        n%5?
                n%5>3?
                        f(1),f(n+1):
                        n>4?
                                f(5),f(n-5):
                                f(n-1,p(*c)):
                n&&p(c[n/5]);
}
main(i){
        for(;++i<101;p(32))
                c="XLC",f(i/10),
                c="IVX",f(i%10);
        p(10);
}

JavaScript, 123

Inspiriert von einer längeren Version bin ich in einer polnischen Newsgroup auf etwas gestoßen (zumindest meinte Chrome, es sei polnisch).

for(i=100,a=[];n=i--;a[i]=r)
  for(r=y='',x=5;n;y++,x^=7)
    for(m=n%x,n=n/x^0;m--;)
      r='IVXLC'[m>2?y+n-(n&=-2)+(m=1):+y]+r;
alert(a)

Q ( 81 80)

2. Schnitt:

1_,/'[($)``X`XX`XXX`XL`L`LX`LXX`LXXX`XC cross``I`II`III`IV`V`VI`VII`VIII`IX],"C"

1. Schnitt:

1_,/'[$:[``X`XX`XXX`XL`L`LX`LXX`LXXX`XC cross``I`II`III`IV`V`VI`VII`VIII`IX]],"C"

Python, 168

r=lambda n,l,v:(r(n,l[1:],v[1:])if n<v[0]else l[0]+r(n-v[0],l,v))if n else''
for i in range(1,101):print r(i,'C XC L XL X IX V IV I'.split(),[100,90,50,40,10,9,5,4,1]),

Erläuterung

Nehmen Sie mit diesen Werten den größten Wert, der nicht größer als n ist, und subtrahieren Sie ihn von n. Wiederholen, bis n 0 ist.

'C'  = 100
'XC' = 90
'L'  = 50
'XL' = 40
'X'  = 10
'IX' = 9
'V'  = 5
'IV' = 4
'I'  = 1

Ruby 1.9, 140 132

r=" "
100.times{r+=?I
0while[[?I*4,"IV"],["VIV","IX"],[?X*4,"XL"],["LXL","XC"],[/(.)((?!\1)[^I])\1/,'\2']].any?{|q|r.sub! *q}
$><<r}

Dies zählt buchstäblich von 1 bis 100 in römischen Ziffern. Beginnt mit einer leeren Zeichenfolge, fügt in einer Schleife ein "I" hinzu und wendet dann wiederholt eine Reihe von Substitutionsregeln an, wobei effektiv 1 hinzugefügt wird.

Bearbeiten: Versionsnummer hinzugefügt, da ?Inur in 1.9 funktioniert und @ Howards Änderungen zum Trimmen einiger Zeichen verwendet wurden.

Ruby 112 Zeichen

101.times{|n|r=' ';[100,90,50,40,10,9,5,4,1].zip(%w(C XC L XL X IX V IV I)){|(k,v)|a,n=n.divmod k;r<<v*a};$><<r}

Grundsätzlich wird die hier erläuterteto_roman Methode verwendet , der Kürze halber wird jedoch ein gezipptes Array verwendet.

Mathematica 159 150 142

c = {100, 90, 50, 40, 10, 9, 5, 4, 1};
Table["" <> Flatten[ConstantArray @@@ Thread@{StringSplit@"C XC L XL X IX V IV I", 
  FoldList[Mod, k, Most@c]~Quotient~c}], {k, 100}]

Eingebaute Lösung : IntegerString38 Zeichen

IntegerString[k, "Roman"]~Table~{k, 100}

Perl 205

@r = split //, "IVXLC";
@n = (1, 5, 10, 50, 100);

for $num (1..100) {
  for($i=@r-1; $i>=0; $i--) {
    $d = int($num / $n[$i]);
    next if not $d;
    $_ .= $r[$i] x $d;
    $num -= $d * $n[$i];
  }
  $_ .= " ";
}
s/LXXXX/XC/g;
s/XXXX/XL/g;
s/VIIII/IX/g;
s/IIII/IV/g;
print;

Golf gespielt:

@r=split//,"IVXLC";@n=(1,5,10,50,100);for$num(1..100){for($i=@r-1;$i>=0;$i--){$d=int($num/$n[$i]);next if!$d;$_.=$r[$i]x$d;$num-=$d*$n[$i];}$_.=" ";}s/LXXXX/XC/g;s/XXXX/XL/g;s/VIIII/IX/g;s/IIII/IV/g;print;

MUMPS 184

S V(100)="C",V(90)="XC",V(50)="L",V(40)="XL",V(10)="X",V(9)="IX",V(5)="V",V(4)="IV",V(1)="I" F I=1:1:100 S S=I,N="" F  Q:'S  S N=$O(V(N),-1) I S&(S'<N ) S S=S-N W V(N) S N="" w:'S " "

Gleicher Algorithmus wie @cardboard_box, von dem ich die Erklärung wörtlich genommen habe -

Erläuterung

Nehmen Sie mit diesen Werten den größten Wert, der nicht größer als n ist, und subtrahieren Sie ihn von n. Wiederholen, bis n 0 ist.

'C'  = 100
'XC' = 90
'L'  = 50
'XL' = 40
'X'  = 10
'IX' = 9
'V'  = 5
'IV' = 4
'I'  = 1

R , 85 Bytes

R=.romans
for(r in 1:100){while(r>0){cat(names(R[I<-R<=r][1]))
r=r-R[I][1]}
cat(" ")}

Probieren Sie es online!

Verwendet die zufällige utilsPaketvariable .romans, um die Werte der römischen Ziffern abzurufen, führt jedoch die Konvertierung selbst durch. Der eingebaute Ansatz wäre 20 Bytes:cat(as.roman(1:100))

APL 128

Ich habe eine Indizierungslösung in APL ausprobiert:

r←⍬                                                                             
i←1                                                      
l:r←r,' ',('   CXI LV CX'[,⍉((1+(4 4 2 2⊤0 16 20 22 24 32 36 38 39 28)[;1+(3⍴10)⊤i])×3)-4 3⍴2 1 0])~' '
→(100≥i←i+1)/l                                                                  
r              

Sie kann im Indexursprung 0 4 Bytes kürzer sein als in 1, aber das reale Space-Hog ist die Erzeugung der Indexmatrix über:

4 4 2 2⊤0 16 20 22 24 32 36 38 39 28

Bisher konnte ich die Indizes nicht on the fly generieren!

LaTeX (138)

\documentclass{minimal}
\usepackage{forloop}
\begin{document}
\newcounter{i}
\forloop{i}{1}{\value{i} < 101}{\roman{i}\par}
\end{document}

Python, 125

' '.join(i+j for i in['']+'X XX XXX XL L LX LXX LXXX XC C'.split()for j in['']+'I II III IV V VI VII VIII IX'.split())[1:-38]

PHP, 38 37 Bytes

<ol type=I><?=str_repeat("<li>",100);

_{-1 Byte dank @manatwork}

Dieselbe Idee wie Patricks Antwort, jedoch in einer kompakteren Sprache. Schlägt Mathematica !

Probieren Sie es online!

VBA (Excel), 245 Byte

Funktion für Wiederholung und Ersetzen erstellt - 91 Bytes

Function s(a,b):s=String(a,b):End Function Function b(x,y,z):b=Replace(x,y,z):End Function

mit sofortigem Fenster ( 154 Bytes )

p="I":for x=1to 100:?b(b(b(b(b(b(b(b(s(x,p),s(100,p),"C"),s(90,p),"XC"),s(50,p),"L"),s(40,p),"XL"),s(10,p),"X"),s(9,p),"IX"),s(5,p),"V"),s(4,p),"IV"):next

Java (OpenJDK 8) , 152 Byte

a->{String[] t=",X,XX,XXX,XL,L,LX,LXX,LXXX,XC,,I,II,III,IV,V,VI,VII,VIII,IX".split(",");for(int i=1;i<100;i++){a+=t[i/10]+t[i%10+10]+" ";}return a+"C";}

Probieren Sie es online!

Erläuterung:

String[] t=",X,XX,XXX,XL,L,LX,LXX,LXXX,XC,,I,II,III,IV,V,VI,VII,VIII,IX".split(",");
//Create an array of numerals, first half represents tens place, second half represents ones place
    for(int i=1;i<100;i++){             
//Loop 99 times
        a+=t[i/10]+t[i%10+10]+" ";   
//Add tens place and ones place to the string
    }return a+"C";                         
//Add numeral for 100 and return the string

TeX, 354 Bytes

\let~\let~\d\def~\a\advance~\b\divide~\x\expandafter~\f\ifnum{~~\newcount~\n~\i~\j~\k~\u~\v}~~\or\d\p#1{\ifcase#1C~2~L~5~X~2~V~5~I\fi}\d\q#1{\p{#1~}}\d\r{\j0
\v100\d\m{\d\w{\f\n<\v\else\p\j\a\n-\v\x\w\fi}\w\f\n>0\k\j\u\v\d\g{\a\k2\b\u\q\k}\g\f\q\k=2\g\fi\a\n\u\f\n<\v\a\n-\u\a\j2\b\v\q\j\else\p\k\fi\x\m\fi}\m}\i1\d\c{
\f\i<101 \n\i\r\a\i1 \x\c\fi}\c\bye

Einige Erklärungen: TeX bietet einen eingebauten Befehl \romannumeralzum Konvertieren von Zahlen in römische Ziffern. Da die Frage die Verwendung integrierter Funktionen nicht zulässt, handelt es sich bei dem obigen Code um eine Golf-Version desselben Algorithmus, für den Knuths ursprünglicher TeX-Compiler verwendet \romannumeral(siehe TeX: Das Programm , § 69,print_roman_int ) in TeX erneut implementiert hat.

Da er die Freude, herauszufinden, wie dieser Code funktioniert, dem Leser überlassen möchte, weigert sich Knuth, diesen Teil des Codes zu erklären. Also folge ich dem Beispiel und gebe nur eine ungolfed und leicht modifizierte Version, die näher am Original liegt als der obige Code:

\newcount\n
\newcount\j
\newcount\k
\newcount\u
\newcount\v

\def\chrnum#1{\ifcase#1m\or 2\or d\or 5\or c\or 2\or l\or 5\or x\or 2\or v\or 5\or i\fi}
\def\chrnumM#1{\chrnum{#1\or}}

\def\roman#1{%
    \n=#1\relax
    \j=0\relax
    \v=1000\relax
    \def\mainloop{%
        \def\while{%
            \ifnum\n<\v
            \else
                \chrnum\j
                \advance\n -\v
                \expandafter\while
            \fi
        }\while
        \ifnum\n>0\relax
            \k=\j \advance\k 2\relax
            \u=\v \divide\u \chrnumM\k
            \ifnum\chrnumM\k=2\relax
                \advance\k 2\relax
                \divide\u \chrnumM\k
            \fi
            \advance\n \u
            \ifnum\n<\v
                \advance\n -\u
                \advance\j 2\relax
                \divide\v \chrnumM\j
            \else
                \chrnum\k
            \fi
            \expandafter\mainloop
        \fi
    }\mainloop
}

\newcount\i \i=1
\def\countloop{%
    \ifnum\i<100\relax
        \roman\i\ 
        \advance\i 1
        \expandafter\countloop
    \fi
}\countloop
\bye