Ваше завдання - перетворити задане додатне ціле число з арабської цифри в римську цифру.

Все стає складним, коли ти рахуєш до 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

Оцінка балів

Це код-гольф . Найкоротший код виграти в байтах.

Математика, 67 байт

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

Уникайте будь-яких проблем з Mперетворенням вхідного сигналу в базовий 1000 та перетворення кожної цифри окремо за допомогою RomanNumeral. Потім складаємо їх, вставляючи (...)зліва.

На жаль, Mathematica представляє нулі, Nтому їх потрібно позбутися.

JavaScript (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 повторює кожну римську "букву" якомога більше разів, використовуючи список римських "букв" та їх десяткові значення. В іншому випадку рекурсивно формується відповідь з підрозділу та модуля з 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]}"}

Рубі, 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)}

Через рік після початкової публікації я думаю, що я дізнався щось про гольф.

_{Дякуємо Value Ink за ваші цінні коментарі.}

134 байт TCL

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