blocks|key|1662941|text|非常简单:将查询传递给Google并截取答案。下一个。:p|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1662942|顺便说一句，这不应该是一个社区维基吗？|1662943|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Real simple: pass the query to Google and screenscrape the answer. Next. :p

BTW, shouldn't this be a community wiki?

blocks|key|1663001|text|在C#中，作为Int32的扩展方法|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1663002|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();
++++}
}|code-block|syntax|javascript|1663003|下划线应在相应字母上方加下划线，以使其为真正的罗马数字。|1663004|entityMap^0|7|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

In C#, as an extension method to <code>Int32</code>:

<pre><code>public static class Int32Extension {
 public static string ToRomanNumeral(this int number) {
 Dictionary&lt;int, string&gt; lookup = new Dictionary&lt;int, string&gt;() {
 { 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 =&gt; -1 * k)) {
 while (number &gt;= key) {
 number -= key;
 answer.Append(lookup[key]);
 }
 }
 return answer.ToString();
 }
}
</code></pre>

The underscores should be overlines above the respective letter to be true Roman Numeral.

blocks|key|1663055|text|来自一种模糊的类似C的语言，叫做LPC+(Pike的前身)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663056|string+roman_numeral(int+val)+{
++++check_argument(1,+val,+#'intp);
++++unless(val)
++++++++return+"N";
++++string+out+=+"";
++++if(val+<+0)+{
++++++++out+%2B=+"-";
++++++++val+=+-val;
++++}
++++if(val+>=+1000)+{
++++++++out+%2B=+"M"+*+(val+/+1000);
++++++++val+%25=+1000;
++++}
++++if(val+>=+100)+{
++++++++int+part+=+val+/+100;
++++++++switch(part)+{
++++++++case+9++++++:
++++++++++++out+%2B=+"CM";
++++++++++++break;
++++++++case+6+..+8+:
++++++++++++out+%2B=+"D"+%2B+("C"+*+(part+-+5));
++++++++++++break;
++++++++case+5++++++:
++++++++++++out+%2B=+"D";
++++++++++++break;
++++++++case+4++++++:
++++++++++++out+%2B=+"CD";
++++++++++++break;
++++++++default+++++:
++++++++++++out+%2B=+"C"+*+part;
++++++++++++break;
++++++++}
++++++++val+%25=+100;
++++}
++++if(val+>=+10)+{
++++++++int+part+=+val+/+10;
++++++++switch(part)+{
++++++++case+9++++++:
++++++++++++out+%2B=+"XC";
++++++++++++break;
++++++++case+6+..+8+:
++++++++++++out+%2B=+"L"+%2B+("X"+*+(part+-+5));
++++++++++++break;
++++++++case+5++++++:
++++++++++++out+%2B=+"L";
++++++++++++break;
++++++++case+4++++++:
++++++++++++out+%2B=+"XL";
++++++++++++break;
++++++++default+++++:
++++++++++++out+%2B=+"X"+*+part;
++++++++++++break;
++++++++}
++++++++val+%25=+10;
++++}
++++switch(val)+{
++++case+9++++++:
++++++++out+%2B=+"IX";
++++++++break;
++++case+6+..+8+:
++++++++out+%2B=+"V"+%2B+("I"+*+(val+-+5));
++++++++break;
++++case+5++++++:
++++++++out+%2B=+"V";
++++++++break;
++++case+4++++++:
++++++++out+%2B=+"IV";
++++++++break;
++++default+++++:
++++++++out+%2B=+"I"+*+val;
++++++++break;
++++}
++++return+out;
}|code-block|syntax|javascript|1663057|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

From a vaguely C-like language called LPC (precursor of Pike):

<pre><code>string roman_numeral(int val) {
 check_argument(1, val, #'intp);
 unless(val)
 return "N";
 string out = "";
 if(val &lt; 0) {
 out += "-";
 val = -val;
 }
 if(val &gt;= 1000) {
 out += "M" * (val / 1000);
 val %= 1000;
 }
 if(val &gt;= 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 &gt;= 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;
}
</code></pre>

blocks|key|1663094|text|通用lisp+(SBCL)。通过"wc+-c“统计63个字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663095|(format+t+"~@R~%25"+(parse-integer+(elt+*posix-argv*+1)))
(quit)|code-block|syntax|javascript|1663096|这只适用于3999以下的数字。|1663097|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Common lisp (SBCL). 63 characters counted by "wc -c". 

<pre><code>(format t "~@R~%" (parse-integer (elt *posix-argv* 1)))
(quit)
</code></pre>

This only works for numbers upto 3999.

blocks|key|1663144|text|在Python中-取自ActiveState+(制片人:+Paul+Winkler)，并压缩了一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1663145|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+%2B=+nums[i]+*+count
++++++n+-=+ints[i]+*+count
+++return+result|code-block|syntax|javascript|1663146|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/81611/^0|B|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

In Python - taken from <a href="http://code.activestate.com/recipes/81611/" rel="nofollow noreferrer">ActiveState</a> (credits: Paul Winkler) and compressed a bit:

<pre><code>def int2roman(n):
 if not 0 &lt; n &lt; 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
</code></pre>

blocks|key|1663173|text|Perl，19个笔划。保证对1到12之间的值有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663174|sub+r{chr+8543%2Bpop}|code-block|syntax|javascript|1663175|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Perl, 19 strokes. Guaranteed to work for values between 1 and 12.

<pre><code>sub r{chr 8543+pop}
</code></pre>

blocks|key|1448353|text|C#：179个字符(不包括空格/制表符)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1448354|++++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%2B%2B+)
++++++++++++while+(a+>=+v[i])
++++++++++++{
++++++++++++++++a+-=+v[i];
++++++++++++++++s+%2B=+"M+CM+D+CD+C+XC+L+XL+X+IX+V+IV+I".Split()[i];
++++++++++++}
++++++++return+s;
++++}|code-block|syntax|javascript|1448355|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

C#: 179 chars (not including spaces/tabs)

<pre><code> 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 &lt; 13; i++ )
 while (a &gt;= v[i])
 {
 a -= v[i];
 s += "M CM D CD C XC L XL X IX V IV I".Split()[i];
 }
 return s;
 }
</code></pre>

blocks|key|1663247|text|VB:+193个字符|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663248|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+%2B=+"M%7CCM%7CD%7CCD%7CC%7CXC%7CL%7CXL%7CX%7CIX%7CV%7CIV%7CI".Split("%7C")(i)
++++++++End+While
++++Next
++++Return+s
End+Function|code-block|syntax|javascript|1663249|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

VB: 193 chars

<pre><code>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 &gt;= 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
</code></pre>

blocks|key|1448400|text|Java:+286个有效字符|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1448401|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%2Bx[i],d-n[i],i):p(s,d,i%2B1);}

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

}|code-block|syntax|javascript|1448402|所谓“有效字符”，我指的是打印字符和所需的空格(例如，在类型和参数之间)，而不是纯粹的修饰空格(换行符和缩进)。|1448403|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>Java: 286 significant characters</h2>

<pre><code>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&lt;=i?s:n[i]&lt;=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));
 }

}
</code></pre>

By "significant characters", I mean the printing characters and required spaces (e.g. between type and argument), but not pure cosmetic whitespace (newlines and indentation).

blocks|key|1663333|text|Delphi+(或Pascal，这里没有任何特定于Delphi的东西)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663334|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+%2B+T[I];
++++++++N+:=+N+-+V[I];
++++Until+N+=+0;
End;|code-block|syntax|javascript|1663335|如何让每个人都得到角色的重要性？(我数了8个必要的空格，其余的都只是为了格式化。)|1663336|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Delphi (or Pascal, there's nothing Delphi-specific here):

<pre><code>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 &lt; V[I] do Inc(I);
 Result := Result + T[I];
 N := N - V[I];
 Until N = 0;
End;
</code></pre>

How is everyone getting the character counts? (I count 8 essential spaces, all the rest are simply for formatting.)

blocks|key|1663371|text|Perl+5.10|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1663372|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));$_%25=$c;}say$o'|code-block|syntax|javascript|1663373|你输入一行，它会给你一个罗马数字的等价物。第一个版本甚至允许您输入多行。|1663374|下面是一个更短的版本，它只适用于一行，并且忽略了边缘情况。所以4变成了IIII而不是IV。|1663375|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));$_%25=$c;}say$o'|1663376|下面是第一个版本作为Perl脚本的样子。|1663377|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);

++++$_+%25=+$c;
++}
++say+$o;
}|1663378|entityMap^0|0|9|0|0|0|V|1|Z|4|16|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|19|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|V|$]]

<h2><code>Perl 5.10</code></h2>
<pre><code>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=&quot;&quot;;while(@l){$o.=pop(@l)x($_/($c=pop @l));$_%=$c;}say$o'
</code></pre>
You input a line, it gives you the Roman numeral equivelent. This first version even lets you input more than one line.
Here is a shorter version that only works for one line, and ignores edge cases. so <code>4</code> becomes <code>IIII</code> instead of <code>IV</code>.
<pre><code>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'
</code></pre>
Here is what the first version would look like as a Perl script.
<pre><code>use 5.010;
while(&lt;&gt;){
 @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=&quot;&quot;;
 while(@l){
 $o .= pop(@l) x ($_/($c=pop @l));
 # $l = pop @l;
 # $c = pop @l;
 # $o .= $l x ($_/$c);

 $_ %= $c;
 }
 say $o;
}
</code></pre>

blocks|key|1663443|text|这是一个包含252个有意义的字符的C解决方案。从0+<=+I<+4000开始有效。我之所以写这篇文章，主要是因为很多解决方案都在数组点处包含了IV和IX。解码它:t是我们的临时缓冲区，我们回填它，这样我们就不必在输出时反转它。传入的缓冲区必须至少为16个字符(对于3888+->+MMMDCCCLXXXVIII)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663444|+char*+i2r(int+i,+char*+r)+{
+++++char+t[20];
+++++char*+o=t%2B19;*o=0;
+++++char*+s="IVXLCDMM";
+++++for+(char*p=s%2B1;*p&&i;p%2B=2)+{
+++++++++int+x=i%2510;
+++++++++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);
+}|code-block|syntax|javascript|1663445|我总是忘了把电源打开。以下是252个字符的内容：|1663446|+#include+<stdio.h>
+#include+<string.h>
+#include+<stdlib.h>
+void+main(int+a,char**v){
+++++char+buf[16];
+++++printf("%25s\n",i2r(atoi(v[1])));
+}|1663447|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is a C solution in 252 meaningful chars. Valid from 0 &lt;= i &lt; 4000. Mostly I wrote this because so many solutions include IV and IX at array points. Decoding it: t is our temp buffer that we back fill so that we don't have to reverse it on output. The buffer passed in must be at least 16 chars (for 3888 -> MMMDCCCLXXXVIII).

<pre><code> char* i2r(int i, char* r) {
 char t[20];
 char* o=t+19;*o=0;
 char* s="IVXLCDMM";
 for (char*p=s+1;*p&amp;&amp;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&amp;&amp;x!=5;--x)*--o=p[-1];
 if(x)*--o=*p;
 }
 i/=10;
 }
 return strcpy(r,o);
 }
</code></pre>

And I always forget to put the main on. So much for 252 chars:

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

blocks|key|1663470|text|Pike|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1663471|60个字符，有效范围为0-+10000：|1663472|int+main+(int+c,+array+a)+{
++++write(String.int2roman((int)a[1]));
}|code-block|syntax|javascript|1663473|entityMap|0|LINK|mutability|MUTABLE|url|http://pike.ida.liu.se/generated/manual/modref/ex/predef_3A_3A/String/int2roman.html^0|0|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<h2><a href="http://pike.ida.liu.se/generated/manual/modref/ex/predef_3A_3A/String/int2roman.html" rel="nofollow noreferrer">Pike</a></h2>

60 characters, valid for 0 to 10000:

<pre><code>int main (int c, array a) {
 write(String.int2roman((int)a[1]));
}
</code></pre>

blocks|key|1448655|text|语言:+Erlang，字符计数:+222|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1448656|EDIT2:+Erlang预处理器允许一些不平衡的宏，所以这个版本少了9个字符。|1448657|-module(n2).
-export([y/1]).
-define(D(V,S),n(N)when+N>=V->[??S%7Cn(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].|code-block|syntax|javascript|1448658|编辑:受Darius+version启发的简短版本(231个字符)|offset|length|1448659|-module(n).
-export([y/1]).
y(N)->io:format([n(N),10]).
n(N)when+N>9->[Y%7C%7CC<-n(N+div+10),{K,Y}<-lists:zip("IVXLC","XLCDM"),K==C]%2B%2Bo(N+rem+10);n(N)->o(N).
o(N)->lists:nth(N%2B1,[[]%7Cstring:tokens("I+II+III+IV+V+VI+VII+VIII+IX","+")]).|1448660|它的可读性较差，但节省了2个字符(233个字符)。|1448661|-module(n).
-export([y/1]).
-define(D(V,S),n(N)when+N>=V->[??S%7Cn(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].|1448662|命令行版本：|1448663|-module(n).
-export([y/1]).
-define(D(V,S),n(N)when+N>=V->[??S%7Cn(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].|1448664|调用：|1448665|$+erl+-noshell+-noinput+-run+n+y+2009
MMIX|1448666|编辑:我使用文字宏展开法节省了17个字符。|1448667|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/394574/code-golf-new-year-edition-integer-to-roman-numeral#394807^0|0|0|0|4|E|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1D|8|@]|9|@$K|1E|L|1F|1|1G]]|A|$]]|$1|M|3|N|5|F|7|1H|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1J|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1L|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1N|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|1O|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]]]

<h3>Language: Erlang, Char count: 222</h3>

EDIT2: Erlang preprocessor allows some sort of unbalanced macros so this version is 9 chars shorter.

<pre><code>-module(n2).
-export([y/1]).
-define(D(V,S),n(N)when N&gt;=V-&gt;[??S|n(N-V)];).
y(N)-&gt;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)-&gt;[10].
</code></pre>

EDIT: Shorter version inspired by <a href="https://stackoverflow.com/questions/394574/code-golf-new-year-edition-integer-to-roman-numeral#394807">Darius version</a> (231 chars)

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

It's less readable but save 2 chars (233 chars).

<pre><code>-module(n).
-export([y/1]).
-define(D(V,S),n(N)when N&gt;=V-&gt;[??S|n(N-V)]).
y(N)-&gt;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)-&gt;[10].
</code></pre>

Command line version:

<pre><code>-module(n).
-export([y/1]).
-define(D(V,S),n(N)when N&gt;=V-&gt;[??S|n(N-V)]).
y([N])-&gt;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)-&gt;[10].
</code></pre>

Invocation:

<pre><code>$ erl -noshell -noinput -run n y 2009
MMIX
</code></pre>

EDIT: I saved 17 chars using literal macro expansion.

blocks|key|1663583|text|语言:+dc+(通过shell)字符计数:122|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663584|编辑:Q等同于2Q|1663585|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|code-block|syntax|javascript|1663586|编辑:通过优化主循环堆栈操作，增加两个字符|1663587|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|1663588|编辑:保存2个字符|1663589|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|1663590|以前的版本：|1663591|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|1663592|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

<h3>Language: dc (through shell) Char count:122</h3>

EDIT: q is equivalent of 2Q

<pre><code>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!&lt;qrdPr1-lbx]dsbxLarz3&lt;c]dscx10P' &lt;&lt;&lt;$1
</code></pre>

EDIT: two more chars by optimizing main loop stack manipulations

<pre><code>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!&lt;qrdPr1-lbx]dsbxLarz3&lt;c]dscx10P' &lt;&lt;&lt;$1
</code></pre>

EDIT: save 2 chars

<pre><code>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!&lt;qSardPrLa1-lbx]dsbxrszz2&lt;c]dscx10P' &lt;&lt;&lt;$1
</code></pre>

Previous version:

<pre><code>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!&lt;qSaSadPLaLa1-lbx]dsbxrszz2&lt;c]dscx10P' &lt;&lt;&lt;$1
</code></pre>

blocks|key|1448748|text|语言:+C，字符计数:+174|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1448749|#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)}|code-block|syntax|javascript|1448750|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h3>Language: C, Char count: 174</h3>

<pre><code>#define R(s,v)for(;n&gt;=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)}
</code></pre>

blocks|key|1663675|text|我不是Haskell专家，这对于赢家来说太长了，但这是我前段时间写的一个解决方案，用来解决Euler+#89。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663676|toRoman+0+=+""
toRoman+1+=+"I"
toRoman+2+=+"II"
toRoman+3+=+"III"
toRoman+4+=+"IV"
toRoman+n
%7C+n+>=+1000+=+repeatRoman+'M'+1000
%7C+n+>=+900+=+subtractRoman+"CM"+900
%7C+n+>=+500+=+subtractRoman+"D"+500
%7C+n+>=+400+=+subtractRoman+"CD"+400
%7C+n+>=+100+=+repeatRoman+'C'+100
%7C+n+>=+90+=+subtractRoman+"XC"+90
%7C+n+>=+50+=+subtractRoman+"L"+50
%7C+n+>=+40+=+subtractRoman+"XL"+40
%7C+n+>=+10+=+repeatRoman+'X'+10
%7C+n+>=+9+=+subtractRoman+"IX"+9
%7C+n+>=+5+=+subtractRoman+"V"+5
%7C+otherwise+=+error+"Hunh?"
where
++++repeatRoman+c+n'+=+(take+(n+`div`+n')+(repeat+c))+%2B%2B+(toRoman+$+n+`mod`+n')
++++subtractRoman+s+n'+=+s+%2B%2B+(toRoman+$+n+-+n')|code-block|syntax|javascript|1663677|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'm no Haskell expert, and this is too long to be a winner, but here's a solution I wrote a while back to solve Euler #89.

<pre><code>toRoman 0 = ""
toRoman 1 = "I"
toRoman 2 = "II"
toRoman 3 = "III"
toRoman 4 = "IV"
toRoman n
| n &gt;= 1000 = repeatRoman 'M' 1000
| n &gt;= 900 = subtractRoman "CM" 900
| n &gt;= 500 = subtractRoman "D" 500
| n &gt;= 400 = subtractRoman "CD" 400
| n &gt;= 100 = repeatRoman 'C' 100
| n &gt;= 90 = subtractRoman "XC" 90
| n &gt;= 50 = subtractRoman "L" 50
| n &gt;= 40 = subtractRoman "XL" 40
| n &gt;= 10 = repeatRoman 'X' 10
| n &gt;= 9 = subtractRoman "IX" 9
| n &gt;= 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')
</code></pre>

blocks|key|1663733|text|在C#+(在.NET+4+RC上运行)中，包含335个字符(如果删除了无关的格式)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663734|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%2B
++++++++++++++++++++++++++++++++++++new+string(t.y[2],t.x%255/4)%2B
++++++++++++++++++++++++++++++++++++new+string(t.y[0],t.x%255/4*t.x/5)%2B
++++++++++++++++++++++++++++++++++++new+string(t.y[1],Math.Abs(t.x%255/4-t.x/5))%2B
++++++++++++++++++++++++++++++++++++new+string(t.y[2],t.x%255%254)));
++++}
}|code-block|syntax|javascript|1663735|我知道它不能击败当前最好的C#答案(182个字符)，但这只是一个很大的LINQ一行。有一次我看到一个写成a+single+LINQ+query的光线跟踪器，我开始从这个角度开始接触code+golfs。|offset|length|1663736|由于这种方法是有效的，我正在研究相同算法的Haskell版本(肯定会更短)。|1663737|entityMap|0|LINK|mutability|MUTABLE|url|http://dotnetkicks.com/linq/Taking_LINQ_to_Objects_to_Extremes_A_fully_LINQified_RayTracer^0|0|0|1G|J|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

In C# (running on .NET 4 RC), with 335 chars (if you remove the extraneous formatting).

<pre><code>using System;
using System.Linq;
class C
{
 static void Main()
 {
 Console.WriteLine(
 Console.ReadLine()
 .PadLeft(4,'0')
 .Select(d=&gt;d-'0')
 .Zip(new[]{" M","MDC","CLX","XVI"},(x,y)=&gt;new{x,y})
 .Aggregate("",(r,t)=&gt;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)));
 }
}
</code></pre>

I know it does not beat the current best C# answer (182 chars) but this is just one big LINQ one-liner. Once I saw a raytracer written as <a href="http://dotnetkicks.com/linq/Taking_LINQ_to_Objects_to_Extremes_A_fully_LINQified_RayTracer" rel="nofollow noreferrer">a single LINQ query</a>, I started approaching code golfs from this perspective.

Since this approach is functional, I'm working on a Haskell version of the same algorithm (will surely be shorter).

blocks|key|1448879|text|我的C#/LINQ+answer的哈斯克尔版本，234个字符：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1448880|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.(%2B%2B"000").reverse=<<getLine
r=replicate
a+x=div(mod+x+5)4|code-block|syntax|javascript|1448881|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/394574/code-golf-new-year-edition-integer-to-roman-numeral/2385261#2385261^0|2|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Haskell version of my <a href="https://stackoverflow.com/questions/394574/code-golf-new-year-edition-integer-to-roman-numeral/2385261#2385261">C#/LINQ answer</a>, 234 chars:

<pre><code>main=putStrLn.foldr(\(y,x)s-&gt;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=&lt;&lt;getLine
r=replicate
a x=div(mod x 5)4
</code></pre>

blocks|key|1663782|text|J，20个字符！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1663783|'MDCLXVI'#~(7$5+2)#:|code-block|syntax|javascript|1663784|用法：|1663785|+++'MDCLXVI'#~(7$5+2)#:+2009
MMVIIII|1663786|好吧，它不能正确地做减法，但是嘿，它很酷！|1663787|解释；|1663788|(7$5+2)|offset|length|style|CODE|1663789|这将接受正确的参数(+list+5+2)，并将其转换为一个大小为7的list+-即5+2+5+2+5+2+5。|1663790|(7$5+2)#:+2009|1663791|这做了“反基础”操作--基本上做了迭代的div和mod操作，返回列表2+0+0+0+0+0+1+4。|1663792|然后，#~使用前面的列表作为计数，从'MDCLXVI'中提取相应的字符。|1663793|entityMap^0|0|0|0|0|0|0|0|7|0|G|3|15|D|0|0|E|0|Y|F|0|3|2|I|9|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$Q|1B|R|1C|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@$Q|1E|R|1F|S|T]|$Q|1G|R|1H|S|T]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1I|8|@$Q|1J|R|1K|S|T]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1L|8|@$Q|1M|R|1N|S|T]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1O|8|@$Q|1P|R|1Q|S|T]|$Q|1R|R|1S|S|T]]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|13|$]]

<h2>J, 20 characters!</h2>

<pre><code>'MDCLXVI'#~(7$5 2)#:
</code></pre>

Usage:

<pre><code> 'MDCLXVI'#~(7$5 2)#: 2009
MMVIIII
</code></pre>

Okay, it doesn't do subtraction properly, but hey it's pretty cool!

Explanation;

<code>(7$5 2)</code>

This takes the right argument (the list <code>5 2</code>) and turns it into a list of size 7 - namely <code>5 2 5 2 5 2 5</code>.

<code>(7$5 2)#: 2009</code>

This does the "anti-base" operation - basically doing iterative div and mod operations, returning the list <code>2 0 0 0 0 0 1 4</code>.

Then <code>#~</code> uses the previous list as a tally to pull corresponding characters out of <code>'MDCLXVI'</code>.

blocks|key|1448947|text|Excel+8个字符(不包括数字)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1448948|=罗马(N)|1448949|最高可达3000。|1448950|开个玩笑|1448951|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Excel 8 chars (not lincluding the number): 

=ROMAN(N) 

Works up to 3000. 

Tongue in cheek

blocks|key|1448962|text|哈斯克尔，245个字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1448963|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)+%2B%2B+numeral+xs+(n+`mod`+m)|code-block|syntax|javascript|1448964|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Haskell, 245 charaters.

<pre><code>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)
</code></pre>

Write a program that take a single command line argument N and prints out the corresponding <a href="http://en.wikipedia.org/wiki/Roman_numerals" rel="nofollow noreferrer">Roman Numeral</a>.

Eg N = 2009 should print MMIX.

Let's say this should work for 0 &lt; N &lt; 3000.

(Had fun playing my first ever round of code golf with the <a href="https://stackoverflow.com/questions/392788/code-golf-christmas-edition-how-to-print-out-a-christmas-tree-of-height-n">Christmas edition</a>, and thought this could fit for New Year. Googled to see if this has come up before elsewhere and it looks like it hasn't, but let me know if this is too hard or too easy or if the rules need changing. )

Happy MMIX!

Code Golf New Year Edition - Integer to Roman Numeral

Python

Erlang

Java

Perl

编写一个带有单个命令行参数N的程序，并打印出相应的。例如N= 2009应打印MMIX。假设这应该适用于0<N< 3000。(用打我的第一轮代码高尔夫很有趣，我想这可以用来迎接新年。我谷歌了一下，看看以前是否在其他地方出现过这个问题，看起来没有，但请让我知道这是太难还是太容易，或者规则是否需要改变。)MMIX快乐！

问Code Golf新年版-从整数到罗马数字
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Code Golf新年版-从整数到罗马数字EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Code Golf新年版-从整数到罗马数字
EN