रोमन अंकों में 1 से 100… तक की गणना करें


29

एक प्रोग्राम लिखें जो रोमन अंकों में 1 से 100 तक गिना जाए और इन नंबरों को मानक आउटपुट द्वारा प्रिंट करें। प्रत्येक संख्या को रिक्त स्थान द्वारा अलग किया जाना चाहिए।

आप ऐसा करने के लिए रोमन अंकों और न ही बाहरी अनुप्रयोग या लाइब्रेरी में बदलने के लिए किसी भी फ़ंक्शन का उपयोग नहीं कर सकते।

वांछित परिणाम है

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

जैसा कि यह एक कोड गोल्फ चुनौती है, सबसे छोटा कोड जीतता है


4
39 एक X.
Thor

); @Thor फिक्स्ड, धन्यवाद
Averroes

1
मैं वास्तव में इसके लिए INTERCAL का उपयोग करना चाहता हूं।
वीजुन झोउ

क्या इसे नए सिरे से अलग किया जा सकता है? इसके अलावा रिक्त स्थान / प्रमुख स्थान / अनुगामी के बारे में क्या?
फंतासी

जवाबों:


68

पर्ल 69 बाइट्स

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

जादू फार्मूला के माध्यम से काम करता है। अभिव्यक्ति "32e$&"%72726प्रत्येक अंक को निम्नलिखित तरीके से रूपांतरित करती है: 0
3.32, 1 3.320, 2 इंक .3200, 3 3.32000, 4 इंक .29096, 5 इंक। 56, 6 इंक। 560, 7 इंक। 5600, 8. इंक। 56000, 9।

अनुवाद लागू करने के बाद y/016/IXV/, हम इस के बजाय:
0⇒32, 1⇒32 मैं , 2⇒32 द्वितीय , 3⇒32 तृतीय , 4⇒29 मैं 9 वी , 5⇒5 वी , 6⇒5 छठी , 7⇒5 सातवीं , 8⇒5 आठवीं , 9⇒5 मैं 9 एक्स 8

शेष अंक ( 2-57-9) हटा दिए गए हैं। ध्यान दें कि यह एक बाइट द्वारा एक सूत्र का उपयोग करके सुधार किया जा सकता है जो 012इसके बजाय 016, सरल /XVI60-9/करने के लिए अनुवाद करता है /XVI0-9/। मैं एक खोजने में सक्षम नहीं था, लेकिन शायद आपके पास बेहतर भाग्य होगा।

एक बार एक अंक को इस तरीके से बदलने के बाद, प्रक्रिया अगले अंक के लिए दोहराती है, परिणाम को जोड़ती है, और पिछले XVIs का CLXउसी समय अनुवाद करते हुए नए अंक का अनुवाद होता है।

अद्यतन
व्यापक खोज ने कुछ भी छोटा नहीं दिखाया। हालाँकि, मैंने एक वैकल्पिक 69 बाइट समाधान खोजा था:

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

यह एक के लिए एक 0-2प्रतिस्थापन का उपयोग करता है IXV, लेकिन एक मॉड्यूल है जो अब एक अंक है।


अपडेट: 66 65 बाइट्स

यह संस्करण उल्लेखनीय रूप से भिन्न है, इसलिए मुझे शायद इसके बारे में कुछ शब्द कहना चाहिए। यह जिस सूत्र का उपयोग करता है वह वास्तव में एक बाइट है!

फॉर्मूला को छोटा करने में असमर्थ, इससे अधिक, मैंने यह तय करने का निर्णय लिया कि मेरे पास क्या था। जब तक मैं अपने पुराने दोस्त को याद नहीं करता तब तक यह लंबा नहीं था $\। जब एक printस्टेटमेंट जारी किया जाता है, $\तो आउटपुट के अंत में स्वचालित रूप से जोड़ा जाता है। मैं $a[$_]एक दो बाइट सुधार के लिए अजीब निर्माण से छुटकारा पाने में सक्षम था :

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

बहुत बेहतर, लेकिन यह $\=!print$"अभी भी थोड़ा वर्बोज़ दिख रहा था। फिर मुझे एक वैकल्पिक, समान लंबाई का सूत्र याद आया जो मैंने पाया था कि 3उसके किसी भी अंक के रूपांतरण में संख्या नहीं थी । इसलिए, इसके $\=2+printबजाय इसका उपयोग करना संभव होना चाहिए , और परिणामस्वरूप 3एक स्थान के साथ स्थानापन्न करना चाहिए :

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

इसके अलावा printऔर के बीच आवश्यक व्हाट्सएप के कारण 67 बाइट्स for

संपादित करें : इसे एक बाइट द्वारा print, मोर्चे पर ले जाकर सुधारा जा सकता है :

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

क्योंकि प्रतिस्थापन के लिए पूरी तरह से मूल्यांकन करने की आवश्यकता है print, असाइनमेंट $\अभी भी अंतिम होगा। के बीच सफेद स्थान को निकाल geऔर forएक प्रतिवाद चेतावनी जारी करेगी, लेकिन अन्यथा मान्य है।

लेकिन, अगर कोई ऐसा फॉर्मूला था जो 1कहीं भी इस्तेमाल नहीं हुआ, तो बचत के लायक दो बाइट्स $\=2+printबन जाती हैं $\=print। यहां तक ​​कि अगर यह एक बाइट लंबा था, तो भी यह एक सुधार होगा।

जैसा कि यह पता चला है, इस तरह का एक सूत्र मौजूद है, लेकिन यह मूल की तुलना में एक बाइट है, जिसके परिणामस्वरूप 65 बाइट्स का अंतिम स्कोर होता है :

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

क्रियाविधि

सवाल पूछा गया था कि कोई ऐसा फॉर्मूला खोजने के बारे में कैसे जा सकता है। सामान्य तौर पर, डेटा के किसी भी सेट को सामान्य बनाने के लिए एक जादू फार्मूला खोजना संभावना की बात है। यही है, आप एक ऐसा रूप चुनना चाहते हैं जो वांछित परिणाम के समान कुछ बनाने की संभावना है।

पहले कुछ रोमन अंकों को छोड़कर:

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

देखा जाए तो कुछ नियमितता है। विशेष रूप से, 0-3 से और फिर 5-8 से , प्रत्येक क्रमिक अवधि एक अंक से लंबाई में बढ़ जाती है। अगर हम अंकों के अंक से एक मानचित्रण बनाना चाहता था, हम एक अभिव्यक्ति है चाहेगा भी प्रत्येक अगली अवधि के लिए एक अंक से लंबाई में बढ़ जाती है। एक तार्किक विकल्प k • 10 d है जहां d इसी अंक का है, और k किसी भी पूर्णांक स्थिर है।

यह 0-3 के लिए काम करता है , लेकिन 4 को पैटर्न को तोड़ने की जरूरत है। हम यहाँ क्या कर सकते हैं एक मॉड्यूल पर काम कर रहा है:
k • 10 d % m , जहाँ m k के बीच कहीं है • 10 3 और k • 10 4 । यह सीमा 0-3 से अछूता रहेगा , और 4 को संशोधित करेगा जिसमें यह चार नहीं होगा I। यदि हम अपने खोज एल्गोरिथ्म को अतिरिक्त रूप से बाधित करते हैं जैसे कि 5 का मॉड्यूलर अवशेष , तो इसे j कहते हैं, यह m / 1000 से कम है , यह सुनिश्चित करेगा कि हमारे पास 5-8 से भी नियमितता है । परिणाम कुछ इस प्रकार है:

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

जैसा कि आप देख सकते हैं, अगर हम प्रतिस्थापित 0करते हैं I, तो 0-3 और 5-8 सभी को सही ढंग से मैप करने की गारंटी है! हालांकि, 4 और 9 के मूल्यों के लिए मजबूर होना जरूरी है। विशेष रूप से, 4 को एक 0और एक j(उस क्रम में) को शामिल करने की आवश्यकता होती है , और 9 को एक को शामिल करने की आवश्यकता होती है 0, इसके बाद एक और अंक होता है जो कहीं और दिखाई नहीं देता है। निश्चित रूप से, कई अन्य सूत्र हैं, जो कुछ संयोग से वांछित परिणाम उत्पन्न कर सकते हैं। उनमें से कुछ छोटे भी हो सकते हैं। लेकिन मुझे नहीं लगता कि ऐसा कोई भी है जो इस एक के रूप में सफल होने की संभावना है।

मैंने कई प्रतिस्थापनों के साथ Iऔर / या Vकुछ सफलता के साथ प्रयोग किया । लेकिन अफसोस, मेरे पास पहले से कुछ भी कम नहीं है। यहां सबसे छोटे समाधानों की एक सूची दी गई है जो (1-2 बाइट्स भारी समाधानों की संख्या सूची के लिए बहुत अधिक हैं):

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

3
आपको मैजिक फॉर्मूला कैसा लगा?
रुबेन वेरबॉघ

1
@RubenVerborgh मैं जल्द ही कार्यप्रणाली के बारे में अधिक जानकारी के साथ अपने पोस्ट को अपडेट करूंगा।
प्रिमो

15

HTML + जावास्क्रिप्ट + सीएसएस (137)

HTML (9)

<ol></ol>

जावास्क्रिप्ट (101)

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

सीएसएस (27)

ol{list-style:upper-roman​}

उत्पादन

रोमन अंकों के साथ क्रमांकित सूची

...

JSBin पर डेमो


1
81 बाइट जेएस-ओनली संस्करण: document.write('<ol>'+"<li style='list-style:upper-roman'/>".repeat(100)+'</ol>')(ES6)
पेपरजम

या क्रोम में 66document.write("<li style='list-style:upper-roman'/>".repeat(100))
23

10

अजगर ११६

बेहतर गोल्फ खिलाड़ी के जवाब का कोड:

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'

8

अजगर, १३ ९

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'

6

सी, 177 160 147 चर

छोटे समाधान हैं, लेकिन सी में कोई भी नहीं है, इसलिए यहां मेरा प्रयास है।

नया समाधान, मेरे पिछले एक से पूरी तरह अलग:

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");
}

पिछला समाधान (160 वर्ण):

लॉजिक:
1. f1 से 10 तक की संख्या को प्रिंट करता cहै। अंकों का उपयोग किया जाता है, जो IVXया हो सकता है XLC। एक बार दसियों के लिए एक बार फोन किया।
2. यदि n%5==0- कुछ नहीं या c[n/5]जो Iया V( Lया C) प्रिंट है ।
3. यदि n%4==4- 4या 9- प्रिंट I(या X), द्वारा n+1
4. यदि n>4प्रिंट 5(यानी Vया L) तो n-5
5. यदि n<4(प्रिंट) Iतो n-1(अर्थात nबार 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);
}

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");}
गैस्ट्रोपनर

5

जावास्क्रिप्ट, 123

एक लंबे संस्करण से प्रेरित होकर मैं एक पोलिश समाचार समूह में आया (कम से कम, क्रोम ने सोचा कि यह पोलिश था)।

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)

5

क्यू ( 81 80)

2 कट:

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

1 कट:

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

4

अजगर, १६th

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

व्याख्या

इन मूल्यों का उपयोग करते हुए, n से बड़ा नहीं मान लें और इसे n से घटाएं। N 0 तक दोहराएं।

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

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""दो पात्रों को बचाता है। नहीं तो बहुत अच्छा।
cemper93

4

रूबी 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}

यह सचमुच रोमन अंकों में 1 से 100 तक गिना जाता है। एक रिक्त स्ट्रिंग के साथ शुरू होता है, फिर "I" को जोड़ने के माध्यम से लूप करता है और फिर बार-बार प्रतिस्थापन नियमों की एक श्रृंखला को लागू करता है, प्रभावी रूप से 1 जोड़ रहा है।

संपादित करें: जोड़ा संस्करण संख्या, ?Iकेवल 1.9 में काम करता है, और कुछ पात्रों को ट्रिम करने के लिए @ हावर्ड के परिवर्तनों का उपयोग किया।


आप दो चार बचा सकते हैं: r while-> 0while, r.sub!(*q)-> r.sub! *q। आप लूप के अंदर प्रिंट भी खींच सकते हैं और 100.times{...}मैप स्टेटमेंट के बजाय उपयोग कर सकते हैं ।
हावर्ड

(%w[IIII VIV XXXX LXL]<</(.)((?!\1)[^I])\1/).zip(%w(IV IX XL XC)<<'\2')7 वर्ण बचाता है।
स्टेन्सलैग

4

रूबी 112 चार्ट

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}

मूल रूप से यहां बताई गई to_romanविधि का उपयोग कर रहे हैं , लेकिन संक्षिप्तता के लिए ज़िपित सरणी का उपयोग कर रहे हैं।


4

गणितज्ञ 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}]

रोमन संख्याएँ


अंतर्निहित समाधान : IntegerString38 वर्ण

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

2

प्रति 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;

golfed:

@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;

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

उसी एल्गोरिदम के रूप में @ कार्डबोर्ड_बॉक्स, जिनसे मैंने स्पष्टीकरण शब्दशः लिया है -

व्याख्या

इन मूल्यों का उपयोग करते हुए, n से बड़ा नहीं मान लें और इसे n से घटाएं। N 0 तक दोहराएं।

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

2

आर , 85 बाइट्स

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

इसे ऑनलाइन आज़माएं!

रोमन अंकों के मूल्यों को प्राप्त करने के लिए यादृच्छिक utilsपैकेज चर .romansका उपयोग करता है , लेकिन स्वयं द्वारा रूपांतरण करता है; बिल्ट दृष्टिकोण 20 बाइट्स होगा:cat(as.roman(1:100))


हैरानी की बात है, आप जिस अंतर्निहित दृष्टिकोण का उल्लेख कर रहे हैं वह काम नहीं करता है ... एक को टाइप करना है cat(paste(as.roman(1:100)))या बस as.roman(1:100)। अजीब।
JayCe

@ जयके अजीब; मुझे वास्तव में इसका परीक्षण नहीं करना चाहिए था ... डॉक्स ने catसंकेत दिया कि यह कम रूपांतरण करता है printऔर केवल atomicवैक्टर पर काम करता है - ताकि यह समझा सके!
गिउसेप्पे

1

एपीएल 128

मैंने एपीएल में एक अनुक्रमण समाधान की कोशिश की:

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              

यह इंडेक्स ओरिजिन 0 में 1 के बजाय 4 बाइट्स छोटा हो सकता है, लेकिन असली स्पेस हॉग इंडेक्स मैट्रिक्स की जनरेशन है:

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

अभी तक मैं उड़ने पर सूचक उत्पन्न करने में सक्षम नहीं हूं!


1

LaTeX (138)

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

1
-1: सवाल कहता है "आप रोमन अंकों में बदलने के लिए किसी भी निर्मित फ़ंक्शन का उपयोग नहीं कर सकते हैं"
izabera

1

अजगर, 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]

1

PHP, 38 37 बाइट्स

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

-1 बाइट थैंक्स टू @manatwork

पैट्रिक के जवाब के रूप में एक ही विचार है , लेकिन एक अधिक कॉम्पैक्ट भाषा में। गणितज्ञ धड़कता है !

इसे ऑनलाइन आज़माएं!


के साथ बयान को समाप्त करें ;, फिर कोई आवश्यकता नहीं है ?>

1

VBA (एक्सेल), 245 बाइट्स

पुनरावृत्ति और बदलें के लिए बनाया गया फंक्शन - 91 बाइट्स

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

तत्काल विंडो का उपयोग करना ( 154 बाइट्स )

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


0

जावा (ओपनजेडके 8) , 152 बाइट्स

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";}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

0

TeX, 354 बाइट्स

\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

कुछ स्पष्टीकरण: TeX \romannumeralसंख्याओं को रोमन अंकों में परिवर्तित करने के लिए एक अंतर्निहित कमांड प्रदान करता है । जैसा कि प्रश्न अंतर्निहित कार्यों का उपयोग करने की अनुमति नहीं देता है, उपरोक्त कोड उसी एल्गोरिथ्म का एक गोल्फ संस्करण है जिसे नथ के मूल TeX संकलक के लिए उपयोग करता है \romannumeral( TeX देखें : कार्यक्रम ,, 69, print_roman_int) को TeX में फिर से लागू किया गया है।

जैसा कि वह यह बताने की खुशी छोड़ना चाहता है कि यह कोड पाठक के लिए कैसे काम करता है, नथ ने कोड के इस हिस्से का स्पष्टीकरण देने से इनकार कर दिया। तो मैं सूट का पालन करूंगा और बस एक अनऑर्गलाइज्ड और थोड़ा संशोधित संस्करण दूंगा, जो उपरोक्त कोड की तुलना में मूल के करीब है:

\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
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.