17

编写一个程序，接受一个命令行参数 N 并打印出相应的Roman Numeral。

例如 N = 2009 应该打印 MMIX。

假设这应该适用于 0 < N < 3000。

（在圣诞节版玩我的第一轮代码高尔夫很开心，并认为这可能适合新年。谷歌搜索看看这是否在其他地方出现过，看起来没有，但如果这让我知道太难或太容易，或者规则需要改变。）

快乐MMIX！

4

31 回答 31

17

Perl：69 笔（数一下！）

包括调用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这篇文章（顺便说一句，它很巧妙）。

于 2009-01-14T21:46:32.147 回答
14

在 C# 中，作为扩展方法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();
    }
}

下划线应在相应字母上方的上划线为真正的罗马数字。

于 2008-12-27T02:49:21.317 回答
11

通用口齿不清（SBCL）。“wc -c”计算的 63 个字符。 

(format t "~@R~%" (parse-integer (elt *posix-argv* 1)))
(quit)

这仅适用于最多 3999 的数字。

于 2008-12-27T02:55:21.337 回答
6

C#：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;
    }
于 2008-12-27T03:49:49.913 回答
5

Perl，19 笔。保证适用于 1 到 12 之间的值。

sub r{chr 8543+pop}
于 2008-12-27T03:10:38.887 回答
5

语言：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 的原始帖子

于 2008-12-27T10:35:55.697 回答
4

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

（我第一次看到这个算法是在 Gimpel's Algorithms in Snobol4 中；Snobol 更优雅地表达了它。）

于 2008-12-27T08:28:29.820 回答
4

语言：C，字符数：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)}
于 2008-12-27T20:33:53.553 回答
3

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 脚本的样子。

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;
}
于 2008-12-27T05:57:25.460 回答
3

派克

60 个字符，有效范围为 0 到 10000：

int main (int c, array a) {
    write(String.int2roman((int)a[1]));
}
于 2008-12-27T06:14:18.907 回答
3

一个简单的 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)
于 2010-10-27T13:07:56.800 回答
2

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 特性：

  1. 哈希是由偶数长度的列表构成的。
  2. 可以使用紧凑的语法指定字符串列表，使用qw.
  3. 字符串可以自动强制转换为整数，如在<=>对键进行排序时使用的比较运算符。
  4. 有一个x操作员可以复制字符串/列表。不幸的是，在这里打高尔夫球，与 ;x具有相同的优先级/。如果/更高，括号也是可选的。
于 2008-12-27T05:41:38.537 回答
2

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 操作，返回 list 2 0 0 0 0 0 1 4。

然后#~使用前面的列表作为计数，将相应的字符拉出'MDCLXVI'。

于 2010-04-15T17:13:27.337 回答
2

红宝石，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
于 2009-01-02T10:27:42.777 回答
2

在 Python 中 - 取自ActiveState（学分：Paul Winkler）并压缩了一下：

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
于 2008-12-27T03:05:31.830 回答
2

语言：dc（通过 shell） 字符数：122

编辑： 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

编辑：通过优化主循环堆栈操作再增加两个字符

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
于 2008-12-27T10:22:27.487 回答
2

我不是 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')
于 2009-07-04T18:59:31.393 回答
1

来自一种叫做 LPC（Pike 的前身）的模糊的类 C 语言：

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;
}
于 2008-12-27T02:50:25.417 回答
1

Python，190 字节。基于来自ActiveState的片段，通过Federico。

一些小的优化：删除多余的 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！从balabaster偷了使用内联符号数组的想法。

于 2008-12-27T03:44:37.443 回答
1

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
于 2008-12-27T03:56:56.173 回答
1

Excel 8 个字符（不包括数字）：

=罗马（N）

工作量高达 3000。

舌在脸颊

于 2010-11-29T16:11:54.930 回答
0

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

}

“重要字符”是指打印字符和所需的空格（例如，类型和参数之间），但不是纯粹的装饰性空格（换行符和缩进）。

于 2008-12-27T05:09:59.143 回答
0

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个必要的空格，其余的都只是为了格式化。）

于 2008-12-27T05:51:30.277 回答
0

这是 252 个有意义的字符的 C 解决方案。从 0 <= i < 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])));
 }
于 2008-12-27T06:11:16.820 回答
0

语言：C，字符数：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);}
于 2008-12-27T07:35:54.873 回答
0

非常简单：将查询传递给 Google 并截取答案。下一个。:p

顺便说一句，这不应该是一个社区维基吗？

于 2008-12-27T02:41:56.540 回答
0

语言：Erlang，字符数：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].

编辑：受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

编辑：我使用文字宏扩展保存了 17 个字符。

于 2008-12-27T09:45:10.977 回答
0

Railo 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>
于 2009-01-02T22:49:06.857 回答
0

在 C# 中（在 .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)));
    }
}

我知道它并没有击败当前的最佳 C# 答案（182 个字符），但这只是一个大的 LINQ 单线。一旦我看到一个写成单个 LINQ 查询的光线追踪器，我就开始从这个角度接近代码高尔夫。

由于这种方法是有效的，我正在研究相同算法的 Haskell 版本（肯定会更短）。

于 2010-03-05T07:49:27.067 回答
0

我的C#/LINQ 答案的 Haskell 版本，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
于 2010-03-05T09:07:36.190 回答
0

哈斯克尔，245 个字符。

roman = numeral [(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")]
numeral [] n = ""
numeral ((m,c):xs) n = concat (replicate (n `div` m) c) ++ numeral xs (n `mod` m)
于 2010-11-29T17:24:54.733 回答