Diesmal habe ich echte Arbeit geleistet, alten Code aktualisiert und bin auf einen Ausdruck gestoßen, der dem entspricht, was man in guter, altmodischer Mathematik als πx + e ^x schreiben würde . Ich dachte, es wäre möglich, es kürzer als in der Sprache zu schreiben, mit der ich arbeite (APL), und präsentiere daher diese sehr einfache Herausforderung:

Schreiben Sie eine Funktion oder ein Programm, das (auf irgendeine Weise) null oder mehr Zahlen akzeptiert und (auf irgendeine Weise) das Ergebnis des obigen Ausdrucks für x = jede der angegebenen Zahlen mit mindestens 3 signifikanten Stellen für jedes Ergebnis zurückgibt .

Wenn Ihre Sprache nicht π und / oder e hat , verwenden Sie die Werte 3.142 und 2.718.

Die Bewertung ist die Anzahl der Bytes. Stellen Sie Ihrer Antwort daher Folgendes voran # LanguageName, 00 bytes.

Standard-Schlupflöcher sind nicht erlaubt.

Edit: Jetzt ist die Lösung kam ich mit, ○+*, gefunden wurde . Der ursprüngliche Code war (○x)+*x.

Dyalog APL, 3 Zeichen

Als stillschweigende Phrase.

○+*

Monadisch ○multipliziert sein Argument mit π, monadisch *ist die Exponentialfunktion exp. ○+*ist so ein zug der (○+*)ωgleich ist (○ω)+(*ω). Da dies APL ist, funktioniert der Ausdruck für Argumente beliebiger Form, z. G. Sie können einen Vektor beliebiger Länge übergeben.

In J ist die gleiche Lösung möglich wie o.+^in o.Sein ○und ^Sein *.

Emotinomicon, 48 Bytes / 13 Zeichen

Ich mache es nicht, weil es kurz ist, sondern weil es Spaß macht. Probieren Sie es hier aus. Sie müssen es kopieren und in das Textfeld einfügen.

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

Erläuterung:

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

Hier ist das Programm in seiner nativen Umgebung, dem Mobiltelefon:

R, 25 24 Bytes

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

Ist es das? Sie erhält Eingaben vom Benutzer, weist sie zu x, berechnet ihre exponentielle Multiplikation mit piund gibt schließlich cat()das Ergebnis aus.

edit: 1 Byte gespeichert dank Alex A.

JavaScript (ES6), 39 34 Bytes

5 Bytes gespart dank @ edc65

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

Nimmt Eingaben als ein Array von Zahlen und gibt sie im gleichen Format aus.

Dank der Reduzierung gibt es jetzt drei gleichwertige 45-Byte-Programme, die alle ES5-kompatibel sind:

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

Die Eingaben sollten einzeln eingegeben werden. Drücken Sie OK, ohne etwas einzugeben, um den Vorgang zu beenden.

Die dritte hebt ein interessantes Merkmal in JS hervor: die withAussage. Obwohl die Verwendung manchmal unsicher ist (daher im strengen Modus deaktiviert), kann sie dennoch verwendet werden, um das Eingeben eines Objektnamens und eines Zeitraums bei jedem Zugriff zu sparen. Zum Beispiel können Sie dies tun:

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

pushund lengthwerden dann als Eigenschaften von verwendet x, was mit xSein resultieren wird [0,1,2,3,4].

Dies funktioniert für jedes Objekt, auch für Nicht-Variablen. So können Sie beispielsweise Folgendes tun:

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

charAtund lengthwerden als Eigenschaften des Strings aufgerufen. "0x"+x-0Konvertiert xvon einem hexadezimalen Wert in eine Zahl. Dies sind also alertdie Zahlen 0 bis 15.

Mathematica, 11-10 Bytes

N@Pi#+E^#&

Mit 1 Byte dank LegionMammal978 gespeichert.

Pyth, 11 13

VQ+*N.n0^.n1N

Nimmt nun xals Liste z[1.25, 2.38, 25]

Vorherige (11 Bytes): +*Q.n0^.n1Q

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

Im Ernst, 10 Bytes

,`;e(╦*+`M

Hex Dump:

2c603b6528cb2a2b604d

Probieren Sie es online

Nimmt Eingaben als Liste (siehe Link zum Beispiel).

Erläuterung:

,                               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 nicht ASCII - Zeichen verwenden, so dass jeder von ihnen als ein Byte im Rechner gespeichert ist: π, Ans, +, e^(, und Ans. Es wird davon ausgegangen, dass der vorherige Ausdruck die Eingabe ist (wie {1,2,3}).

Python 2, 38 Bytes ( 52 49 Bytes mit Mathe)

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

Wenn ich das Mathe-Modul benutzen muss:

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

Die Eingabe sollte eine Liste von Zahlen sein

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

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

MATL , 9 Bytes

Diese Antwort verwendet die aktuelle Version der Sprache ( 3.1.0 ), die vor der Herausforderung liegt.

itYP*wZe+

Die Eingabe ist ein Vektor, der alle Zahlen enthält (Liste in eckigen Klammern und durch Leerzeichen, Semikolon-Kommas getrennt), wie z [5.3 -7 3+2j]. Komplexe Werte sind zulässig. Die Ausgabe hat 15 signifikante Stellen.

Beispiel

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

Erläuterung

Einfache Bedienung:

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

Prüfung:

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

Erläuterung: Bei der Zahlenformatierung sind mehrere Probleme aufgetreten.

Erstens erfordert die Frage 3 Sig-Feigen. Matlab hat keine eingebaute Funktion zum Runden von Sig-Feigen (nur durch Dezimalstellen), so dass die folgende Problemumgehung erforderlich war:

floor(log10(pi*x+exp(x)))) berechnet die größte signifikante Ziffer.

@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))Nimmt Eingaben xund rundet auf 3 signifikante Stellen.

Eine weitere Anforderung bestand darin, mehrere Eingaben zu verarbeiten. Der obige Code kann nur mit einer einzelnen Nummer funktionieren. Um dies abzuschwächen, wird arrayfundie Funktion für jedes Vektorelement ausgewertet.

Als letztes Problem zeigt Matlab das Ergebnis von Arrayfun mit einer eigenen Rundung an, die zu Ausgaben führt, 1.0e+04 * 0.0006die gegen die 3-Sig-Fig-Anforderung verstoßen. Wurde also num2strverwendet, um das Array in ein charFormat zu verwandeln .

Matlab ist gut für die numerische Analyse geeignet, aber ehrlich gesagt ist es schlecht, wenn es um die Feinformatierung von Zahlen geht

UPD: Nun, das ist peinlich, dass ich verwirrt bin

mit mindestens 3 signifikanten Ziffern

mit

mit 3 signifikanten Ziffern

Wie auch immer, ich werde meine Antwort in dieser Form hinterlassen, da die 15-Byte-Matlab-Lösung bereits von @costrom bereitgestellt wird

Julia, 12 Bytes

x->π*x+e.^x

Dies ist eine anonyme Funktion, die ein Array akzeptiert und ein Array von Floats zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=x->....

Julia hat eingebaute Konstanten πund e- Sie haben es erraten - π und e. Der .^Operator ist eine vektorisierte Potenzierung.

Japt, 12 Bytes

N®*M.P+M.EpZ

Nimmt die Eingabe als durch Leerzeichen getrennte Zahlen. Probieren Sie es online!

Wie es funktioniert

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

Wie APL ○+*, aber die pi timesFunktion von J wird aufgerufen o., was ein Byte länger ist.

Haskell, 22 19 Bytes

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

Probieren Sie es online!

Edit: -3 Bytes dank @ H.PWiz

Par , 8 Bytes

✶[″℗↔π*+

Akzeptiert Eingaben als (1 2 3)

Erläuterung

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

Schläger , 27 Bytes

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

wenn in die Funktionsposition eines Ausdrucks gesetzt:

(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

Nimmt Eingaben als Array, das durch Leerzeichen (z [1 2 3]. B. ) getrennt ist. Probieren Sie es online aus.

Erläuterung

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

Nicht konkurrierend, weil es die Herausforderung nachholt, aber hey, keine Preise für die Kürze zu gewinnen. : P Probieren Sie es hier!

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

Zeile 0

Hier ist eine Ansicht des Stapels in Zeile 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

ødann geht es in die nächste n-te Zeile. Wenn 0eingegeben wird, geht dies direkt zu Zeile 2. Andernfalls gehen wir zu Zeile 1.

Linie 1

1-)E*(:0eø

Dies multipliziert E- imal, was ist e^i. Wir dekrementieren den Zähler (anfangs I), multiplizieren den STOS (unsere Laufleistung e) mit E, kehren zum Zähler zurück und tun dies ( i'ist der aktuelle Zähler):

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

ødann macht man eines von zwei dingen. Wenn der Zähler nicht 0 ist, gehen wir zur "nächsten" 0. Zeile, dh zum Anfang der aktuellen Zeile. Wenn es Null ist, dann0e ergibt es 1 und geht zur nächsten Zeile.

Zeile 2

$+n~

$Lässt die Theke fallen (AUF DEM BODEN!). +addiert die ersten beiden Ergebnisse, ngibt diese Zahl aus und ~beendet das Programm.

Fall 1: Eingang ist 0. Der TOS ist 1 ("e ^ 0") und der STOS ist 0 (pi * 0). Wenn Sie sie hinzufügen, erhalten Sie das richtige Ergebnis.

Fall 2: Eingabe ist nicht 0. Das Ergebnis ist wie erwartet.