रोमन अंक में कनवर्ट करें!

Question

आपका कार्य किसी दिए गए धनात्मक पूर्णांक को अरबी अंक से रोमन अंक में बदलना है ।

जब आप 4000 तक गिनती करते हैं तो चीजें मुश्किल हो जाती हैं।

रोमनों ने ऐसा किया कि उस प्रतीक को गुणा करने के लिए एक प्रतीक के ऊपर एक रेखा जोड़कर 1 000। हालाँकि, ASCII में ओवरलाइन बिल्कुल प्रदर्शित करने योग्य नहीं हैं। इसके अलावा, एक प्रतीक द्वारा गुणा करने के लिए डबल ओवरलाइन हैं 1 000 000, और फिर एक प्रतीक द्वारा गुणा करने के लिए ट्रिपल ओवरलाइन 1 000 000 000, आदि ...

इसलिए, मैंने ओवरलाइन को बदलने के लिए कोष्ठक का उपयोग करने का निर्णय लिया ।

प्रतीकों को व्यक्तिगत रूप से कोष्ठकों में रखा जा सकता है। उदाहरण के लिए, दोनों (VI)और के (V)(I)मान्य प्रतिनिधित्व हैं 6 000। (V)M6000 का वैध प्रतिनिधित्व भी है।

(I)प्रतिनिधित्व करने का एक वैध तरीका है 1 000।

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

Input: 1
Output: I
Input: 2
Output: II
Input: 3
Output: III
Input: 4
Output: IV
Input: 15
Output: XV
Input: 40
Output: XL
Input: 60
Output: LX
Input: 67
Output: LXVII
Input: 400
Output: CD
Input: 666
Output: DCLXVI
Input: 3000
Output: MMM
Input: 3999
Output: MMMCMXCIX
Input: 4000
Output: M(V)
Input: 4999
Output: M(V)CMXCIX
Input: 6000
Output: (VI)
Input: 6000000
Output: ((VI))
Input: 6006000
Output: ((VI)VI)
Input: 6666666666
Output: (((VI)DCLXVI)DCLXVI)DCLXVI

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स में सबसे छोटा कोड जीत जाता है।

Comments

यह एक डुप्लिकेट सुराग नहीं है क्यों के लिए औचित्य। इसके बिना बेहतर होगा आईएमओ।

— Mego

मैं औचित्य कहां जोड़ूंगा?

— लीकी नून

इसे छोड़ दो। अगर कोई यह सवाल करता है कि यह डुप्लिकेट है या नहीं, तो टिप्पणियों में या चैट में चर्चा करें।

— मीगो

@ मेगो डन। :-)

— लीकेय नून

है (IV)4000 का एक स्वीकार्य प्रतिनिधित्व?

— नील

Answer 1

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

Fold["("<>#<>")"<>#2&,RomanNumeral[#~IntegerDigits~1000]/."N"->""]&

Mइनपुट को आधार 1000 में परिवर्तित करके और प्रत्येक अंक को अलग से परिवर्तित करके सभी परेशानियों से बचा जाता है RomanNumeral। फिर हम उन्हें (...)बाईं ओर से जोड़कर मोड़ते हैं ।

दुर्भाग्य से, गणितज्ञ शून्य का प्रतिनिधित्व करता है, Nइसलिए हमें उनसे छुटकारा पाने की आवश्यकता है।

Comments

सब कुछ के लिए अपने

— निर्माणों के

@ OldBunny2800 मुझे आश्चर्य होगा अगर यह किसी भी गोल्फिंग भाषा द्वारा पीटा नहीं गया हालांकि।

— मार्टिन एंडर

@ OldBunny2800 और इसे प्राप्त करने के लिए असली पैसे खर्च होते हैं। यह बुरी बात है।

— 1819

@ मार्टिनबटनर ने सोचा कि मैं बस RomanNumeralकर सकता हूं?

— लीकेज नून

@ केनीलाऊ यह आउटपुट के MMMMलिए है 4000, यह केवल कल्पना करने के लिए काम करना शुरू कर देता है 5000(और फिर आपको इसके लिए समान समस्या आती है 4000000)। फिर भी, यह कोष्ठक के बजाय ओवरबार का उपयोग करता है। यदि आप इसके साथ ठीक हैं, तो आपको चुनौती विनिर्देश में ऐसा कहना चाहिए।

— मार्टिन एंडर

Answer 2

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

f=n=>n<4e3?"M1000CM900D500CD400C100XC90L50XL40X10IX9V5IV4I1".replace(/(\D+)(\d+)/g,(_,r,d)=>r.repeat(n/d,n%=d)):`(${f(n/1e3)})`+f(n%1e3)

4000 से कम की संख्या के लिए, रोमन "पत्र" और उनके दशमलव मानों की सूची का उपयोग करके प्रत्येक रोमन "पत्र" को जितनी बार संभव हो दोहराता है। अन्यथा पुनरावृत्ति 1000 के साथ विभाजन और मोडुलो से उत्तर का निर्माण करती है। सौभाग्य से repeatट्रंकटेट करता है इसलिए मुझे स्वयं ऐसा करने की आवश्यकता नहीं है।

Answer 3

आम लिस्प, 108

(defun p(n)(if(> n 0)(if(< n 4000)(format()"~@R"n)(format()"(~A)~@[~A~]"(p(floor n 1000))(p(mod n 1000))))))

Ungolfed

(defun p(n)
  (if (> n 0)
      (if (< n 4000)

          ;; Built-in Roman formatter (between 1 and 3999)
          (format () "~@R" n)

          ;; Divide N by 1000, as 1000*Q + R.
          ;; First print (p Q) in parentheses (recursively)
          ;; Then, if it is not NIL, the remainder R.
          (format () "(~A)~@[~A~]"
                  (p (floor n 1000))
                  (p (mod n 1000))))))

टेस्ट

दो परीक्षण प्रश्न से अलग आउटपुट देते हैं:

(loop for (in out) in '((1 "I")
                        (2 "II")
                        (3 "III")
                        (4 "IV")
                        (15 "XV")
                        (40 "XL")
                        (60 "LX")
                        (67 "LXVII")
                        (400 "CD")
                        (666 "DCLXVI")
                        (3000 "MMM")
                        (3999 "MMMCMXCIX")
                        (4000 "M(V)")
                        (4999 "M(V)CMXCIX")
                        (6000 "(VI)")
                        (6000000 "((VI))")
                        (6006000 "((VI)VI)")
                        (6666666666 "(((VI)DCLXVI)DCLXVI)DCLXVI"))
   for computed = (p in)
   unless (string= out computed)
   collect (list in out computed))

=> ((4000 "M(V)" "(IV)")
    (4999 "M(V)CMXCIX" "(IV)CMXCIX"))

Answer 4

आर, 134

m=1000;x=scan();while(x[1]>=m)x=c(floor(x[1]/m),x[1]%%m,x[-1]);cat(rep("(",length(x)),sep="");cat(as.character(as.roman(x)),sep=")")

यह सबसे अच्छा विकल्प नहीं है, लेकिन मुझे लगता है कि विचार इस के समान सुंदर होना चाहिए।

Answer 5

अजगर, 188 194

-6 बाइट्स कुछ व्हाट्सएप से छुटकारा पाने के

इस चुनौती ने मुझे उस समय वापस ला दिया जब मैं पहली बार कार्यक्रम सीख रहा था ...

def f(x,s=zip("M CM D CD C XC L XL X IX V IV I".split(),[1e3,900,500,400,100,90,50,40,10,9,5,4,1])):
 r=""if x<4e3else"("+f(x/1e3)+")";x%=1e3
 for a,b in s:
    while x>=b:r+=a;x-=b
 return r

यह सबसे छोटा समाधान नहीं हो सकता है, लेकिन मुझे इस समस्या को सुलझाने में मज़ा आया।

कोशिश करके देखो!

Answer 6

रूबी, 137 134 130 बाइट्स

पुनरावर्ती फ़ंक्शन जो स्ट्रिंग लौटाता है। यदि संभव हो तो मैं अंक सांकेतिक शब्दों में बदलने की कोशिश कर रहा हूँ, लेकिन मुझे यकीन नहीं है कि कैसे।

वूप्स, यह व्यावहारिक रूप से @ नील के ES6 उत्तर का सीधा पोर्ट है।

f=->x{(x<t=1e3)?"CM900D500CD400C100XC90L50XL40X10IX9V5IV4I1".gsub(/(\D+)(\d+)/){v=$2.to_i;s=x/v;x%=v;$1*s}:"(#{f[x/t]})#{f[x%t]}"}

Answer 7

रूबी, 185 161 144 बाइट्स

r=->i{i>(t=1e3)? "(#{r[i/t]})"+r[i%t]:(s=?I*i;"IVXXLCCDM".scan(/(.)(.)(.)/){|x,y,z|{x*5=>y,x*4=>x+y,y*2=>z,y+x+y=>x+z}.map{|x,y|s.gsub!x,y}};s)}

मूल पोस्ट के एक साल बाद, मुझे लगता है कि मैंने गोल्फ के बारे में कुछ सीखा है।

_{आपकी बहुमूल्य टिप्पणियों के लिए धन्यवाद इंक।}

Comments

gsubपहला तर्क के रूप में एक स्ट्रिंग ले सकते हैं, regex पैटर्न में प्रतिस्थापन की आवश्यकता को हटाने के बाद से s.gsub! x,yयह स्वचालित रूप से करता है। इसके अलावा, आप शायद अपने aसरणी के असाइनमेंट को वापस कर सकते हैं क्योंकि आप इसे केवल एक बार उपयोग करते हैं, और इसे सीधे each_sliceकॉल में डालते हैं।

— वैल्यू इंक

"IVXXLCCDM".scan(/(.)(.)(.)/){|x,b,c|...भी काम करता है

— मूल्य इंक

इसके अलावा r[x]कार्यात्मक के बराबर है r.(x)जब भी Stabby lambdas शामिल कर रहे हैं

— मूल्य इंक

@ValueInk धन्यवाद। r[x]माणिक में मेरे सभी बाहरी पुनरावर्ती गोल्फ के लिए यह चाल उपयोगी साबित होने वाली है!

— MegaTom

Answer 8

बंधन 134 बाइट्स

proc f r {
set map {M 1000+ CM 900+ D 500+ CD 400+ C 100+ XC 90+ L 50+ XL 40+ X 10+ IX 9+ V 5+ IV 4+ I 1+}
expr [string map $map $r]0}

इसे यहाँ आज़माएँ: https://rextester.com/BJC92885