Introduzione:

Ispirato da una discussione che dura già da molti anni sull'espressione $6÷2(1+2)$ .

Con l'espressione $6÷2(1+2)$ , i matematici vedranno rapidamente che la risposta corretta è $1$ , mentre le persone con un background matematico semplice da scuola vedranno rapidamente che la risposta corretta è $9$ . Da dove viene questa controversia e quindi diverse risposte? Esistono due regole contrastanti nel modo in cui $6÷2(1+2)$ è scritto. Uno a causa della parte 2(e uno a causa del simbolo di divisione ÷.

Sebbene sia i matematici che le 'persone comuni' useranno PEMDAS (Parentesi - Esponenti - Divisione / Moltiplicazione - Aggiunta / Sottrazione), per i matematici l'espressione viene valutata come questa di seguito, perché $2(3)$ è proprio come per esempio $2x^2$ un monomiale aka " un singolo termine dovuto alla moltiplicazione implicita per giustapposizione " (e quindi parte di Pin PEMDAS), che sarà valutato in modo diverso da $2×(3)$ (un binomio aka due termini):

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

Considerando che per "gente comune", $2(3)$ e $2×(3)$ saranno gli stessi (e quindi parte di MDin PEMDAS), quindi useranno invece questo:

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

$6÷2×(1+2)$÷/÷÷/÷$a ÷ b$$(a) / (b)$$\frac{a}{b}$$6÷2×(1+2)$

^{†: Anche se ho trovato più fonti che spiegano come è ÷stato usato in passato (vedi ††† sotto), non sono stato in grado di trovare prove definitive che questo sia cambiato da qualche parte intorno al 1918. Ma per il bene di questa sfida supponiamo che il 1918 fosse la svolta in cui ÷e /iniziando a significare la stessa cosa, in cui differivano in passato.}

^{††: Altri simboli sono stati usati anche in passato per la divisione, come :nel 1633 (o ora ancora nei Paesi Bassi e in altri paesi europei non di lingua inglese, poiché questo è ciò che ho imparato personalmente nella scuola primaria xD) o )in il 1540s. Ma per questa sfida ci concentriamo solo sul significato pre-1918 del simbolo obelus ÷.
†††: Fonti: questo articolo in generale . E le regole pre-1918 relative ÷sono menzionate in: questo articolo di The American Mathematical Monthly del febbraio 1917 ; questo libro tedesco di Teutsche Algebra del 1659 pagina 9 e pagina 76 ; questo Un primo libro in Algebradal 1895 pagina 46 [48/189] .}

Leggermente fuori tema: riguardo alla discussione effettiva su questa espressione: in primo luogo non dovrebbe mai essere scritto così! La risposta corretta è irrilevante, se la domanda non è chiara. * Fai clic sul pulsante "chiudi perché non è chiaro cosa stai chiedendo" * .
E per la cronaca, anche diverse versioni dei calcolatori Casio non sanno come gestire correttamente questa espressione:

Sfida:

Ti vengono dati due input:

• Un'espressione matematica (valida) che consiste solo dei simboli 0123456789+-×/÷()
• Un anno

÷$year<1918$/$year\ge1918$

Regole della sfida:

• Puoi supporre che l'espressione matematica sia valida e usi solo i simboli 0123456789+-×/÷(). Questo significa anche che non dovrai affrontare l'espiazione. (Puoi anche usare simboli diversi per ×o ÷(cioè *o %), se aiuta il golf o se la tua lingua supporta solo ASCII.)
• Puoi aggiungere delimitatori di spazio all'espressione di input se ciò aiuta la valutazione (forse manuale) dell'espressione.
• L'I / O è flessibile. L'input può essere una stringa, un array di caratteri, ecc. L'anno può essere un numero intero, un oggetto data, una stringa, ecc. L'output sarà un numero decimale.
• Puoi presumere che non ci sarà alcuna divisione per 0 casi di test.
• Puoi supporre che i numeri nell'espressione di input siano non negativi (quindi non dovrai occuparti di differenziare il -simbolo come negativo rispetto -al simbolo di sottrazione). L'output può comunque essere negativo!
• Puoi presumere che N(sarà sempre scritto come N×(invece. Ci concentreremo solo sulla seconda controversia sui simboli di divisione /contro ÷questa sfida.
• I valori di output decimali devono avere una precisione di almeno tre cifre decimali.
• ÷$4÷2÷2$$year<1918$$4÷2÷2 → \frac{4}{\frac{2}{2}} → \frac{4}{1} → 4$$4$$2 ÷2$$2 ÷2$$2$$2$
• ÷×/$4÷2×2÷3$
• $[0000, 9999]$

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

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

Provalo online!

Prevede il segno di uguaglianza =anziché ÷e *invece di ×.

Il codice si avvale di un brutto sovraccarico per l'operatore, sfruttando il fatto che =è un operatore da destra a sinistra con una precedenza molto bassa (il comportamento esatto che vogliamo da prima del 1918 ÷), e R mantiene la sua precedenza originale quando è sovraccarico. Il resto viene fatto automaticamente per noi da eval.

Come bonus, ecco lo stesso approccio esatto implementato nella sintassi del terser. Questa volta il nostro operatore di divisione speciale è tilde ( ~):

Julia 0,7 , 51 byte

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

Provalo online!

JavaScript (ES6),  130 129  120 byte

Salvato 9 byte grazie a @ScottHamper

Accetta input come (year)(expr). Si aspetta %e *invece di ÷e ×.

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

Provalo online!

Come?

Elaborazione di espressioni fogliari

$h$$e$%$y$

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

Esempi:

• 8%2diventa (8)/(2), la cui forma semplificata è8/2
• 2+3%3+2 diventa (2+3)/(3+2)
• 8%2%2diventa (8)/((2)/(2)), la cui forma semplificata è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()

Trattare con espressioni nidificate

$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 (pre-release) , 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:])

Provalo online!

Prende %invece di ÷e *invece di×

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

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

La ruggine non ha niente come "eval", quindi è un po 'difficile. Fondamentalmente, questo è un valutatore di infissi Djisktra standard da palude con una piccola modifica. ÷ è un operatore con una precedenza variabile: inferiore a tutto il resto (tranne parentesi) nella modalità <1918, superiore a tutto il resto nella modalità> = 1918. È anche "associato a destra" (o a sinistra?) Per <1918 per soddisfare la specifica 4 ÷ 2 ÷ 2, e l'associazione è "falsata" rendendo ÷ precedenza negativa, quindi durante la valutazione trattando qualsiasi precedenza <0 come associata. C'è più spazio per il golf, ma penso sia una buona brutta copia.

Ungolfed su play.rust-lang.org