Giới thiệu:

Lấy cảm hứng từ một cuộc thảo luận đã diễn ra trong nhiều năm liên quan đến biểu thức .$6÷2(1+2)$

Với biểu thức , các nhà toán học sẽ nhanh chóng thấy rằng câu trả lời đúng là , trong khi những người có nền toán học đơn giản từ trường học sẽ nhanh chóng thấy rằng câu trả lời đúng là . Vì vậy, tranh cãi này và do đó câu trả lời khác nhau đến từ đâu? Có hai quy tắc mâu thuẫn trong cách viết . Một do một phần , và một do biểu tượng phân chia .$6÷2(1+2)$$1$$9$$6÷2(1+2)$2(÷

Mặc dù cả hai nhà toán học và 'người bình thường' sẽ sử dụng PEMDAS (ngoặc - số mũ - Division / Nhân - Bổ sung / Trừ), cho các nhà toán học biểu thức được đánh giá như thế này dưới đây, vì là giống như ví dụ một đơn thức aka " một thuật ngữ đơn do nhân ngụ ý bởi kề nhau " (và do đó là một phần của trong ), mà sẽ được đánh giá khác biệt so với (một nhị thức aka hai nhiệm kỳ):$2(3)$$2x^2$PPEMDAS$2×(3)$

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

Trong khi đó cho 'người bình thường', và sẽ giống nhau (và do đó là một phần của trong ), vì vậy họ sẽ sử dụng này để thay thế:$2(3)$$2×(3)$MDPEMDAS

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

Tuy nhiên, ngay cả khi chúng ta đã viết biểu thức ban đầu là , vẫn có thể có một số tranh cãi do việc sử dụng biểu tượng chia . Trong toán học hiện đại, các ký hiệu và có cùng một nghĩa chính xác: chia. Một số quy tắc trước-1918 ^† về dấu chia ^†† trạng thái đó nó có một ý nghĩa khác với dấu chia . Điều này là do sử dụng để có nghĩa là " chia số / biểu hiện trên trái cùng với số / biểu hiện ở phía bên phải " ^††† . Vì vậy, sau đó, sẽ là hoặc ngay bây giờ. Trong trường hợp$6÷2×(1+2)$a ÷ b ( a ) / ( b ) a÷/÷÷/÷$a ÷ b$$(a) / (b)$$\frac{a}{b}$$6÷2×(1+2)$ sẽ được đánh giá như thế này bởi những người trước năm 1918:

^{: Mặc dù tôi đã tìm thấy nhiều nguồn giải thích về cách ÷sử dụng trong quá khứ (xem bên dưới), tôi không thể tìm thấy bằng chứng chắc chắn điều này đã thay đổi ở đâu đó vào khoảng năm 1918. Nhưng vì thách thức này, chúng tôi cho rằng năm 1918 là bước ngoặt nơi ÷và /bắt đầu có nghĩa là cùng một điều, nơi chúng khác nhau trong quá khứ.}

^{: Các biểu tượng khác cũng đã được sử dụng trong quá khứ để phân chia, như :vào năm 1633 (hoặc hiện vẫn ở Hà Lan và các quốc gia không nói tiếng Anh khác ở châu Âu, vì đây là những gì cá nhân tôi đã học ở trường tiểu học xD) hoặc )ở những năm 1540. Nhưng đối với thử thách này, chúng tôi chỉ tập trung vào ý nghĩa trước năm 1918 của biểu tượng obelus ÷.
: Nguồn: bài viết này nói chung . Và trước-1918 quy định liên quan ÷được đề cập trong: này Các American Mathematical Monthly bài báo từ tháng hai năm 1917 ; cuốn sách Đại số Teutsche của Đức này từ 1659 trang 9 và trang 76 ; Đây là cuốn sách đầu tiên trong đại sốtừ 1895 trang 46 [48/189] .}

Hơi lạc đề: liên quan đến cuộc thảo luận thực tế về biểu hiện này: Không bao giờ nên viết như thế này ngay từ đầu! Câu trả lời đúng là không liên quan, nếu câu hỏi không rõ ràng. * Nhấp vào nút "đóng vì không rõ bạn đang hỏi gì" * .
Và để ghi lại, ngay cả các phiên bản khác nhau của máy tính Casio cũng không biết cách xử lý đúng biểu thức này:

Thử thách:

Bạn được cung cấp hai đầu vào:

• Một biểu thức toán học (hợp lệ) chỉ bao gồm các ký hiệu 0123456789+-×/÷()
• Một năm

Và bạn đưa ra kết quả của biểu thức toán học, dựa trên năm (nơi ÷được sử dụng khác nhau khi , nhưng được sử dụng chính xác như khi ).$year<1918$y e a r ≥ 1918/$year\ge1918$

Quy tắc thử thách:

• Bạn có thể giả sử biểu thức toán học là hợp lệ và chỉ sử dụng các ký hiệu 0123456789+-×/÷(). Điều này cũng có nghĩa là bạn sẽ không phải đối phó với lũy thừa. (Bạn cũng được phép sử dụng một ký hiệu khác cho ×hoặc ÷(tức là *hoặc %), nếu nó giúp chơi gôn hoặc nếu ngôn ngữ của bạn chỉ hỗ trợ ASCII.)
• Bạn được phép thêm dấu phân cách không gian vào biểu thức nhập nếu điều này giúp đánh giá (có lẽ là thủ công) của biểu thức.
• I / O là linh hoạt. Đầu vào có thể là một chuỗi, mảng ký tự, v.v ... Năm có thể là một số nguyên, đối tượng ngày, chuỗi, v.v ... Đầu ra sẽ là một số thập phân.
• Bạn có thể cho rằng sẽ không có bất kỳ phân chia nào cho 0 trường hợp thử nghiệm.
• Bạn có thể giả sử các số trong biểu thức đầu vào sẽ không âm (vì vậy bạn sẽ không phải xử lý phân biệt -ký hiệu âm so -với ký hiệu trừ). Tuy nhiên, đầu ra vẫn có thể âm!
• Bạn có thể giả định N(sẽ luôn luôn được viết như N×(thay thế. Chúng ta sẽ chỉ tập trung vào cuộc tranh cãi thứ hai về các biểu tượng phân chia /so với ÷trong thử thách này.
• Giá trị đầu ra thập phân phải có độ chính xác ít nhất ba chữ số thập phân.
• Nếu biểu thức đầu vào chứa nhiều ÷(tức là ) với , chúng được đánh giá như sau: . (Hoặc bằng chữ: số được chia cho biểu thức , trong đó biểu thức lần lượt có nghĩa là số được chia cho số )$4÷2÷2$$year<1918$$4÷2÷2 → \frac{4}{\frac{2}{2}} → \frac{4}{1} → 4$$4$$2 ÷2$$2 ÷2$$2$$2$
• Lưu ý rằng cách thức ÷hoạt động ngầm có nghĩa là nó có quyền ưu tiên của toán tử ×và /(xem trường hợp thử nghiệm ).$4÷2×2÷3$
• Bạn có thể giả sử năm đầu vào nằm trong phạm vi .$[0000, 9999]$

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ỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , 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 và kiểu trả về, 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 (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

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

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 byte

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

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

Mong đợi dấu bằng =thay vì ÷và *thay vì ×.

Mã này sử dụng một số toán tử quá tải khó chịu, lợi dụng thực tế =là toán tử từ phải sang trái có độ ưu tiên rất thấp (hành vi chính xác mà chúng ta muốn từ trước năm 1918 ÷) và R vẫn giữ nguyên quyền ưu tiên ban đầu khi nó quá tải. Phần còn lại được thực hiện tự động đối với chúng tôi bởi eval.

Như một phần thưởng, đây là cách tiếp cận chính xác tương tự được thực hiện theo cú pháp terser. Lần này toán tử phân chia đặc biệt của chúng tôi là dấu ngã ( ~):

Julia 0,7 , 51 byte

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

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

JavaScript (ES6),  130 129  120 byte

Đã lưu 9 byte nhờ @Scott Hamper

Đưa đầu vào là (year)(expr). Mong đợi %và *thay vì ÷và ×.

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

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

Làm sao?

Xử lý biểu thức lá

$h$$e$%$y$

$y<1918$X%Y(X)/(Y)

Ví dụ:

• 8%2trở thành (8)/(2), có hình thức đơn giản hóa là8/2
• 2+3%3+2 trở thành (2+3)/(3+2)
• 8%2%2trở thành (8)/((2)/(2)), có hình thức đơn giản hóa là8/(2/2)

$y\ge 1918$%/

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

Xử lý các biểu thức lồng nhau

$h$

$g$

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 (tiền phát hành) , 324 310 306 byte

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

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

Mất %thay vì ÷và *thay vì×

Perl 5, 47 97 95 byte

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

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

TIO

Rust - 1066 860 783 755 740 byte

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 không có bất cứ thứ gì như 'eval' nên điều này hơi khó khăn. Về cơ bản, đây là một công cụ đánh giá hỗn hợp Djisktra shunting-yard tiêu chuẩn với một sửa đổi nhỏ. Là toán tử có độ ưu tiên thay đổi: thấp hơn mọi thứ khác (nhưng dấu ngoặc đơn) ở chế độ <1918, cao hơn mọi thứ khác trong chế độ> = 1918. Nó cũng là 'liên kết phải' (hoặc trái?) Cho <1918 để đáp ứng đặc điểm kỹ thuật 4 ÷ 2 2 và liên kết được 'giả mạo' bằng cách đặt ưu tiên âm, sau đó trong quá trình đánh giá xử lý bất kỳ ưu tiên nào <0 như được liên kết. Có nhiều chỗ để chơi gôn hơn nhưng đây là một dự thảo tốt.

Ungolfed tại play.rust-lang.org