Code Golf New Year Edition - Целое число с римской цифрой

Ответ 1

Perl: 69 ударов (count 'em!)

Шестьдесят девять ударов, включая первый вызов perl:

$ perl -ple's!.!($#.=5x$&*8%29628)=~y$IVCXL4620-8$XLMCDIXV$d!eg;last}{'
3484
MMMCDLXXXIV

• Читает одну строку, пишет одну строку.
• Работает от 0 до 3999 включительно. (Печатает пустую строку для 0.)
• В соревнованиях по гольфу на Perl это обычно оценивается как 62 удара = 58 для кода + 4 для переключателей.
• Почему, да, это несогласованные фигурные скобки. Спасибо за вопрос. =)

Кредиты: первоначально из-за Ton Hospel. Трюк, связанный с несогласованными фигурными скобками, находится от rev.pl в этот пост (который, кстати, изобретателен).

Ответ 2

В С# в качестве метода расширения до Int32:

public static class Int32Extension {
    public static string ToRomanNumeral(this int number) {
        Dictionary<int, string> lookup = new Dictionary<int, string>() {
            { 1000000, "M_" },
            { 900000, "C_D_" },
            { 500000, "D_" },
            { 400000, "C_D_" },
            { 100000, "C_" },
            { 90000, "X_C_" },
            { 50000, "L_" },
            { 40000, "X_L_" },
            { 10000, "X_" },
            { 9000, "MX_"},
            { 5000, "V_" },
            { 4000, "MV_" },
            { 1000, "M" },
            { 900, "CM" },
            { 500, "D" },
            { 400, "CD" },
            { 100,"C" },
            { 90, "XC" },
            { 50, "L" },
            { 40, "XL" },
            { 10, "X" },
            { 9, "IX" },
            { 5, "V" },
            { 4, "IV" },
            { 1, "I" }
        };

        StringBuilder answer = new StringBuilder();
        foreach (int key in lookup.Keys.OrderBy(k => -1 * k)) {
            while (number >= key) {
                number -= key;
                answer.Append(lookup[key]);
            }
        }
        return answer.ToString();
    }
}

Символы подчеркивания должны быть надстрочными над соответствующей буквой как настоящая римская цифра.

Ответ 3

Общий lisp (SBCL). 63 символа подсчитаны "wc -c".

(format t "[email protected]~%" (parse-integer (elt *posix-argv* 1)))
(quit)

Это работает только для чисел до 3999.

Ответ 4

С#: 179 символов (без пробелов/вкладок)

    static string c(int a)
    {
        int[] v = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };
        var s = ""; 
        for ( var i = 0; i < 13; i++ )
            while (a >= v[i])
            {
                a -= v[i];
                s += "M CM D CD C XC L XL X IX V IV I".Split()[i];
            }
        return s;
    }

Ответ 5

Perl, 19 штрихов. Гарантируется работа для значений от 1 до 12.

sub r{chr 8543+pop}

Ответ 6

Язык: JavaScript.

129 символов без добавления форматирования

Следующий код является результатом викторины кодирования, которая прошла несколько лет назад в pl.comp.lang.javascript newsgrup. Я не автор кода.

function rome(N,s,b,a,o){
  for(s=b='',a=5;N;b++,a^=7)for(o=N%a,N=N/a^0;o--;)
  s='IVXLCDM'.charAt(o>2?b+N-(N&=~1)+(o=1):b)+s;return s
}

Оригинальное сообщение от Elus

Ответ 7

Python, 173 байта.

r=lambda n:o[n]if n<10 else''.join(dict(zip('ivxlc','xlcdm'))[c]for c in r(n//10))+o[n%10]
o=' i ii iii iv v vi vii viii ix'.split(' ')
import sys
print r(int(sys.argv[1]))

(Я впервые увидел этот алгоритм в алгоритмах Гимпеля в Snobol4, Snobol выразил его более элегантно.)

Ответ 8

Язык: C, Char count: 174

#define R(s,v)for(;n>=v;n-=v)printf(#s);
main(int n,char**a){n=atoi(a[1]);R(M,1000)R(CM,900)R(D,500)R(CD,400)R(C,100)R(XC,90)R(L,50)R(XL,40)R(X,10)R(IX,9)R(V,5)R(IV,4)R(I,1)}

Ответ 9

Perl 5.10

perl -nE'@l=qw{1 I 4 IV 5 V 9 IX 10 X 40 XL 50 L 90 XC 100 C 400 CD 500 D 900 CM 1000 M};
$o="";while(@l){$o.=pop(@l)x($_/($c=pop @l));$_%=$c;}say$o'

Вы вводите строку, она дает вам римскую цифру эквивалентную. Эта первая версия даже позволяет вводить несколько строк.

Ниже приведена более короткая версия, которая работает только для одной строки и игнорирует случаи краев. поэтому 4 становится IIII вместо IV.

perl -nE'@l=qw{1 I 5 V 10 X 50 L 100 C 500 D 1000 M};
while(@l){$o.=pop(@l)x($_/($c=pop @l));$_%=$c;}say$o'

Вот что первая версия будет выглядеть как Perl script.

use 5.010;
while(<>){
  @l=qw{1 I 4 IV 5 V 9 IX 10 X 40 XL 50 L 90 XC 100 C 400 CD 500 D 900 CM 1000 M};
  $o="";
  while(@l){
    $o .= pop(@l) x ($_/($c=pop @l));
    # $l = pop @l;
    # $c = pop @l;
    # $o .= $l x ($_/$c);

    $_ %= $c;
  }
  say $o;
}

Ответ 10

Pike

60 символов, действительный для 0 до 10000:

int main (int c, array a) {
    write(String.int2roman((int)a[1]));
}

Ответ 11

Простая версия Haskell, которая все еще сохраняет ясность. 205, включая пробел.

l = ["M","CM","L","CD","C","XC","L","XL","X","IX","V","IV","I"]
v = [1000,900,500,400,100,90,50,40,10,9,5,4,1]
roman n i
    | n == 0 = ""
    | n >= v!!i = l!!i ++ roman (n-v!!i) i
    | otherwise = roman n (i+1)

Ответ 12

В Python - взято из ActiveState (кредиты: Пол Винклер) и сжал бит:

def int2roman(n):
   if not 0 < n < 4000: raise ValueError
   ints = (1000, 900,  500, 400, 100,  90, 50,  40, 10,  9,   5,  4,   1)
   nums = ('M',  'CM', 'D', 'CD','C', 'XC','L','XL','X','IX','V','IV','I')
   result = ""
   for i in range(len(ints)):
      count = int(n / ints[i])
      result += nums[i] * count
      n -= ints[i] * count
   return result

Ответ 13

Perl, 145 штрихов (если вы разделите все новые строки, которые являются необязательными), действительный для 1..3999:

%t=qw(1000 M 900 CM 500 D 400 CD 100 C 90 XC 50 L 40 XL 10 X 9 IX 5 V 4 IV 1 I);
$d=pop;
for(sort{$b<=>$a}keys%t){$r.=$t{$_}x($d/$_);$d%=$_}
print$r

Некоторые сказали бы, что я мог бы использовать say, но здесь нет версии say -capable Perl. Если используется say, вы можете вычесть 2 из счета хода.: -)

Для программистов, не относящихся к Perl, эта программа использует ряд полезных функций Perl:

• Хеши строятся из списков четной длины.
• Списки строк могут быть указаны в компактном синтаксисе, используя qw.
• Строки могут автоматически зависеть от целых чисел, используемых в операторе сравнения <=> при сортировке ключей.
• Существует оператор x, который делает копии строк/списков. К сожалению, для игры в гольф здесь x имеет одинаковый приоритет /; если / были выше, скобки также были бы необязательными.

Ответ 14

Язык: dc (через оболочку) Char count: 122

EDIT: q эквивалентно 2Q

dc -e '[I]1[IV]4[V]5[IX]9[X]10[XL]40[L]50[XC]90[C]100[CD]400[D]500[CM]900[M]?1000[szsz2Q]sq[~Sa[d0!<qrdPr1-lbx]dsbxLarz3<c]dscx10P' <<<$1

EDIT: еще два символа, оптимизируя манипуляции с стеком основного цикла

dc -e '[I]1[IV]4[V]5[IX]9[X]10[XL]40[L]50[XC]90[C]100[CD]400[D]500[CM]900[M]?1000[szsz2Q]sq[~Sa[d0!<qrdPr1-lbx]dsbxLarz3<c]dscx10P' <<<$1

ИЗМЕНИТЬ: сохранить 2 символа

dc -e '[I]1[IV]4[V]5[IX]9[X]10[XL]40[L]50[XC]90[C]100[CD]400[D]500[CM]900[M]1000?[sz2Q]sq[r~r[d0!<qSardPrLa1-lbx]dsbxrszz2<c]dscx10P' <<<$1

Предыдущая версия:

dc -e '[I]1[IV]4[V]5[IX]9[X]10[XL]40[L]50[XC]90[C]100[CD]400[D]500[CM]900[M]1000?[sz2Q]sq[r~r[d0!<qSaSadPLaLa1-lbx]dsbxrszz2<c]dscx10P' <<<$1

Ответ 15

Ruby, 136 символов

n = $*[0].to_i
for k,v in [1e3,900,500,400,100,90,50,40,10,9,5,4,1].zip %w{M CM D CD C XC L XL X IX V IV I}
  until n < k
    n -= k
    print v
  end
end

Ответ 16

Я не эксперт Haskell, и это слишком долго, чтобы стать победителем, но вот решение, которое я написал некоторое время назад, чтобы решить Euler # 89.

toRoman 0 = ""
toRoman 1 = "I"
toRoman 2 = "II"
toRoman 3 = "III"
toRoman 4 = "IV"
toRoman n
| n >= 1000 = repeatRoman 'M' 1000
| n >= 900 = subtractRoman "CM" 900
| n >= 500 = subtractRoman "D" 500
| n >= 400 = subtractRoman "CD" 400
| n >= 100 = repeatRoman 'C' 100
| n >= 90 = subtractRoman "XC" 90
| n >= 50 = subtractRoman "L" 50
| n >= 40 = subtractRoman "XL" 40
| n >= 10 = repeatRoman 'X' 10
| n >= 9 = subtractRoman "IX" 9
| n >= 5 = subtractRoman "V" 5
| otherwise = error "Hunh?"
where
    repeatRoman c n' = (take (n `div` n') (repeat c)) ++ (toRoman $ n `mod` n')
    subtractRoman s n' = s ++ (toRoman $ n - n')

Ответ 17

J, 20 символов!

'MDCLXVI'#~(7$5 2)#:

Использование:

   'MDCLXVI'#~(7$5 2)#: 2009
MMVIIII

Хорошо, это не делает вычитание правильно, но эй это довольно круто!

Объяснение;

(7$5 2)

Это принимает правильный аргумент (список 5 2) и превращает его в список размером 7 - а именно 5 2 5 2 5 2 5.

(7$5 2)#: 2009

Это выполняет "анти-базовую" операцию - в основном выполняет итеративные операции div и mod, возвращая список 2 0 0 0 0 0 1 4.

Затем #~ использует предыдущий список в качестве подсчета, чтобы вывести соответствующие символы из 'MDCLXVI'.

Ответ 18

Из неопределенного C-подобного языка, называемого LPC (предшественник Pike):

string roman_numeral(int val) {
    check_argument(1, val, #'intp);
    unless(val)
        return "N";
    string out = "";
    if(val < 0) {
        out += "-";
        val = -val;
    }
    if(val >= 1000) {
        out += "M" * (val / 1000);
        val %= 1000;
    }
    if(val >= 100) {
        int part = val / 100;
        switch(part) {
        case 9      :
            out += "CM";
            break;
        case 6 .. 8 :
            out += "D" + ("C" * (part - 5));
            break;
        case 5      :
            out += "D";
            break;
        case 4      :
            out += "CD";
            break;
        default     :
            out += "C" * part;
            break;
        }
        val %= 100;
    }
    if(val >= 10) {
        int part = val / 10;
        switch(part) {
        case 9      :
            out += "XC";
            break;
        case 6 .. 8 :
            out += "L" + ("X" * (part - 5));
            break;
        case 5      :
            out += "L";
            break;
        case 4      :
            out += "XL";
            break;
        default     :
            out += "X" * part;
            break;
        }
        val %= 10;
    }
    switch(val) {
    case 9      :
        out += "IX";
        break;
    case 6 .. 8 :
        out += "V" + ("I" * (val - 5));
        break;
    case 5      :
        out += "V";
        break;
    case 4      :
        out += "IV";
        break;
    default     :
        out += "I" * val;
        break;
    }
    return out;
}

Ответ 19

Python, 190 байт. На основе фрагмента из ActiveState через Федерико.

Несколько небольших оптимизаций: удаление излишнего вызова int(), разделение строки для получения массива, удаление пробелов,...

import sys
n=int(sys.argv[1])
N=(1000,900,500,400,100,90,50,40,10,9,5,4,1)
r=""
for i in range(len(N)):
 c=n/N[i]
 r+='M,CM,D,CD,C,XC,L,XL,X,IX,V,IV,I'.split(',')[i]*c
 n-=N[i]*c
print r

РЕДАКТИРОВАТЬ: лишний, не поддельный и удалить проверку диапазона - благодаря Chris и dreeves! Украли идею использования символьного массива inline из balabaster.

Ответ 20

VB: 193 символа

Function c(ByVal a)
    Dim v() = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}
    Dim s = ""
    For i = 0 To 12
        While a >= v(i)
            a -= v(i)
            s += "M|CM|D|CD|C|XC|L|XL|X|IX|V|IV|I".Split("|")(i)
        End While
    Next
    Return s
End Function

Ответ 21

Excel 8 символов (не включая номер):

= РОМАН (N)

Работает до 3000.

Язык в щеке

Ответ 22

Реальный прост: передайте запрос в Google и закройте его. Следующий.: Р

Кстати, разве это не сообщество wiki?

Ответ 23

Java: 286 значащих символов

public class R {

    String[]x="M,CM,D,C,XC,L,X,IX,V,I".split(",");
    int[]n={1000,900,500,100,90,50,10,9,5,1};

    String p(String s,int d,int i){return 10<=i?s:n[i]<=d?p(s+x[i],d-n[i],i):p(s,d,i+1);}

    public static void main(String[] a) {
        System.out.println(new R().p("",Integer.parseInt(a[0]),0));
    }

}

Под "значащими символами" подразумеваются печатные символы и требуемые пробелы (например, между типом и аргументом), но не чисто косметические пробелы (новые строки и отступы).

Ответ 24

Delphi (или Pascal, здесь нет ничего особенного в Delphi):

Function ToRoman(N : Integer) : String;

Const
    V : Array [1..13] of Word = (1000,900,500,400,100,90,50,40,10.9,5,4,1);
    T : Array [1..13] of String = ('M','CM','D','CD','C','XC','L','XL','X','IX','V','I');

Var I : Word;

Begin
    I := 1;
    Repeat
        While N < V[I] do Inc(I);
        Result := Result + T[I];
        N := N - V[I];
    Until N = 0;
End;

Как каждый получает персонаж? (Я считаю 8 основных пространств, все остальное просто для форматирования.)

Ответ 25

Вот C-решение в 252 значащих символах. Действителен от 0 <= я < 4000. В основном я написал это, потому что так много решений включают IV и IX в точках массива. Декодирование: t является нашим временным буфером, который мы заполняем, чтобы нам не пришлось отменить его на выходе. Пропущенный буфер должен быть не менее 16 символов (для 3888 → MMMDCCCLXXXVIII).

 char* i2r(int i, char* r) {
     char t[20];
     char* o=t+19;*o=0;
     char* s="IVXLCDMM";
     for (char*p=s+1;*p&&i;p+=2) {
         int x=i%10;
         if (x==9) {*--o=p[1];*--o=p[-1];}
         else if (x==4) {*--o=*p;*--o=p[-1];}
         else {
             for(;x&&x!=5;--x)*--o=p[-1];
             if(x)*--o=*p;
         }
         i/=10;
     }
     return strcpy(r,o);
 }

И я всегда забываю поставить главное. Так много для 252 символов:

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 void main(int a,char**v){
     char buf[16];
     printf("%s\n",i2r(atoi(v[1])));
 }

Ответ 26

Язык: C, Char count: 195

Основываясь на основном решении me.yahoo.com/joe_mucchielle C:

char t[99],*o=t+99,*s="IVXLCDMM",*p,x;n(v){*--o=p[v];}main(int i,int**v){i=atoi(v[1]);*o=0;
for(p=s+1;*p&&i;p+=2){x=i%10;if(x%5==4)n(x==9),n(-1);else{for(;x%5;--x)n(-1);if(x)n(0);}i/=10;}puts(o);}

Ответ 27

Язык: Erlang, Char count: 222

EDIT2: препроцессор Erlang допускает некоторые несбалансированные макросы, поэтому эта версия имеет 9 символов меньше.

-module(n2).
-export([y/1]).
-define(D(V,S),n(N)when N>=V->[??S|n(N-V)];).
y(N)->io:format(n(N)).
?D(1000,M)?D(900,CM)?D(500,D)?D(400,CD)?D(100,C)?D(90,XC)?D(50,L)?D(40,XL)?D(10,X)?D(9,IX)?D(5,V)?D(4,IV)?D(1,I)n(0)->[10].

EDIT: более короткая версия, вдохновленная версией Darius (231 символ)

-module(n).
-export([y/1]).
y(N)->io:format([n(N),10]).
n(N)when N>9->[Y||C<-n(N div 10),{K,Y}<-lists:zip("IVXLC","XLCDM"),K==C]++o(N rem 10);n(N)->o(N).
o(N)->lists:nth(N+1,[[]|string:tokens("I II III IV V VI VII VIII IX"," ")]).

Это менее читаемо, но сохраните 2 символа (233 символа).

-module(n).
-export([y/1]).
-define(D(V,S),n(N)when N>=V->[??S|n(N-V)]).
y(N)->io:format(n(N)).
?D(1000,M);?D(900,CM);?D(500,D);?D(400,CD);?D(100,C);?D(90,XC);?D(50,L);?D(40,XL);?D(10,X);?D(9,IX);?D(5,V);?D(4,IV);?D(1,I);n(0)->[10].

Версия командной строки:

-module(n).
-export([y/1]).
-define(D(V,S),n(N)when N>=V->[??S|n(N-V)]).
y([N])->io:format(n(list_to_integer(N))),init:stop().
?D(1000,M);?D(900,CM);?D(500,D);?D(400,CD);?D(100,C);?D(90,XC);?D(50,L);?D(40,XL);?D(10,X);?D(9,IX);?D(5,V);?D(4,IV);?D(1,I);n(0)->[10].

Призвание:

$ erl -noshell -noinput -run n y 2009
MMIX

EDIT: я сохранил 17 символов, используя расширение буквенного макроса.

Ответ 28

Railel CFML - 53 символа, 46 без пробелов...

<cfoutput>
    #NumberFormat( N , 'roman' )#
</cfoutput>

Или, для других двигателей CF, не уверен, что они самые короткие, но они сделают это сейчас...

CFML - 350..453 символов:

<cffunction name="RomanNumberFormat">
    <cfset var D = ListToArray('M,CM,D,C,XC,L,X,IX,V,IV,I') />
    <cfset var I = [1000,900,500,100,90,50,10,9,5,4,1] />
    <cfset var R = '' />
    <cfset var x = 1 />
    <cfset var A = Arguments[1] />
    <cfloop condition="A GT 0">
        <cfloop condition="A GTE I[x]">
            <cfset R &= D[x] />
            <cfset A -= I[x] />
        </cfloop>
        <cfset x++ />
    </cfloop>
    <cfreturn R />
</cffunction>

<cfoutput>
    #RomanNumberFormat(N)#
</cfoutput>

CFScript - 219..323 символов:

<cfscript>
    function RomanNumberFormat(A)
    {
        var D = ListToArray('M,CM,D,C,XC,L,X,IX,V,IV,I');
        var I = [1000,900,500,100,90,50,10,9,5,4,1];
        var R = '';
        var x = 1;
        while ( A > 0 )
        {
            while( A >= I[x] )
            {
                R &= D[x];
                A -= I[x];
            }
            x++;
        }
        return R;
    }

    WriteOutput( RomanNumberFormat(N) );
</cfscript>

Ответ 29

В С# (работает на .NET 4 RC), с 335 символами (если вы удалите постороннее форматирование).

using System;
using System.Linq;
class C
{
    static void Main()
    {
        Console.WriteLine(
                Console.ReadLine()
                .PadLeft(4,'0')
                .Select(d=>d-'0')
                .Zip(new[]{"  M","MDC","CLX","XVI"},(x,y)=>new{x,y})
                .Aggregate("",(r,t)=>r+
                                    new string(t.y[2],t.x%5/4)+
                                    new string(t.y[0],t.x%5/4*t.x/5)+
                                    new string(t.y[1],Math.Abs(t.x%5/4-t.x/5))+
                                    new string(t.y[2],t.x%5%4)));
    }
}

Я знаю, что он не превзошел текущий лучший ответ С# (182 символа), но это всего лишь один большой линейный LINQ. Как только я увидел raytracer, написанный как один запрос LINQ, я начал с этого подхода приближаться к гольф-кодам.

Поскольку этот подход является функциональным, я работаю над версией Haskell того же алгоритма (безусловно, будет короче).

Ответ 30

версия Haskell моего ответа С#/LINQ, 234 символа:

main=putStrLn.foldr(\(y,x)s->concat[s,r(a x)(y!!2),r(a x*div x 5)(y!!0),r(abs(a x-div x 5))(y!!1),r(mod(mod x 5)4)(y!!2)])"".zip["XVI","CLX","MDC","  M"].map(read.(:[])).take 4.(++"000").reverse=<<getLine
r=replicate
a x=div(mod x 5)4