Viết chương trình đếm từ 1 đến 100 bằng Chữ số La Mã và in các số này theo đầu ra tiêu chuẩn. Mỗi một số phải được phân cách bằng dấu cách.

Bạn không thể sử dụng bất kỳ hàm dựng sẵn nào để chuyển đổi thành chữ số La Mã cũng như ứng dụng hoặc thư viện bên ngoài để làm như vậy.

Kết quả mong muốn là

I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI XVII XVIII XIX XX XXI XXII XXIII XXIV XXV XXVI XXVII XXVIII XXIX XXX XXXI XXXII XXXIII XXXIV XXXV XXXVI XXXVII XXXVIII XXXIX XL XLI XLII XLIII XLIV XLV XLVI XLVII XLVIII XLIX L LI LII LIII LIV LV LVI LVII LVIII LIX LX LXI LXII LXIII LXIV LXV LXVI LXVII LXVIII LXIX LXX LXXI LXXII LXXIII LXXIV LXXV LXXVI LXXVII LXXVIII LXXIX LXXX LXXXI LXXXII LXXXIII LXXXIV LXXXV LXXXVI LXXXVII LXXXVIII LXXXIX XC XCI XCII XCIII XCIV XCV XCVI XCVII XCVIII XCIX C

Vì nó là một thử thách golf mã, mã ngắn nhất sẽ thắng .

Perl 69 byte

s;.;y/XVI60-9/CLXVIX/dfor$a[$_].="32e$&"%72726;gefor 1..100;print"@a"

Hoạt động bằng công thức ma thuật. Biểu thức "32e$&"%72726biến đổi từng chữ số theo cách sau:
0⇒32, 1⇒320, 2⇒3200, 3⇒32000, 4⇒29096, 5⇒56, 6⇒560, 7⇒5600, 8⇒56000, 9⇒50918

Sau khi áp dụng bản dịch y/016/IXV/, chúng tôi có cái này thay thế:
0⇒32, 1⇒32 I , 2⇒32 II , 3⇒32 III , 4⇒29 I 9 V , 5⇒5 V , 6⇒5 VI , 7⇒5 VII , 8⇒5 VIII , 9⇒5 I 9 X 8

Phần còn lại của các chữ số ( 2-57-9) được loại bỏ. Lưu ý rằng điều này có thể được cải thiện bằng một byte bằng cách sử dụng một công thức mà dịch 012thay vì 016, đơn giản hóa /XVI60-9/để /XVI0-9/. Tôi không thể tìm thấy một cái, nhưng có lẽ bạn sẽ gặp may mắn hơn.

Khi một chữ số đã được chuyển đổi theo cách này, quy trình sẽ lặp lại cho chữ số tiếp theo, nối thêm kết quả và dịch các chữ số trước XVIsang CLXcùng lúc dịch cho chữ số mới xảy ra.

Cập nhật
Tìm kiếm đầy đủ không tiết lộ bất cứ điều gì ngắn hơn. Tôi đã làm, tuy nhiên, tìm một giải pháp 69 byte thay thế:

s;.;y/XVI0-9/CLXIXV/dfor$a[$_].="57e$&"%474976;gefor 1..100;print"@a"

Cái này sử dụng 0-2thay thế cho IXV, nhưng có một modulo dài hơn một chữ số.

Cập nhật: 66 65 byte

Phiên bản này là khác biệt đáng chú ý, vì vậy tôi có lẽ nên nói một vài từ về nó. Công thức nó sử dụng thực sự dài hơn một byte!

Không thể rút ngắn công thức nhiều hơn nó, tôi quyết định đánh golf những gì tôi có. Nó đã không lâu cho đến khi tôi nhớ người bạn cũ của tôi $\. Khi một đạo luật printđược ban hành, $\sẽ tự động được thêm vào cuối của đầu ra. Tôi đã có thể thoát khỏi $a[$_]cấu trúc khó xử để cải thiện hai byte:

s;.;y/XVI60-9/CLXVIX/dfor$\.="32e$&"%72726;ge,$\=!print$"for 1..100

Tốt hơn nhiều, nhưng điều đó $\=!print$"vẫn có vẻ hơi dài dòng. Sau đó, tôi nhớ một công thức thay thế có độ dài bằng nhau mà tôi đã tìm thấy không chứa số 3trong bất kỳ biến đổi chữ số nào của nó. Vì vậy, nó có thể được sử dụng $\=2+printthay thế và thay thế kết quả 3bằng một khoảng trắng:

s;.;y/XVI0-9/CLXIIX V/dfor$\.="8e$&"%61535;ge,$\=2+print for 1..100

Cũng 67 byte, do khoảng trắng cần thiết giữa printvà for.

Chỉnh sửa : Điều này có thể được cải thiện bởi một byte, bằng cách di chuyển printvề phía trước:

$\=2+print!s;.;y/XVI0-9/CLXIIX V/dfor$\.="8e$&"%61535;gefor 1..100

Bởi vì sự thay thế cần phải đánh giá hoàn toàn trước print, việc chuyển nhượng $\vẫn sẽ diễn ra sau cùng. Xóa khoảng trắng giữa gevà forsẽ đưa ra cảnh báo khấu hao, nhưng nếu không thì hợp lệ.

Nhưng, nếu có một công thức không sử dụng ở 1bất cứ đâu, $\=2+printsẽ trở thành $\=printmột khoản tiết kiệm trị giá hai byte khác. Ngay cả khi nó dài hơn một byte, nó vẫn sẽ là một cải tiến.

Hóa ra, một công thức như vậy tồn tại, nhưng nó dài hơn một byte so với ban đầu, dẫn đến số điểm cuối cùng là 65 byte :

$\=print!s;.;y/XVI60-9/CLXXI V/dfor$\.="37e$&"%97366;gefor 1..100

Phương pháp luận

Câu hỏi đã được hỏi làm thế nào người ta có thể đi tìm một công thức như vậy. Nói chung, việc tìm ra một công thức ma thuật để khái quát bất kỳ tập hợp dữ liệu nào là vấn đề xác suất. Đó là, bạn muốn chọn một hình thức có khả năng nhất có thể để tạo ra một cái gì đó tương tự với kết quả mong muốn.

Kiểm tra một vài chữ số La Mã đầu tiên:

0:
1: I
2: II
3: III
4: IV
5: V
6: VI
7: VII
8: VIII
9: IX

có một số thường xuyên được nhìn thấy. Cụ thể, từ 0-3 và sau đó lại từ 5-8 , mỗi thuật ngữ liên tiếp tăng chiều dài thêm một chữ số. Nếu chúng ta muốn tạo ánh xạ từ chữ số sang chữ số, chúng ta sẽ muốn có một biểu thức cũng tăng chiều dài thêm một chữ số cho mỗi thuật ngữ liên tiếp. Một lựa chọn logic là k • 10 ^d trong đó d là chữ số tương ứng và k là hằng số nguyên bất kỳ.

Điều này hoạt động cho 0-3 , nhưng 4 cần phải phá vỡ mô hình. Những gì chúng ta có thể làm ở đây là giải quyết một modulo:
k • 10 ^d % m , trong đó m nằm ở đâu đó giữa k • 10 ³ và k • 10 ⁴ . Điều này sẽ khiến phạm vi 0-3 không bị ảnh hưởng và sửa đổi 4 sao cho nó không chứa bốn Igiây. Nếu chúng tôi bổ sung hạn chế thuật toán tìm kiếm của chúng tôi sao cho dư lượng mô-đun là 5 , hãy gọi nó là j , nhỏ hơn m / 1000 , điều này sẽ đảm bảo rằng chúng tôi cũng có độ đều đặn từ 5-8 . Kết quả là một cái gì đó như thế này:

0: k
1: k0
2: k00
3: k000
4: ????
5: j
6: j0
7: j00
8: j000
9: ????

Như bạn có thể thấy, nếu chúng tôi thay thế 0bằng I, 0-3 và 5-8 đều được đảm bảo để được ánh xạ chính xác! Các giá trị cho 4 và 9 cần phải được ép buộc mặc dù. Cụ thể, 4 cần chứa một 0và một j(theo thứ tự đó) và 9 cần chứa một 0, theo sau là một chữ số khác không xuất hiện ở bất kỳ nơi nào khác. Chắc chắn, có một số công thức khác, mà bởi một số sự trùng hợp ngẫu nhiên có thể tạo ra kết quả mong muốn. Một số trong số họ thậm chí có thể ngắn hơn. Nhưng tôi không nghĩ có cái nào có khả năng thành công như cái này.

Tôi cũng đã thử nghiệm với nhiều sự thay thế cho Ivà / hoặc Vvới một số thành công. Nhưng than ôi, không có gì ngắn hơn những gì tôi đã có. Dưới đây là danh sách các giải pháp ngắn nhất tôi tìm thấy (số lượng giải pháp nặng hơn 1-2 byte là quá nhiều để liệt kê):

y/XVI60-9/CLXVIX/dfor$\.="32e$&"%72726
y/XVI0-9/CLXIXV/dfor$\.="57e$&"%474976
y/XVI0-9/CLXIVXI/dfor$\.="49e$&"%87971

y/XVI0-9/CLXIIXIV/dfor$\.="7e$&"%10606  #
y/XVI0-9/CLXIIXIV/dfor$\.="7e$&"%15909  # These are all essentially the same
y/XVI0-9/CLXIIXIV/dfor$\.="7e$&"%31818  #

y/XVI0-9/CLXIIX V/dfor$\.="8e$&"%61535  # Doesn't contain 3 anywhere

y/XVI60-9/CLXXI V/dfor$\.="37e$&"%97366 # Doesn't contain 1 anywhere

HTML + JavaScript + CSS (137)

HTML (9)

<ol></ol>

JavaScript (101)

for(i=1;i<=100;i++){document.getElementsByTagName('ol')[0].appendChild(document.createElement('li'))}

CSS (27)

ol{list-style:upper-roman​}

Đầu ra

...

Bản trình diễn trên JSBin

Con trăn 116

mã golf tốt hơn của câu trả lời của scleaver:

r=lambda a,b,c:('',a,2*a,3*a,a+b,b,b+a,b+a+a,b+3*a,a+c);print' '.join(i+j for i in r(*'XLC')for j in r(*'IVX'))+' C'

Con trăn, 139

print' '.join(' '.join(i+j for  j in ' _I_II_III_IV_V_VI_VII_VIII_IX'.split('_'))for i in ' _X_XX_XXX_XL_L_LX_LXX_LXXX_XC'.split('_'))+' C'

C, 177 160 147 ký tự

Có những giải pháp ngắn hơn, nhưng không có giải pháp nào trong C, vì vậy đây là thử của tôi.

Giải pháp mới, hoàn toàn khác với giải pháp trước đây của tôi:

char*c;
f(n){
    printf("%.*s",n%5>3?2:n%5+n/5,c+=n%5>3?n%4*4:2-n/5);
}
main(i){
        for(;i<100;putchar(32))
                c="XLXXXC",f(i/10),
                c="IVIIIX",f(i++%10);
        puts("C");
}

Giải pháp trước đó (160 ký tự):

Logic:
1. fin một số từ 1 đến 10. clà các chữ số được sử dụng, có thể là IVXhoặc XLC. Gọi một lần cho hàng chục lần cho những người.
2. Nếu n%5==0- không in gì hoặc c[n/5]đó là Ihoặc V(hoặc Lhoặc C).
3. Nếu n%4==4- 4hoặc 9- in I(hoặc X), bởi n+1.
4. Nếu n>4- in 5(tức là Vhoặc L) thì n-5.
5. Nếu n<4- in Ithì n-1(tức là nlần I).

char*c;
p(c){putchar(c);}
f(n){
        n%5?
                n%5>3?
                        f(1),f(n+1):
                        n>4?
                                f(5),f(n-5):
                                f(n-1,p(*c)):
                n&&p(c[n/5]);
}
main(i){
        for(;++i<101;p(32))
                c="XLC",f(i/10),
                c="IVX",f(i%10);
        p(10);
}

JavaScript, 123

Lấy cảm hứng từ một phiên bản dài hơn mà tôi đã bắt gặp trong một nhóm tin Ba Lan (ít nhất, Chrome nghĩ rằng đó là tiếng Ba Lan).

for(i=100,a=[];n=i--;a[i]=r)
  for(r=y='',x=5;n;y++,x^=7)
    for(m=n%x,n=n/x^0;m--;)
      r='IVXLC'[m>2?y+n-(n&=-2)+(m=1):+y]+r;
alert(a)

Q ( 81 80)

Cắt lần 2

1_,/'[($)``X`XX`XXX`XL`L`LX`LXX`LXXX`XC cross``I`II`III`IV`V`VI`VII`VIII`IX],"C"

Cắt thứ 1:

1_,/'[$:[``X`XX`XXX`XL`L`LX`LXX`LXXX`XC cross``I`II`III`IV`V`VI`VII`VIII`IX]],"C"

Con trăn, 168

r=lambda n,l,v:(r(n,l[1:],v[1:])if n<v[0]else l[0]+r(n-v[0],l,v))if n else''
for i in range(1,101):print r(i,'C XC L XL X IX V IV I'.split(),[100,90,50,40,10,9,5,4,1]),

Giải trình

Sử dụng các giá trị này, lấy giá trị lớn nhất không lớn hơn n và trừ nó khỏi n. Lặp lại cho đến khi n bằng 0.

'C'  = 100
'XC' = 90
'L'  = 50
'XL' = 40
'X'  = 10
'IX' = 9
'V'  = 5
'IV' = 4
'I'  = 1

Hồng ngọc 1.9, 140 132

r=" "
100.times{r+=?I
0while[[?I*4,"IV"],["VIV","IX"],[?X*4,"XL"],["LXL","XC"],[/(.)((?!\1)[^I])\1/,'\2']].any?{|q|r.sub! *q}
$><<r}

Điều này theo nghĩa đen được tính từ 1 đến 100 bằng chữ số La Mã. Bắt đầu với một chuỗi trống, sau đó lặp lại thông qua nối thêm "I" và sau đó liên tục áp dụng một loạt các quy tắc thay thế, thêm hiệu quả 1.

Chỉnh sửa: Đã thêm số phiên bản, vì ?Ichỉ hoạt động trong 1.9 và sử dụng các thay đổi của @ Howard để cắt bớt một số ký tự.

Ruby 112 ký tự

101.times{|n|r=' ';[100,90,50,40,10,9,5,4,1].zip(%w(C XC L XL X IX V IV I)){|(k,v)|a,n=n.divmod k;r<<v*a};$><<r}

Về cơ bản sử dụng to_romanphương pháp được giải thích ở đây , nhưng sử dụng một mảng được nén cho ngắn gọn.

Toán học 159 150 142

c = {100, 90, 50, 40, 10, 9, 5, 4, 1};
Table["" <> Flatten[ConstantArray @@@ Thread@{StringSplit@"C XC L XL X IX V IV I", 
  FoldList[Mod, k, Most@c]~Quotient~c}], {k, 100}]

Giải pháp tích hợp : IntegerString, 38 ký tự

IntegerString[k, "Roman"]~Table~{k, 100}

perl 205

@r = split //, "IVXLC";
@n = (1, 5, 10, 50, 100);

for $num (1..100) {
  for($i=@r-1; $i>=0; $i--) {
    $d = int($num / $n[$i]);
    next if not $d;
    $_ .= $r[$i] x $d;
    $num -= $d * $n[$i];
  }
  $_ .= " ";
}
s/LXXXX/XC/g;
s/XXXX/XL/g;
s/VIIII/IX/g;
s/IIII/IV/g;
print;

Chơi gôn

@r=split//,"IVXLC";@n=(1,5,10,50,100);for$num(1..100){for($i=@r-1;$i>=0;$i--){$d=int($num/$n[$i]);next if!$d;$_.=$r[$i]x$d;$num-=$d*$n[$i];}$_.=" ";}s/LXXXX/XC/g;s/XXXX/XL/g;s/VIIII/IX/g;s/IIII/IV/g;print;

NHIỀU 184

S V(100)="C",V(90)="XC",V(50)="L",V(40)="XL",V(10)="X",V(9)="IX",V(5)="V",V(4)="IV",V(1)="I" F I=1:1:100 S S=I,N="" F  Q:'S  S N=$O(V(N),-1) I S&(S'<N ) S S=S-N W V(N) S N="" w:'S " "

Thuật toán tương tự như @cardboard_box, từ đó tôi đã lấy lời giải thích nguyên văn -

Giải trình

Sử dụng các giá trị này, lấy giá trị lớn nhất không lớn hơn n và trừ nó khỏi n. Lặp lại cho đến khi n bằng 0.

'C'  = 100
'XC' = 90
'L'  = 50
'XL' = 40
'X'  = 10
'IX' = 9
'V'  = 5
'IV' = 4
'I'  = 1

R , 85 byte

R=.romans
for(r in 1:100){while(r>0){cat(names(R[I<-R<=r][1]))
r=r-R[I][1]}
cat(" ")}

Hãy thử trực tuyến!

Sử dụng utilsbiến gói ngẫu nhiên .romansđể lấy các giá trị của các chữ số La Mã, nhưng tự chuyển đổi; cách tiếp cận dựng sẵn sẽ là 20 byte:cat(as.roman(1:100))

APL 128

Tôi đã thử một giải pháp lập chỉ mục trong APL:

r←⍬                                                                             
i←1                                                      
l:r←r,' ',('   CXI LV CX'[,⍉((1+(4 4 2 2⊤0 16 20 22 24 32 36 38 39 28)[;1+(3⍴10)⊤i])×3)-4 3⍴2 1 0])~' '
→(100≥i←i+1)/l                                                                  
r              

Nó có thể ngắn hơn 4 byte trong chỉ mục gốc 0 thay vì 1 nhưng hog không gian thực là việc tạo ma trận chỉ mục thông qua:

4 4 2 2⊤0 16 20 22 24 32 36 38 39 28

Cho đến nay tôi đã không thể tạo ra các chỉ số một cách nhanh chóng!

LaTeX (138)

\documentclass{minimal}
\usepackage{forloop}
\begin{document}
\newcounter{i}
\forloop{i}{1}{\value{i} < 101}{\roman{i}\par}
\end{document}

Con trăn, 125

' '.join(i+j for i in['']+'X XX XXX XL L LX LXX LXXX XC C'.split()for j in['']+'I II III IV V VI VII VIII IX'.split())[1:-38]

PHP, 38 37 byte

<ol type=I><?=str_repeat("<li>",100);

_{-1 byte nhờ @manatwork}

Ý tưởng tương tự như câu trả lời của Patrick , nhưng trong một ngôn ngữ nhỏ gọn hơn. Beats Mathematica !

Hãy thử trực tuyến!

VBA (Excel), 245 byte

đã tạo Hàm để lặp lại và thay thế - 91 byte

Function s(a,b):s=String(a,b):End Function Function b(x,y,z):b=Replace(x,y,z):End Function

sử dụng cửa sổ ngay lập tức ( 154 byte )

p="I":for x=1to 100:?b(b(b(b(b(b(b(b(s(x,p),s(100,p),"C"),s(90,p),"XC"),s(50,p),"L"),s(40,p),"XL"),s(10,p),"X"),s(9,p),"IX"),s(5,p),"V"),s(4,p),"IV"):next

Java (OpenJDK 8) , 152 byte

a->{String[] t=",X,XX,XXX,XL,L,LX,LXX,LXXX,XC,,I,II,III,IV,V,VI,VII,VIII,IX".split(",");for(int i=1;i<100;i++){a+=t[i/10]+t[i%10+10]+" ";}return a+"C";}

Hãy thử trực tuyến!

Giải trình:

String[] t=",X,XX,XXX,XL,L,LX,LXX,LXXX,XC,,I,II,III,IV,V,VI,VII,VIII,IX".split(",");
//Create an array of numerals, first half represents tens place, second half represents ones place
    for(int i=1;i<100;i++){             
//Loop 99 times
        a+=t[i/10]+t[i%10+10]+" ";   
//Add tens place and ones place to the string
    }return a+"C";                         
//Add numeral for 100 and return the string

TeX, 354 byte

\let~\let~\d\def~\a\advance~\b\divide~\x\expandafter~\f\ifnum{~~\newcount~\n~\i~\j~\k~\u~\v}~~\or\d\p#1{\ifcase#1C~2~L~5~X~2~V~5~I\fi}\d\q#1{\p{#1~}}\d\r{\j0
\v100\d\m{\d\w{\f\n<\v\else\p\j\a\n-\v\x\w\fi}\w\f\n>0\k\j\u\v\d\g{\a\k2\b\u\q\k}\g\f\q\k=2\g\fi\a\n\u\f\n<\v\a\n-\u\a\j2\b\v\q\j\else\p\k\fi\x\m\fi}\m}\i1\d\c{
\f\i<101 \n\i\r\a\i1 \x\c\fi}\c\bye

Một số giải thích: TeX cung cấp một lệnh tích \romannumeralhợp để chuyển đổi số thành chữ số La Mã. Như câu hỏi không cho phép sử dụng built-in chức năng, các mã trên là một phiên bản golfed của thuật toán tương tự của Knuth gốc sử dụng trình biên dịch TeX cho \romannumeral(xem TeX: Chương trình , § 69, print_roman_int) được triển khai lại trong TeX.

Khi muốn để lại niềm vui khó hiểu về cách mã này hoạt động với người đọc, Knuth từ chối đưa ra lời giải thích về phần này của mã. Vì vậy, tôi sẽ làm theo và chỉ đưa ra một phiên bản không được chỉnh sửa và sửa đổi một chút, gần với bản gốc hơn mã trên:

\newcount\n
\newcount\j
\newcount\k
\newcount\u
\newcount\v

\def\chrnum#1{\ifcase#1m\or 2\or d\or 5\or c\or 2\or l\or 5\or x\or 2\or v\or 5\or i\fi}
\def\chrnumM#1{\chrnum{#1\or}}

\def\roman#1{%
    \n=#1\relax
    \j=0\relax
    \v=1000\relax
    \def\mainloop{%
        \def\while{%
            \ifnum\n<\v
            \else
                \chrnum\j
                \advance\n -\v
                \expandafter\while
            \fi
        }\while
        \ifnum\n>0\relax
            \k=\j \advance\k 2\relax
            \u=\v \divide\u \chrnumM\k
            \ifnum\chrnumM\k=2\relax
                \advance\k 2\relax
                \divide\u \chrnumM\k
            \fi
            \advance\n \u
            \ifnum\n<\v
                \advance\n -\u
                \advance\j 2\relax
                \divide\v \chrnumM\j
            \else
                \chrnum\k
            \fi
            \expandafter\mainloop
        \fi
    }\mainloop
}

\newcount\i \i=1
\def\countloop{%
    \ifnum\i<100\relax
        \roman\i\ 
        \advance\i 1
        \expandafter\countloop
    \fi
}\countloop
\bye