Per una volta, stavo facendo un vero lavoro, aggiornando il vecchio codice, e mi sono imbattuto in un'espressione che è equivalente a quello che sarebbe scritto come πx + e ^x in una buona matematica vecchio stile. Ho pensato che sarebbe stato possibile scriverlo più breve di quanto non fosse scritto nella lingua con cui lavoro (APL), e quindi presentare questa sfida molto semplice:

Scrivi una funzione o un programma che (in ogni caso) accetta zero o più numeri e restituisce (in qualsiasi modo) il risultato dell'espressione precedente per x = ciascuno dei numeri dati con almeno 3 cifre significative per ogni risultato.

Se la tua lingua non ha π e / o e , usa i valori 3.142 e 2.718.

Il punteggio è il numero di byte, quindi prefiggi la tua risposta # LanguageName, 00 bytes.

Non sono ammessi fori ad anello standard.

Edit: Ora la soluzione mi è venuta, ○+*, è stato trovato . Il codice originale era (○x)+*x.

Dyalog APL, 3 personaggi

Come una frase tacita.

○+*

Monadic ○moltiplica il suo argomento con π, monadic *è la funzione esponenziale exp. ○+*è un treno tale che (○+*)ωè uguale a (○ω)+(*ω). Poiché questo è APL, la frase funziona per argomenti di forma arbitraria, e. g. puoi passare un vettore di lunghezza arbitraria.

La stessa soluzione è possibile in J come o.+^con l' o.essere ○e l' ^essere *.

Emotinomicon, 48 byte / 13 caratteri

Lo faccio, non perché è corto, ma perché è divertente. Provalo qui. Dovrai copiarlo + incollarlo nella casella di testo.

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

Spiegazione:

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

Ecco il programma nel suo ambiente nativo, il telefono cellulare:

R, 25 24 byte

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

È così? Riceve input dall'utente, lo assegna a x, calcola la sua esponenziale, lo moltiplica pie infine cat()stampa il risultato.

modifica: 1 byte salvato grazie ad Alex A.

JavaScript (ES6), 39 34 byte

5 byte salvati grazie a @ edc65

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

Accetta input come una matrice di numeri e output nello stesso formato.

Grazie alla riduzione, ora ci sono tre programmi equivalenti a 45 byte, tutti conformi 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))

Gli ingressi devono essere inseriti uno alla volta. Premere OK senza inserire nulla per uscire.

Il terzo evidenzia una caratteristica interessante in JS: la withdichiarazione. Anche se a volte non è sicuro da usare (quindi disabilitato in modalità rigorosa), può comunque essere utilizzato per salvare digitando un nome e un periodo di oggetto ogni volta che è necessario accedervi. Ad esempio, puoi farlo:

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

pushe lengthvengono quindi utilizzati come proprietà di x, che risulterà con xessere[0,1,2,3,4] .

Funziona su qualsiasi oggetto, anche senza variabili, quindi ad esempio puoi farlo:

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

charAte lengthsono chiamati come proprietà della stringa. "0x"+x-0converte xda un valore esadecimale in un numero, quindi questi sono alerti numeri da 0 a 15.

Mathematica, 11 10 byte

N@Pi#+E^#&

Con 1 byte salvato grazie a LegionMammal978.

Pyth, 11 13

VQ+*N.n0^.n1N

Adesso ci vuole x un elenco, ad es[1.25, 2.38, 25]

Precedente (11 byte): +*Q.n0^.n1Q

VQ            +       * N .n0            ^ .n1 N
For each      Add     List Item * Pi     e ^ List Item
input item

Scherzi a parte, 10 byte

,`;e(╦*+`M

Dump esadecimale:

2c603b6528cb2a2b604d

Provalo online

Accetta gli input come un elenco (vedere il collegamento per esempio).

Spiegazione:

,                               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 byte

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

TI-BASIC, 5 byte

πAns+e^(Ans

TI-BASIC non usa byte ASCII, così ognuno di questi è memorizzato come un byte nel calcolatore: π, Ans, +, e^(, e Ans. Presuppone che l'espressione precedente sia l'input (come{1,2,3} ).

Python 2, 38 byte ( 52 49 byte con matematica)

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

Se devo usare il modulo di matematica:

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

L'input dovrebbe essere un elenco di numeri

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

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

MATL , 9 byte

Questa risposta utilizza la versione corrente del linguaggio ( 3.1.0 ), che è precedente alla sfida.

itYP*wZe+

L'input è un vettore che contiene tutti i numeri (elenco racchiuso tra parentesi quadre e separato da spazi, virgole di punti e virgola), come [5.3 -7 3+2j] . Sono ammessi valori complessi. L'output ha 15 cifre significative.

Esempio

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

Spiegazione

Operazioni semplici:

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

MATLAB: 70 byte

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

Test:

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

Spiegazione: Si sono verificati diversi problemi con la formattazione dei numeri.

Innanzitutto, la domanda richiede 3 sig-fichi. Matlab non ha una funzione integrata per l'arrotondamento di sig-figs (solo con cifre decimali), quindi è stata richiesta la seguente soluzione alternativa:

floor(log10(pi*x+exp(x)))) calcola la cifra significativa più grande.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))accetta input xe arrotonda a 3 cifre significative.

Un altro requisito era gestire più input. Il codice sopra può funzionare solo con un singolo numero. Per mitigare questo, usiamo arrayfunper valutare la funzione per ogni elemento vettoriale.

L'ultimo problema, Matlab mostra il risultato di arrayfun con il suo arrotondamento che porta a output come quello 1.0e+04 * 0.0006che viola il requisito 3 sig-fig. Quindi, è num2strstato utilizzato per trasformare l'array in charformato.

Matlab è buono per l'analisi numerica, ma, francamente, fa schifo quando si tratta di una formattazione dei numeri

UPD: beh, è ​​imbarazzante che abbia confuso

con almeno 3 cifre significative

con

con 3 cifre significative

In ogni caso, lascerò la mia risposta in questo modulo perché la soluzione Matlab a 15 byte è già fornita da @costrom

Julia, 12 byte

x->π*x+e.^x

Questa è una funzione anonima che accetta un array e restituisce un array di float. Per chiamarlo, dagli un nome, ad esf=x->... .

Julia ha costanti incorporate πe eper — avete indovinato — π ed e, rispettivamente. L' .^operatore è esponenziale vettoriale.

Japt, 12 byte

N®*M.P+M.EpZ

Accetta input come numeri separati da spazio. Provalo online!

Come funziona

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 byte

o.+^

Come APL ○+*, ma pi timesviene chiamata la funzione di J o., che è più lunga di un byte.

Haskell, 22 19 byte

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

Provalo online!

Modifica: -3 byte grazie a @ H.PWiz

Par , 8 byte

✶[″℗↔π*+

Accetta input come (1 2 3)

Spiegazione

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

Racchetta , 27 byte

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

quando messo nella posizione di funzione di un'espressione:

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

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)

CJam, 13 byte

q~{_P*\me+}%p

Prende l'input come un array separato da spazi (ad es [1 2 3].). Provalo online.

Spiegazione

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 byte

Non competitiva perché postdatizza la sfida, ma ehi, non vincere alcun premio per brevità. : P Provalo qui!

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

Riga 0

Ecco una vista dello stack nella riga 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

øquindi passa all'ennesima riga successiva. Quando 0viene immesso, questo passa direttamente alla riga 2. Altrimenti, andiamo alla riga 1.

Linea 1

1-)E*(:0eø

Questo si moltiplica E ivolte, che è e^i. Decrementiamo il contatore (inizialmente I), moltiplichiamo lo STOS (la nostra corsae potenza ) per E, torniamo al contatore e facciamo questo ( i'è il contatore corrente):

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

øquindi fa una delle due cose. Se il contatore non è 0, andiamo alla "prossima" 0a riga, ovvero all'inizio della riga corrente. Se è zero, allora0e produce 1 e passa alla riga successiva.

Linea 2

$+n~

$ lascia cadere il bancone (SUL PIANO!). +aggiunge i primi due risultati,n genera quel numero ed ~esce dal programma.

Caso 1: l'ingresso è 0. Il TOS è 1 ("e ^ 0") e lo STOS è 0 (pi * 0). Aggiungendoli si ottiene il risultato corretto.

Caso 2: l'input non è 0. Il risultato è come ci si potrebbe aspettare.