로마 숫자에 대한 기본 계산기를 만듭니다.

요구 사항

• 지원 +, -, *,/
• 입력과 출력은 심볼 당 하나의 빼기 접두사 만 예상해야합니다 (즉, 3은 앞에 IIV2 가 있기 때문에 될 수 없습니다 )IV
• 십의 힘이 더 큰 숫자에서 제외된다 (예를 들어있는 최소한의 지원 현대 표준 규칙에서 입력 및 출력 필요 뺄셈의 원리의 취급 I, X, C필요한 감산기하지만 V, L, D)과 뺄셈 이상 숫자에서 수행되지 않습니다 빼기 10 배 (예 : IX지원해야하지만 IC필수는 아님)
• 입력과 출력은 가장 큰 값부터 시작하여 값의 순서대로 왼쪽에서 오른쪽이어야합니다 (즉, 19 = XIXnot IXX, 10은 9보다 큼)
• 핸드 계산기를 사용하는 것처럼 왼쪽에서 오른쪽으로, 우선 순위가 없습니다.
• 1-4999 사이의 전체 양수 입력 / 출력 지원 (V̅ 필요 없음)
• 로마 숫자 변환을 수행하는 라이브러리가 없습니다

당신이 결정

• 대소 문자 구분
• 입력에 공백이 있거나 공백이 없습니다.
• 십진수 출력을 얻으면 어떻게됩니까? 잘림, 응답 없음, 오류 등
• 처리 할 수없는 출력을 위해 수행 할 작업 음수 또는 숫자를 크게 인쇄합니다.
• 최소 요구 사항보다 더 뺄셈 원리를 더 자유롭게 사용할 수 있는지 여부

추가 크레딧

• -50- 최대 99999 이상을 처리하십시오. 기호 에는 반드시 vinculum이 포함 되어야합니다

샘플 입력 / 출력

XIX + LXXX                 (19+80)
XCIX

XCIX + I / L * D + IV      (99+1/50*500+4)
MIV

가장 짧은 코드가 승리합니다.

자바 스크립트 (ES6), 238

c=s=>{X={M:1e3,CM:900,D:500,CD:400,C:100,XC:90,L:50,XL:40,X:10,IX:9,V:5,IV:4,I:1}
n=eval('W='+s.replace(/[\w]+/g,n=>(o=0,n.replace(/[MDLV]|C[MD]?|X[CL]?|I[XV]?/g,d=>o+=X[d]),
o+';W=W')));o='';for(i in X)while(n>=X[i])o+=i,n-=X[i];return o}

용법:

c("XIX + LXXX")
> "XCIX"
c('XCIX + I / L * D + IV')
> "MIV"

주석이 달린 버전 :

/**
 * Process basic calculation for roman numerals.
 * 
 * @param {String} s The calculation to perform
 * @return {String} The result in roman numerals
 */
c = s => {
  // Create a lookup table.
  X = {
    M: 1e3, CM: 900, D: 500, CD: 400, C: 100, XC: 90, 
    L: 50,  XL: 40,  X: 10,  IX: 9,   V: 5,   IV: 4, I: 1
  };
  // Do the calculation.
  // 
  // The evaluated string is instrumented to as below:
  //   99+1/50*500+4 -> W=99;W=W+1;W=W/50;W=W*500;W=W+4;W=W
  //                 -> 1004
  n = eval('W=' + s.replace(
    // Match all roman numerals.
    /[\w]+/g,
    // Convert the roman number into an integer.
    n => (
      o = 0,
      n.replace(
        /[MDLV]|C[MD]?|X[CL]?|I[XV]?/g,
        d => o += X[d]
      ),
      // Instrument number to operate left-side operations.
      o + ';W=W'
    )
  ));

  // Convert the result into roman numerals.
  o = '';
  for (i in X)
    while (n >= X[i])
      o += i,
      n -= X[i];

  // Return calculation result.
  return o
}

T-SQL, 1974 년-50 = 1924 바이트

SQL에서 골프를 타는 것은 모래 쐐기만으로 18 홀을하는 것과 동등하다는 것을 알고 있습니다.

이것은 입력과 출력 모두에 대한 vinculum을 지원합니다. 나는 그것을 표시하기 위해 후행 물결표를 사용하는 규칙을 채택 했으므로 V ~ 5000, X ~ 10000 등입니다. 또한 표준 현대 로마 숫자 사용법에 따라 최대 399,999의 출력을 처리해야합니다. 그 후, 그것은 INT의 지원되는 범위에있는 부분의 비표준 로마 인코딩을 부분적으로 수행합니다.

모두 정수 수학이므로 정수가 아닌 결과는 내재적으로 반올림됩니다.

DECLARE @i VARCHAR(MAX)
SET @i='I+V*IV+IX*MXLVII+X~C~DCCVI'
SELECT @i

DECLARE @t TABLE(i INT IDENTITY,n VARCHAR(4),v INT)
DECLARE @u TABLE(n VARCHAR(50),v INT)
DECLARE @o TABLE(n INT IDENTITY,v CHAR(1))
DECLARE @r TABLE(n INT IDENTITY,v INT,r VARCHAR(MAX))
DECLARE @s TABLE(v INT,s VARCHAR(MAX))
DECLARE @p INT,@x VARCHAR(4000)='SELECT ',@j INT=1,@m INT,@y INT,@z VARCHAR(2),@q VARCHAR(50)='+-/*~]%'
INSERT @t(n,v) VALUES('i',1),('iv',4),('v',5),('ix',9),('x',10),('xl',50),('l',50),('xc',90),('c',100),('cd',400),('d',500),('cm',900),('m',1000),('mv~',4000),('v~',5000),('mx~',9000),('x~',10000),('x~l~',40000),('l~',50000),('x~c~',90000),('c~',100000)
INSERT @u VALUES('%i[^i'+@q,-2),('%v[^vi'+@q,-10),('%x[^xvi'+@q,-20),('%l[^lxvi'+@q,-100),('%c[^clxvi'+@q,-200),('%d[^dclxvi'+@q,-1000),('%mx~%',-2010),('%x~l~%',-20060),('%x~c~%',-20110)
WHILE PATINDEX('%[+-/*]%', @i)!=0
BEGIN
    SET @p=PATINDEX('%[+-/*]%', @i)
    INSERT @o(v) SELECT SUBSTRING(@i,@p,1)
    INSERT @r(r) SELECT SUBSTRING(@i,1,@p-1)
    SET @i=STUFF(@i,1,@p,'')
END 
INSERT @r(r) SELECT @i
UPDATE r SET v=COALESCE(q.v,0) FROM @r r LEFT JOIN (SELECT r.r,SUM(u.v)v FROM @u u JOIN @r r ON r.r LIKE u.n GROUP BY r.r)q ON q.r=r.r
UPDATE r SET v=r.v+q.v FROM @r r JOIN (SELECT r.n,r.r,SUM((LEN(r.r)-LEN(REPLACE(r.r,t.n,REPLICATE(' ',LEN(t.n)-1))))*t.v) v FROM @r r JOIN @t t ON CHARINDEX(t.n,r.r) != 0 AND (LEN(t.n)=1 OR (LEN(t.n)=2 AND RIGHT(t.n,1)='~')) GROUP BY r.n,r.r) q ON q.r=r.r AND q.n = r.n
SELECT @m=MAX(n) FROM @o
SELECT @x=@x+REPLICATE('(',@m)+CAST(v AS VARCHAR) FROM @r WHERE n=1
WHILE @j<=@m
BEGIN
    SELECT @x=@x+o.v+CAST(r.v AS VARCHAR)+')'
    FROM @o o JOIN @r r ON r.n=o.n+1 WHERE o.n=@j
    SET @j=@j+1
END 
INSERT @s(v,s) EXEC(@x+',''''')
UPDATE @s SET s=s+CAST(v AS VARCHAR(MAX))+' = '
SET @j=21
WHILE @j>0
BEGIN
    SELECT @y=v,@z=n FROM @t WHERE i = @j
    WHILE @y<=(SELECT v FROM @s)
    BEGIN
        UPDATE @s SET v=v-@y,s=s+@z
    END  
    SET @j=@j-1
END
SELECT @x+' = '+UPPER(s) FROM @s

바이트 수를 줄일 수 있고 관용적 인 SQL의 더 우아한 예가 될 수있는 WHILE 루핑을 대체하기 위해 세트 기반 솔루션을 계속 사용하고 있습니다. 테이블 별명 사용을 최소한으로 줄이면 얻을 수있는 바이트도 있습니다. 그러나이 언어에서는 본질적으로 이길 수 없기 때문에 나는 주로 돈키호테 의상을 과시하기 위해 여기에 있습니다. :)

상단의 SELECT @i는 입력을 반복합니다.

I+V*IV+IX*MXLVII+X~C~DCCVI

그리고 끝에있는 SELECT는 다음을 반환합니다.

SELECT (((((1+5)*4)+9)*1047)+90706) = 125257 = C~X~X~V~CCLVII

이 SQLFiddle 에서 직접 테스트 할 수 있습니다.

그리고 교육적 가치를 악용하지 않을 경우 왜 대답을 잃어 버리는가?

자바 스크립트 - 482 476 자

String.prototype.m=String.prototype.replace;eval("function r(a){return a>999?'Mk1e3j899?'CMk900j499?'Dk500j399?'CDk400j99?'Ck100j89?'XCk90j49?'Lk50j39?'XLk40j9?'Xk10j8?'IX':a>4?'Vk5j3?'IV':a>0?'Ik1):''}".m(/k/g,"'+r(a-").m(/j/g,"):a>"));s=prompt();h=s.match(/\w+/gi);for(k in h)s=s.m(h[k],eval(eval("'0'+h[k].m(/IVu4pIXu9pXLu40pXCu90pCDu400pCMu900pMu1000pDu500pCu100pLu50pXu10pVu5pIu1')".m(/u/g,"/g,'+").m(/p/g,"').m(/")))+")");for(k in h)s="("+s;alert(r(Math.floor(eval(s))))

샘플 입 / 출력 작동 :

XIX + LXXX -> XCIX
XCIX + I / L * D + IV -> MIV

많은 수를 잘못 처리합니다.

MMM+MMM -> MMMMMM
M*C -> MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM

그리고 공백도 허용하지만 필수는 아닙니다.

그러나 골프를 타면서 몇 가지 문제가 있습니다.

• 입력이 올바른지 확인하지 않습니다. 입력이 제대로 구성되지 않으면 동작이 정의되지 않습니다 (실제로는 매우 기괴하고 이상합니다).
• 출력에서 분수를 자릅니다 (그러나 그것들을 사용하여 중간 계산을 수행 할 수 있습니다).
• 실제로 eval 함수를 남용합니다.
• 음수를 처리하려고 시도하지 않습니다.
• 대소 문자를 구분합니다.

이 대체 버전은 5000에서 99999까지의 숫자를 처리하지만 600 598 584자를 갖습니다 .

String.prototype.m=String.prototype.replace;eval("function r(a){return a>8zz?'XqCqk9e4j4zz?'Lqk5e4j3zz?'XqLqk4e4jzz?'Xqk1e4j89z?'IqXqk9e3j49z?'Vqk5e3j9z?'Mk1e3j8z?'CMk900j4z?'Dk500j3z?'CDk400jz?'Ck100j89?'XCk90j49?'Lk50j39?'XLk40j9?'Xk10j8?'IX':a>4?'Vk5j3?'IV':a>0?'Ik1):''}".m(/k/g,"'+r(a-").m(/j/g,"):a>").m(/q/g,"\u0305").m(/z/g,"99"));s=prompt();h=s.match(/\w+/gi);for(k in h)s=s.m(h[k],eval(eval("'0'+h[k].m(/IVu4pIXu9pXLu40pXCu90pCDu400pCMu900pMu1000pDu500pCu100pLu50pXu10pVu5pIu1')".m(/u/g,"/g,'+").m(/p/g,"').m(/")))+")");for(k in h)s="("+s;console.log(r(Math.floor(eval(s))))

자바 479 361 348 278 253

303 자-최대 100 만 개의 숫자를 지원하기위한 50 개, vinculum 지원으로 완료 :

function p(s){s=s[r](/(^|[*\/+-])/g,"0;s$1=");for(i in v){f=R("\\b"+i);while(f.test(s))s=s[r](f,v[i]+"+")}eval(s+"0");h="";for(i in v)while(s>=v[i]){h+=i;s-=v[i]}return h}v={M̅:1e6,D̅:5e5,C̅:1e5,L̅:5e4,X̅:1e4,V̅:5e3,M:1e3,CM:900,D:500,CD:400,C:100,XC:90,L:50,XL:40,X:10,IX:9,V:5,IV:4,I:1};r="replace";R=RegExp

사용법 : p(text)예를 p('XIX + LXXX')들어을 반환합니다 XCIX.

설명 주석이있는 코드 :

// Array mapping characters to values
v={M¯:1e6,D¯:5e5,C¯:1e5,L¯:5e4,X¯:1e4,V¯:5e3,M:1e3,CM:900,D:500,CD:400,C:100,XC:90,L:50,XL:40,X:10,IX:9,V:5,IV:4,I:1};
// Shortcut for String.replace
r='replace';
R=RegExp;

// The heart of the program
function p(s) {
    // Replace operators with ";s+=", ";s-=", and so on
    s=s[r](/(^|[*\/+-])/g,'0;s$1=');
    // Loop over the character map and replace all letters with numbers
    for(i in v){
        f=R('\\b'+i);
        while(f.test(s))
            s=s[r](f, v[i]+'+')
    }
    eval(s+'0');
    // Set up our return string
    h='';
    // Replace digits with characters
    for(i in v)
        while(s>=v[i]) {
            h+=i;
            s-=v[i];
        }
    return h;
}

이것은 주어진 샘플과 내가 시도한 다른 모든 것에서 작동합니다. 예 :

XIX + LXXX = XCIX
XCIX + I / L * D + IV = MIV
XL + IX/VII + II * XIX = CLXXI
CD + C + XL + X + I = DLI
M̅ + I = M̅I
MMMM + M = V̅

루비 2.1, 353 (그리고 다른 많은 반복들) , 295-50 = 245

vinculum 처리는 ~ 23자를 추가합니다.

입력에서 "IL"또는 "VM"을 처리하고 음수 (높은 정수로 이동) 또는 소수 (잘라 내기) 또는 공백에서 오류없이 실패합니다. 이제 음수 첫 번째 숫자도 처리합니다 (총수가 음수 인 경우에도 여전히 실패합니다). * 또는 /로 시작하거나 결과가 4 백만 이상인 경우에도 실패합니다.

"수동 계산기"기능을 위해 Object # send를 사용합니다.

m=%w{I V X L C D M V̅ X̅ L̅ C̅ D̅ M̅};n=m.zip((0..12).map{|v|(v%2*4+1)*10**(v/2)}).to_h
d=0
gets.scan(/([-+*\/])?([A-Z̅]+)/){|o,l|f=t=0
l.scan(/.̅?/){t-=2*f if f<v=n[$&]
t+=f=v}
d=d.send o||:+,t}
7.downto(1){|v|z=10**v
y=(d%z)*10/z
q,w,e=m[v*2-2,3]
$><<(y>8?q+e : y<4?q*y : y<5?q+w : w+q*(y-5))}

언 골프 드 :

m=%w{I V X L C D M V̅ X̅ L̅ C̅ D̅ M̅} # roman numerals
n=m.zip((0..12).map{|v|(v%2*4+1)*10**(v/2)}).to_h # map symbols to values
d=0
gets. # get input and...
  scan(/([-+*\/])?([A-Z̅]+)/) { |l,o|  # for each optional operator plus number
    f=t=0
    l.scan(/.̅?/){                           # read the number in one letter at a time
      t -= 2 * f if f < (v=n[$&])           # if the number's greater than the prev, subtract the prev twice since you already added it
      t += (f = v)                          # add this, and set prev to this number
    }
    d = d.send((o || :+), t)                # now that we've built our number, "o" it to the running total (default to +)
}
7.upto(1) { |v|                        # We now print the output string from left to right
  z = 10**v                            # z = [10, 100, 1000, etc.]
  y = (d%z)*10/z                       # if d is 167 and z is 100, y = 67/10 = 6 
  q,w,e = m[v*2-2,3]                   # q,w,e = X, L, C
  $><< (                               # print: 
    y>8 ? q+e :                        # if y==9,    XC
      y<4 ? q*y :                      # if y<4,     X*y
        y>3 ? q+w :                    # if y==4,    XL
          q*(y-5)                      # else,       L + X*(y-5)
  )
}

파이썬 2 - 427 418 404 401 396 395 392 문자

표준 입력에서 읽습니다. 대문자 만 처리하고 (추가 문자 8 개로 대소 문자를 구분하지 않음) 공백이 필요합니다. 유효성 검사가 수행되지 않습니다-다양한 경우에 어떻게 작동하는지 테스트하지 않았습니다. 그러나 VC = 95와 같은 숫자는 처리합니다.

N=['?M','DC','LX','VI'];t=0;o='+'
for q in raw_input().split():
 if q in"+-*/":o=q;continue
 n=s=0;X=1
 for l in q:
  x=''.join(N).find(l);v=(5-x%2*4)*10**(3-x/2)
  if X<x:n+=s;s=v;X=x
  elif X>x:n+=v-s;s=0
  else:n+=v+s;s=0
 exec"t"+o+"=n+s"
r=t/1000*'M'
for p,d in enumerate("%04d"%(t%1e3)):
 i="49".find(d);g=N[p]
 if i<0:
  if'4'<d:r+=g[0]
  r+=int(d)%5*g[1]
 else:r+=g[1]+N[p-i][i]
print r

그리고 ungolfed 버전 :

# Numerals grouped by powers of 10
N = ['?M','DC','LX','VI']
# Start with zero plus whatever the first number is
t = 0
o = '+'
for q in raw_input().split():
    if q in "+-*/":
        # An operator; store it and skip to the next entry
        o = q
        continue
    # n holds the converted Roman numeral, s is a temp storage variable
    n = s = 0
    # X stores our current index moving left-to-right in the string '?MDCLXVI'
    X = 1
    for l in q:
        # x is the index of the current letter in '?MDCLXVI'
        x = ''.join(N).find(l)
        # Calculate the value of this letter based on x
        v = (5 - x%2 * 4) * 10 ** (3 - x/2)
        if X < x:
            # We're moving forward in the list, e.g. CX
            n += s      # Add in any previously-stored value
            s = v       # Store this value in case we have something like CXL
            X = x       # Advance the index
        elif X > x:
            # Moving backward, e.g. XC
            n += v - s  # Add the current value and subtract the stored one
            s=0
        else:
            # Same index as before, e.g. XX
            n += v + s  # Add the current value and any stored one
            s = 0
    # Update total using operator and value (including leftover stored value
    # if any)
    exec "t" + o + "=n+s"

# Now convert the answer back to Roman numerals
# Special-case the thousands digit
r = t / 1000 * 'M'
# Loop over the number mod 1000, padded with zeroes to four digits (to make
# the indices come out right)
for p, d in enumerate("%04d" % (t % 1e3)):
    i = "49".find(d)
    g = N[p]
    if i < 0:
        # i == -1, thus d isn't '4' or '9'
        if '4' < d:
            # >= 5, so add the 5's letter
            r += g[0]
        # ... plus (digit % 5) copies of the 1's letter
        r += int(d) % 5 * g[1]
    else:
        # If it's a 4 or 9, add the 1's letter plus the appropriate
        # larger-valued letter
        r += g[1] + N[p-i][i]
print r

나는 펄이 더 나아질 것 같은 느낌이 들지만 그것을 충분히 모른다. 코드 골프에서 첫 찌르기 위해, 나는 이것에 대해 꽤 기분이 좋습니다.

PHP — 549 525 524 520 바이트

너무 혁신적인 것은 없습니다 : 왼쪽에서 오른쪽으로 우선 순위를 정하기 위해 연산자를 정규화하고, 로마자를 10 진수로 변환 eval하고, 문장에서 실행 합니다. 예 : XCIX + I / L * D + IV 는 return 과 같은 것으로 변환됩니다 ((((((( ++ + )) + (+1)) / (+50)) * (+500)) + (+4)); 그런 다음 10 진수를 로마자로 다시 변환합니다.

• 최종 결과가 잘립니다
• 1보다 작은 답변은 비워집니다.
• 입력이 잘못되면 결과가 정의되지 않습니다

$f='str_replace';$g='str_split';$c=array('M'=>1e3,'CM'=>900,'D'=>500,'CD'=>400,'C'=>100,'XC'=>90,'L'=>50,'XL'=>40,'X'=>10,'IX'=>9,'V'=>5,'IV'=>4,'I'=>1);$j='['.$f(array('+','-','*','/'),array('])+[','])-[','])*[','])/['), $argv[1]).'])';$j=str_repeat('(',substr_count($j,')')).$j;$j=$f('[','(',$j);$j=$f(']',')',$j);foreach($g('IVIXXLXCCDCM',2)as$w)$j=$f($w,'+'.$c[$w],$j);foreach($g('IVXLCDM')as$w)$j=$f($w,'+'.$c[$w],$j);$k=eval('return '.$j.';');$l='';foreach($c as$a=>$b){while($k>=$b){$l.=$a;$k-=$b;}}print$l."\n";

예 :

$ php roman.php 'XCIX + I / L * D + IV' — test case
MIV                                     — 1004

$ php roman.php 'XXXII * LIX'           — 32 × 59
MDCCCLXXXVIII                           — 1888

파이썬-446 바이트

이것은 상당히 향상 될 수 있습니다. 나는 파이썬을 사용하여 첫 스윙을해야한다고 느꼈습니다. 첫 패스에서 3 가지를한다

1. 숫자와 연산자를 토큰 화
2. 숫자를 평가하고 사용 x가능한 모든 조합을 포함 하도록 기호 테이블 을 확대합니다 (사용되지 않더라도). 예를 들어,이 동안 XIX, 상기 부분의 값을 lexed되고 "X":10, "XI":11및 "XIX":19심볼 테이블에 추가
3. 왼쪽에서 오른쪽으로 평가하기 위해 중첩 된 parens 삽입

마지막으로 eval원래 문자열을 호출 하고 (추가 된 parens는 제외) 기호 테이블을 제공합니다.

그런 다음 정수를 로마자로 변환하는 알려진 솔루션에 방금 붙여 넣었습니다. 이만큼 오랫동안 노력했기 때문에 ... 새로운 것을 배우도록 자유롭게 개선하십시오 :)

m = zip ((1000,900,500,400,100,90,50,40,10,9,5,4,1),
( 'M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', ' 나는'))
데프 도이 트 :
 x = { 'M': 1e3, 'D': 500, 'C': 100, 'L': 50, 'X': 10, 'V': 5, 'I': 1}; y = [] ; z = ''; a = '0'; s = '+'+ s
 s.upper ()에서 c의 경우 :
  x가 c 인 경우 :
   z + = c; y.append (x [c])
   len (y)> 1 및 y [-1]> y [-2] : y [-2] * =-1 인 경우
   x [z] = 합 (y)
  "+ / *-"에서 elif c : a = '('+ a + z + ')'+ c; y = []; z = ''
 a + = z; i = eval (a, x); r = ''
 n에서 c의 경우 m : d = int (i / n); r + = c * d; i- = n * d
 r을 반환


인쇄 doit ( "XIX + LXXX")
인쇄 doit ( "XCIX + I / L * D + IV")