编写一个程序，该程序采用单个命令行参数N并打印出相应的Roman Numeral。
例如，N = 2009应打印MMIX。
让我们说这应该适用于0＆lt; N＆lt; 3000。
（在Christmas edition玩我的第一轮代码高尔夫玩得很开心，并认为这适合新年。用Google搜索，看看它是否在其他地方出现，看起来没有，但如果这太难或太容易，或者规则需要改变，请告诉我。）
快乐的MMIX！
答案 0 :(得分：17)
第六次包括调用perl：
$ perl -ple's!.!($#.=5x$&*8%29628)=~y$IVCXL4620-8$XLMCDIXV$d!eg;last}{'
3484
MMMCDLXXXIV
致谢：最初归于Ton Hospel。涉及不匹配括号的技巧来自this post中的rev.pl（顺便提一下，巧妙）。
答案 1 :(得分：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();
}
}
下划线应在相应的字母上方拼写为真正的罗马数字。
答案 2 :(得分：11)
Common lisp（SBCL）。由“wc -c”计算的63个字符。
(format t "~@R~%" (parse-integer (elt *posix-argv* 1)))
(quit)
这仅适用于最高3999的数字。
答案 3 :(得分：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;
}
答案 4 :(得分：5)
sub r{chr 8543+pop}
答案 5 :(得分：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的原帖
答案 6 :(得分：4)
#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)}
答案 7 :(得分：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的算法中的Snobol4 ; Snobol更优雅地表达了它。）
答案 8 :(得分：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;
}
答案 9 :(得分：3)
答案 10 :(得分：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)
答案 11 :(得分：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能力的Perl版本。如果使用say，可以随意减去2次中风计数。 ： - ）
对于非Perl程序员，该程序利用了许多有用的Perl功能：
qw <=>比较运算符在排序键时使用的那样。x运算符可以复制字符串/列表。不幸的是，在这里打高尔夫球，x的优先级与/相同;如果/更高，则括号也是可选的。答案 12 :(得分：2)
'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'中提取相应的字符。
答案 13 :(得分：2)
编辑：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
答案 14 :(得分：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
答案 15 :(得分：2)
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 :(得分：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')
答案 17 :(得分：1)
Excel 8个字符（不包括数字）：
= ROMAN（N）
最多可达3000个。
舌头在脸颊
答案 18 :(得分：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
答案 19 :(得分：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开始使用符号数组内联的想法。
答案 20 :(得分：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;
}
答案 21 :(得分：0)
Haskell，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)
答案 22 :(得分：0)
真的很简单：将查询传递给Google，然后屏幕显示答案。下一个。 ：P
顺便说一下，这不应该是社区维基吗？答案 23 :(得分：0)
我的C#/LINQ answer的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
答案 24 :(得分：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单线程。一旦我看到一个写成a single LINQ query的光线跟踪器，我开始从这个角度接近代码高尔夫球。
由于这种方法是有效的，我正在研究相同算法的Haskell版本（肯定会更短）。
答案 25 :(得分：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>
答案 26 :(得分：0)
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 version（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个字符。
答案 27 :(得分：0)
语言：C，字数：195
严重基于me.yahoo.com/joe_mucchielle's C solution：
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);}
答案 28 :(得分：0)
这是一个有效的252个字符的C解决方案。有效期为0＆lt; = i＆lt; 4000.我写这篇文章的原因很多，因为许多解决方案包括阵列点的IV和IX。解码它：t是我们回填的临时缓冲区，这样我们就不必在输出时反转它。传入的缓冲区必须至少为16个字符（对于3888 - ＆gt; 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])));
}
答案 29 :(得分：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个必要的空格，其余的只是用于格式化。）
答案 30 :(得分：0)
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));
}
}
“重要字符”是指打印字符和所需空格（例如类型和参数之间），但不是纯化妆空白（换行符和缩进）。