17

इनपुट:

पूर्णांक।

आउटपुट:

पहले पूर्णांक को इसके समतुल्य रोमन अंक में परिवर्तित करें।
फिर उस रोमन अंक के प्रत्येक कैपिटल लेटर को उनके ASCII / UNICODE दशमलव मान में बदलें।
और उन का योग आउटपुट।

उदाहरण:

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

रोमन संख्याएँ: यहाँ एक शायद उपयोगी रोमन अंक परिवर्तक है।

चुनौती नियम:

स्टैंडर्ड रोमन अंक नियम लागू होते हैं, इसलिए कोई वैकल्पिक रूपों की तरह IIIIया VIIIIके बजाय IVऔर IX। *
1,000 से अधिक रोमन संख्याओं के ऊपर मैक्रॉन लाइनें हैं ¯(UNICODE nr 175)। तो एक लाइन के रूप में +175और दो के रूप में मायने रखता है +350।
आपको किसी भी प्रकार के इनपुट और आउटपुट प्रकार का उपयोग करने की अनुमति है, जब तक कि यह पूर्णांक का प्रतिनिधित्व करता है।
परीक्षण मामलों की सीमा में होंगे 1 - 2,147,483,647।

* रोमन अंक नियम (विकिपीडिया से उद्धरण):

संख्याएं प्रतीकों के संयोजन और मूल्यों को जोड़कर बनाई जाती हैं, इसलिए IIदो (दो वाले) हैं और XIIIतेरह (एक दस और तीन वाले) हैं। क्योंकि प्रत्येक अंक का दस, एक सौ और इतने के गुणकों का प्रतिनिधित्व करने के बजाय एक निश्चित मूल्य है, स्थिति के अनुसार, "जगह रखने" शून्य की आवश्यकता नहीं है, जैसे कि 207 या 1066 की संख्या में; उन संख्याओं को CCVII(दो सैकड़ों, एक पाँच और दो) और MLXVI(एक हजार, एक पचास, दस, एक और एक) के रूप में लिखा जाता है ।

सबसे बड़े से शुरू होने वाले, मूल्य के क्रम में प्रतीकों को बाएं से दाएं रखा जाता है। हालांकि, कुछ विशिष्ट मामलों में, चार पात्रों को उत्तराधिकार में दोहराए जाने से बचने के लिए (जैसे IIIIया XXXX), घटाव संकेतन का अक्सर उपयोग किया जाता है:

Iपहले से रखा गया है Vया Xएक कम इंगित करता है, इसलिए चार है IV(पांच से कम है) और नौ है IX(दस से कम है)

Xपहले रखा गया है Lया Cदस कम इंगित करता है, इसलिए चालीस है XL(पचास से कम दस) और नब्बे है XC(सौ से कम दस)

Cपहले सौ Dया उससे Mकम का संकेत दिया जाता है , इसलिए चार सौ CD(पांच सौ से कम सौ) और नौ सौ CM(एक हजार से कम सौ)
उदाहरण के लिए, MCMIVएक हजार नौ सौ और चार, 1904 ( Mएक हजार है, CM) नौ सौ और IVचार है)।

रोमन अंकों के आधुनिक उपयोग के कुछ उदाहरणों में शामिल हैं:
1954 MCMLIV; 1990 के रूप में MCMXC; 2014 के रूप में MMXIV
स्रोत

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामलों:

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

code-golf integer roman-numerals

— केविन क्रूज़सेन
स्रोत

गणितज्ञ, 181 173 166 151 बाइट्स

golfed

(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]
)&

Mathematica का RomanNumeralकार्यान्वयन 9999 के लिए (IX) CMXCIX देता है, और इसलिए कार्यक्रम उस संख्या के लिए 971 देता है।

जैसा कि लिखा गया है, प्रकार (...)) का एक रोमन अंक (...) ... लंबाई 4, ((...)) के रोमन अंकों के लिए एएससीआईआई कोड की एक नेस्टेड सूची देता है। लंबाई 3 की सूची, (...) ... लंबाई 2 की सूची देता है, और ... लंबाई की सूची 1 लौटाता है। अंतिम पंक्ति उन नियमों को प्रत्येक वर्ग के लिए उचित संख्या में मैक्रोन में परिवर्तित करती है। सूची, उन macrons को जोड़ता है और फिर आउटपुट को वापस करने के लिए संपूर्ण नेस्टेड सूची को भेजता है।

— HiggstonRainbird
स्रोत

1

PPCG में आपका स्वागत है!

— बेटसेग

@betseg धन्यवाद! यह एक मजेदार पहली समस्या थी।

— हिग्गस्टनरैनबर्ड

10

पायथन 3, 281 278 273 269 बाइट्स

कोडगोल्फ में मेरा पहला प्रयास, यहाँ हम चलते हैं। जुड़े हुए प्रश्न को देखे बिना इसे करने की कोशिश की, तो यह शायद भयानक है :)

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 बाइट्स छोटे, गेबर फेकेट के लिए धन्यवाद

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)

— jDomantas
स्रोत

आप कुछ बाइट्स को गोल्फ के return 0 if n==0 elseसाथ बदल सकते हैंreturn 0if n<1else

— गेबर फेकेट

fफ़ंक्शन का नाम होने पर आपके गोल्फ संस्करण में कॉल होते हैं g।

— गैबोर फेकेट

कुछ और बचाने के n//9*10>=10*lलिए बदलें n//9>=l।

— गेबेर फेकेट

फिक्स्ड फंक्शन का नाम, मैंने इसे जांचने के लिए बदल दिया है कि क्या मैंने इसे सही ढंग से गोल्फ किया है और इसे वापस बदलना भूल गया।

— jDomantas 10

3

रूबी, 188 बाइट्स

रोमन अंक रूपांतरण के लिए मेरे पुराने रूबी जवाब के आधार पर एक अनुकूलन । इसे ऑनलाइन आज़माएं!

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}

— मान स्याही
स्रोत

3

मैथेमेटिका, 198 बाइट्स

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@#&

दुर्भाग्य से, बिल्टिन यहाँ बहुत मदद नहीं करता है, हालांकि मुझे यकीन है कि यह कहीं अधिक गोल्फ हो सकता है।

नोट: यहाँ के9999 -> 971 अनुसार मूल्यांकन करता है ।

— मार्टिन
स्रोत

2

बैच, 373 बाइट्स

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

मान 1, 4, 5 और 9 उपयोग के लिए एक लुकअप तालिका के अनुसार संख्या के प्रत्येक अंक के अनुवाद से काम करता है M(V), M(X), (M(V))और (M(X))। यदि आप चाहें (IV), (IX), ((IV))और ((IX))उसके बाद का उपयोग call:l 77 509 261 511और call:l 252 859 436 861क्रमशः।

— नील
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 183 बाइट्स

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)

नोट: न केवल पसंद करता (IV)है M(V), बल्कि पसंद भी करता (VI)है (V)M; वास्तव में यह केवल एम का उपयोग नंबर की शुरुआत में करेगा।

— नील
स्रोत

1

पायथन, 263 बाइट्स

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

— एली जी
स्रोत

PPCG में आपका स्वागत है, अच्छा पहला जवाब!

— कॉपर

1

आर, 115 बाइट्स

इसलिए ... मैं अपना समाधान पोस्ट कर रहा हूं क्योंकि मुझे सवाल बहुत दिलचस्प लगता है। मैंने बिना पैकेज के रोमन नंबरों से निपटने के लिए आर की क्षमताओं के साथ अपना सर्वश्रेष्ठ प्रदर्शन किया : आप केवल ' दस्तावेज़ ' के रूप में 1और के बीच के इनपुट नंबरों को देख सकते हैं।3899as.roman बताते हैं।

यही कारण है कि मैं के बीच सीमा देकर थोड़ा धोखा दिया है 1करने के लिए में पाश: ~~इसके बारे में लंबाई है~~ ~~के निर्गम (~~ ) । वास्तव में, इस वेबसाइट के अनुसार , सबसे लंबा रोमन संख्या (14 वर्ण) है, जो कि मेल खाती है ।~~11~~ 14for~~as.roman(3899)MMMDCCCXCIX~~
MMDCCCLXXXVIII2888

इसके अलावा, आप lengthइस फ़ंक्शन के आउटपुट की गणना नहीं कर सकते ।

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)

यदि कोई भी उपरोक्त समस्याओं से निपटने के लिए कोई समाधान देखता है, तो कृपया बेझिझक टिप्पणी करें।

— फ़्रेडरिक
स्रोत

0

पायथन 3, 315 बाइट्स

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 संस्करण:

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

स्पष्टीकरण: यह संस्करण एक अलग दृष्टिकोण का उपयोग करता है, यह संख्या में रोमन अंकों की घटनाओं की गणना करता है।

[abs(((n-4)%5)-1)]Iरोमन संख्या में s की संख्या है।

[((n+10**g)//(10**g*5))%2for g in r(10)] की संख्या है V,L,D,(V),(L),(D),((V)),((L)),((D)) s की संख्या है।

[(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)] की संख्या है X,C,M,(X),(C),(M),((X)),((C)),((M)) s की संख्या है।

यह तब चरित्र के मूल्य के साथ घटनाओं को गुणा करता है और इसका योग लौटाता है।

— गैबोर फेकेट
स्रोत

इंटीजर समय के माध्यम से आगे और पीछे चला जाता है