Romen rakamları için temel bir hesap makinesi oluşturun.

Gereksinimler

• Destekler +, -, *,/
• Girdi ve çıktı sembol başına sadece bir çıkartıcı öneki beklemelidir (3 olamaz yani IIViki tane çünküI önceV )
• On sadece güçler büyük sayılar çıkarılır (örn hangi minimum destek Modern standart sözleşmeler de giriş ve çıkış gerekenlerden çıkarma ilkesinin Taşıma I, X, Cgerekli olan çıkartıcı değil V, L, D) ve çıkarma daha bir numaradan yapılması asla 10x çıkarıcı (örn IX. Desteklenmelidir ancakIC gerekli değildir).
• Girdi ve çıktı, en büyükten başlayarak (yani 19 = XIX değil IXX, 10 9'dan büyüktür)
• Soldan sağa, sanki bir el hesap makinesi kullanıyormuşsunuz gibi operatör önceliği yok.
• 1-4999 arasında tüm pozitif sayılar giriş / çıkışını destekler (V̅'ye gerek yoktur)
• Sizin için romen rakamı dönüşümü yapan kütüphane yok

Karar vermen için

• Büyük küçük harf duyarlılığı
• Girdilerdeki boşluklar veya boşluk yok
• Ondalık bir çıktı alırsanız ne olur. Kes, cevap yok, hata vb.
• İşleyemediğiniz çıktı için ne yapmalı? Basılacak büyüklükteki negatifler veya sayılar.
• Çıkarma ilkesinin asgari şarttan daha liberal bir şekilde kullanılmasının desteklenip desteklenmeyeceği.

Ekstra kredi

• -50 - 99999 veya daha büyük boyutlara kadar kullanın. Semboller bir vinculum içermelidir

Örnek giriş / çıkış

XIX + LXXX                 (19+80)
XCIX

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

En kısa kod kazanır.

JavaScript (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}

Kullanımı:

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

Açıklamalı sürüm:

/**
 * 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 bayt

SQL'de golf oynamanın bir kum takozundan başka bir şey olmadan 18 delik oynamaya eşdeğer olduğunu biliyorum, ancak bunun meydan okumasını sevdim ve bence metodolojik olarak birkaç ilginç şey yapmayı başardım.

Bu, giriş ve çıkış için vinculum'u desteklemez. Onu temsil etmek için bir izleyen tilde kullanma kuralını kabul ettim, bu yüzden V ~ 5000, X ~ 10000, vb. Bundan sonra, INT'nin desteklediği aralıktaki herhangi bir şeyin kısmen standart olmayan Roma kodlamasını yapacak.

Tamamen matematik olduğu için, tamsayı olmayan sonuçlar dolaylı olarak yuvarlanır.

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

Hala bayt sayısını azaltabilir ve deyimsel SQL daha zarif bir örnek olabilir WHILE döngü bazı değiştirmek için set tabanlı bir çözüm ile müdahalesi. Ayrıca, tablo diğer adlarının kullanımını en aza indirgeyerek elde edilecek bazı baytlar da vardır. Ancak bu dilde kazanılamayacağı için, çoğunlukla sadece Don Kişot kıyafetimi göstermek için buradayım. :)

Üstteki SELECT @ i girişi tekrarlar:

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

Ve sonunda SEÇ:

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

Ve bu SQLFiddle'da kendiniz test edebilirsiniz

Ve nasıl çalıştığına dair bazı yorumlar eklemek için geri döneceğim, çünkü eğitim değerinden faydalanmayacaksanız neden açık bir şekilde kaybeden bir cevap yayınlamalısınız?

Javascript - 482 476 karakter

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))))

Örnek giriş / çıkış çalışır:

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

Büyük sayıları da kötü işliyor:

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

Ve boşlukları da kabul eder, ancak gerektirmez.

Ancak, golf oynadığım için bazı sorunları var:

• Girdinin iyi biçimlendirilmiş olup olmadığını doğrulamaz. Girdi iyi biçimlendirilmemişse, davranış tanımsızdır (ve pratikte çok tuhaf ve gariptir).
• Çıktıdaki kesir sayılarını kısaltır (ancak onlarla ara hesaplamalar yapabilir).
• Değerlendirme işlevini gerçekten kötüye kullanır.
• Negatif sayıları ele almaya çalışmaz.
• Büyük / küçük harfe duyarlıdır.

Bu alternatif sürüm 5000'den 99999'a kadar olan sayıları işler, ancak 600 598 584 karakter içerir:

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))))

JavaScript 479 361 348 278 253

303 karakter - vinculum desteği ile 1 milyona kadar olan sayıları desteklemek için 50 karakter:

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

Kullanım: p(text)ör.p('XIX + LXXX') geri döner XCIX.

Açıklayıcı yorumları içeren kod:

// 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;
}

Bu verilen örnekler ve denediğim diğerleri için geçerlidir. Örnekler:

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̅

Ruby 2.1, 353 (ve diğer birçok iterasyon) , 295 - 50 = 245

Vinculum kullanımı ~ 23 karakter ekler.

Bu girişte "IL" veya "VM" işler ve negatif (yüksek ints gider) veya ondalık (kesme) veya herhangi bir boşluk hatasız başarısız. Şimdi de negatif bir ilk sayı ele alır (toplam negatifse yine de başarısız olur). * Veya / veya sonuç 4 milyon veya daha büyükse de başarısız olur.

Nesne # gönderme "el hesap makinesi" işlevselliği için kullanır.

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))}

Ungolfed:

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)
  )
}

Python 2 - 427 418 404 401 396 395 392 karakter

Standart girişten okur. Sadece büyük harf kullanır (8 ekstra karakter pahasına büyük / küçük harfe duyarlı olmayabilir) ve boşluk gerektirir. Doğrulama yapmaz - çeşitli durumlarda nasıl kırıldığını test etmedim. Ancak VC = 95 gibi sayıları işler.

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

Ve ungolfed versiyonu:

# 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

Perl'in daha iyi olacağına inanıyorum, ama yeterince bilmiyorum. Kod golf de bir ilk bıçak için olsa da, bu konuda oldukça iyi hissediyorum.

PHP - 549 525 524 520 bayt

Çok yenilikçi bir şey yok: operatörleri soldan sağa önceliği sağlamak için normalleştirir, Roma'yı ondalığa dönüştürür eval, ifade üzerinde çalışır , örneğin XCIX + I / L * D + IV , dönüş gibi bir şeye dönüştürülür (((((+90 +9)) + (+1)) / (+50)) * (+500)) + (+4)); , ondalık sayıyı tekrar Roma'ya çevirir.

• nihai sonuçlar kesildi
• 1'den daha az cevap boş çıkıyor
• yanlış giriş verilirse sonuçlar tanımsız

$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";

Örneğin

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

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

Python - 446 bayt

Bu önemli ölçüde geliştirilebilir. Python kullanarak ilk salınımı yapmak zorunda olduğumu hissettim. İlk geçişte 3 şey yapar

1. sayıları ve operatörleri tokenize eder
2. sayıları değerlendirir ve sembol tablosunu xkarşılaşılan tüm kombinasyonları içerecek şekilde büyütür (kullanılmasalar bile). Örneğin, süre XIX, kısmi değerleri lexed olan "X":10, "XI":11ve "XIX":19simge tablosuna eklenir
3. soldan sağa değerlendirmeyi zorunlu kılmak için yuvalanmış parens ekler

Sonunda, evalorijinal dizeyi çağırır (eklenen parenler hariç) ve ona sembol tablosu verir.

Daha sonra tamsayı Roma'ya dönüştürmek için bilinen bir çözüme yapıştırdım, çünkü bu kadar uzun süre çalıştım ... yeni bir şeyler öğrenebilmem için lütfen geliştirmekten çekinmeyin :)

m =), 1000,900,500,400,100,90,50,40,10,9,5,4,1 ((zip
( 'M', 'CM', 'D', 'CD', 'C', 'XC', 'L' 'XL', 'X', 'IX', 'V', 'IV',' BEN'))
def doit (ler) i:
 X = { 'M' 1E3, 'D', 500 'C': 100, 'L': 50, 'X': 10, 'V': 5, 'I' 1}; y = [] z = '' a '0'; s = '+' + s
 s.upper () içindeki c için:
  x cinsinden c:
   z + = C; y.append (x [c])
   len (y)> 1 ve y [-1]> y [-2] ise: y [-2] * = - 1
   x [Z] = toplamı (y)
  "+ / * -" içindeki elif c: a = '(' + a + z + ')' + c; y = []; z = ''
 a + = z; i = eval (a, x); r = ''
 n için c, m olarak: d = int (i / n); r + = c * d; i- = n * d
 dönüş r


doit yazdır ("XIX + LXXX")
yazdırma dokümanı ("XCIX + I / L * D + IV")