Pour une fois, je faisais un vrai travail, mettant à jour l'ancien code et tombais sur une expression équivalente à ce qui serait écrit comme πx + e ^x dans de bonnes mathématiques à l'ancienne. J'ai pensé qu'il serait possible de l'écrire plus court que ce qu'il était écrit dans la langue avec laquelle je travaille (APL), et présente donc ce défi très simple:

Écrivez une fonction ou un programme qui (par tous les moyens) accepte zéro ou plusieurs nombres, et renvoie (par tous les moyens) le résultat de l'expression ci-dessus pour x = chacun des nombres donnés avec au moins 3 chiffres significatifs pour chaque résultat.

Si votre langue n'a pas π et / ou e , utilisez les valeurs 3.142 et 2.718.

Le scoring est un nombre d'octets, donc faites précéder votre réponse # LanguageName, 00 bytes.

Les trous de boucle standard ne sont pas autorisés.

Edit: Maintenant , la solution que je suis venu avec, ○+*, a été trouvé . Le code d'origine était (○x)+*x.

Dyalog APL, 3 caractères

Comme une phrase tacite.

○+*

Monadic ○multiplie son argument par π, monadic *est la fonction exponentielle exp. ○+*est un train tel qui (○+*)ωest égal à (○ω)+(*ω). Puisque c'est APL, la phrase fonctionne pour les arguments de forme arbitraire, e. g. vous pouvez passer un vecteur de longueur arbitraire.

La même solution est possible en J comme o.+^avec l' o.être ○et l' ^être *.

Emotinomicon, 48 octets / 13 caractères

Je le fais, non pas parce qu'il est court, mais parce que c'est amusant. Essayez-le ici. Vous devrez le copier + coller dans la zone de texte.

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

Explication:

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

Voici le programme dans son environnement natif, le téléphone portable:

R, 25 24 octets

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

Est-ce ceci? Il obtient l'entrée de l'utilisateur, l'affecte à x, calcule son exponentielle, le multiplie piet enfincat() imprime le résultat.

edit: 1 octets sauvés grâce à Alex A.

JavaScript (ES6), 39 34 octets

5 octets enregistrés grâce à @ edc65

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

Prend les entrées sous forme de tableau de nombres et les sorties dans le même format.

Grâce à la réduction, il existe désormais trois programmes équivalents de 45 octets, tous compatibles 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))

Les entrées doivent être entrées une à la fois. Appuyez sur OK sans rien entrer pour quitter.

La troisième met en évidence une caractéristique intéressante de JS: la withdéclaration. Bien que parfois dangereux à utiliser (donc désactivé en mode strict), il peut toujours être utilisé pour enregistrer la saisie d'un nom d'objet et d'une période chaque fois que vous devez y accéder. Par exemple, vous pouvez faire ceci:

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

push et length sont ensuite utilisés comme propriétés de x, ce qui se traduira par xêtre[0,1,2,3,4] .

Cela fonctionne sur tout objet, même les non-variables, donc par exemple, vous pouvez le faire:

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

charAtet lengthsont appelés en tant que propriétés de la chaîne. "0x"+x-0convertit xd'une valeur hexadécimale en nombre, donc ce alertsont les nombres de 0 à 15.

Mathematica, 11 10 octets

N@Pi#+E^#&

Avec 1 octet enregistré grâce à LegionMammal978.

Pyth, 11 13

VQ+*N.n0^.n1N

Prend maintenant xcomme une liste, par exemple[1.25, 2.38, 25]

Précédent (11 octets): +*Q.n0^.n1Q

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

Sérieusement, 10 octets

,`;e(╦*+`M

Vidage hexadécimal:

2c603b6528cb2a2b604d

Essayez-le en ligne

Prend les entrées sous forme de liste (voir le lien par exemple).

Explication:

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

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

TI-BASIC, 5 octets

πAns+e^(Ans

TI-BASIC n'utilise pas octets ASCII, donc chacun d' entre eux est stocké comme un octet dans la calculatrice: π, Ans, +, e^(et Ans. Il suppose que l'expression précédente est l'entrée (comme {1,2,3}).

Python 2, 38 octets ( 52 49 octets avec mathématiques)

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

Si je dois utiliser le module mathématique:

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

L'entrée doit être une liste de nombres

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

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

MATL , 9 octets

Cette réponse utilise la version actuelle du langage ( 3.1.0 ), qui est antérieure au défi.

itYP*wZe+

L'entrée est un vecteur contenant tous les nombres (liste entourée de crochets et séparés par des espaces, virgules de points-virgules), tels que [5.3 -7 3+2j]. Les valeurs complexes sont autorisées. La sortie comporte 15 chiffres significatifs.

Exemple

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

Explication

Opérations simples:

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

MATLAB: 70 octets

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

Tester:

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

Explication: La mise en forme des nombres a rencontré plusieurs problèmes.

Tout d'abord, la question nécessite 3 sig-figs. Matlab n'a pas de fonction intégrée pour l'arrondi par sig-figs (uniquement par des décimales), donc la solution de contournement suivante était requise:

floor(log10(pi*x+exp(x)))) calcule le plus grand chiffre significatif.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x)) prend l'entrée x et arrondit à 3 chiffres significatifs.

Une autre exigence était de gérer plusieurs entrées. Le code ci-dessus ne peut fonctionner qu'avec un seul numéro. Pour atténuer cela, nous utilisonsarrayfun pour évaluer la fonction de chaque élément vectoriel.

Le dernier problème, Matlab affiche le résultat de arrayfun avec son propre arrondi qui conduit à des sorties comme celles 1.0e+04 * 0.0006qui violent l'exigence de 3 sig-fig. Donc, a num2strété utilisé pour transformer le tableau enchar format.

Matlab est bon pour l'analyse numérique, mais, franchement, il est nul en ce qui concerne la mise en forme fine des nombres

UPD: eh bien, c'est gênant que j'ai confondu

avec au moins 3 chiffres significatifs

avec

avec 3 chiffres significatifs

Quoi qu'il en soit, je vais laisser ma réponse sous cette forme car la solution Matlab à 15 octets est déjà donnée par @costrom

Julia, 12 octets

x->π*x+e.^x

Il s'agit d'une fonction anonyme qui accepte un tableau et renvoie un tableau de flottants. Pour l'appeler, donnez-lui un nom, par exemplef=x->... .

Julia a des constantes intégrées πet epour - vous l'aurez deviné - π et e, respectivement. L' .^opératrice est l'exponentiation vectorisée.

Japt, 12 octets

N®*M.P+M.EpZ

Prend les entrées sous forme de nombres séparés par des espaces. Essayez-le en ligne!

Comment ça fonctionne

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 octets

o.+^

Identique à APL ○+*, mais la pi timesfonction de J est appelée o., ce qui représente un octet de plus.

Haskell, 22 19 octets

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

Essayez-le en ligne!

Edit: -3 octets grâce à @ H.PWiz

Par , 8 octets

✶[″℗↔π*+

Accepte l'entrée en tant que (1 2 3)

Explication

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

Raquette , 27 octets

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

lorsqu'il est mis en position de fonction d'une expression:

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

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)

CJam, 13 octets

q~{_P*\me+}%p

Prend l'entrée comme un tableau séparé par des espaces (par exemple [1 2 3]). Essayez-le en ligne.

Explication

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 octets

Non compétitif car il est postérieur au défi, mais bon, ne remportant aucun prix pour sa brièveté. : P Essayez-le ici!

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

Ligne 0

Voici une vue de la pile de la ligne 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

øpasse ensuite à la Nième ligne suivante. Quand0 est entré, cela va directement à la ligne 2. Sinon, nous allons à la ligne 1.

Ligne 1

1-)E*(:0eø

Cela multiplie E ifois, ce qui est e^i. Nous décrémentons le compteur (initialement I), multiplions le STOS (notre epuissance de fonctionnement ) par E, revenons au compteur et faisons ceci ( i'est le compteur actuel):

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

øfait alors l'une des deux choses. Si le compteur n'est pas 0, alors nous allons à la "prochaine" 0ème ligne, c'est-à-dire au début de la ligne courante. Si elle est nulle, elle 0edonne 1 et passe à la ligne suivante.

Ligne 2

$+n~

$laisse tomber le comptoir (AU SOL!). +ajoute les deux premiers résultats, naffiche ce nombre et ~quitte le programme.

Cas 1: l'entrée est 0. Le TOS est 1 ("e ^ 0") et le STOS est 0 (pi * 0). Leur ajout donne le résultat correct.

Cas 2: l'entrée n'est pas 0. Le résultat est comme vous pouvez vous y attendre.