Pela primeira vez, eu estava realizando algum trabalho de verdade, atualizando o código antigo e encontrei uma expressão equivalente ao que seria escrito como πx + e ^x em uma boa matemática antiquada. Eu pensei que seria possível escrevê-lo mais curto do que foi escrito na linguagem com a qual trabalho (APL), e, portanto, apresentar este desafio muito simples:

Escreva uma função ou programa que (por qualquer meio) aceite zero ou mais números e retorne (por qualquer meio) o resultado da expressão acima para x = cada um dos números fornecidos com pelo menos 3 dígitos significativos para cada resultado.

Se o seu idioma não possuir π e / ou e , use os valores 3.142 e 2.718.

A pontuação é o número de bytes, portanto, anteceda sua resposta # LanguageName, 00 bytes.

Não são permitidos orifícios padrão.

Edit: Agora, a solução que eu vim ○+*, foi encontrada . O código original (○x)+*x.

Dyalog APL, 3 caracteres

Como uma frase tácita.

○+*

Monádico ○multiplica seu argumento com π, monádico *é a função exponencial exp. ○+*é um trem que (○+*)ωé igual a (○ω)+(*ω). Como se trata de APL, a frase funciona para argumentos de forma arbitrária, e. g. você pode passar um vetor de comprimento arbitrário.

A mesma solução é possível em J, assim como o.+^no o.ser ○e no ^ser *.

Emotinomicon, 48 bytes / 13 caracteres

Eu faço isso, não porque seja curto, mas porque é divertido. Experimente aqui. Você terá que copiar e colar na caixa de texto.

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

Explicação:

😼  ⏪   🆙  😦  ✖   😎  😿  ➕   😼  🆙  😄  ⏩   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

Aqui está o programa em seu ambiente nativo, o telefone celular:

R, 25 bytes 24

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

É isso? Ele obtém a entrada do usuário, atribui-a x, calcula sua multiplicação exponencial pie finalmente cat()imprime o resultado.

edit: 1 bytes economizados graças a Alex A.

JavaScript (ES6), 39 34 bytes

Guardado 5 bytes graças a @ edc65

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

Recebe entrada como uma matriz de números e sai no mesmo formato.

Graças à redução, agora existem três programas equivalentes de 45 bytes, todos compatíveis com 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))

As entradas devem ser inseridas uma de cada vez. Pressione OK sem inserir nada para sair.

O terceiro destaca um recurso interessante em JS: a withdeclaração. Embora algumas vezes seja inseguro de usar (desabilitado no modo estrito), ele ainda pode ser usado para salvar a digitação do nome do objeto e do período sempre que você precisar acessá-lo. Por exemplo, você pode fazer isso:

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

pushe lengthsão usadas como propriedades de x, o que resultará em xexistência [0,1,2,3,4].

Isso funciona em qualquer objeto, mesmo que não seja variável, por exemplo, você pode fazer isso:

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

charAte lengthsão chamados como propriedades da sequência. "0x"+x-0converte xde um valor hexadecimal em um número, então esses alertsão os números de 0 a 15.

Mathematica, 11 10 bytes

N@Pi#+E^#&

Com 1 byte salvo, graças ao LegionMammal978.

Pitão, 11 13

VQ+*N.n0^.n1N

Agora leva xcomo uma lista, por exemplo[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

Sério, 10 bytes

,`;e(╦*+`M

Hex Dump:

2c603b6528cb2a2b604d

Experimente Online

Toma entradas como uma lista (veja o link, por exemplo).

Explicação:

,                               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

O TI-BASIC não usar bytes ASCII, de modo que cada um deles é armazenado como um byte na calculadora: π, Ans, +, e^(, e Ans. Assume que a expressão anterior é a entrada (como {1,2,3}).

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

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

Se eu tiver que usar o módulo de matemática:

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

A entrada deve ser uma lista de números

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

> [5.8599999999999994, 13.671524, 29.505290232, 67.143510850576007, 164.04623849186558]

MATL , 9 bytes

Esta resposta usa a versão atual do idioma ( 3.1.0 ), anterior ao desafio.

itYP*wZe+

Entrada é um vetor que contém todos os números (lista entre colchetes e separados por espaços, vírgulas de ponto e vírgula), como [5.3 -7 3+2j]. Valores complexos são permitidos. A saída possui 15 dígitos significativos.

Exemplo

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

Explicação

Operações diretas:

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

Teste:

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

Explicação: Houve vários problemas com a formatação de números.

Em primeiro lugar, a questão requer 3 sig-figs. O Matlab não possui uma função interna para arredondar por sig-figs (apenas por casas decimais), portanto, a seguinte solução alternativa foi necessária:

floor(log10(pi*x+exp(x)))) calcula o maior dígito significativo.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))recebe entrada xe arredonda para 3 dígitos significativos.

Outro requisito era lidar com várias entradas. O código acima pode funcionar apenas com um único número. Para mitigar isso, usamos arrayfunpara avaliar a função para cada elemento do vetor.

O último problema, o Matlab, exibe o resultado do arrayfun com seu próprio arredondamento que leva a saídas como as 1.0e+04 * 0.0006que violam o requisito de 3 sig-fig. Então, num2strfoi usado para transformar o array em charformato.

O Matlab é bom para análise numérica, mas, francamente, é péssimo quando se trata de formatação de números finos

UPD: bem, isso é embaraçoso que eu confundi

com pelo menos 3 dígitos significativos

com

com 3 dígitos significativos

De qualquer forma, deixarei minha resposta neste formulário porque a solução Matlab de 15 bytes já é fornecida por @costrom

Julia, 12 bytes

x->π*x+e.^x

Esta é uma função anônima que aceita uma matriz e retorna uma matriz de carros alegóricos. Para chamá-lo, dê um nome, por exemplo f=x->....

Julia tem constantes internas πe epara - você adivinhou - π e e, respectivamente. O .^operador é exponenciação vetorizada.

Japonês, 12 bytes

N®*M.P+M.EpZ

Recebe a entrada como números separados por espaço. Experimente online!

Como 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.+^

O mesmo que APL ○+*, mas a pi timesfunção de J é chamada o., que é um byte a mais.

Haskell, 22 19 bytes

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

Experimente online!

Edit: -3 bytes graças a @ H.PWiz

Par , 8 bytes

✶[″℗↔π*+

Aceita entrada como (1 2 3)

Explicação

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

Raquete , 27 bytes

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

quando colocado na posição da função de uma expressão:

(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

Recebe a entrada como uma matriz separada por espaços (por exemplo [1 2 3]). Experimente online.

Explicação

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

Incompetente porque pós-datado o desafio, mas ei, não ganhando nenhum prêmio por brevidade. : P Experimente aqui!

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

Linha 0

Aqui está uma visão da pilha na linha 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

ødepois vai para a próxima enésima linha. Quando0 é inserido, isso vai direto para a linha 2. Caso contrário, vamos para a linha 1.

Linha 1

1-)E*(:0eø

Isso multiplica E ivezes, o que é e^i. Diminuímos o contador (inicialmente I), multiplicamos o STOS (nossa epotência de funcionamento ) por E, voltamos ao balcão e fazemos isso ( i'é o contador atual):

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

øentão faz uma de duas coisas. Se o contador não for 0, então vamos para a próxima linha 0, ou seja, o início da linha atual. Se for zero, então0e gera 1 e passa para a próxima linha.

Linha 2

$+n~

$derruba o balcão (NO ANDAR!). +adiciona os dois primeiros resultados, ngera esse número e ~sai do programa.

Caso 1: entrada é 0. O TOS é 1 ("e ^ 0") e o STOS é 0 (pi * 0). Adicioná-los produz o resultado correto.

Caso 2: a entrada não é 0. O resultado é o esperado.