Đầu vào:

Một số nguyên.

Đầu ra:

1. Đầu tiên chuyển đổi số nguyên thành số La Mã tương đương.
2. Sau đó chuyển đổi từng chữ in hoa của Số La Mã đó thành giá trị thập phân ASCII / UNICODE của chúng.
3. Và đầu ra tổng của những người.

Thí dụ:

1991 -> MCMXCI -> 77+67+77+88+67+73 -> 449
^ input                                ^ output

Chữ số La Mã: Đây là một Công cụ chuyển đổi số La Mã có lẽ hữu ích.

Quy tắc thử thách:

• Quy tắc số La Mã tiêu chuẩn được áp dụng, do đó, không có hình thức thay thế nào như IIIIhoặc VIIIIthay vì IVvà IX. *
• Các dòng Macron trên Chữ số La Mã trên 1.000 là ¯(UNICODE số 175). Vì vậy, một dòng được tính là +175và hai là +350.
• Bạn được phép sử dụng bất kỳ loại đầu vào và đầu ra nào, miễn là nó đại diện cho các số nguyên.
• Các trường hợp thử nghiệm sẽ nằm trong phạm vi 1 - 2,147,483,647.

* Quy tắc số La Mã (trích dẫn từ Wikipedia):

Các số được hình thành bằng cách kết hợp các ký hiệu và thêm các giá trị, IIhai (hai cái) và XIIImười ba (mười và ba) cũng vậy. Bởi vì mỗi chữ số có một giá trị cố định thay vì đại diện cho bội số của mười, một trăm, v.v., theo vị trí, không cần phải "giữ" các số 0, như trong các số như 207 hoặc 1066; những con số đó được viết là CCVII(hai trăm, năm và hai) và MLXVI(một nghìn, năm mươi, mười, năm và một).

Các biểu tượng được đặt từ trái sang phải theo thứ tự giá trị, bắt đầu bằng giá trị lớn nhất. Tuy nhiên, trong một vài trường hợp cụ thể, để tránh bốn ký tự được lặp lại liên tiếp (chẳng hạn như IIIIhoặc XXXX), ký hiệu trừ thường được sử dụng như sau:

• Iđặt trước Vhoặc Xchỉ ra một ít hơn, vì vậy bốn là IV(một ít hơn năm) và chín là IX(một ít hơn mười)
• Xđược đặt trước Lhoặc Cchỉ ra mười ít hơn, vì vậy bốn mươi là XL(mười ít hơn năm mươi) và chín mươi là XC(mười dưới một trăm)
• Cđặt trước Dhoặc Mchỉ ra một trăm ít hơn, vì vậy bốn trăm là CD(một trăm ít hơn năm trăm) và chín trăm là CM(một trăm ít hơn một nghìn)
  Ví dụ: MCMIVlà một nghìn chín trăm bốn, 1904 ( Mlà một nghìn, CMlà chín trăm và IVlà bốn).

Một số ví dụ về việc sử dụng chữ số La Mã hiện đại bao gồm:
1954 như MCMLIV; Năm 1990 như MCMXC; 2014 là MMXIV
NGUỒN

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

100          ->   67
1            ->   73
4            ->   159
22           ->   322
5000         ->   261
2016         ->   401
1000000000   ->   427
1991         ->   449
9999         ->   800
1111111111   ->   2344
2147483647   ->   5362

Toán học, 181 173 166 151 byte

Chơi gôn

(q=Select[ToCharacterCode@#,64<#<99&]&/@StringSplit[RomanNumeral[#],"_"];p=PadLeft;l=Length;Total[p[q,4]+p[{350,350*Mod[l@q,2],175,0}[[-l@q;;]],4],2])&

Bị đánh cắp

(
q = Select[
     ToCharacterCode@#,
     64<#<99&
    ]&/@StringSplit[RomanNumeral@#,"_"];
p=PadLeft;
l=Length;
Total[
   p[q,4]+
   p[{350,350*Mod[l@q,2],175,0}[[-l@q;;]],4]
   ,2]
)&

Việc RomanNumeraltriển khai của Mathicala mang lại (IX) CMXCIX cho 9999, và do đó chương trình trả về 971 cho số đó.

Như đã viết, một chữ số La Mã thuộc loại ((...)) (...) ... trả về một danh sách các mã ASCII lồng nhau cho các chữ số La Mã có độ dài 4, ((...)) ... trả về danh sách độ dài 3, (...) ... trả về danh sách độ dài 2 và ... trả về danh sách độ dài 1. Dòng cuối cùng chuyển đổi các quy tắc đó thành số lượng macron thích hợp cho từng phần của liệt kê, thêm các macron đó vào, sau đó tính tổng toàn bộ danh sách lồng nhau để trả về đầu ra.

Python 3, 281 278 273 269 ​​byte

Nỗ lực đầu tiên của tôi tại codegolf, ở đây chúng tôi đi. Đã thử làm nó mà không nhìn vào câu hỏi được liên kết, vì vậy nó có thể rất tệ :)

def f(n):d=len(str(n))-1;l=10**d;return 0if n<1else(n<l*4and[73,88,67,77,263,242,252,438,417,427][d]+f(n-l))or(l<=n//9and[161,155,144,340,505,494,690,855,844][d]+f(n-9*l))or(n<l*5and[159,164,135,338,514,485,688,864,835][d]+f(n-4*l))or[86,76,68][d%3]+(d//3*175)+f(n-5*l)

Nhỏ hơn 8 byte, nhờ Gábor Fekete

Ung dung:

def f(n):
d = len(str(n)) - 1 # number of digits minus one
l = 10 ** d         # largest power of 10 that is not larger than parameter
if n == 0:
    return 0
elif n < 4 * l: # starts with X, C, M, ...
    return [
        ord('I'),
        ord('X'),
        ord('C'),
        ord('M'),
        ord('X') + 175, 
        ord('C') + 175, 
        ord('M') + 175, 
        ord('X') + 350, 
        ord('C') + 350, 
        ord('M') + 350
    ][d] + f(n - l)
elif n // 9 * 10 >= 10 * l: # starts with IX, XC, ...
    return [
        ord('I') + ord('X'), 
        ord('X') + ord('C'), 
        ord('C') + ord('M'),
        ord('M') + ord('X') + 175,
        ord('X') + ord('C') + 350,
        ord('C') + ord('M') + 350,
        ord('M') + ord('X') + 525,
        ord('X') + ord('C') + 700,
        ord('C') + ord('M') + 700
    ][d] + f(n - 9*l)
elif n < 5 * l: # starts with IV, XL, CD, ... 
    return [
        ord('I') + ord('V'),
        ord('X') + ord('L'),
        ord('C') + ord('D'),
        ord('M') + ord('V') + 175,
        ord('X') + ord('L') + 350,
        ord('C') + ord('D') + 350,
        ord('M') + ord('V') + 525,
        ord('X') + ord('L') + 700,
        ord('C') + ord('D') + 700
    ][d] + f(n - 4 * l)
else: # starts with V, L, D, ...
    return [
        ord('V'), 
        ord('L'), 
        ord('D'),
        ord('V') + 175, 
        ord('L') + 175, 
        ord('D') + 175,
        ord('V') + 350, 
        ord('L') + 350, 
        ord('D') + 350
    ][d] + f(n - 5 * l)

Ruby, 188 byte

Một bản chuyển thể dựa trên câu trả lời Ruby cũ của tôi để chuyển đổi chữ số La Mã . Hãy thử trực tuyến!

f=->x,i=0{k=0;(x<t=1e3)?"CM900D500CD400C100XC90L50XL40X10IX9V5IV4I1".gsub(/(\D+)(\d+)/){v=$2.to_i;s=x/v;x%=v;($1*s).bytes.map{|c|k+=c==73&&i>0?77+175*~-i:c+175*i}}:k=f[x/t,i+1]+f[x%t,i];k}

Toán học, 198 byte

Tr[Tr@Flatten[ToCharacterCode/@#]+Length@#*Tr@#2&@@#&/@Partition[Join[SplitBy[Select[Characters@#/."\&"->1,MemberQ[Join["A"~CharacterRange~"Z",{1}],#]&],LetterQ]/. 1->175,{{0}}],2]]&@RomanNumeral@#&

Thật không may, nội dung tích hợp không giúp ích nhiều ở đây, mặc dù tôi chắc chắn rằng điều này có thể được chơi golf nhiều hơn nữa.

Lưu ý: Đánh giá 9999 -> 971theo đây .

Mẻ, 373 byte

@echo off
set/an=%1,t=0,p=1
call:l 73 159 86 161
call:l 88 164 76 155
call:l 67 135 68 144
call:l 77 338 261 340
call:l 263 514 251 505
call:l 242 485 243 494
call:l 252 688 436 690
call:l 438 864 426 855
call:l 417 835 418 844
call:l 427 0 0 0
echo %t%
exit/b
:l
set/ad=n/p%%10,p*=10,c=d+7^>^>4,d-=9*c,t+=%4*c,c=d+3^>^>3,d-=5*c,t+=%3*c+%2*(d^>^>2)+%1*(d^&3)

Hoạt động bằng cách dịch từng chữ số của số theo một bảng tra cứu cho các giá trị 1, 4, 5 và 9. Sử dụng M(V), M(X), (M(V))và (M(X)). Nếu bạn thích (IV), (IX), ((IV))và ((IX))sau đó sử dụng call:l 77 509 261 511và call:l 252 859 436 861tương ứng.

JavaScript (ES6), 183 byte

f=(n,a=0)=>n<4e3?[256077,230544,128068,102535,25667,23195,12876,10404,2648,2465,1366,1183,329].map((e,i)=>(d=e>>8,c=n/d|0,n-=c*d,r+=c*(e%256+a*-~(i&1))),r=0)|r:f(n/1e3,a+175)+f(n%1e3)

Lưu ý: không chỉ thích (IV)đến M(V), nhưng cũng thích (VI)đến (V)M; trong thực tế, nó sẽ chỉ sử dụng M ở đầu số.

Python, 263 byte

def g(m):x=0;r=[73,86,88,76,67,68,77,261,263,251,242,243,252,436,438,426,417,418,427,0,0];return sum([b%5%4*r[i+(i*1)]+((b==9)*(r[i+(i*1)]+r[(i+1)*2]))+((b==4)*(r[i+(i*1)]+r[i+1+(i*1)]))+((b in [5,6,7,8])*r[i+1+(i*1)])for i,b in enumerate(map(int,str(m)[::-1]))])

R, 115 byte

Vì vậy, ... tôi đang đăng giải pháp của mình vì tôi thấy câu hỏi khá thú vị. Tôi đã làm hết sức mình với năng lực của R để đối phó với các số la mã không có gói: bạn chỉ có thể nhập số giữa 1và 3899, như tài liệuas.roman của tài liệu giải thích.

Đó là lý do tại sao tôi đã lừa dối một chút bằng cách đưa ra phạm vi giữa 1để trong vòng lặp: đó là chiều dài của đầu ra 's ( ) . Trên thực tế, theo trang web này , số La Mã dài nhất là (14 ký tự), tương ứng với .11 14foras.roman(3899)MMMDCCCXCIX
MMDCCCLXXXVIII2888

Hơn nữa, bạn không thể tính toán lengthđầu ra của hàm này.

a=scan();v=0;for(i in 1:14){v=c(v,as.numeric(charToRaw(substring(as.character(as.roman(a)),1:14,1:14)[i])))};sum(v)

Nếu bất cứ ai nhìn thấy một giải pháp để đối phó với các vấn đề trên, xin vui lòng bình luận.

Python 3, 315 byte

def p(n=int(input()),r=range):return sum([f*g for f,g in zip([abs(((n-4)%5)-1)]+[t for T in zip([((n+10**g)//(10**g*5))%2for g in r(10)],[(n%(10**g*5))//(10**g*4)+max((n%(10**g*5)%(10**g*4)+10**(g-1))//(10**g),0)for g in r(1,10)])for t in T],[73,86,88,76,67,68,77,261,263,251,242,243,252,436,438,426,417,418,427])])

Phiên bản bị đánh cắp:

def p(n=int(input()),r=range):
    return sum([f*g for f,g in zip(
        [abs(((n-4)%5)-1)]+
        [t for T in zip(
            [((n+10**g)//(10**g*5))%2for g in r(10)],
            [(n%(10**g*5))//(10**g*4)+max((n%(10**g*5)%(10**g*4)+10**(g-1))//(10**g),0)for g in r(1,10)]
        )for t in T],
        [73,86,88,76,67,68,77,261,263,251,242,243,252,436,438,426,417,418,427])])

Giải thích: Phiên bản này sử dụng một cách tiếp cận khác, nó đếm số lần xuất hiện của các chữ số La Mã trong số.

[abs(((n-4)%5)-1)]là số Is trong số La Mã.

[((n+10**g)//(10**g*5))%2for g in r(10)]là số V,L,D,(V),(L),(D),((V)),((L)),((D))s trong số.

[(n%(10**g*5))//(10**g*4)+max((n%(10**g*5)%(10**g*4)+10**(g-1))//(10**g),0)for g in r(1,10)]là số của X,C,M,(X),(C),(M),((X)),((C)),((M))s trong số.

Sau đó, nó nhân các lần xuất hiện với giá trị của ký tự và trả về tổng của nó.