Если задано строго положительное целое число, верните самую короткую римскую цифру, используя только аддитивное правило. Вывод должен состоять из нуля или более каждого из символов MDCLXVIв этом порядке. Следовательно, число 14должно давать, XIIIIа не XIV.

Числовые значения символов: M= 1000, D= 500, C= 100, L= 50, X= 10, V= 5, I= 1.

Примеры

3 → III

4 → IIII

9 → VIIII

42 → XXXXII

796 → DCCLXXXXVI

2017 → MMXVII

16807 → MMMMMMMMMMMMMMMMDCCCVII

Простой английский , 1059 1025 678 641 451 399 байт

Сохранено 34 байта путем удаления сообщения об ошибке. Тогда сэкономил 384 байта, играя в гольф. Затем сохранили 190 байтов, объединив операцию деления с операцией добавления («z») в новую операцию («p»). Затем сэкономил 52 байта, играя в гольф.

A s is a string.
To p a r remainder a s a x string a n number:
If the x is "", exit.
Divide the r by the n giving a q quotient and the r.
Fill a t s with the x's first's target given the q.
Append the t to the s.
To convert a r number to a s:
p the r the s "M" 1000.
p the r the s "D" 500.
p the r the s "C" 100.
p the r the s "L" 50.
p the r the s "X" 10.
p the r the s "V" 5.
p the r the s "I" 1.

Вот не окончательная версия окончательного кода, а также ошибка для отрицательного числа:

A roman numeral is a string.

To process a remainder given a roman numeral and a letter string is a number:
  If the letter is "", exit.
  Divide the remainder by the number giving a quotient and the remainder.
  Fill a temp string with the letter's first's target given the quotient.
  Append the temp string to the roman numeral.

To convert a number to a roman numeral:
  If the number is negative, exit.
  Put the number in a remainder.
  Process the remainder given the roman numeral and "M" is 1000.
  Process the remainder given the roman numeral and "D" is  500.
  Process the remainder given the roman numeral and "C" is  100.
  Process the remainder given the roman numeral and "L" is   50.
  Process the remainder given the roman numeral and "X" is   10.
  Process the remainder given the roman numeral and "V" is    5.
  Process the remainder given the roman numeral and "I" is    1.

APL (Dyalog) , 25 22 байта

'MDCLXVI'/⍨(0,6⍴2 5)∘⊤

Попробуйте онлайн!

Retina , 57 42 байта

Преобразует в одинарный, затем жадно заменяет сгустки Is с более высокими значениями в порядке.

.*
$*I
I{5}
V
VV
X
X{5}
L
LL
C
C{5}
D
DD
M

Попробуйте онлайн

_{Сэкономили 15 байтов благодаря Мартину}

Python 2 , 64 байта

f=lambda n,d=5,r='IVXLCD':r and f(n/d,7-d,r[1:])+n%d*r[0]or'M'*n

Попробуйте онлайн!

Вместо того, чтобы создавать выходную строку с самого начала, жадно занимая большую часть, это создает ее с конца. Например, число I's' n%5, затем число V's' n/5%2и так далее. Это смешанное базовое преобразование с чередующимися соотношениями 5 и 2.

Вот итерационный эквивалент:

Python 2 , 68 байт

n=input();s='';d=5
for c in'IVXLCD':s=n%d*c+s;n/=d;d^=7
print'M'*n+s

Попробуйте онлайн!

Их Mнужно обрабатывать отдельно, потому что может присутствовать любое их количество, так как нет большей цифры. Таким образом, после назначения других значений места оставшееся значение преобразуется в M's'.

Для сравнения жадная стратегия (69 байт):

Python 2 , 69 байт

f=lambda n,d=1000,r='MDCLXVI':r and n/d*r[0]+f(n%d,d/(d%3*3-1),r[1:])

Попробуйте онлайн!

Текущее значение цифры dделится на 2 или 5 для получения следующей цифры. Значение d%3скажите нам, какой: если d%3==1, разделите на 2; и если d%3==2, разделите на 5.

Mathematica, 81 байт

Table@@@Thread@{r=Characters@"MDCLXVI",#~NumberDecompose~FromRomanNumeral@r}<>""&

Явное использование значений и получение соответствующих цифр кажется на один байт длиннее:

Table@@@Thread@{RomanNumeral[n={1000,500,100,50,10,5,1}],#~NumberDecompose~n}<>""&

Excel, 236 193 161 байт

43 байта сэкономлено благодаря @ BradC

На данный момент ответ действительно полностью принадлежит @ BradC . Еще 32 байта сохранены.

=REPT("M",A1/1E3)&REPT("D",MOD(A1,1E3)/500)&REPT("C",MOD(A1,500)/100)&REPT("L",MOD(A1,100)/50)&REPT("X",MOD(A1,50)/10)&REPT("V",MOD(A1,10)/5)&REPT("I",MOD(A1,5))

отформатирован:

=REPT("M",A1/1E3)
    &REPT("D",MOD(A1,1E3)/500)
    &REPT("C",MOD(A1,500)/100)
    &REPT("L",MOD(A1,100)/50)
    &REPT("X",MOD(A1,50)/10)
    &REPT("V",MOD(A1,10)/5)
    &REPT("I",MOD(A1,5))

Perl 5 , 66 байт

65 байт кода + -pфлаг.

$s=1e3;for$@(MDCLXVI=~/./g){$\.=$@x($_/$s);$_%=$s;$s/=--$|?2:5}}{

Попробуйте онлайн!

Без изменения количества байтов, MDCLXVI=~/./gможно заменить на M,D,C,L,X,V,I; и --$|?2:5по $|--*3+2.

Гораздо дольше ( 99 байт ) есть:

$_=M x($_/1e3).D x($_%1e3/500).C x($_%500/100).L x($_%100/50).X x($_%50/10).V x($_%10/5).I x($_%5)

CJam , 35 28 байт

-7 байт благодаря Мартину Эндеру

q~{5md\2md\}3*]W%"MDCLXVI".*

Попробуйте онлайн!

объяснение

q~         e# Read and eval input (push the input as an integer).
{          e# Open a block:
 5md\      e#  Divmod the top value by 5, and bring the quotient to the top.
 2md\      e#  Divmod that by 2, and bring the quotient to the top.
}3*        e# Run this block 3 times.
]W%        e# Wrap the stack in an array and reverse it. Now we've performed the mixed-base
           e# conversion.
"MDCLXVI"  e# Push this string.
.*         e# Element-wise repetition of each character by the numbers in the other array.
           e# Implicitly join and print.

C #, 127 байт

f=n=>n>999?"M"+f(n-1000):n>499?"D"+f(n-500):n>99?"C"+f(n-100):n>49?"L"+f(n-50):n>9?"X"+f(n-10):n>4?"V"+f(n-5):n>0?"I"+f(n-1):""

Чисто жестко закодированное троичное выражение, использующее рекурсию.

Полная / Отформатированная версия:

using System;

class P
{
    static void Main()
    {
        Func<int, string> f = null;
        f = n => n > 999 ? "M" + f(n - 1000)
                         : n > 499 ? "D" + f(n - 500)
                                   : n > 99 ? "C" + f(n - 100)
                                            : n > 49 ? "L" + f(n - 50)
                                                     : n > 9 ? "X" + f(n - 10)
                                                             : n > 4 ? "V" + f(n - 5)
                                                                     : n > 0 ? "I" + f(n - 1)
                                                                             : "";

        Console.WriteLine(f(3));
        Console.WriteLine(f(4));
        Console.WriteLine(f(42));
        Console.WriteLine(f(796));
        Console.WriteLine(f(2017));
        Console.WriteLine(f(16807));

        Console.ReadLine();
    }
}

05AB1E , 29 26 25 байт

¸5n3×Rvćy‰ì}"MDCLXVI"Ss×J

Попробуйте онлайн!

объяснение

¸                           # wrap input in a list
 5n                         # push 5**2
   3×                       # repeat it 3 times
     Rv                     # for each digit y in its reverse
       ć                    # extract the head of the list 
                            # (div result of the previous iteration, initially input)
        y‰                  # divmod with y
          ì                 # prepend to the list
           }                # end loop
            "MDCLXVI"S      # push a list of roman numerals
                      s×    # repeat each a number of times corresponding to the result
                            # of the modulus operations
                        J   # join to string

JavaScript (ES6), 81 75 69 байт

Сохранено 6 байтов благодаря @Neil за перенос @ ответа Йорг Хюльсерманна

Сохранено 6 байтов благодаря @Shaggy

n=>'MDCLXVI'.replace(/./g,(c,i)=>c.repeat(n/a,n%=a,a/=i%2?5:‌​2),a=1e3)

Тестовые случаи:

f=
n=>'MDCLXVI'.replace(/./g,(c,i)=>c.repeat(n/a,n%=a,a/=i%2?5:‌​2),a=1e3)

const testCases = [3, 4, 42, 796, 2017, 16807]
testCases.forEach(testCase => console.log(f(testCase)))

/// , 50 байт

/1/I//IIIII/V//VV/X//XXXXX/L//LL/C//CCCCC/D//DD/M/

Попробуйте онлайн!

Принимает ввод в унарном виде, и я (ab) использую поле нижнего колонтитула на TIO для ввода, поэтому выводу предшествует символ новой строки.

Python 3 , 100 97 96 94 93 91 90 байт

• сохранено 4 + 2 байта: использование def; массив как параметр по умолчанию уменьшил пространство отступа; объявление нежелательной переменной удалено
• @shooqie сохранил 1 байтовое a%=сокращение
• сохранено 2 байта: переставлены и (a//i)удалены скобки
• @Wondercricket сохранено 1 байт: переместите массив из параметра по умолчанию в функцию, которая была удалена []за счет одного отступа, таким образом экономя 1 байт.

def f(a):
 b=1000,500,100,50,10,5,1
 for i in b:print(end=a//i*'MDCLXVI'[b.index(i)]);a%=i

Попробуйте онлайн!

Cubix , 69 74 80 байт

/.UI,..N&..0\0&/52"IVXLCDM"U,r%ws;rr3tu;pw..u;qrUosv!s.u\psq,!@Us(0;U

Попробуйте онлайн!

        / . U I
        , . . N
        & . . 0
        \ 0 & /
5 2 " I V X L C D M " U , r % w
s ; r r 3 t u ; p w . . u ; q r
U o s v ! s . u \ p s q , ! @ U
s ( 0 ; U . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

Смотреть это работает

Мне удалось сжать это немного больше, но все еще есть некоторые неприятные запреты, особенно на верхней грани.

• 52"IVXLCDM"Uпоместите необходимые делители и символы в стек. 5 и 2 будут использоваться для уменьшения значения div / mod, а символы будут отбрасываться после использования.
• UIN0/&0\&,/UРазвернитесь на верхнюю грань и начните длинный тур, чтобы получить ввод и толкнуть 1000 в стек. Начальное деление сделано и разворот на rследующий фрагмент. Это была область, на которую я смотрел, чтобы сэкономить.
• ,r%ws;rrначало цикла divmod. целочисленное деление, поверните результат без мода, затем переставьте верхнюю часть стека, чтобы уменьшить ввод, делитель тока и результат деления.
• 3tus вывести текущий символ наверх и поменять его местами с результатом деления.
• !vsoUs(0;Uэто цикл печати. в то время как результат div больше 0, поменяйте местами вывод символов, поменяйте местами назад, уменьшите, нажмите 0 и отбросьте его. На 0 перенаправить через поп стек (удалить результат деления) и вокруг куба.
• \u;pwpsq,!@Urq;uс небольшим перенаправлением это удаляет персонажа из стека, поднимает 5 и 2 на вершину, меняет их местами и толкает один обратно вниз. Остальное используется для уменьшения делителя. Остановитесь, если оно уменьшится до 0, в противном случае сдвиньте 5 или 2 вниз и снова войдите в цикл.

Mathematica, 130 байт

(f=#~NumberDecompose~{1000,500,100,50,10,5,1};""<>{Flatten@Table[Table[{"M","D","C","L","X","V","I"}[[i]],f[[i]]],{i,Length@f}]})&

Python 2 , 109 90 байт

lambda n,r=[1000,500,100,50,10,5,1]:''.join(n%a/b*c for a,b,c in zip([n+1]+r,r,'MDCLXVI'))

Попробуйте онлайн!

PHP , 70 байт

for($r=1e3;$a=&$argn;)$a/$r<1?$r/=++$i%2?2:5:$a-=$r*print MDCLXVI[$i];

Попробуйте онлайн!

T-SQL, 164 байта

SELECT REPLICATE('M',n/1000)+IIF(n%1000>499,'D','')
      +REPLICATE('C',n%500/100)+IIF(n%100>49,'L','')
      +REPLICATE('X',n%50/10)+IIF(n%10>4,'V','')
      +REPLICATE('I',n%5)
FROM t

Добавлены разрывы строк только для удобства чтения.

Эта версия намного длиннее (230 символов), но ощущается гораздо более похожей на SQL:

DECLARE @ INT,@r varchar(99)=''SELECT @=n FROM t
SELECT'I's,1v INTO m
INSERT m VALUES('V',5),('X',10),('L',50),('C',100),('D',500),('M',1000)
L:
    SELECT @-=v,@r+=s 
    FROM m WHERE v=(SELECT MAX(v)FROM m WHERE v<=@)
IF @>0GOTO L
SELECT @r

Создает таблицу m со всеми сопоставлениями значений символов, а затем перебирает нахождение наибольшего значения <= число, объединяя соответствующий символ.

Japt , 34 байта

"IVXLCD"£%(U/=Y=v *3+2Y)îXÃw i'MpU

Проверьте это онлайн!

"IVXLCD"£    %(U/=Y=v  *3+2Y )îXÃ w i'MpU
"IVXLCD"mXY{U%(U/=Y=Yv *3+2,Y)îX} w i'MpU : Ungolfed
                                          : Implicit: U = input number
"IVXLCD"mXY{                    }         : Map each char X and its index Y in this string to:
                  Y=Yv *3+2               :   Set Y to 5 for even indexes, 2 for odd.
               U/=                        :   Divide U by this amount.
            U%(            ,Y)            :   Modulate the old value of U by 5.
                              îX          :   Repeat the character that many times.
                                          : This returns e.g. "IIVCCCD" for 16807.
                                  w       : Reverse the entire string.
                                    i'MpU : Prepend U copies of 'M' (remember U is now the input / 1000).
                                          : Implicit: output result of last expression

JavaScript (ES6), 65 байт

Рекурсивная функция.

f=(n,a=(i=0,1e3))=>n?a>n?f(n,a/=i++&1?5:2):'MDCLXVI'[i]+f(n-a):''

Как?

Второй рекурсивный вызов f(n-a)действительно должен быть f(n-a,a). Опуская второй параметр, aи iповторно инициализируются (до 1000 и 0 соответственно) каждый раз, когда новая римская цифра добавляется к окончательному результату. Это вызывает больше рекурсии, чем необходимо, но не изменяет результат функции и сохраняет 2 байта.

Контрольные примеры

f=(n,a=(i=0,1e3))=>n?a>n?f(n,a/=i++&1?5:2):'MDCLXVI'[i]+f(n-a):''

console.log(f(3))
console.log(f(4))
console.log(f(9))
console.log(f(42))
console.log(f(796))
console.log(f(2017))
console.log(f(16807))

J , 26 23 байта

3 байта сэкономлено благодаря Адаму.

'MDCLXVI'#~(_,6$2 5)&#:

Попробуйте онлайн!

Похоже на APL ответ в основном одно и то же.

'MDCLXVI'#~(_,6$2 5)&#:
           (       )&#:   mixed base conversion from decimal
              6$2 5       2 5 2 5 2 5
            _,            infinity 2 5 2 5 2 5
                          this gives us e.g. `0 0 0 0 1 0 4` for input `14`
'MDCLXVI'#~               shape each according to the number of times on the right
                          this is greedy roman numeral base conversion

Пакет, 164 байта

@set/pn=
@set s=
@for %%a in (1000.M 500.D 100.C 50.L 10.X 5.V 1.I)do @call:c %%~na %%~xa
@echo %s:.=%
@exit/b
:c
@if %n% geq %1 set s=%s%%2&set/an-=%1&goto c

Принимает участие в STDIN.

Oracle SQL, 456 байт

select listagg((select listagg(l)within group(order by 1)from dual start with trunc((n-nvl(n-mod(n,p),0))/v)>0 connect by level<=trunc((n-nvl(n-mod(n,p),0))/v)))within group(order by v desc)from (select 2849n from dual)cross join(select 1000v,null p,'m'l from dual union select 500,1000,'d'from dual union select 100,500,'c'from dual union select 50,100,'l'from dual union select 10,50,'x'from dual union select 5,10,'v'from dual union select 1,5,'i'from dual)

Выходы:

mmdcccxxxxviiii

Обратите внимание, что фактический размер строки составляет 460 байт, поскольку он включает в себя номер ввода (2849).

Ungolfed:

select listagg(
            (select listagg(l, '') within group(order by 1) 
             from dual 
             start with trunc((n-nvl(p*trunc(n/p),0))/v) > 0 
             connect by level <= trunc((n-nvl(p*trunc(n/p),0))/v) )
        ) within group(order by v desc)
from (select 2348 n
    from dual
) cross join (
    select 1000v, null p, 'm' l from dual union 
    select 500, 1000, 'd' from dual union
    select 100, 500, 'c' from dual union
    select 50, 100, 'l' from dual union
    select 10, 50, 'x' from dual union
    select 5, 10, 'v' from dual union
    select 1, 5, 'i' from dual     
)

Как это работает: я вычисляю, сколько каждой буквы мне нужно, вычисляя максимум, что я могу получить с более высоким значением (бесконечность для M), а затем делаю целочисленное деление между значением текущей буквы и результатом этого.

Например, 2348, сколько Cмне нужно? trunc((2348-mod(2348,500))/100)= 3

Затем я listaggпереписываю это письмо 3 раза (используя CONNECT BYдля генерации 3 нужных мне строк). Наконец-то у меня listaggвсе вместе.

Вроде громоздко, но большинство из них select from dualв таблице преобразования, и я не могу ничего с этим поделать ...

Java (OpenJDK 8) , 119 118 байт

n->{String s="";for(int v[]={1,5,10,50,100,500,1000},i=7;i-->0;)for(;n>=v[i];n-=v[i])s+="IVXLCDM".charAt(i);return s;}

Попробуйте онлайн!

Сохраненный байт благодаря @TheLethalCoder

Древесный уголь , 61 50 46 байтов

ＮνＡ⁰χＷφ«Ｗ¬‹νφ«§MDCLXVIχＡ⁻νφν»Ａ⁺¹χχＡ÷φ⎇﹪χ²¦²¦⁵φ

Попробуйте онлайн!

Объяснение:

Ｎν                   Take input as number and assign it to ν
Ａ⁰χ                  Let χ=0
Ｗφ«                  While φ>0 (φ has a predefined value of 1000)
    Ｗ¬‹νφ«               While v>=φ 
        §MDCLXVIχ             Take the char from string "MDCLXVI" at position χ
        Ａ⁻νφν»               Let ν=ν-φ
    Ａ⁺¹χχ                Increment χ
    Ａ÷φ⎇﹪χ²¦²¦⁵φ        If χ is odd, divide φ by 5, else divide φ by 2

• Благодаря Нилу сэкономлено 4 байта, а я все еще пытаюсь понять, как поступить со второй частью его комментария.

C ++, 272 байта

#include <cstdio>
#include <map>
std::map<int,char> m = {{1000,'M'},{500,'D'},{100,'C'},{50,'L'},{10,'X'},{5,'V'},{1,'I'}};
int main(){unsigned long x;scanf("%d",&x);for(auto i=m.rbegin();i!=m.rend();++i)while(x>=i->first){printf("%c", i->second);x=x-i->first;}return 0;}

C 183 байта

#include <stdio.h>
int v[]={1000,500,100,50,10,5,1};
char*c="MDCLXVI";
int main(){int x;scanf("%d",&x);for(int i=0;i<sizeof v/sizeof(int);i++)for(;x>=v[i];x-=v[i])putc(c[i],stdout);}

Тот же алгоритм, что и раньше, только использование простых массивов c вместо std :: map, частично вдохновленных ответом @ xnor, и использование строки для хранения букв.

Common Lisp, 113 байт

Это анонимная функция, возвращающая результат в виде строки.

(lambda(value)(setf(values a b)(floor v 1000))(concatenate 'string(format()"~v,,,v<~>"a #\M)(format nil"~@:r"b)))

Ungolfed, с описательными именами переменных и комментариями:

(defun format-roman (value)
  ;; Get "value integer-divided by 1000" and "value mod 1000"
  (setf (values n_thousands remainder) (floor value 1000))
  (concatenate 'string
               ;; Pad the empty string n_thousands times, using "M" as the 
               ;; padding character
               (format () "~v,,,v<~>" n_thousands #\M)
               ;; Format the remainder using "old-style" Roman numerals, i.e. 
               ;; numerals with "IIII" instead of "IV"
               (format nil "~@:r" remainder)))

CL имеет встроенный форматер римских цифр. К сожалению, это не работает для чисел больше 3999.

Древесный уголь , 34 байта

ＮςＡ²ξＦMDCLXVI«×ι÷ςφＡ﹪ςφςＡ÷φξφＡ÷χξξ

Первоначально основано на ответе @ CarlosAlego. Порт Python-решения @ xnor также составляет 34 байта:

ＮθＡ⁵ξＦIVXLCD«←×ι﹪θξＡ÷θξθＡ÷χξξ»←×Mθ

Изменить: Порт другого решения Python @ xnor оказывается 33 байта!

ＮθＦMDCLXVI«×ι÷θφＡ﹪θφθＡ÷φ⁺׳﹪φ³±¹φ

Попробуйте онлайн! Ссылка на подробную версию кода. Обратите внимание, что я использовал ⁺׳﹪φ³±¹вместо, ⁻׳﹪φ³¦¹потому что в настоящее время девербозификатор не может вставить разделитель.