Giriş:

$6÷2(1+2)$ ifadesiyle ilgili uzun yıllardır devam eden bir tartışmadan esinlenmiştir .

$6÷2(1+2)$ ifadesiyle , matematikçiler hızlı bir şekilde doğru cevabın $1$ olduğunu göreceklerdir , oysa okuldan basit bir matematik geçmişine sahip kişiler hızlı bir şekilde doğru cevabın $9$ olduğunu göreceklerdir . Peki bu tartışma ve bu nedenle farklı cevaplar nereden geliyor? $6÷2(1+2)$ nin nasıl yazıldığına dair çelişkili iki kural vardır . Biri parçaya 2(diğeri ise bölme sembolüne bağlı ÷.

Hem matematikçiler hem de “sıradan insanlar” PEMDAS (Parantez - Üstatlar - Bölme / Çarpma - Toplama / Çıkarma) kullanacak olsalar da , matematikçiler için ifade aşağıdaki gibi değerlendirilir, çünkü $2(3)$ tıpkı $2x^2$ bir monomiyal gibidir. aka " nedeniyle yan yana ile örtülü çarpma tek bir terim " (ve bu nedenle bir parçası Polarak PEMDASfarklı değerlendirilecektir), $2×(3)$ , (a binom aka iki dönem):

$$6÷2(1+2) → \frac{6}{2(3)} → \frac{6}{6} → 1$$

'Sıradan insan' için ise $2(3)$ ve $2×(3)$ aynı (ve dolayısıyla parçası olacak MDin PEMDASbu yerine kullanacağız böylece):

$$6÷2(1+2) → 6/2×(1+2) → 6/2×3 → 3×3 → 9$$

Ancak, mümkün olduğunca orijinal ifadeyi yazılı olurdu bile $6÷2×(1+2)$ , hala nedeniyle bölünme sembolünün kullanılması için bazı tartışmalara olabilir ÷. Modern matematikte, /ve ÷sembolleri aynı anlama sahiptir: böl. Bazı kurallar öncesi 1918 ^† bölünme sembolü ilişkin ÷^†† o bölünme sembolü farklı bir anlamı olduğunu devlet /. Bunun nedeni ÷demek "için kullanılan sağdaki sayı / ifadesiyle soldaki numarası / ifadesini bölmek " ^††† . Öyleyse $a ÷ b$ , olur$(a) / (b)$ veya$\frac{a}{b}$ şimdi. Bu durumda$6÷2×(1+2)$1918 öncesi insanlar tarafından bu şekilde değerlendirilecektir:

^{†: ÷Geçmişte nasıl kullanıldığını açıklayan birçok kaynak bulmama rağmen (bkz. Aşağıda †††), bunun 1918 civarında bir yerde değiştiğini ispatlayamadım. Fakat bu zorluğun uğruna, 1918’in dönüm noktası nerede ÷ve /geçmişte farklıydı aynı şeyi ifade etmek için başlayan.}

^{††: Diğer semboller de olduğu gibi, bölünme geçmişte kullanılmıştır :ya da (bu ben şahsen ilkokul xD öğrendiklerinizi olduğundan, Hollanda ve diğer Avrupa dışı İngilizce konuşulan ülkelerde hala şimdi ya) 1633 yılında )içinde 1540'larda. Ancak bu meydan okuma için yalnızca 1918 öncesi obelus sembolünün anlamına odaklanıyoruz ÷.
†††: Kaynaklar: genel olarak bu makale . Ve ilişkin 1918 öncesi kurallar ÷bahsediliyor: Bu American Mathematical Aylık Şubat 1917 den makalesinde ; bu Alman Teutsche Cebir kitabı 1659 sayfa 9 ve sayfa 76'dan ; Bu Cebirde A İlk Kitap1895 sayfa 46'dan [48/189] .}

Biraz konu dışı: bu ifade hakkındaki gerçek tartışma hakkında: Asla böyle bir şey yazılmamalıdır! Soru net değilse, doğru cevap konuyla ilgisizdir. * "Kapat, çünkü ne istediğin belli değil" düğmesine tıklar * .
Ve kayıt için, Casio hesap makinelerinin farklı versiyonları bile bu ifadeyle nasıl başa çıkılacağını bilmiyor:

Meydan okuma:

Size iki giriş verilmiştir:

• Yalnızca sembollerden oluşan (geçerli) bir matematiksel ifade 0123456789+-×/÷()
• Bir yıl

Ve çıkış (yıllık göre matematiksel ifade sonucu, ÷zaman farklı kullanılan $year<1918$ , ancak tam da aynı kullanıldığı /zaman $year\ge1918$ ).

Meydan okuma kuralları:

• Matematiksel ifadenin geçerli olduğunu ve sadece sembolleri kullandığını varsayabilirsiniz 0123456789+-×/÷(). Bu da üstelikle uğraşmak zorunda kalmayacağınız anlamına geliyor. ( Golfe yardımcı oluyorsa veya diliniz yalnızca ASCII'yi destekliyorsa, ×veya için ÷( *veya veya %) farklı semboller kullanmanıza da izin verilir .)
• Bu, ifadenin (belki de el ile) değerlendirmesine yardımcı oluyorsa, giriş sınırlayıcısına boşluk sınırlayıcıları eklemenize izin verilir.
• G / Ç esnektir. Giriş bir dize, karakter dizisi, vb. Olabilir. Yıl bir tam sayı, tarih nesnesi, dize vb. Olabilir. Çıktı ondalık bir sayı olacaktır.
• 0 test vakası ile herhangi bir bölünme olmayacağını varsayabilirsiniz.
• Girdi ifadesindeki sayıların negatif olmadığını varsayabilirsiniz (bu nedenle -, negatif simge ile -çıkarma sembolü olarak ayırt etmek zorunda kalmazsınız ). Çıktı yine de negatif olabilir!
• Bunun yerine N(her zaman yazılacağını varsayabilirsiniz N×(. Biz sadece bölünme sembollerin ikinci tartışmalara odaklanmak gerekir /vs ÷bu mücadelede.
• Ondalık çıkış değerleri, en az üç ondalık basamak kesinliğine sahip olmalıdır.
• Giriş ifade çoklu içeriyorsa ÷(örn $4÷2÷2$ ) ile $year<1918$ , bunlar aşağıdaki şekilde değerlendirilmiştir: $4÷2÷2 → \frac{4}{\frac{2}{2}} → \frac{4}{1} → 4$. (Ya bir deyişle:numarası$4$ekspresyonu bölünür$2 ÷2$ifadesi,$2 ÷2$numara çevirmek vasıtalarının$2$sayısı ile bölünür$2$).
• ÷×/$4÷2×2÷3$
• $[0000, 9999]$

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

Input-expression:   Input-year:   Output:      Expression interpretation with parenthesis:

6÷2×(1+2)           2018          9            (6/2)×(1+2)
6÷2×(1+2)           1917          1            6/(2×(1+2))
9+6÷3-3+15/3        2000          13           ((9+(6/3))-3)+(15/3)
9+6÷3-3+15/3        1800          3            (9+6)/((3-3)+(15/3))
4÷2÷2               1918          1            (4/2)/2
4÷2÷2               1900          4            4/(2/2)
(1÷6-3)×5÷2/2       2400          -3.541...    ((((1/6)-3)×5)/2)/2
(1÷6-3)×5÷2/2       1400          1.666...     ((1/(6-3))×5)/(2/2)
1×2÷5×5-15          2015          -13          (((1×2)/5)×5)-15
1×2÷5×5-15          1719          0.2          (1×2)/((5×5)-15)
10/2+3×7            1991          26           (10/2)+(3×7)
10/2+3×7            1911          26           (10/2)+(3×7)
10÷2+3×7            1991          26           (10/2)+(3×7)
10÷2+3×7            1911          0.434...     10/(2+(3×7))
4÷2+2÷2             2000          3            (4/2)+(2/2)
4÷2+2÷2             1900          2            4/((2+2)/2)
4÷2×2÷3             9999          1.333...     ((4/2)×2)/3
4÷2×2÷3             0000          3            4/((2×2)/3)
((10÷2)÷2)+3÷7      2000          2.928...     ((10/2)/2)+(3/7)
((10÷2)÷2)+3÷7      1900          0.785...     (((10/2)/2)+3)/7
(10÷(2÷2))+3×7+(10÷(2÷2))+3×7
                    1920          62           (10/(2/2))+(3×7)+(10/(2/2))+(3×7)
(10÷(2÷2))+3×7+(10÷(2÷2))+3×7
                    1750          62           (10/(2/2))+(3×7)+(10/(2/2))+(3×7)
10÷2/2+4            2000          6.5          ((10/2)/2)+4
10÷2/2+4            0100          2            10/((2/2)+4)
9+6÷3-3+15/3        9630          13           9+(6/3)-3+(15/3)
9+6÷3-3+15/3        0369          3            (9+6)/(3-3+(15/3))

R , 68 66 bayt

function(x,y,`=`=`/`)eval(parse(t=`if`(y<1918,x,gsub('=','/',x))))

Çevrimiçi deneyin!

Eşitlik işareti Bekliyor =yerine ÷ve *yerine ×.

Bu kod, bazı kötü operatör aşırı yüklemelerinden yararlanır, =çok düşük önceliğe sahip bir sağdan sola operatör olduğu gerçeğinden faydalanır ( 1918 öncesi için tam olarak istediğimiz davranış ÷) ve R, ilk önceliğini korur. aşırı yüklendi. Gerisi bizim için otomatik olarak yapılır eval.

Bir bonus olarak, burada terser sözdiziminde uygulanan aynı yaklaşım. Bu sefer özel bölüm operatörümüz tilde ( ~):

Julia 0.7 , 51 bayt

~=/;f(x,y)=eval(parse(y<1918?x:replace(x,'~','/')))

Çevrimiçi deneyin!

JavaScript (ES6),  130 129  120 bayt

@ScottHamper sayesinde 9 bayt kaydedildi

Girişi olarak alır (year)(expr). Bekler %ve *yerine ÷ve ×.

y=>g=e=>(e!=(e=e.replace(/\([^()]*\)/,h=e=>eval(e.split`%`.reduceRight((a,c)=>y<1918?`(${c})/(${a})`:c+'/'+a))))?g:h)(e)

Çevrimiçi deneyin!

Nasıl?

Yaprak ifadelerinin işlenmesi

$h$$e$%$y$

$y<1918$, düşük önceliğe zorlamak için bu dönüşüme X%Ydönüşüyoruz (X)/(Y)ve bu işlemi tüm dizeler için sağdan sola birliği zorlamak için sağdan sola tekrarlıyoruz.

Örnekler:

• 8%2olur (8)/(2)kimin basitleştirilmiş bir şeklidir,8/2
• 2+3%3+2 olur (2+3)/(3+2)
• 8%2%2olur (8)/((2)/(2))kimin basitleştirilmiş bir şeklidir,8/(2/2)

Eğer $y\ge 1918$, her %biri basit bir şekilde a'ya dönüştürülür /.

h = e =>                    // e = input string
  eval(                     // evaluate as JS code:
    e.split`%`              //   split e on '%'
    .reduceRight((a, c) =>  //   for each element 'c', starting from the right and
                            //   using 'a' as the accumulator:
      y < 1918 ?            //     if y is less than 1918:
        `(${c})/(${a})`     //       transform 'X%Y' into '(X)/(Y)'
      :                     //     else:
        c + '/' + a         //       just replace '%' with '/'
    )                       //   end of reduceRight()
  )                         // end of eval()

Yuvalanmış ifadelerle başa çıkmak

Yukarıda belirtildiği gibi, işlev $h$ Bir yaprak ifadesinde, yani parantez içine alınmış başka alt ifadesiz bir ifade üzerinde çalışacak şekilde tasarlanmıştır.

Bu yüzden yardımcı fonksiyonu kullanıyoruz. $g$ Bu tür yaprak ifadelerini özyinelemeli olarak tanımlamak ve işlemek.

g = e => (            // e = input
  e !=                // compare the current expression with
    ( e = e.replace(  // the updated expression where:
        /\([^()]*\)/, //   each leaf expression '(A)'
        h             //   is processed with h
      )               // end of replace()
    ) ?               // if the new expression is different from the original one:
      g               //   do a recursive call to g
    :                 // else:
      h               //   invoke h on the final string
)(e)                  // invoke either g(e) or h(e)

Python 3.8 (yayın öncesi) , 324 310 306 bayt

lambda s,y:eval((g(s*(y<1918))or s).replace('%','/'))
def g(s):
 if'%'not in s:return s
 l=r=j=J=i=s.find('%');x=y=0
 while j>-1and(x:=x+~-')('.find(s[j])%3-1)>-1:l=[l,j][x<1];j-=1
 while s[J:]and(y:=y+~-'()'.find(s[J])%3-1)>-1:r=[r,J+1][y<1];J+=1
 return g(s[:l]+'('+g(s[l:i])+')/('+g(s[i+1:r])+')'+s[r:])

Çevrimiçi deneyin!

Alır %yerine ÷ve *yerine×

Perl 5, 47 97 95 bayt

/ /;$_="($`)";$'<1918?s-%-)/(-g:y-%-/-;$_=eval

$_="($F[0])";1while$F[1]<1918&&s-\([^()]+\)-local$_=$&;s,%,)/((,rg.")"x y,%,,-ee;y-%-/-;$_=eval

TIO

Pas - 1066 860 783 755 740 bayt

macro_rules! p{($x:expr)=>{$x.pop().unwrap()}}fn t(s:&str,n:i64)->f64{let (mut m,mut o)=(vec![],vec![]);let l=|v:&Vec<char>|*v.last().unwrap();let z=|s:&str|s.chars().nth(0).unwrap();let u=|c:char|->(i64,fn(f64,f64)->f64){match c{'÷'=>(if n<1918{-1}else{6},|x,y|y/x),'×'|'*'=>(4,|x,y|y*x),'-'=>(2,|x,y|y-x),'+'=>(2,|x,y|y+x),'/'=>(5,|x,y|y/x),_=>(0,|_,_|0.),}};macro_rules! c{($o:expr,$m:expr)=>{let x=(u(p!($o)).1)(p!($m),p!($m));$m.push(x);};};for k in s.split(" "){match z(k){'0'..='9'=>m.push(k.parse::<i64>().unwrap() as f64),'('=>o.push('('),')'=>{while l(&o)!='('{c!(o,m);}p!(o);}_=>{let j=u(z(k));while o.len()>0&&(u(l(&o)).0.abs()>=j.0.abs()){if j.0<0&&u(l(&o)).0<0{break;};c!(o,m);}o.push(z(k));}}}while o.len()>0{c!(o,m);}p!(m)}

Rust 'eval' gibi bir şeye sahip değil, bu yüzden biraz zor. Temel olarak, bu küçük bir değişiklik ile bataklık standart bir Djisktra şantiye bahçesinde ek değerlendiricidir. ÷ değişken önceliği olan bir operatördür: <1918 modundaki her şeyden düşük (ancak parantez),> = 1918 modundaki her şeyden yüksek. Aynı zamanda <1918 için 4 ÷ 2 ÷ 2 şartnamesini yerine getirmesi için 'sağ ilişkili' (veya sol?) Ve association önceliği negatif hale getirerek ilişkilendirme, daha sonra ilişkili olduğu gibi <0 olan herhangi bir önceliği tedavi etme işleminde 'sahte'dir. Golf için daha fazla yer var ama bence iyi bir taslak.

Play.rust-lang.org de Ungolfed