Sua tarefa é converter um número inteiro positivo de número arábico para número romano.

As coisas ficam difíceis quando você conta até 4000.

Os romanos fizeram isso adicionando uma linha acima de um símbolo para multiplicá-lo por 1 000. No entanto, as linhas de cima não são exatamente exibidas no ASCII. Além disso, existem linhas duplas para multiplicar um símbolo por 1 000 000e, em seguida, linha tripla para multiplicar um símbolo por 1 000 000 000, etc ...

Portanto, decidi usar parênteses para substituir as linhas excessivas.

Os símbolos podem ser colocados individualmente entre parênteses. Por exemplo, ambos (VI)e (V)(I)são representações válidas de 6 000. (V)Mtambém é uma representação válida de 6000.

(I)é uma maneira válida de representar 1 000.

Casos de teste

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

Pontuação

Isso é código-golfe . O código mais curto em bytes vence.

Mathematica, 67 bytes

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

Evita todos os problemas Mconvertendo a entrada na base 1000 e convertendo cada dígito separadamente com RomanNumeral. Em seguida, dobramos-os inserindo (...)da esquerda.

Infelizmente, o Mathematica representa zeros, Nportanto precisamos nos livrar deles.

JavaScript (ES6), 136 bytes

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

Para números abaixo de 4000, repita cada "letra" romana o máximo de vezes possível, usando a lista de "letras" romanas e seus valores decimais. Caso contrário, recursivamente cria a resposta da divisão e do módulo com 1000. Felizmente, repeattrunca para que eu não precise fazer isso sozinho.

Lisp comum, 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))))))

Testes

Dois testes fornecem resultados diferentes dos da pergunta:

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

Não é praticamente a melhor opção, mas acho que a ideia deve ser bastante semelhante a isso.

Python, 188194

-6 bytes de se livrar de algum espaço em branco

Esse desafio me trouxe de volta a quando eu estava aprendendo a programar ...

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

Pode não ser a solução mais curta, mas eu me diverti jogando golfe nesse problema.

Experimente!

Ruby, 137 134 130 bytes

Função recursiva que retorna a string. Estou tentando jogar as codificações numéricas um pouco mais, se possível, mas não sei como.

Opa, é praticamente uma porta direta da resposta ES6 do @ Neil agora.

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

Ruby, 185 161 144 bytes

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

Mais de um ano após o post original, acho que aprendi algo sobre golfe.

_{Obrigado Value Ink por seus valiosos comentários.}

TCL 134 bytes

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}

Experimente aqui: https://rextester.com/BJC92885