Sie sollen den Wert von:

Wo Ihre Eingabe ist I.

Regeln

• Sie dürfen keine integrierten Integralfunktionen verwenden.
• Sie dürfen keine eingebauten unendlichen Summierungsfunktionen verwenden.
• Ihr Code muss in angemessener Zeit ausgeführt werden (<20 Sekunden auf meinem Computer)
• Sie können davon ausgehen, dass die Eingabe größer als 0, aber kleiner als die Obergrenze Ihrer Sprache ist.
• Es kann sich um eine beliebige Form der Standardrückgabe / -ausgabe handeln.

Sie können Ihre Ergebnisse unter überprüfen Wolfram |Alpha (Sie können dies überprüfen, indem Sie Ihre beabsichtigte Eingabe mit der verknüpften Abfrage verknüpfen.)

Beispiele

(Rufen wir die Funktion auf f)

f(1) -> 2.18273
f(50) -> 6.39981
f(10000) -> 6.39981
f(2.71828) -> 5.58040
f(3.14159) -> 5.92228

Ihre Antwort sollte genau sein ±.0001.

Julia, 79 77 38 Bytes

I->sum(x->(e/x)^x,0:1e-5:min(I,9))/1e5

Dies ist eine anonyme Funktion, die einen numerischen Wert akzeptiert und einen Gleitkommawert zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Der Ansatz hier besteht darin, eine rechte Riemannsche Summe zu verwenden, um das Integral zu approximieren, das durch die folgende Formel gegeben ist:

In unserem Fall ist a = 0 und b = I die Eingabe. Wir teilen den Integrationsbereich in n = 10 ⁵ diskrete Teile, also so x = 1 / n = 10 ^-5 . Da dies relativ zur Summe eine Konstante ist, können wir diese aus der Summe herausziehen und einfach die Funktionsbewertungen an jedem Punkt summieren und durch n dividieren .

Die Funktion verhält sich überraschend gut (Handlung aus Mathematica):

Da die Funktion für Eingaben größer als 9 nahezu 0 ergibt, wird die Eingabe auf I gekürzt, wenn I kleiner als 9 ist, oder auf andere Weise auf 9. Dies vereinfacht die Berechnungen, die wir durchführen müssen, erheblich.

Ungolfed-Code:

function g(I)
    # Define the range over which to sum. We truncate the input
    # at 9 and subdivide the region into 1e5 pieces.
    range = 0:1e-5:min(I,9)

    # Evaluate the function at each of the 1e5 points, sum the
    # results, and divide by the number of points.
    return sum(x -> (e / x)^x, range) / 1e5
end

39 Bytes gespart dank Dennis!

Jelly, 20 - 19 - 17 Bytes

ð«9×R÷øȷ5µØe÷*×ḢS

Dies leiht den cleveren Trunk mit 9 aus der Antwort von @ AlexA. Und verwendet eine rechte Riemann-Summe , um das entsprechende Integral zu schätzen.

Verkürzte Testfälle dauern eine Weile, sind aber schnell genug. Probieren Sie es online aus!

Wie es funktioniert

ð«9×R÷øȷ5µØe÷*×ḢS  Main link. Input: I

      øȷ5          Niladic chain. Yields 1e5 = 100,000.

ð                  Dyadic chain. Left argument: I. Right argument: 1e5.
 «9                Compute min(I, 9).
   ×               Multiply the minimum with 1e5.
    R              Range; yield [1, 2, ..., min(I, 9) * 1e5] or [0] if I < 1e-5.
     ÷             Divide the range's items by 1e5.
                   This yields r := [1e-5, 2e-5, ... min(I, 9)] or [0] if I < 1e-5.

         µ         Monadic chain. Argument: r
          Øe÷      Divide e by each element of r.
             *     Elevate the resulting quotients to the corresponding elements,
                   mapping t -> (e/t) ** t over r.
                   For the special case of r = [0], this yields [1], since
                   (e/0) ** 0 = inf ** 0 = 1 in Jelly.
              ×Ḣ   Multiply each power by the first element of r, i.e., 1e-5 or 0.
                S  Add the resulting products.

ES7, 78 Bytes

i=>[...Array(n=2e3)].reduce(r=>r+Math.exp(j+=i)/j**j,0,i>9?i=9:0,i/=n,j=-i/2)*i

Hierbei wird die Rechteckregel mit 2000 Rechtecken verwendet, die (zumindest für die Beispiele) eine ausreichend genaue Antwort zu liefern scheinen, die Genauigkeit kann jedoch bei Bedarf leicht erhöht werden. Es muss der 9-Trick verwendet werden, da sonst die Genauigkeit bei großen Werten abnimmt.

73-Byte-Version, die Rechtecke mit einer Breite von ~ 0,001 verwendet, sodass sie oberhalb von ~ 700 nicht funktionieren, da Math.exp auf Infinity trifft:

i=>[...Array(n=i*1e3|0)].reduce(r=>r+Math.exp(j+=i)/j**j,0,i/=n,j=-i/2)*i

Golflua , 83 Zeichen

Ich gebe es zu: Es dauerte eine Weile, bis ich herausgefunden hatte, mit welchem min(I,9)Trick Alex willkürlich hohe Zahlen berechnen konnte, da das Integral zu diesem Zeitpunkt konvergierte.

\f(x)~M.e(x)/x^x$b=M.mn(I.r(),9)n=1e6t=b/n g=0.5+f(b/2)~@k=1,n-1g=g+f(k*t)$I.w(t*g)

Ein ungolfed Lua-Äquivalent wäre

function f(x)
   return math.exp(x)/x^x
end

b=math.min(io.read("*n"),9)
n=1e6
t=b/n
g=0.5+f(b/2)

for k=1,n-1 do
   g=g+f(k*t)
end
io.write(t*g)

Python 2, 94 76 Bytes

Vielen Dank an @Dennis für die Rettung von 18 Bytes!

lambda I,x=1e5:sum((2.71828/i*x)**(i/x)/x for i in range(1,int(min(I,9)*x)))

Probieren Sie es online mit Testcases!

Verwendung der Rechteckmethode für die Approximation. Mit einer Rechteckbreite von 0,0001 erreiche ich die geforderte Präzision. Abschneiden von Eingaben größer 9, um Speicherfehler bei sehr großen Eingaben zu vermeiden.

Perl 6, 90 55 Bytes

{my \x=1e5;sum ((e/$_*x)**($_/x)/x for 1..min($_,9)*x)}

Verwendung

my &f = {my \x=1e5;sum ((e/$_*x)**($_/x)/x for 1..min($_,9)*x)}

f(1).say;       # 2.1827350239231
f(50).say;      # 6.39979602775846
f(10000).say;   # 6.39979602775846
f(2.71828).say; # 5.58039854392816
f(3.14159).say; # 5.92227602782184

Es ist spät und ich muss schlafen, ich werde sehen, ob ich das morgen noch kürzer kriege.

BEARBEITEN: Nachdem ich die Methode von @DenkerAffe gesehen habe, konnte ich sie etwas kürzer machen.

Pyth, 34 29 Bytes

5 Bytes mit Hilfe von @Dennis gespeichert!

J^T5smcc^.n1d^ddJmcdJU*hS,Q9J

Probieren Sie es online!

Erläuterung

Gleicher Algorithmus wie in meiner Python-Antwort .

J ^ T5smcc ^ .n1d ^ ddJmcdJU * hS, Q9J # Q = input
Stellen Sie J ^ T5 # so ein, dass die Breite des Rechtecks ​​* 10 ^ 5 ist
                       hS, Q9 # Eingänge abschneiden größer 9
                 mcdJU / J # reichen von Null bis Eingang in J-Schritten
     mcc ^ .n1d ^ ddJ # berechne Fläche für jedes Element in der Liste
    s # Alle Bereiche summieren und Ergebnis ausgeben

MATL , 26 Bytes

9hX<t1e6XK:K/*ttZebb^/sK/*

Dies approximiert das Integral als Riemannsche Summe. Wie von Alex argumentiert, können wir das Integrationsintervall bei ungefähr 9 abschneiden, da die Funktionswerte darüber hinaus sehr klein sind.

Der Maximalwert der Funktion ist kleiner als 3, daher sollte ein Schritt von ungefähr 1e-5 ausreichen, um die gewünschte Genauigkeit zu erzielen. Für die maximale Eingabe 9 benötigen wir also ungefähr 1e6 Punkte.

Dies dauert im Online-Compiler für jeden Eingabewert ca. 1,5 Sekunden.

Probieren Sie es online !

9hX<         % input number, and limit to 9
t            % duplicate
1e6XK:       % generate vector [1,2,...,1e6]. Copy 1e6 to clipboard K
K/*          % divide by 1e6 and multiply by truncated input. This gives 
             % a vector with 1e6 values of x from 0 to truncated input
ttZe         % duplicate twice. Compute exp(x)
bb^          % rotate top three elements of stack twice. Compute x^x
/            % divide to compute exp(x)/x^x
s            % sum function values
K/*          % multiply by the step, which is the truncated input divided
             % by 1e6

Vitsy, 39 Bytes

Dachte, ich könnte genauso gut meinen eigenen Beitrag leisten. ¯ \ _ (ツ) _ / ¯ Dies verwendet die linke Riemann-Summenschätzung von Integralen.

D9/([X9]1a5^D{/V}*0v1{\[EvV+DDv{/}^+]V*

D9/([X9]               Truncation trick from Alex A.'s answer.
D                      Duplicate input.
 9/                    Divide it by 9.
   ([  ]               If the result is greater than 0
     X9                Remove the top item of the stack, and push 9.

1a5^D{/V}*0v0{         Setting up for the summation.
1                      Push 1.
 a5^                   Push 100000.
    D                  Duplicate the top item of the stack.
     {                 Push the top item of the stack to the back.
      /                Divide the top two items of the stack. (1/100000)
       V               Save it as a global variable.
                       Our global variable is ∆x.
        }              Push the bottom item of the stack to the top.
         *             Multiply the top two items.
                       input*100000 is now on the stack.
          0v           Save 0 as a temporary variable.
            0          Push 1.
             {         Push the bottom item of the stack to the top.
                       input*100000 is now the top of the stack.

\[EvV+DDv{/}^+]        Summation.
\[            ]        Loop over this top item of the stack times.
                       input*100000 times, to be exact.
  E                    Push Math.E to the stack.
   v                   Push the temporary variable to the stack.
                       This is the current value of x.
    V+                 Add ∆x.
      DD               Duplicate twice.
        v              Save the temporary variable again.
         {             Push the top item of the stack to the back.
          /            Divide the top two items.
                       e/x
           }           Push the top item back to the top of the stack.
            ^          Put the second to top item of the stack to the power of the top item.
                       (e/x)^x
             +         Add that to the current sum.

V*                     Multiply by ∆x

Dadurch bleibt die Summe oben auf dem Stapel. Der unten stehende Link "Online ausprobieren" Nzeigt Ihnen am Ende das Ergebnis.

Probieren Sie es online!