Senin görevin verilen bir pozitif tamsayıyı Arap rakamından Roma rakamına dönüştürmektir.

4000'e düştüğünüzde işler zorlaşıyor.

Romalılar bunu, sembolü sembolle çarpmak için sembol üzerine bir çizgi ekleyerek yaptılar 1 000. Ancak, ASCII'de genel hatlar tam olarak görüntülenemez. Ayrıca, bir simgeyi çarpmak için çift üst çizgi 1 000 000ve ardından bir simgeyle çarpmak için üç üst çizgi vardır 1 000 000 000, vb.

Bu nedenle, üst çizgileri değiştirmek için parantez kullanmaya karar verdim .

Semboller ayrı ayrı parantez içine yerleştirilebilir. Örneğin, hem (VI)ve hem (V)(I)de geçerli temsilleridir 6 000. (V)M6000'in geçerli bir temsilidir.

(I)geçerli bir temsil yoludur 1 000.

testcases

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

puanlama

Bu kod golfü . Bayt kazanmak için en kısa kod.

Mathematica, 67 bayt

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

MGirişi temel 1000'e dönüştürerek ve her bir basamağı ayrı ayrı dönüştürerek tüm sorunlardan kaçınır RomanNumeral. Sonra onları (...)soldan yerleştirerek katlarız .

Ne yazık ki, Mathematica sıfırları temsil ediyor, Nbu yüzden onlardan kurtulmamız gerekiyor.

JavaScript (ES6), 136 bayt

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

4000'in altındaki sayılar için, her Roma "harfini" Roma "harfleri" listesini ve ondalık değerlerini kullanarak mümkün olduğunca çok tekrarlayın. Aksi halde 1000 ile bölme ve modulo'dan gelen cevabı tekrar tekrar oluştururlar. Neyse ki repeatkısalır, bu yüzden kendim yapmak zorunda değilim.

Yaygın Lisp, 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))))))

Testler

İki test sorudan farklı çıktılar verir:

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

R, 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=")")

Hemen hemen en iyi seçenek değil, ama fikrin buna oldukça benzer olması gerektiğini düşünüyorum.

Python, 188194

Bazı boşluklardan kurtulmak için -6 bayt

Bu zorluk beni programlamayı ilk öğrendiğim zamana getirdi ...

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

En kısa çözüm olmayabilir, ama bu problemi golf oynadım.

Denemek!

Yakut, 137 134 130 bayt

Dizeyi döndüren özyinelemeli işlev. Mümkünse sayısal kodlamaları biraz daha aşağı golf etmeye çalışıyorum, ama nasıl emin değilim.

Maalesef, şu anda @ Neil'in ES6 cevabının doğrudan bir limanı.

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

Yakut, 185161144 bayt

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

Orijinal gönderiden bir yıl sonra, golf hakkında bir şeyler öğrendiğimi düşünüyorum.

_{Değerli yorumlarınız için teşekkür ederiz Mürekkep Değer.}

TCL 134 bayt

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}

Burada deneyin: https://rextester.com/BJC92885