Votre tâche consiste à convertir un entier positif donné du chiffre arabe en chiffre romain.

Les choses deviennent difficiles quand on compte jusqu'à 4000.

Les romains l'ont fait en ajoutant une ligne au-dessus d'un symbole pour multiplier ce symbole par 1 000. Cependant, les surlignages ne sont pas exactement affichables en ASCII. En outre, il existe des doubles surlignages pour multiplier un symbole par 1 000 000, puis un triple surlignage pour multiplier un symbole par 1 000 000 000, etc.

Par conséquent, j'ai décidé d'utiliser des parenthèses pour remplacer les surlignages.

Les symboles peuvent être placés individuellement entre parenthèses. Par exemple, les deux (VI)et (V)(I)sont des représentations valides de 6 000. (V)Mest également une représentation valide de 6000.

(I)est une façon valable de représenter 1 000.

Cas de test

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

Notation

C'est du code-golf . Le code le plus court en octets gagne.

Mathematica, 67 octets

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

Évite tout problème avec la Mconversion de l'entrée en base 1000 et la conversion de chaque chiffre séparément avec RomanNumeral. Nous les replions ensuite en les insérant (...)par la gauche.

Malheureusement, Mathematica représente des zéros Net nous devons donc nous en débarrasser.

JavaScript (ES6), 136 octets

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

Pour les nombres inférieurs à 4000, répète chaque "lettre" romaine autant de fois que possible, en utilisant la liste des "lettres" romaines et leurs valeurs décimales. Sinon, construit récursivement la réponse de la division et du module avec 1000. Heureusement repeattronque donc je n'ai pas à le faire moi-même.

Lisp commun, 108

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

Non golfé

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

Les tests

Deux tests donnent des résultats différents de ceux de la question:

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

Ce n'est pas la meilleure option, mais je pense que l'idée devrait être assez similaire à cela.

Python, 188 194

-6 octets pour se débarrasser de certains espaces

Ce défi m'a ramené à la première fois que j'ai appris à programmer ...

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

Ce n'est peut-être pas la solution la plus courte, mais je me suis amusé à jouer à ce problème.

Essaye le!

Rubis, 137 134 130 octets

Fonction récursive qui renvoie la chaîne. J'essaie de jouer un peu plus sur les encodages numériques si possible, mais je ne sais pas comment.

Oups, c'est pratiquement un port direct de la réponse ES6 de @ Neil maintenant.

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

Rubis, 185161144 octets

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

Plus d'un an après la publication originale, je pense avoir appris quelque chose sur le golf.

_{Merci Value Ink pour vos précieux commentaires.}

TCL 134 octets

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}

Essayez-le ici: https://rextester.com/BJC92885