Introducción:

Inspirado por una discusión que ya lleva muchos años con respecto a la expresión .$6÷2(1+2)$

Con la expresión , los matemáticos verán rápidamente que la respuesta correcta es , mientras que las personas con antecedentes matemáticos simples de la escuela verán rápidamente que la respuesta correcta es . Entonces, ¿de dónde viene esta controversia y, por lo tanto, diferentes respuestas? Hay dos reglas en conflicto en cómo se escribe . Uno debido a la parte y otro debido al símbolo de división .$6÷2(1+2)$$1$$9$$6÷2(1+2)$2(÷

Aunque tanto los matemáticos como las 'personas comunes' usarán PEMDAS (Paréntesis - Exponentes - División / Multiplicación - Suma / Resta), para los matemáticos la expresión se evalúa así a continuación, porque es como, por ejemplo, un monomio también conocido como " un solo término debido a la multiplicación implícita por yuxtaposición " (y, por lo tanto, parte de in ), que se evaluará de manera diferente a (un binomio, también conocido como dos términos):$2(3)$$2x^2$ 2 × ( 3 )PPEMDAS$2×(3)$

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

Mientras que para la gente común '', y será el mismo (y por lo tanto parte de la en ), por lo que vamos a usar esto en su lugar:$2(3)$$2×(3)$MDPEMDAS

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

Sin embargo, incluso si hubiéramos escrito la expresión original como , todavía puede haber cierta controversia debido al uso del símbolo de división . En las matemáticas modernas, los símbolos y tienen exactamente el mismo significado: dividir. Algunas reglas anteriores a 1918 ^{† con} respecto al símbolo de división ^†† establecen que tenía un significado diferente que el símbolo de división . Esto se debe a que solía significar " dividir el número / expresión a la izquierda con el número / expresión a la derecha " ^††† . Entonces entonces, sería o ahora. En cuyo caso$6÷2×(1+2)$a ÷ b ( a ) / ( b ) a÷/÷÷/÷$a ÷ b$$(a) / (b)$$\frac{a}{b}$$6÷2×(1+2)$ sería evaluado así por personas anteriores a 1918:

^{†: Aunque he encontrado múltiples fuentes que explican cómo ÷se usó en el pasado (ver ††† más abajo), no he podido encontrar una prueba definitiva de que esto cambió en algún lugar alrededor de 1918. Pero por el bien de este desafío, asumimos que 1918 fue el punto de inflexión donde ÷y /comenzando a significar lo mismo, donde diferían en el pasado.}

^{††: Otros símbolos también se han utilizado en el pasado para la división, como :en 1633 (o ahora todavía en los Países Bajos y otros países europeos que no hablan inglés, ya que esto es lo que aprendí personalmente en la escuela primaria xD) o )en La década de 1540. Pero para este desafío solo nos enfocamos en el significado anterior al 1918 del símbolo obelus ÷.
†††: Fuentes: este artículo en general . Y las reglas anteriores a 1918 con respecto a ÷se mencionan en: este artículo de The American Mathematical Monthly de febrero de 1917 ; este libro alemán de álgebra teutsche de 1659, página 9 y página 76 ; este primer libro en álgebrade 1895 página 46 [48/189] .}

Ligeramente fuera de tema: con respecto a la discusión real sobre esta expresión: ¡Nunca debería escribirse así en primer lugar! La respuesta correcta es irrelevante, si la pregunta no está clara. * Hace clic en el botón "cerrar porque no está claro lo que está preguntando" * .
Y para el registro, incluso las diferentes versiones de las calculadoras Casio no saben cómo manejar adecuadamente esta expresión:

Reto:

Te dan dos entradas:

• Una expresión matemática (válida) que consta solo de los símbolos 0123456789+-×/÷()
• Un año

Y genera el resultado de la expresión matemática, basada en el año (donde ÷se usa de manera diferente cuando , pero se usa exactamente igual que cuando ).$year<1918$y e a r ≥ 1918/$year\ge1918$

Reglas de desafío:

• Puede suponer que la expresión matemática es válida y solo usa los símbolos 0123456789+-×/÷(). Esto también significa que no tendrá que lidiar con la exponenciación. (También se le permite usar símbolos diferentes para ×o ÷(es decir, *o %), si esto ayuda al golf o si su idioma solo es compatible con ASCII).
• Se le permite agregar delimitadores de espacio a la expresión de entrada si esto ayuda a la evaluación (quizás manual) de la expresión.
• I / O es flexible. La entrada puede ser como una cadena, una matriz de caracteres, etc. El año puede ser como un entero, un objeto de fecha, una cadena, etc. La salida será un número decimal.
• Puede suponer que no habrá división por 0 casos de prueba.
• Puede suponer que los números en la expresión de entrada no serán negativos (por lo que no tendrá que tratar de diferenciar el -símbolo como negativo frente -al símbolo de resta). ¡Sin embargo, la salida aún puede ser negativa!
• Puede suponer N(que siempre se escribirá como en su N×(lugar. Sólo nos centraremos en la segunda controversia de los símbolos de división /frente a ÷este reto.
• Los valores de salida decimales deben tener una precisión de al menos tres dígitos decimales.
• Si la expresión de entrada contiene múltiples ÷(es decir, ) con el , se evalúan así: . (O en palabras: el número se divide por la expresión , donde la expresión a su vez significa que el número se divide por el número ).$4÷2÷2$$year<1918$$4÷2÷2 → \frac{4}{\frac{2}{2}} → \frac{4}{1} → 4$42÷22÷222$4$$2 ÷2$$2 ÷2$$2$$2$
• Tenga en cuenta que la forma en que ÷funciona implícitamente significa que tiene prioridad sobre el operador ×y /(ver caso de prueba ).$4÷2×2÷3$
• Puede suponer que el año de entrada está dentro del rango .$[0000, 9999]$

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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 bytes

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

Pruébalo en línea!

Espera signo de igualdad en =lugar de ÷y en *lugar de ×.

El código utiliza una sobrecarga de operadores desagradable, aprovechando el hecho de que =es un operador de derecha a izquierda con muy poca precedencia (el comportamiento exacto que deseamos desde antes de 1918 ÷), y R conserva su precedencia original cuando es sobrecargado. El resto se hace automáticamente por nosotros eval.

Como beneficio adicional, aquí está el mismo enfoque exacto implementado en la sintaxis terser. Esta vez, nuestro operador de división especial es tilde ( ~):

Julia 0.7 , 51 bytes

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

Pruébalo en línea!

JavaScript (ES6),  130129  120 bytes

Guardado 9 bytes gracias a @ScottHamper

Toma entrada como (year)(expr). Espera %y en *lugar de ÷y ×.

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

Pruébalo en línea!

¿Cómo?

Procesando expresiones de hoja

$h$$e$%$y$

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

Ejemplos:

• 8%2se convierte (8)/(2), cuya forma simplificada es8/2
• 2+3%3+2 se convierte (2+3)/(3+2)
• 8%2%2se convierte (8)/((2)/(2)), cuya forma simplificada es8/(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()

Manejo de expresiones anidadas

$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 (prelanzamiento) , 324 310 306 bytes

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

Pruébalo en línea!

Toma en %lugar de ÷y en *lugar de×

Perl 5, 47 97 95 bytes

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

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

TIO

Óxido - 1066 860 783 755 740 bytes

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 no tiene nada como 'evaluar', así que esto es un poco difícil. Básicamente, este es un evaluador infijo de patio de maniobras Djisktra estándar de pantano con una modificación menor. ÷ es un operador con una precedencia variable: más bajo que todo lo demás (excepto paréntesis) en modo <1918, más alto que todo lo demás en modo> = 1918. También es 'asociado a la derecha' (¿o a la izquierda?) Para que <1918 cumpla con la especificación 4 ÷ 2 ÷ 2, y la asociación se 'falsifica' haciendo que la prioridad sea negativa, luego durante la evaluación se trata cualquier prioridad <0 como asociada. Hay más espacio para jugar al golf, pero creo que este es un buen borrador.

Sin golf en play.rust-lang.org