Muchas gracias a todos por su ayuda con el cálculo . Ahora necesito ayuda con mi próxima prueba de trigonometría.

En la prueba, tendré que simplificar las expresiones. Se me dará una entrada como 4sin(x)/(2cos(x))y tendré que producir una expresión más simple pero equivalente (como 2tan(x)). Todos los ángulos están en grados, y fingiremos que no hay problemas de división por cero o de dominio no válido. (Por ejemplo, supondremos que tan (x + 1) cot (x + 1) sin (x) / sin (x) es siempre 1.)

Me colé en la oficina del profesor y obtuve una lista de 100 problemas que podrían estar en la prueba. Por favor, dame el código para resolverlos todos. Es posible que algunos de los problemas ya estén simplificados tanto como sea posible; Si es así, simplemente devuelva la entrada.

Necesito expresiones para simplificar, pero también quiero un programa corto (o función) para que el profesor no se dé cuenta. Intente minimizar la suma de la duración del programa y la duración total de todas las soluciones.

Solo para aclarar, está bien si algunas de las expresiones se devuelven sin cambios, o incluso se devuelven en una forma equivalente pero más larga. Además, el programa solo necesita trabajar en las expresiones enumeradas a continuación; puede devolver resultados incorrectos o incluso romper para otras entradas.

Como puede ver, todos los problemas siguen un formato similar. xes la única variable utilizada, no hay espacios y los paréntesis siguen a cada nombre de función. (Las funciones son sin, cos, tan, sec, csc, y tan.) No hay funciones anidadas, pero dentro de una función pueden ser una expresión como 3x+4.5o -2-.7x. Se pueden usar exponentes, pero solo en funciones (por ejemplo sin(x-.5)^7), y la potencia siempre es un número entero por encima de uno. La multiplicación se indica mediante concatenación.

Las salidas también deberán estar en este formato. No válido: sin x, sin(x)/cos(x)tan(x)[? Es la tangente multiplicado o dividido], cos(x[cerrar todos los paréntesis], 4*sin(x),sec(x)^1

Puedo usar cualquier lenguaje de programación, a menos que se base en funciones integradas de simplificación o manejo de expresiones. Las funciones trigonométricas incorporadas están bien. (Tendré una calculadora científica muy básica durante la prueba). Además, como leeré el programa escrito en papel, solo puedo usar caracteres ASCII imprimibles (0x20 a 0x7E) y líneas nuevas.

1/(sec(x))
4+sin(x)+3
(cos(7x+4)-sin(-3x))/(sin(-3x))
2sin(x)2tan(x).25cos(x)^3cos(x)+1+1
7cos(x)sec(x)/(14tan(x)csc(x))
sin(x)cos(x)/sec(x)
8sin(x)cos(x)sin(x)/tan(x)+8sin(x)
sin(x)^9cos(x)cot(x)sec(x)csc(x)sec(x)tan(x)/(cot(x)^2tan(x)cos(x)^4cot(x)sin(x))
tan(x)cos(x)csc(x)
tan(x+1)sin(x-1)cos(x+1)^3tan(x-1)^2sin(-x+1)csc(x+1)tan(-x+1)/(cos(x-1)cot(x+1))
(cos(2x)+cot(2x)-sin(2x)+csc(2x)^3)/(cot(2x)+sin(2x))
cos(90-x)cos(x)
sin(x+180)sec(450-x)
tan(-x)sin(x+90)sec(x-90)
tan(x+180)^2
cot(-x)cos(-x)
cot(180-x)^3cos(270-x)^2
sin(.1x-.2)sin(.1x-.2)sin(.1x-.2)sin(.2-.1x)sin(.2-.1x)
sin(x)
sin(90-x)sin(x)+cos(90-x)/sec(x)
tan(3x+2)cos(3x+2)/sin(3x+2)-1
cos(x)cos(x)cos(x)cos(x)cos(x)
sec(2x+1)sec(-1-2x)+sec(-2x-1)sec(2x+1)
cos(4x)cot(4x)tan(4x)sin(4x)csc(4x)
-cos(x)+cos(x)+sin(2x-4)-1/csc(2x-4)
sec(x)sec(x+2)cot(x)tan(x-2)tan(x+180)
tan(x)(tan(x))
3sin(x)sin(x)/(3)
cos(x)sin(x)
tan(x)sec(x)^2
tan(x)^2-sec(x)^2
7+sin(x)csc(x)csc(x)+cot(x)^2
sin(90)+cos(-90)+sec(180)
csc(1)+csc(10)-csc(30)-csc(60)+csc(90)
sin(36000001)
csc(800)+(cot(720+x)-sec(4x-720))
sin(-x)+sin(x)
csc(-x)+csc(x)
4sin(x)-sin(x)+tan(x)-2tan(x)
cot(x)+10cot(x+90)+99cot(x+180)+.01cot(x-90)
tan(x)tan(x+180)
sec(x)sin(x+180)tan(x-270)cot(x-450)csc(x+90)
sin(x)/cot(x)+sin(x)/cot(x)
sin(x)csc(x)+tan(x)cot(x)+cos(x)sec(x)
cot(x)
9tan(x+90)+90tan(x+9)
cos(x-9999)+tan(x+99999)
2tan(x)tan(x)/2
tan(x)/tan(x-360)+cos(x+180)/cos(x)
csc(4x)sec(270-4x)
cot(91+x)tan(x-449)
csc(2x)(csc(2x)-sin(2x))
csc(x+1)^2-cot(x+1)cot(x+1)
cot(x)cot(x)+1
tan(x)^2-sec(x)sec(x)
tan(x)/cot(x)+csc(x)/csc(x)
cot(x)sin(x)/cos(x)
csc(x)tan(x)cos(x)
csc(x)cot(x)cos(x)
csc(x+90)csc(-x+270)-1
cot(x)/cot(x)+tan(x)/cot(x)+cot(x)cot(x)
sec(x)sec(x)sec(x)sec(x+90)sec(x-90)sec(x+180)
1-cos(x)cos(x+180)+sin(x)^2
sec(x)sec(x)sec(x)sec(x)/cos(x)+cot(x)
cot(x+1)csc(x-1)sec(x+1)tan(x-1)sin(x+1)cos(x-1)
sin(x)-cos(x)+tan(x)-sec(x)+cos(x)-csc(x)
tan(x+23515)-sec(-.27x-23456)
sec(-.9x)
-tan(-x)-csc(360-x)
cos(-x)sec(x)sin(x)csc(-x)
tan(-x)^2-sin(-x)/sin(x)
tan(x)tan(x)+1
csc(x)^2-1
cot(2x)cot(2x)-csc(2x)/sin(2x)
2sec(x)/(6cos(x))
sec(0)+tan(30)cos(60)-csc(90)sin(120)cot(150)+tan(180)csc(210)sin(240)-cos(270)sec(300)+cot(330)
tan(x-1234567)sec(4781053+x)^2
tan(-1234567x)sec(4781053x)^2
sin(x)^9+cos(x)^7+csc(x)^5-cot(x)^3
cos(-33x-7.7)
sec(-.1-x)+tan(-2x-77)
tan(x)+sin(x)-cos(x)+tan(x)-sin(x)
cos(x)-sec(x)/tan(x)+tan(x)/sin(x)
cot(x)-cos(x)/sin(x)
3cos(x)+2/sec(x)-10sin(x)/(2tan(x))
tan(x+3)^11+sin(x+3)^8-cos(x+3)^5+5
sec(x)+sec(x)
csc(.1x)csc(-.1x)csc(x)
cot(x-7)cot(x-7)cot(x+173)cot(x-7)cot(x+173)cot(x-367)
cos(.0001x+1234567)
cot(45)+tan(225)-sin(210)+cos(-60)
sin(12345)cos(23456)tan(34567)sec(45678)csc(56789)cot(67890)
cos(1234x)+cot(1234)+tan(1234x)+sec(1234)+csc(1234)+sin(1234x)
sec(x)sec(x)sec(x)sec(x)sec(x)sec(x)
csc(x)cot(x)sec(x)csc(x)tan(x)sec(x)cot(x)csc(x)cot(x)cos(x)cos(x)cot(x)sin(x)sin(x)cot(x)
csc(2553273)+cot(1507348)-sec(5518930)+csc(5215523)+tan(3471985)-sec(4985147)
sin(20x)+cos(20x)-tan(20x)+sin(20x)-csc(20x)+cot(20x)-tan(20x)+csc(20x)
cot(100000)+cot(100000x)+cot(100000x)+cot(100000)
csc(5x+777)sin(5x+777)
csc(4.5x)

Nota: Este escenario es completamente ficticio. En la vida real, hacer trampa y ayudar a otros a hacer trampa está mal y nunca se debe hacer.

Python, 436 + 1909 = 2345

Esta debe ser una de las soluciones más ineficientes imaginables y los matemáticos probablemente se avergonzarán, pero he logrado juntar algo que realmente simplifica aproximadamente la mitad de las expresiones sin ningún tipo de codificación:

from math import*
import exrex,re
d=lambda f:lambda x:f(x*pi/180)
sin,cos,tan=d(sin),d(cos),d(tan)
i=lambda f:lambda x:1/f(x)
sec,csc,cot=i(cos),i(sin),i(tan)
t=lambda s:[round(eval(re.sub('([\d\).])([\(a-z])','\\1*\\2',s).replace('^','**')+'+0')*1e9)for x in[1,44]]
def f(I):
 try:return min((s for s in exrex.generate('(-?\d|\(1/\d\.\))?([+-]?(sin|cos|tan|cot|sec|csc)\(x\)(\^\d)?){0,4}')if s and t(s)==t(I)),key=len)
 except:return I

El resultado para los 100 casos de prueba debe ser el siguiente (donde #marca expresiones que no fueron simplificadas):

cos(x)
7+sin(x)
#
2+tan(x)^2cos(x)^2
(1/2.)cos(x)
sin(x)cos(x)^2
#
sin(x)^2tan(x)^7
1
#
#
sin(x)cos(x)
-1
-1
tan(x)^2
-cot(x)cos(x)
-cot(x)cos(x)^2
#
sin(x)
2sin(x)cos(x)
0
cos(x)^5
#
#
#
#
tan(x)^2
sin(x)^2
sin(x)cos(x)
tan(x)sec(x)^2
-1
7+cot(x)^2+csc(x)
0
#
#
#
0
0
3sin(x)-tan(x)
#
tan(x)^2
-tan(x)sec(x)
2sin(x)tan(x)
3
cot(x)
#
#
tan(x)^2
0
#
1
#
1
csc(x)^2
-1
sec(x)^2
1
1
cot(x)^2
-1-sec(x)^2
cot(x)^2+sec(x)^2
sec(x)^4csc(x)^2
2
cot(x)+sec(x)^5
#
sin(x)+tan(x)-csc(x)-sec(x)
#
#
tan(x)+csc(x)
-1
sec(x)^2
sec(x)^2
cot(x)^2
-1
(1/3.)sec(x)^2
#
#
#
#
#
#
2tan(x)-cos(x)
cos(x)-csc(x)+sec(x)
0
0
#
2sec(x)
#
#
#
3
#
#
sec(x)^6
cot(x)^4csc(x)
#
#
#
1
#

La idea es muy simple:

• generar una gran cantidad de posibles expresiones
• seleccione aquellos que producen el mismo resultado que la expresión que desea simplificar, comparándolos para algunos (aquí dos) valores x
• de las expresiones equivalentes devuelven la más corta

El problema es que hay muchas expresiones posibles para verificar, así que lo limité a un subconjunto.

Para ser honesto, no tuve la paciencia suficiente para probar el código de golf anterior. (Dígame si cree que eso es hacer trampa). En su lugar, utilicé una regla mucho más larga pero más eficiente para generar un subconjunto de expresiones aún más pequeño que, con suerte, todavía contiene todas las simplificaciones deseadas. Si desea probar eso, reemplace la expresión regular en la penúltima línea del código con lo siguiente (y prepárese para unos minutos de tiempo de cálculo):

'0|((-1|\(1/[23]\.\)|[1237])[+-]?)?(sin\(x\)(\^2)?)?-?(tan\(x\)(\^[27])?)?(cot\(x\)(\^[24])?)?[+-]?(cos\(x\)(\^[25])?)?(sec\(x\)(\^[2456])?)?(csc\(x\)(\^2)?)?'

El programa también contiene bastante sobrecarga que era necesaria para que Python entendiera las expresiones matemáticas. Esto implicó

• redefiniendo sin, cosy tantomar argumentos en grados en lugar de radiens (que es lo que creo que la OP dicho)
• definitoria sec, cscy cotque no son parte del mathpaquete
• insertando todos los signos de multiplicación implícitos
• reemplazando el operador de exponenciación

CJam, 1 + 3000 = 3001

Así como la solución de referencia para dar a las personas algo que superar:

l

Esto lee STDIN en la pila, cuyo contenido se imprime al final del programa.

Estoy seguro de que esto se puede superar, pero también estoy seguro de que no se pueden implementar muchas optimizaciones en los personajes que se obtendrían.

Javascript (438 + 2498 = 2936)

El objeto en el medio opcionalmente contiene salidas simplificadas basadas en la longitud de la entrada y el primer carácter. De lo contrario, la entrada se devuelve sin modificar.

s='sin(x)';(p=prompt)({
    352:s+"^2cos(x)^3+2",
    307:"cos(x)/2",
    348:s+"8(1+cos(x)^2)",
    "81s":s+"^2tan(x)^7",
    "55s":"-sin(0.2-0.1x)^5",
    "39s":"2sec(2x+1)^2",
    "35c":"cos(4x)",
    "36-":0,
    173:s+"^2",
    "25s":0,
    294:s+"3-tan(x)",
    "27s":s+"2/cot(x)",
    "40c":"1+tan(x)^2+cot(x)^2",
    "48c":1,
    "41s":s+"+tan(x)-csc(x)-sec(x)",
    "26c":-1,
    "24t":"1+tan(x)^2",
    "96s":"2.5+1/cos(30)",
    "34t":"2tan(x)-cos(x)",
    353:0,
    "36s":"6sec(x)",
    "90s":"cot(x)^4csc(x)"
}[(i=p()).length+i[0]]||i)

El espacio en blanco es solo para decoración y no está incluido en el recuento de caracteres.

Es una pena que agregar todas estas soluciones solo me haya ahorrado algunos caracteres, pero mejor que nada. La simplificación se realizó a través de wolframalpha, solo confiaré en ella.