Выпуск нового года гольфа кода - целое число к римской цифре
28 ответов
Perl: 69 штрихов (считают их!)
Шестьдесят девять штрихов включая вызов жемчуга во-первых:
$ perl -ple's!.!($#.=5x$&*8%29628)=~y$IVCXL4620-8$XLMCDIXV$d!eg;last}{'
3484
MMMCDLXXXIV
- Читает одну строку, пишет одна строка.
- Работы от 0 до 3 999, включительно. (Пустая строка печати для 0.)
- На соревнованиях гольфа Perl это обычно выигрывается как 62 штриха = 58 для кода + 4 для переключателей.
- Да ведь да, им не соответствуют фигурные скобки.Спасибо за вопрос.=)
Кредиты: первоначально из-за Тонны Hospel. Прием, включающий несогласованные фигурные скобки, от rev.pl в этом сообщении (который несущественно, оригинально).
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>
Язык: 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);}
Язык: 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 символов с помощью литерального макрорасширения.
Вот решение C в 252 значимых символах. Допустимый от 0 < = я < 4000. Главным образом я записал это, потому что столько решений включает IV и IX в точках массива. Декодирование его: t является нашим временным буфером, что мы поддерживаем заливку так, чтобы мы не инвертировали его на выводе. Буфер передал в, должны быть по крайней мере 16 символов (для 3 888-> 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])));
}
Delphi (или Паскаль, нет ничего определенного для 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 существенные пробелы, все остальные просто для форматирования.)
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));
}
}
"значительными символами", я имею в виду символы печати и требуемые пространства (например, между типом и аргументом), но не чистый косметический пробел (новые строки и добавление отступа).
Реальный простой: передайте запрос Google и screenscrape ответ.Далее. :p
BTW, разве это не должно быть общественной Wiki?
Python, 190 байтов . На основе отрывка от ActiveState, через Federico.
Несколько маленьких оптимизаций: удаление лишнего интервала () вызов, разделяя строку для получения массива, удаляет пробел...
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.
От неопределенно подобного языку C названного LPC (предшественник Пики):
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;
}
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
Язык: dc (через оболочку) Символьное РЕДАКТИРОВАНИЕ count: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
В 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();
}
}
символы нижнего подчеркивания должны быть сверхстроками выше соответствующей буквы, чтобы быть истинной Римской цифрой.
Язык Common LISP (SBCL). 63 символа, считаемые "туалетом-c".
(format t "~@R~%" (parse-integer (elt *posix-argv* 1)))
(quit)
Это только работает на числа до 3 999.
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;
}
Perl, 19 штрихов. Гарантируемый работать на значения между 1 и 12.
sub r{chr 8543+pop}
Язык: 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)}
Язык: 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
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'
Вы вводите строку, она дает Вам Римскую цифру equivelent. Эта первая версия даже позволяет Вам ввести больше чем одну строку.
Вот более короткая версия, которая только работает на одну строку и игнорирует пограничные случаи. так 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;
}
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 выразил это более изящно.)
В 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
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, но у меня нет a say- способная версия Perl здесь. Не стесняйтесь вычитать 2 от штрихового количества при использовании say работы.:-)
Для программистов не-Perl эта программа использует много полезных функций Perl:
- Хеши создаются из списков даже длины.
- Списки строк могут быть указаны в компактном синтаксисе, с помощью
qw. - Строки могут автопринудить в целые числа, как используется в
<=>оператор сравнения в сортировке ключей. - Существует
xоператор, который делает копии строк/списков. К сожалению для игры в гольф здесь,xимеет идентичный приоритет к/; если/были выше, скобки будут дополнительными также.
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
Пика
60 символов, допустимых для от 0 до 10 000:
int main (int c, array a) {
write(String.int2roman((int)a[1]));
}
Я не эксперт по Haskell, и это слишком долго, чтобы быть победителем, но вот решение, которое я написал некоторое время назад для решения Эйлера № 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')
Haskell-версия моего ответа C # / 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
В 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 (конечно, она будет короче).
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' .