Zählen Sie von 1 bis 100… in römischen Ziffern

29

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 .

Averroes
quelle
4
39 fehlt ein X.
Thor
@Thor Fixed, danke;)
Averroes
1
Ich möchte INTERCAL wirklich für dieses verwenden.
Weijun Zhou
Kann es durch Zeilenumbrüche getrennt werden? Was ist auch mit abschließenden / führenden Leerzeichen / Zeilenumbrüchen?
FantaC

Antworten:

68

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 3 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
primo
quelle
3
Wie haben Sie die Zauberformel gefunden?
Ruben Verborgh
1
@RubenVerborgh Ich werde meinen Beitrag in Kürze mit weiteren Informationen zur Methodik aktualisieren.
Primo
15

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

Nummerierte Liste mit römischen Ziffern

...

Demo auf JSBin

Patrick Oscity
quelle
1
81-Byte-Version nur für JS: document.write('<ol>'+"<li style='list-style:upper-roman'/>".repeat(100)+'</ol>')(ES6)
Papierstau
oder 66 in Chromedocument.write("<li style='list-style:upper-roman'/>".repeat(100))
Slai
10

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'
Daniel
quelle
8

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'
scleaver
quelle
6

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);
}
ugoren
quelle
137:f(c,n){printf("%.*s",n%5>3?2:n%5+n/5,"XLXXXCIVIIIX "+c+(n%5>3?n%4*4:2-n/5));}main(i){for(;i<100;f(12,4))f(0,i/10),f(6,i++%10);puts("C");}
Gastropner
5

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)
Paul Walls
quelle
5

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"
scottstein37
quelle
4

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
Pappschachtel
quelle
1
r=lambda n,l,v:n and(n<v[0]and r(n,l[1:],v[1:])or l[0]+r(n-v[0],l,v))or""speichert zwei Zeichen. Ansonsten sehr nett.
Cemper93
4

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.

Histokrat
quelle
Sie können zwei Zeichen speichern: r while-> 0while, r.sub!(*q)-> r.sub! *q. Sie können den Ausdruck auch in die Schleife ziehen und 100.times{...}anstelle der Kartenanweisung verwenden.
Howard
(%w[IIII VIV XXXX LXL]<</(.)((?!\1)[^I])\1/).zip(%w(IV IX XL XC)<<'\2')Spart 7 Zeichen.
Steenslag
4

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.

steenslag
quelle
4

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}]

römische Zahlen


Eingebaute Lösung : IntegerString38 Zeichen

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

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;
Thor
quelle
2

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
bA
quelle
2

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))

Giuseppe
quelle
Überraschenderweise funktioniert der von Ihnen erwähnte integrierte Ansatz nicht wie er ist ... man muss tippen cat(paste(as.roman(1:100)))oder einfach as.roman(1:100). Seltsam.
JayCe
@JayCe ungerade; Ich muss es nicht wirklich getestet haben ... die Dokumente für catzeigen an, dass es weniger Konvertierung ausführt als printund nur auf atomicVektoren funktioniert - das erklärt das!
Giuseppe
1

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!

Graham
quelle
1

LaTeX (138)

\documentclass{minimal}
\usepackage{forloop}
\begin{document}
\newcounter{i}
\forloop{i}{1}{\value{i} < 101}{\roman{i}\par}
\end{document}
Patrick Oscity
quelle
1
-1: Die Frage lautet "Sie können keine eingebaute Funktion verwenden, um in römische Ziffern zu transformieren."
Izabera
1

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]
Die Krypta
quelle
1

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!

Geokavel
quelle
Beenden Sie die Anweisung mit ;, dann ist dies nicht erforderlich ?>.
Manatwork
1

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

remoel
quelle
0

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
X1M4L
quelle
0

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
Siracusa
quelle