कड़ाई से सकारात्मक पूर्णांक को देखते हुए, केवल योगात्मक नियम का उपयोग करके कम से कम संभव रोमन अंक लौटाएं। आउटपुट MDCLXVIमें उस क्रम के प्रत्येक वर्ण का शून्य या अधिक होना चाहिए । 14इसलिए संख्या के XIIIIबजाय देना चाहिए XIV।

वर्णों के संख्यात्मक मान M= 1000, D= 500, C= 100, L= 50, X= 10, V= 5, I= 1 हैं।

उदाहरण

3 → III

4 → IIII

9 → VIIII

42 → XXXXII

796 → DCCLXXXXVI

2017 → MMXVII

16807 → MMMMMMMMMMMMMMMMDCCCVII

— एडम
स्रोत

1

आप अनुमति देने के लिए एक उदार प्रश्नकर्ता रहे 4 -> IIIIहै 9 -> VIIIIके रूप में अच्छी तरह से की बजाय IX?

— मैजिक ऑक्टोपस Urn

1

संबंधित: रोमन अंक में कनवर्ट करें

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

@MagicOctopusUrn VIIII9. के लिए एकमात्र अनुमत आउटपुट है।

— Adám

@ Adám सिर्फ इशारा कर रहा था कि आप इसे एक उदाहरण के रूप में जोड़ना चाह सकते हैं क्योंकि 4 और 9 के लिए नियम समान हैं।

— मैजिक ऑक्टोपस Urn

1

सादा अंग्रेजी , 1059 1025 678 641 451 399 बाइट्स

एक त्रुटि जाल को हटाकर 34 बाइट्स सहेजे गए। फिर गोल्फिंग द्वारा 384 बाइट्स को बचाया। फिर एक नए ऑपरेशन ("पी") में परिशिष्ट ऑपरेशन ("z") के साथ डिवीजन ऑपरेशन को मिलाकर 190 बाइट्स को बचाया। फिर 52 बाइट्स को गोल्फ से बचाया।

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.

यहाँ अंतिम कोड का ungolfed संस्करण है, साथ ही एक ऋणात्मक संख्या के लिए एक त्रुटि जाल:

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.

— सूर्यकांत मणि
स्रोत

10

रुको, क्या यह एक प्रोग्रामिंग भाषा है?

— एड्म

3

@ अदम - हाँ। सादा अंग्रेजी संकलन, और चलाता है, और सब कुछ। स्रोत कोड और IDE github.com/Folds/english

— जैस्पर

1

हालांकि इसे गोल्फ करें - आखिरकार, यह कोड गोल्फ है, भाषा प्रदर्शन नहीं।

— San

2

तो यह वह भाषा है जिसका आप उपयोग करते हैं यदि आप नहीं चाहते कि आपकी नौकरी आउटसोर्स हो तो मैं इसे ले लूं?

— corsiKa

@ कोरसी - एलओएल! केवल अगर हम में से काफी इसका उपयोग करना शुरू कर देते हैं (और अपने पुस्तकालयों में जोड़कर) कि यह महत्वपूर्ण द्रव्यमान प्राप्त करता है।

— जैस्पर

5

APL (Dyalog) , 25 22 बाइट्स

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

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

— TwiNight
स्रोत

अच्छा, और मूल रूप से समाधान मेरे मन में था। हालाँकि, आप reshape ( /) के बजाय प्रतिकृति ( ) का उपयोग कर सकते हैं ⍴ताकि आप प्रत्येक और कटेन-कटौती ( ¨और ,/) को काट सकें ।

— 13

इसके अलावा, आप ट्रेडफेन बॉडी में कनवर्ट कर सकते हैं और इनपुट ले सकते हैं ( ⎕) और कम्यूट ( ⍨) का उपयोग करके पार्न्स को हटा सकते हैं और कंपोज़ ( ∘) कर सकते हैं।

— 13:27 पर Adám

धन्यवाद, लेकिन आपकी दूसरी टिप्पणी का क्या मतलब है? मैं बाइट की गिनती को बढ़ाए बिना ऐसा करने के बारे में नहीं सोच सकता

— ट्विनटेन

1

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

— 14:27 पर Admm

1

यह एक स्निपेट होगा जब तक कि आप फ़ंक्शन {}या ∇f∇उसके आस - पास गिनती न करें

— ट्विनटाइट

5

रेटिना , 57 42 बाइट्स

एकजुट करने के लिए धर्मान्तरित करता है, फिर लालच Iक्रम में उच्च संप्रदायों के साथ एस के गुच्छों को बदलता है ।

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

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

_{मार्टिन को धन्यवाद दिया 15 बाइट्स बचाए}

— mbomb007
स्रोत

वह बहुत चालाक है।

— एडम

7

यह दूसरे रास्ते पर जाने के लिए बहुत छोटा है: tio.run/##K0otycxL/…

— मार्टिन

Iयूनिट के रूप में उपयोग करने में क्या आप इनपुट नहीं ले सकते ?

— 14

2

@ यह मानते हुए कि रेटिना अब आसानी से पूर्णांक इनपुट को संभाल सकती है, मुझे लगता है कि ऐसा करना सस्ता है।

— mbomb007

5

पायथन 2 , 64 बाइट्स

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

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

लालच द्वारा सबसे बड़ा हिस्सा लेने से शुरू से ही आउटपुट स्ट्रिंग बनाने के बजाय, यह इसे अंत से बनाता है। उदाहरण के लिए, I's की संख्या है n%5, तो V' s की संख्या है n/5%2, और इसी तरह। यह 5 और 2 के क्रमिक अनुपात के साथ मिश्रित आधार रूपांतरण है।

यहाँ एक पुनरावृत्त समकक्ष है:

पायथन 2 , 68 बाइट्स

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

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

Mकी जरूरत अलग से नियंत्रित किया जा सकता है क्योंकि उनमें से किसी भी संख्या उपहार के रूप में वहाँ कोई बड़ा अंकों है हो सकता है। इसलिए, अन्य स्थान मान असाइन किए जाने के बाद, शेष मान परिवर्तित हो जाता है M।

तुलना के लिए, एक लालची रणनीति (69 बाइट्स):

पायथन 2 , 69 बाइट्स

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

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

dअगला अंक उत्पन्न करने के लिए वर्तमान अंक मान को या तो 2 या 5 से विभाजित किया जाता है। d%3हमें बताने का मूल्य कि कौन सा: यदि d%3==1, द्वारा विभाजित 2; और अगर d%3==2, 5 से भाग दें।

— XNOR
स्रोत

4

गणितज्ञ, 81 बाइट्स

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

स्पष्ट रूप से मूल्यों का उपयोग करना और संबंधित अंकों को प्राप्त करना लगता है कि यह एक बाइट से अधिक लंबा है:

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

— मार्टिन एंडर
स्रोत

1

अच्छा !:FromRomanNumeral@r

— डेविड

4

एक्सेल, 236 193 161 बाइट्स

~~43 बाइट्स ने @ ब्रैड सी को धन्यवाद दिया~~

इस बिंदु पर, उत्तर वास्तव में पूरी तरह से @ ब्रैडसी का है । एक और 32 बाइट बच गई।

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

प्रारूपित:

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

— Wernisch
स्रोत

आप प्रत्येक तत्व के बीच की जगह के CONCATENATEसाथ &, और QUOTIENTसाथ कुछ बचा लेंगे INT(A/B)।

— ब्रैड

2 और बचत: यह पता चलता है कि अगर यह पूर्णांक नहीं है , तो REPTपहले से ही संख्या को कम कर देता है , इसलिए आप प्रत्येक को हटाकर 30 और बाइट्स बचा सकते हैं INT()। दोनों के 1000साथ प्रतिस्थापित करके 2 और सहेजें 1E3(हालांकि एक्सेल आपके हिट करने के बाद इसे उस तरह से रखना नहीं चाहता है)।

— ब्रैडेक

हाँ, 1E3व्यवहार देखा । उत्तर अपडेट किया गया।

— वेर्निस्क

3

पर्ल 5 , 66 बाइट्स

कोड + -pध्वज के 65 बाइट्स ।

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

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

बाइट की गिनती को बदलने के बिना, MDCLXVI=~/./gइसके द्वारा प्रतिस्थापित किया जा सकता है M,D,C,L,X,V,I; और इसके --$|?2:5द्वारा $|--*3+2।

अब ( 99 बाइट्स ), वहाँ है:

$_=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)

— बापू
स्रोत

3

सीजेएम , 35 28 बाइट्स

मार्टिन एंडर को -7 बाइट्स धन्यवाद

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

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

व्याख्या

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.

— बिजनेस कैट
स्रोत

3

सी #, 127 बाइट्स

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

पुनरावृत्ति का उपयोग करते हुए एक विशुद्ध रूप से कठिन कोडित टर्नरी कथन।

पूर्ण / प्रारूपित संस्करण:

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

— TheLethalCoder
स्रोत

n>0बस है n।

— कैलक्यूलेटरफैनलाइन

@ CalculatorFeline C # में नहीं, एक intको नहीं डाला जा सकता bool।

— द लीथल कोडर

बदकिस्मती से।

— कैलक्यूलेटरफ्लीन

@CalculatorFeline हाँ, C # बहुत दृढ़ता से टाइप किया जाता है क्योंकि यह कभी-कभी खुद अच्छा होता है।

— TheLethalCoder

3

05AB1E , 29 26 25 बाइट्स

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

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

व्याख्या

¸                           # 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

— Emigna
स्रोत

3

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

सहेजे गए 6 बाइट्स @ Jeg Hülsermann के जवाब के लिए @Neil को धन्यवाद

@ बस्ती के लिए 6 बाइट्स का धन्यवाद सहेजा गया

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

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

कोड स्निपेट दिखाएं

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

स्निपेट का विस्तार करें

— क्रेग आयरे
स्रोत

1

आपको कुछ बाइट्स को सहेजने के n%=xलिए repeatविधि के भीतर ले जाने में सक्षम होना चाहिए ।

— झबरा

1

FYI करें PHP उत्तर का एक बंदरगाह केवल 69 बाइट्स है:n=>'MDCLXVI'.replace(/./g,(c,i)=>c.repeat(n/a,n%=a,a/=i%2?5:2),a=1e3)

— नील

धन्यवाद @ नील, मैंने पोस्ट अपडेट कर दी है। हार्ड कोडित सरणी को हटाता है जिसे मैं फिर से लिखना चाहता था

— क्रेग आयरे

2

/// , 50 बाइट्स

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

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

इनपुट को unary में लेता है, और इनपुट के लिए TIO पर पाद फ़ील्ड का उपयोग करके मैं (ab) हूं इसलिए आउटपुट एक नई पंक्ति से पहले है।

— steenbergh
स्रोत

2

पायथन 3 , 100 97 96 94 93 91 90 बाइट्स

बचाया 4 + 2 बाइट्स: का उपयोग def; डिफ़ॉल्ट पैरामीटर के रूप में सरणी ने एक इंडेंटेशन स्पेस को कम कर दिया; अवांछित परिवर्तनशील घोषणा को हटा दिया गया
@shooqie ने 1 बाइट a%=शॉर्टहैंड को बचाया
2 बाइट्स सहेजे गए: पुन: व्यवस्थित और (a//i)हटाए गए ब्रेसिज़
@Ondercricket ने 1 बाइट को बचाया: []एक इंडेंटेशन स्पेस की लागत पर निकाले गए फंक्शन के भीतर डिफॉल्ट पैरामीटर से एरी को ले जाएँ , इस प्रकार 1 बाइट की बचत होती है।

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

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

— officialaimm
स्रोत

1

a%=iएक बाइट छोटी है :)

— जूकी १q

1

आप bफ़ंक्शन के भीतर एक चर के रूप में संग्रहीत करके एक बाइट को भी बचा सकते हैं । यह कोष्ठक की आवश्यकता को दूर करता है -b=1000,500,100,50,10,5,1

— वंडरक्रिकेट

2

क्यूबिक्स , 69 74 80 बाइट्स

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

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

        / . 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 . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

देखो यह चल रहा है

मैं इसे थोड़ा और संपीड़ित करने में कामयाब रहा, लेकिन अभी भी कुछ pesky नो-ऑप्स हैं, खासकर शीर्ष चेहरे पर।

52"IVXLCDM"Uस्टैक पर आवश्यक डिवाइडर और अक्षर डालें। 5 और 2 का उपयोग div / mod मान को कम करने के लिए किया जाएगा और उपयोग के बाद वर्णों को छोड़ दिया जाएगा।
UIN0/&0\&,/Uशीर्ष चेहरे पर यू-टर्न लेता है और इनपुट प्राप्त करने और स्टैक पर 1000 पुश करने के लिए एक लंबा दौरा शुरू करता है। एक प्रारंभिक विभाजन किया जाता है और rअगले स्निपेट पर एक यू-टर्न होता है । यह एक ऐसा क्षेत्र था जिसे मैं कुछ बचत करने के लिए देख रहा था।
,r%ws;rrDivmod लूप की शुरुआत। पूर्णांक विभाजित करते हैं, परिणाम दूर मॉड को घुमाते हैं, फिर स्टैक के शीर्ष को इनपुट, वर्तमान विभाजक और विभाजित परिणाम घटाते हैं।
3tus वर्तमान चरित्र को शीर्ष पर लाएं और इसे विभाजित परिणाम के साथ स्वैप करें।
!vsoUs(0;Uयह प्रिंट लूप है। जबकि div परिणाम 0 से अधिक है, वर्ण आउटपुट के साथ स्वैप करें, वापस स्वैप करें, अपघटन, 0 को धक्का दें और इसे छोड़ दें। पॉप स्टैक पर 0 रीडायरेक्ट (विभाजन परिणाम निकालें) और क्यूब के आसपास।
\u;pwpsq,!@Urq;uथोड़ा पुनर्निर्देशन के साथ, यह चरित्र को ढेर से निकालता है, 5 और 2 को शीर्ष पर लाता है, उन्हें स्वैप करता है और एक वापस नीचे धकेलता है। शेष का उपयोग भाजक को कम करने के लिए किया जाता है। यदि यह 0 से कम हो जाता है, तो रोकें, अन्यथा 5 या 2 को नीचे की ओर धकेलें और लूप में फिर से प्रवेश करें।

— MickyT
स्रोत

1

गणितज्ञ, 130 बाइट्स

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

— J42161217
स्रोत

1

पायथन 2 , 109 90 बाइट्स

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

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

— छड़ी
स्रोत

1000हो सकता है 1e3(यदि आपको कोई आपत्ति नहीं है कि यह एक फ्लोट है, जो एक समस्या नहीं होनी चाहिए)

— कैलक्यूलेटरफैनलाइन

@ कलकटरफलाइन यह परिणाम को एक में बदल देगा float, और आप फ्लोट द्वारा एक स्ट्रिंग को गुणा नहीं कर सकते हैं: c

— रॉड

1

PHP , 70 बाइट्स

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

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

— जार्ग हुल्सरमन
स्रोत

1

टी-एसक्यूएल, 164 बाइट्स

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

केवल पठनीयता के लिए लाइन ब्रेक जोड़े गए।

यह संस्करण बहुत लंबा है (230 वर्ण), लेकिन बहुत अधिक "SQL- जैसा" लगता है:

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

सभी चार-मूल्य मैपिंग के साथ एक टेबल मीटर बनाता है , और फिर सबसे बड़ा मूल्य खोजने के माध्यम से लूप करता है <= संख्या, मिलान चरित्र को समेटते हुए।

— BradC
स्रोत

1

जाप , 34 बाइट्स

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

इसे ऑनलाइन टेस्ट करें!

"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

— ETHproductions
स्रोत

1

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

एक पुनरावर्ती कार्य।

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

कैसे?

दूसरा पुनरावर्ती कॉल f(n-a)वास्तव में होना चाहिए f(n-a,a)। 2 डी पैरामीटर को छोड़ कर, aऔर iहर बार एक नए रोमन अंक को अंतिम परिणाम में जोड़कर (हर बार क्रमशः 1000 और 0 पर) पुनर्निवेशित किया जाता है। यह आवश्यकता से अधिक पुनरावृत्ति का कारण बनता है, लेकिन फ़ंक्शन के परिणाम को नहीं बदलता है और 2 बाइट्स बचाता है।

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

कोड स्निपेट दिखाएं

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

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

जे , 26 23 बाइट्स

3 बाइट्स Adám के लिए धन्यवाद बचा लिया।

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

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

~~एपीएल जवाब~~ के समान मूल रूप से एक ही बात है।

'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

— कोनोर ओ ब्रायन
स्रोत

ऐसा नहीं है कि मैं जे को जानता हूं, लेकिन #.invइसके बजाय क्यों #:?

— अदम

@ अदम आह, अच्छी बात है। मैं #.invइसके बजाय का उपयोग करते हैं #:, क्योंकि कुछ ऐसा 2 #: 4है 0, whilst 2 #.inv 4है1 0 0

— Conor O'Brien

हाँ, मैं एपीएल में वही काम करता हूं। अब आपका समाधान वास्तव में एपीएल समाधान के बराबर है।

— 22

#है /; ~है ⍨; $है ⍴; &है ∘; #:है ⊤। फर्क सिर्फ इतना है कि आप एपीएल जवाब की तरह _इस्तेमाल कर सकते हैं 0।

— अड्म

@ अदम हुह, मस्त।

— कॉनर ओ'ब्रायन

1

बैच, 164 बाइट्स

@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

STDIN पर इनपुट लेता है।

— नील
स्रोत

1

ओरेकल SQL, 456 बाइट्स

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)

आउटपुट:

mmdcccxxxxviiii

कृपया ध्यान दें कि लाइन का वास्तविक आकार 460bytes है, क्योंकि इसमें इनपुट नंबर (2849) शामिल है।

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     
)

यह कैसे काम करता है: मैं गणना करता हूं कि मुझे प्रत्येक पत्र की कितनी आवश्यकता है, सबसे अधिक गणना करके मैं उच्च मूल्य एक (एम के लिए अनन्तता) के साथ मिल सकता हूं, और फिर वर्तमान पत्र के मूल्य और उस के परिणाम के बीच पूर्णांक विभाजन कर रहा हूं।

उदाहरण २३४ Eg, Cमुझे कितने एस की आवश्यकता है? trunc((2348-mod(2348,500))/100)= ३।

फिर, मैं listaggउस पत्र को एक साथ 3 बार ( CONNECT BYमेरी ज़रूरत की 3 पंक्तियों को उत्पन्न करने के लिए शोषण करता है)। अंत में, मैं listaggसब कुछ एक साथ।

किंडा भारी, लेकिन इसका अधिकांश select from dualरूपांतरण तालिका में है और मैं वास्तव में इसके बारे में बहुत कुछ नहीं कर सकता ...

— Demonblack
स्रोत

0

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

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

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

@TheLethalCoder को एक बाइट धन्यवाद दिया

— ओलिवियर ग्रेजायर
स्रोत

1

आप घोषणा कर सकते हैं vऔर iपहले में पाश के लिए एक बाइट को बचाने के लिए?

— द लीथलकोडर

@TheLethalCoder हाँ, सबसे निश्चित रूप से। मैं पहली बार एक पूरी तरह से दूसरे विचार पर था कि यह मेरी आंतरिक समीक्षा को पारित नहीं किया गया था: पी

— ओलिवियर ग्राईगोइरे

0

चारकोल , 61 50 46 बाइट्स

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

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

स्पष्टीकरण:

Ｎν                   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 बाइट्स ने नील को धन्यवाद दिया, जबकि मैं अभी भी यह पता लगाने की कोशिश कर रहा हूं कि उनकी टिप्पणी के दूसरे भाग के साथ कैसे आगे बढ़ना है।

— चार्ली
स्रोत

1

Ｎνएक बाइट से कम है ＡＮν, ¬‹एक बाइट है जो घटाना 1 से कम है, और यदि आप ÷(डिवाइड) के बजाय (IntDivide) का ∕उपयोग करते हैं तो आप φबाहरी लूप स्थिति के रूप में उपयोग कर सकते हैं। हालाँकि, मुझे लगता है कि आप इसे 40 बाइट्स के MDCLXVIबजाय सीधे लूप करके प्राप्त कर सकते हैं ।

— नील

@ निश्चित रूप से, मुझे मूर्खतापूर्ण, यह समझने की कोशिश करना कि कोई "अधिक या बराबर" ऑपरेटर नहीं है जब मैं "कम नहीं" का उपयोग कर सकता था। बहुत चालाक चाल पूर्णांक विभाजन का उपयोग। अब मुझे अपनी टिप्पणी के अंतिम भाग के बारे में सोचने का कुछ समय दें ...

— चार्ली

मैंने अपने स्ट्रिंग लूप विचार में सुधार किया और इसे @ xnor के पायथन उत्तर के एक पोर्ट के साथ एक अलग उत्तर के रूप में पोस्ट किया, जो समान लंबाई का निकला।

— नील

0

सी ++, 272 बाइट्स

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

— HSchmale
स्रोत

0

सी, 183 बाइट्स

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

पहले की तरह समान एल्गोरिथ्म, बस एक सीडी के बजाय सादे सी सरणियों का उपयोग करना :: नक्शा, आंशिक रूप से @ xnor के उत्तर से प्रेरित और पत्रों को संग्रहीत करने के लिए एक स्ट्रिंग का उपयोग करना।

— HSchmale
स्रोत

98 बाइट्स

— छत

0

कॉमन लिस्प, 113 बाइट्स

यह एक अनाम फ़ंक्शन है, परिणाम को स्ट्रिंग के रूप में लौटाता है।

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

Ungolfed, वर्णनात्मक चर नामों और टिप्पणियों के साथ:

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

सीएल में बिल्ट-इन रोमन अंक सूत्र हैं। अफसोस की बात है कि यह 3999 से बड़ी संख्या के लिए काम नहीं करता है।

— shadowtalker
स्रोत

0

चारकोल , 34 बाइट्स

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

मूल रूप से @ कार्लोसएल्गो के उत्तर पर आधारित है। @ Xnor के पायथन समाधान का एक बंदरगाह भी 34 बाइट्स है:

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

संपादित करें: @ xnor के अन्य पायथन समाधान का एक बंदरगाह 33 बाइट्स निकलता है!

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। ध्यान दें कि मैंने ⁺×³﹪φ³±¹इसके बजाय उपयोग किया है ⁻×³﹪φ³¦¹क्योंकि वर्तमान में विभाजक डालने में विफल रहा है।

— नील
स्रोत

1

हुह, कि रोमन की तुलना में अधिक ग्रीक दिखता है।

— आदम

उन लालची रोमन!

उदाहरण

सादा अंग्रेजी , 1059 1025 678 641 451 399 बाइट्स

APL (Dyalog) , 25 22 बाइट्स

रेटिना , 57 42 बाइट्स

पायथन 2 , 64 बाइट्स

गणितज्ञ, 81 बाइट्स

एक्सेल, 236 193 161 बाइट्स

पर्ल 5 , 66 बाइट्स

सीजेएम , 35 28 बाइट्स

व्याख्या

सी #, 127 बाइट्स

05AB1E , 29 26 25 बाइट्स

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

/// , 50 बाइट्स

पायथन 3 , 100 97 96 94 93 91 90 बाइट्स

क्यूबिक्स , 69 74 80 बाइट्स

गणितज्ञ, 130 बाइट्स

पायथन 2 , 109 90 बाइट्स

PHP , 70 बाइट्स

टी-एसक्यूएल, 164 बाइट्स

जाप , 34 बाइट्स

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

कैसे?

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

जे , 26 23 बाइट्स

बैच, 164 बाइट्स

ओरेकल SQL, 456 बाइट्स

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

चारकोल , 61 50 46 बाइट्स

सी ++, 272 बाइट्स

सी, 183 बाइट्स

कॉमन लिस्प, 113 बाइट्स

चारकोल , 34 बाइट्स