Acortar una expresión matemática ya corta

15

Por una vez, estaba haciendo un trabajo real, actualizando el código antiguo, y me topé con una expresión que es equivalente a lo que se escribiría como πx + e x en una buena matemática tradicional . Pensé que sería posible escribirlo más corto de lo que estaba escrito en el idioma con el que trabajo (APL) y, por lo tanto, presentar este desafío muy simple:

Escriba una función o programa que (por cualquier medio) acepte cero o más números y devuelva (por cualquier medio) el resultado de la expresión anterior para x = cada uno de los números dados con al menos 3 dígitos significativos para cada resultado.

Si su idioma no tiene π y / o e , use los valores 3.142 y 2.718.

El puntaje es el número de bytes, por lo tanto, prologue su respuesta con # LanguageName, 00 bytes.

Los agujeros de bucle estándar no están permitidos.


Editar: Ahora la solución que se me ocurrió, ○+*, ha sido encontrado . El código original era (○x)+*x.

Adán
fuente
55
¿De qué dominio se extraen las entradas? ¿Enteros, reales, números complejos?
Martin Ender
1
@ MartinBüttner Lo que quieras, siempre que la salida no esté restringida a un entero.
Adám

Respuestas:

21

Dyalog APL, 3 caracteres

Como una frase tácita.

○+*

Monadic multiplica su argumento con π, monadic *es la función exponencial exp. ○+*es un tren tal que (○+*)ωes igual a (○ω)+(*ω). Como se trata de APL, la frase funciona para argumentos de forma arbitraria, e. sol. Puede pasar un vector de longitud arbitraria.

La misma solución es posible en J como o.+^con o.ser y ^ser *.

FUZxxl
fuente
:-) Ver "Editar:" en OP.
Adám
Entonces, te rechacé por error y solo me di cuenta. ¿Te importa hacer alguna edición menor para que pueda cambiar eso?
ankh-morpork
@ dohaqatar7 ¿Te gusta esto?
FUZxxl
30

Emotinomicon, 48 bytes / 13 caracteres

Lo hago, no porque sea corto, sino porque es divertido. Pruébalo aquí. Tendrás que copiarlo y pegarlo en el cuadro de texto.

😼⏪🆙😦✖😎😿➕😨😼🆙😄⏩

Explicación:

😼  ⏪   🆙  😦  ✖   😎  😿  ➕   😼  🆙  😄  ⏩   explanation
😼                                              take numeric input
    ⏪                                           open loop
        🆙                                      duplicate top of stack
            😦                                  push pi
                ✖                               multiply top two elements on stack
                    😎                          reverse stack
                        😿                      pop N, push e^N
                            ➕                   add top two elements on stack
                                😼              take numeric input
                                    🆙          duplicate top of stack
                                        😄      pop N, push N+1
                                            ⏩   close loop

Aquí está el programa en su entorno nativo, el teléfono móvil: la imagen

Conor O'Brien
fuente
1
Definitivamente la expresión más entretenida.
Adám
77
Lol, un gato para cat?
geokavel
3
Quiero este idioma
Faraz Masroor
2
Supongo que se podría decir que el uso sub- expresiones . (• _ •) (• _ •)> ⌐ ■ - ■ (⌐ ■ _ ■)
Addison Crump
9

R, 25 24 bytes

cat(exp(x<-scan())+pi*x)    

Es esto? Obtiene información del usuario, se la asigna x, calcula su multiplicación exponencial pi, y finalmente cat()imprime el resultado.

editar: 1 bytes guardados gracias a Alex A.

Mutador
fuente
1
Me parece bien.
Adám
2
24 bytes:cat(exp(x<-scan())+pi*x)
Alex A.
En este caso, debe usar <-como lo hice en mi sugerencia en lugar de =porque, de lo contrario, establece el xargumento exppero no asigna la variable x. En una sesión nueva, el código actual fallará.
Alex A.
7

JavaScript (ES6), 39 34 bytes

Guardado 5 bytes gracias a @ edc65

a=>a.map(x=>x*Math.PI+Math.exp(x))

Toma la entrada como una matriz de números y las salidas en el mismo formato.

Gracias a la reducción, ahora hay tres programas equivalentes de 45 bytes, todos compatibles con ES5:

for(;x=prompt();)alert(x*Math.PI+Math.exp(x))
for(M=Math;x=prompt();)alert(x*M.PI+M.exp(x))
with(Math)for(;x=prompt();)alert(x*PI+exp(x))

Las entradas deben ingresarse una a la vez. Presione OK sin ingresar nada para salir.

El tercero destaca una característica interesante en JS: la withdeclaración. Si bien a veces es inseguro de usar (por lo tanto, deshabilitado en modo estricto), todavía se puede usar para guardar la escritura de un nombre de objeto y punto cada vez que necesite acceder a él. Por ejemplo, puedes hacer esto:

x=[];with(x)for(i=0;i<5;i++)push(length);

pushy lengthluego se usan como propiedades de x, lo que resultará en xser[0,1,2,3,4] .

Esto funciona en cualquier objeto, incluso no variables, por ejemplo, puede hacer esto:

with("0123456789ABCDEF")for(i=0;i<length;i++)alert("0x"+charAt(i)-0);

charAty lengthse llaman como propiedades de la cadena. "0x"+x-0convierte xde un valor hexadecimal a un número, por lo que estos son alertlos números del 0 al 15.

ETHproductions
fuente
1
M.pow(M.E,x)es M.exp(x)por definición
edc65
@ edc65 debería aprender mi Math;) ¡Gracias!
ETHproductions
No sabía que withestaba en desuso.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Mi mal; no está en desuso, pero se recomienda evitarlo .
ETHproductions
Eso es lo que recuerdo haber leído. ^ _ ^ Lo uso de todos modos en <canvas>renderizado y (por supuesto) golf.
Conor O'Brien
6

Mathematica, 11 10 bytes

N@Pi#+E^#&

Con 1 byte guardado gracias a LegionMammal978.

DavidC
fuente
Esto actualmente no funciona. Sin embargo, para 10 bytes:1.Pi#+E^#&
LegionMammal978
Faltaba un espacio entre #y Pi. Esto se resuelve utilizando Pi#en lugar de #Pi. Además, Nsolo necesita aplicarse Pi#, no toda la expresión.
DavidC
6

Pyth, 11 13

VQ+*N.n0^.n1N

Ahora toma xcomo una lista, por ejemplo[1.25, 2.38, 25]

Anterior (11 bytes): +*Q.n0^.n1Q

VQ            +       * N .n0            ^ .n1 N
For each      Add     List Item * Pi     e ^ List Item
input item
Alce
fuente
Cuando intento esto con el intérprete en línea, solo funciona para un solo número. ¿O cuál es el formato de entrada? La especificación dice que la entrada es "cero o más números", y la expresión debe evaluarse para "cada uno de los números dados".
Reto Koradi
@RetoKoradi puede ejecutarlo con múltiples números (en líneas separadas) marcando la casilla "cambiar a conjunto de pruebas". No estoy seguro si eso está permitido ahora que lo mencionas.
Moose
5

En serio, 10 bytes

,`;e(╦*+`M

Hex Dump:

2c603b6528cb2a2b604d

Pruébalo en línea

Toma entradas como una lista (ver enlace por ejemplo).

Explicación:

,                               Get input list
 `      `M                      Map this function over it
  ;                             Copy the input value.
   e                            exponentiate
    (                           dig up the other copy
     ╦*                         multiply by pi
       +                        add
quintapia
fuente
5

MATLAB, 15 bytes

@(x)pi*x+exp(x)
costrom
fuente
5

TI-BASIC, 5 bytes

πAns+e^(Ans

TI-Basic no utiliza bytes ASCII, por lo que cada uno de ellos se registra como un byte en la calculadora: π, Ans, +, e^(, y Ans. Se supone que la expresión anterior es la entrada (como {1,2,3}).

NinjaOsoMono
fuente
5

Python 2, 38 bytes ( 52 49 bytes con matemática)

lambda l:[3.142*x+2.718**x for x in l]

Si tengo que usar el módulo matemático:

from math import*
lambda l:[pi*x+e**x for x in l]

La entrada debe ser una lista de números

f([1,2,3,4,5])

> [5.8599999999999994, 13.671524, 29.505290232, 67.143510850576007, 164.04623849186558]
TFeld
fuente
2
If your language does not have π and/or e, use the values 3.142 and 2.718.... Python tiene piy een el mathmódulo.
Zach Gates
@ZachGates Se agregó una versión con módulo matemático.
TFeld
Puede guardar 3 bytes en la mathsolución usandofrom math import*
wnnmaw
@wnnmaw ¡Gracias!
TFeld
También puede afeitarse a otro usando en for x in l:lambda l:pi*x+e**xlugar de la comprensión en ambas respuestas
wnnmaw
4

MATL , 9 bytes

Esta respuesta utiliza la versión actual del lenguaje ( 3.1.0 ), que es anterior al desafío.

itYP*wZe+

La entrada es un vector que contiene todos los números (lista entre corchetes y separados por espacios, comas de punto y coma), como [5.3 -7 3+2j] . Se permiten valores complejos. La salida tiene 15 dígitos significativos.

Ejemplo

>> matl itYP*wZe+
> [1 2 3]
5.859874482048839 13.67224140611024 29.51031488395705

Explicación

Operaciones directas:

i       % input  
t       % duplicate 
YP      % pi   
*       % multiplication
w       % swap elements in stack                           
Ze      % exponential                                      
+       % addition 
Luis Mendo
fuente
4

MATLAB: 70 bytes

@(x)num2str(arrayfun(@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))

Prueba:

ans(1:10)
5.86            13.7            29.5            67.2             164             422            1120            3010            8130           22100

Explicación: Hubo varios problemas con el formateo de números.

En primer lugar, la pregunta requiere 3 sig-figs. Matlab no tiene una función incorporada para redondear por sig-figs (solo por decimales), por lo que se requirió la siguiente solución:

floor(log10(pi*x+exp(x)))) calcula el dígito significativo más grande.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))toma entrada xy redondea a 3 dígitos significativos.

Otro requisito era manejar múltiples entradas. El código anterior solo puede funcionar con un solo número. Para mitigar esto, usamos arrayfunpara evaluar la función para cada elemento vectorial.

El último problema, Matlab muestra el resultado de arrayfun con su propio redondeo que conduce a salidas como las 1.0e+04 * 0.0006que viola el requisito de 3 sig-fig. Entonces, num2strse usó para convertir la matriz en charformato.

Matlab es bueno para el análisis numérico, pero, francamente, es una mierda cuando se trata de un formato de números fino.

UPD: bueno, eso es vergonzoso que confundí

con al menos 3 dígitos significativos

con

con 3 dígitos significativos

De todos modos, dejaré mi respuesta en este formulario porque la solución de Matlab de 15 bytes ya está dada por @costrom

brainkz
fuente
2
¡¿Qué?! ¿Por qué tienes que hacer todo eso?
Adám
44
¿Es este código de boliche?
Stewie Griffin
Agregaré explicaciones para la respuesta
brainkz
1
solo dice un mínimo de 3 higos sig, no exactamente 3. si especificó que format longgera necesario antes de ejecutar el código, caería 3/4 de la longitud aquí
costrom
@costrom Sí, tienes razón, y reconozco que ganas :)
brainkz
4

Julia, 12 bytes

x->π*x+e.^x

Esta es una función anónima que acepta una matriz y devuelve una matriz de flotantes. Para llamarlo, asígnele un nombre, p. Ej.f=x->... .

Julia tiene constantes incorporadas πy epara, lo has adivinado, π y e, respectivamente. El .^operador es la exponenciación vectorizada.

Alex A.
fuente
3

Japt, 12 bytes

N®*M.P+M.EpZ

Toma la entrada como números separados por espacios. Pruébalo en línea!

Cómo funciona

N®   *M.P+M.EpZ
NmZ{Z*M.P+M.EpZ

        // Implicit: N = array of inputs, M = Math object
NmZ{    // Map each item Z in N to:
Z*M.P+  //  Z times PI, plus
M.EpZ   //  E to the power of Z.
        // Implicit: output last expression
ETHproductions
fuente
Odiaba votarte cuando tienes 5,554 repeticiones.
Conor O'Brien
3

J, 4 bytes

o.+^

Igual que APL ○+*, pero pi timesse llama a la función de J o., que es un byte más.

Lynn
fuente
2

Par , 8 bytes

✶[″℗↔π*+

Acepta entrada como (1 2 3)

Explicación

               ## [implicit: read line]
✶              ## Parse input as array of numbers
[              ## Map
 ″             ## Duplicate
 ℗             ## e to the power
 ↔             ## Swap
 π*            ## Multiply by π
 +             ## Add
Ypnypn
fuente
2

Raqueta , 27 bytes

map(λ(x)(+(* pi x)(exp x)))

cuando se coloca en la posición de función de una expresión:

(map(λ(x)(+(* pi x)(exp x))) '(1 2 3 4))

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)
Matthew Butterick
fuente
2

CJam, 13 bytes

q~{_P*\me+}%p

Toma la entrada como una matriz separada por espacios (p [1 2 3]. Ej .). Pruébalo en línea.

Explicación

q~    e# Read the input and evaluate it as an array
{     e# Do this for each number x in the array...
  _P* e# Multiply x by pi
  \me e# Take the exponential of x (same as e^x)
  +   e# Add the two results together
}%
p     e# Pretty print the final array with spaces
NinjaOsoMono
fuente
@NBZ Hecho, gracias por aclarar.
NinjaBearMonkey
1

Reng v.3.3, 53 bytes

Sin competencia porque es posterior al desafío, pero bueno, no gana ningún premio por brevedad. : P Pruébalo aquí!

2²5³*:"G"(%3+i#II*ZA*9+(%2+#E1II0e1+ø
1-)E*(:0eø
$+n~

Línea 0

Aquí hay una vista de la pila en la línea 0:

Sequence read | Stack
2²            | 4
5³            | 4 125
*             | 500
:             | 500 500
"G"           | 500 500 71
(             | 500 71 500
%             | 500 0.142
3+            | 500 3.142
i             | 500 3.142 <i>
#I            | 500 3.142     ; I <- i
I             | 500 3.142 <i>
*             | 500 3.142*<i>
ZA            | 500 3.142*<i> 35 10
*             | 500 3.142*<i> 350
9+            | 500 3.142*<i> 359
(             | 3.142*<i> 359 500
%             | 3.142*<i> 0.718
2+            | 3.142*<i> 2.718
#E            | 3.142*<i>     ; E <- 2.718
1II0          | 3.142*<i> 1 <i> <i> 0
e             | 3.142*<i> 1 <i> <i>==0
1+            | 3.142*<i> 1 <i> (<i>==0)+1

øluego pasa a la siguiente enésima línea. Cuando0 se ingresa, esto va directamente a la línea 2. De lo contrario, vamos a la línea 1.

Línea 1

1-)E*(:0eø

Esto multiplica E iveces, que es e^i. Decrementamos el contador (inicialmente I), multiplicamos el STOS (nuestra epotencia de funcionamiento ) por E, volvemos al contador y hacemos esto ( i'es el contador actual):

Sequence read | Stack (partial)
              | i'
:             | i' i'
0             | i' i' 0
e             | i' i'==0

øentonces hace una de dos cosas. Si el contador no es 0, entonces vamos a la "siguiente" línea 0, es decir, el comienzo de la línea actual. Si es cero, entonces0e produce 1 y pasa a la siguiente línea.

Línea 2

$+n~

$deja caer el mostrador (¡EN EL PISO!). +agrega los dos primeros resultados,n genera ese número y~ sale del programa.

Caso 1: la entrada es 0. El TOS es 1 ("e ^ 0") y el STOS es 0 (pi * 0). Agregarlos produce el resultado correcto.

Caso 2: la entrada no es 0. El resultado es el esperado.

Conor O'Brien
fuente