Pengantar:

Terinspirasi oleh diskusi yang sudah berlangsung selama bertahun-tahun mengenai ungkapan $6÷2(1+2)$ .

Dengan ekspresi $6÷2(1+2)$ , matematikawan akan segera melihat bahwa jawaban yang benar adalah $1$ , sedangkan orang-orang dengan latar belakang matematika sederhana dari sekolah akan dengan cepat melihat bahwa jawaban yang benar adalah $9$ . Jadi dari mana kontroversi ini dan karena itu jawaban yang berbeda datang? Ada dua aturan yang saling bertentangan tentang bagaimana $6÷2(1+2)$ ditulis. Satu karena bagian 2(, dan satu lagi karena simbol pembagian ÷.

Meskipun ahli matematika dan 'orang awam' akan menggunakan PEMDAS (Parenthesis - Exponents - Division / Multiplication - Addition / Subtraction), untuk matematikawan ekspresi dievaluasi seperti ini di bawah ini, karena $2(3)$ sama seperti misalnya $2x^2$ monomial alias " satu istilah karena penggandaan tersirat oleh penjajaran " (dan karena itu bagian dari Pdalam PEMDAS), yang akan dievaluasi secara berbeda dari $2×(3)$ (binomial alias dua istilah):

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

Sedangkan untuk 'orang biasa', $2(3)$ dan $2×(3)$ akan sama (dan karena itu bagian dari MDdalam PEMDAS), jadi mereka akan menggunakan ini sebagai gantinya:

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

Namun, bahkan jika kita akan menulis ekspresi asli sebagai $6÷2×(1+2)$ , masih ada beberapa kontroversi karena penggunaan simbol pembagian ÷. Dalam matematika modern, /dan ÷simbol memiliki arti yang sama persis: membagi. Beberapa aturan pra-1918 ^† mengenai simbol pembagian ÷^†† menyatakan bahwa ia memiliki makna yang berbeda dari simbol pembagian /. Ini karena ÷digunakan untuk berarti " membagi angka / ekspresi di sebelah kiri dengan angka / ekspresi di sebelah kanan " ^††† . Jadi $a ÷ b$ kemudian, akan$(a) / (b)$ atau$\frac{a}{b}$ sekarang. Dalam hal ini$6÷2×(1+2)$akan dievaluasi seperti ini oleh orang-orang sebelum tahun 1918:

^{†: Meskipun saya telah menemukan banyak sumber yang menjelaskan bagaimana ÷digunakan di masa lalu (lihat ††† di bawah), saya belum dapat menemukan bukti yang pasti bahwa ini berubah di suatu tempat sekitar tahun 1918. Tetapi demi tantangan ini kami menganggap 1918 adalah titik balik di mana ÷dan /mulai berarti hal yang sama, di mana mereka berbeda di masa lalu.}

^{††: Simbol-simbol lain juga telah digunakan di masa lalu untuk pembagian, seperti :pada 1633 (atau sekarang masih di Belanda dan negara-negara berbahasa non-Inggris Eropa lainnya, karena ini adalah apa yang saya pelajari secara pribadi di sekolah dasar xD) atau )di 1540-an. Tetapi untuk tantangan ini kita hanya fokus pada makna simbol obelus pra-1918 ÷.
†††: Sumber: artikel ini secara umum . Dan pra-1918 aturan mengenai ÷disebutkan dalam: ini The Amerika matematika Bulanan artikel dari Februari 1917 ; buku Aljabar Teutsche Jerman ini dari 1659 halaman 9 dan halaman 76 ; ini Sebuah Buku Pertama di Aljabar dari 1895 halaman 46 [48/189] .}

Agak di luar topik: mengenai diskusi aktual tentang ungkapan ini: Ini seharusnya tidak pernah ditulis seperti ini sejak awal! Jawaban yang benar tidak relevan, jika pertanyaannya tidak jelas. * Klik tombol "tutup karena tidak jelas apa yang Anda minta" * .
Dan sebagai catatan, bahkan versi kalkulator Casio yang berbeda tidak tahu cara menangani ungkapan ini dengan benar:

Tantangan:

Anda diberi dua input:

• Ekspresi matematis (valid) yang hanya terdiri dari simbol 0123456789+-×/÷()
• Tahun

Dan Anda output hasil dari ekspresi matematika, berdasarkan tahun (mana ÷yang digunakan berbeda ketika $year<1918$ , tapi digunakan persis sama seperti /ketika $year\ge1918$ ).

Aturan tantangan:

• Anda dapat menganggap ekspresi matematika itu valid dan hanya menggunakan simbol 0123456789+-×/÷(). Ini juga berarti Anda tidak perlu berurusan dengan eksponensial. (Anda juga diperbolehkan menggunakan simbol yang berbeda untuk ×atau ÷(yaitu *atau %), jika itu membantu golf atau jika bahasa Anda hanya mendukung ASCII.)
• Anda diizinkan untuk menambahkan pembatas-ruang ke ekspresi-input jika ini membantu evaluasi (mungkin manual) ekspresi.
• I / O fleksibel. Input dapat berupa string, karakter-array, dll. Tahun dapat sebagai integer, objek-tanggal, string, dll. Output akan berupa angka desimal.
• Anda dapat mengasumsikan tidak akan ada pembagian dengan 0 kasus uji.
• Anda dapat menganggap angka-angka dalam ekspresi-input akan menjadi non-negatif (sehingga Anda tidak harus berurusan dengan membedakan -simbol negatif vs- sebagai simbol pengurangan). Namun output masih bisa negatif!
• Anda dapat menganggap N(akan selalu ditulis sebagai N×(gantinya. Kami hanya akan fokus pada kontroversi kedua simbol divisi /vs÷ dalam tantangan ini.
• Nilai output desimal harus memiliki ketepatan setidaknya tiga digit desimal.
• ÷$4÷2÷2$$year<1918$$4÷2÷2 → \frac{4}{\frac{2}{2}} → \frac{4}{1} → 4$$4$$2 ÷2$$2 ÷2$$2$$2$ )
• Perhatikan bahwa cara ÷kerjanya secara implisit berarti memiliki prioritas operator melebihi ×dan /(lihat test case$4÷2×2÷3$).
• Anda dapat menganggap tahun input berada dalam kisaran $[0000, 9999]$.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

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

Cobalah online!

Mengharapkan tanda persamaan =alih- alih ÷dan *bukan ×.

Kode memanfaatkan beberapa kelebihan operator yang jahat, memanfaatkan fakta bahwa itu =adalah operator kanan-ke-kiri dengan prioritas yang sangat rendah (perilaku persis yang kita inginkan dari pra-1918 ÷), dan R mempertahankan prioritas aslinya ketika kode tersebut kelebihan beban. Sisanya secara otomatis dilakukan untuk kita oleh eval.

Sebagai bonus, berikut ini adalah pendekatan yang persis sama yang diterapkan dalam sintaks terser. Kali ini operator divisi khusus kami adalah tilde ( ~):

Julia 0.7 , 51 byte

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

Cobalah online!

JavaScript (ES6),  130 129  120 byte

Disimpan 9 byte berkat @ScottHamper

Mengambil input sebagai (year)(expr). Mengharapkan %dan *bukannya ÷dan ×.

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

Cobalah online!

Bagaimana?

Memproses ekspresi daun

Fungsi pembantu $h$ mengharapkan ekspresi daun $e$sebagai input, proses semua %simbol sesuai dengan aturan tahun ini$y$ (didefinisikan dalam lingkup induk) dan mengevaluasi string yang dihasilkan.

Jika $y<1918$, kami mentransformasikannya X%Ymenjadi (X)/(Y), untuk menegakkan prioritas rendah dan mengulangi proses ini untuk seluruh string dari kanan ke kiri untuk menegakkan asosiatifitas kanan-ke-kiri.

Contoh:

• 8%2menjadi (8)/(2), yang bentuknya disederhanakan8/2
• 2+3%3+2 menjadi (2+3)/(3+2)
• 8%2%2menjadi (8)/((2)/(2)), yang bentuknya disederhanakan8/(2/2)

Jika $y\ge 1918$, masing %- masing hanya berubah menjadi /.

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

Berurusan dengan ekspresi bersarang

Seperti disebutkan di atas, fungsinya $h$ dirancang untuk beroperasi pada ekspresi daun, yaitu ekspresi tanpa sub-ekspresi lain yang terlampir dalam tanda kurung.

Itu sebabnya kami menggunakan fungsi pembantu $g$ untuk mengidentifikasi dan memproses ekspresi daun tersebut secara rekursif.

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 (pra-rilis) , 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:])

Cobalah online!

Mengambil %alih- alih ÷dan *bukannya×

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

Karat - 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 tidak memiliki sesuatu seperti 'eval' jadi ini agak sulit. Pada dasarnya, ini adalah evaluator infiks shisk-yard Djisktra rawa standar dengan modifikasi minor. ÷ adalah operator dengan presedensi variabel: lebih rendah dari yang lainnya (kecuali tanda kurung) dalam mode <1918, lebih tinggi dari yang lainnya dalam mode> = 1918. Hal ini juga 'terkait kanan' (atau kiri?) Untuk <1918 untuk memenuhi spesifikasi 4 ÷ 2 ÷ 2, dan asosiasi 'dipalsukan' dengan menjadikan ÷ didahulukan negatif, kemudian selama evaluasi memperlakukan setiap prioritas <0 sebagai terkait. Ada lebih banyak ruang untuk bermain golf, tetapi saya rasa ini adalah konsep yang bagus.

Tidak di-play di play.rust-lang.org