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.

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 *.

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:

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.

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.

Mathematica, 11 10 bytes

N@Pi#+E^#&

Con 1 byte guardado gracias a LegionMammal978.

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

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

MATLAB, 15 bytes

@(x)pi*x+exp(x)

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

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]

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 

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

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.

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

J, 4 bytes

o.+^

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

Haskell, 22 19 bytes

map(\x->pi*x+exp x)

Pruébalo en línea!

Editar: -3 bytes gracias a @ H.PWiz

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

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)

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

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.