당신의 임무는 주어진 양의 정수 를 아라비아 숫자에서 로마 숫자 로 변환하는 것 입니다.

4000까지 세면 상황이 어려워집니다.

로마인은이 기호를 곱하기 위해 기호 위에 줄을 추가하여이 작업을 수행했습니다 1 000. 그러나 ASCII에서는 오버 라인을 정확하게 표시 할 수 없습니다. 또한 기호에을 곱하는 이중 겹침이 있고 기호 1 000 000에을 곱하기 위해 삼중 겹침 1 000 000 000등이 있습니다.

따라서 괄호 를 사용 하여 개요를 대체 하기로 결정했습니다 .

기호는 괄호 안에 개별적으로 배치 할 수 있습니다 . 예를 들어, (VI)및 (V)(I)은 모두의 유효한 표현입니다 6 000. (V)M또한 6000의 유효한 표현입니다.

(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

채점

이것은 code-golf 입니다. 바이트 단위의 최단 코드가 이깁니다.

수학, 67 바이트

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

M입력을 기준 1000으로 변환하고로 각 숫자를 개별적으로 변환하여 모든 문제를 방지합니다 RomanNumeral. 그런 다음 (...)왼쪽에서 삽입 하여 접습니다 .

불행히도 Mathematica는 0을 나타내 N므로 우리는 그것들을 제거해야합니다.

자바 스크립트 (ES6), 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 미만의 숫자의 경우 로마 "문자"목록과 10 진수 값을 사용하여 각 로마 "문자"를 가능한 한 여러 번 반복합니다. 그렇지 않으면 재귀 적으로 1000으로 나누기와 모듈로에서 답을 얻습니다. 다행히도 repeat잘리지 않으므로 직접 할 필요가 없습니다.

커먼 리스프, 108

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

언 골프

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

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

가장 좋은 옵션은 아니지만 아이디어는 이것과 비슷해야한다고 생각합니다.

파이썬, 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

가장 짧은 해결책은 아니지만이 문제를 재미있게 골랐습니다.

사용해보십시오!

루비, 137 (134) 130 바이트

문자열을 반환하는 재귀 함수 가능한 경우 숫자 인코딩을 조금 더 낮추려고하지만 어떻게 해야할지 모르겠습니다.

@, 그것은 실제로 @Neil의 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]}"}

루비, 185161144 바이트

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

원래 게시물 이후 1 년 동안 골프에 대해 배운 것 같습니다.

_{소중한 의견에 대해 Value Ink에 감사드립니다.}

TCL 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