Vous devez approximer la valeur de:

Où est votre contribution I.

Règles

• Vous ne pouvez utiliser aucune fonction intégrée intégrée.
• Vous ne pouvez pas utiliser de fonctions de sommation infinies intégrées.
• Votre code doit s'exécuter dans un délai raisonnable (<20 secondes sur ma machine)
• Vous pouvez supposer que la saisie est supérieure à 0 mais inférieure à la limite supérieure de votre langue.
• Il peut s'agir de n'importe quelle forme de retour / sortie standard.

Vous pouvez vérifier vos résultats chez Wolfram | Alpha (vous pouvez vérifier en concaténant votre entrée prévue dans la requête liée).

Exemples

(appelons la fonction f)

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

Votre réponse doit être exacte ±.0001.

Julia, 79 77 38 octets

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

Il s'agit d'une fonction anonyme qui accepte une valeur numérique et renvoie un flottant. Pour l'appeler, affectez-le à une variable.

L'approche ici consiste à utiliser une somme de Riemann correcte pour approximer l'intégrale, qui est donnée par la formule suivante:

Dans notre cas, a = 0 et b = I , l'entrée. Nous divisons la région d'intégration en n = 10 ⁵ parties discrètes, donc ∆ x = 1 / n = 10 ^-5 . Puisqu'il s'agit d'une constante par rapport à la somme, nous pouvons la tirer en dehors de la somme et simplement additionner les évaluations de fonction en chaque point et diviser par n .

La fonction est étonnamment bien comportée (graphique de Mathematica):

Puisque la fonction est évaluée à presque 0 pour les entrées supérieures à environ 9, nous tronquons l'entrée à I si I est inférieur à 9, ou 9 sinon. Cela simplifie considérablement les calculs que nous devons effectuer.

Code non golfé:

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

Enregistré 39 octets grâce à Dennis!

Gelée, 20 19 17 octets

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

Cela emprunte l'astuce tronquée à 9 à la réponse de @ AlexA. , Et utilise une bonne somme de Riemann pour estimer l'intégrale correspondante.

Les cas de test tronqués prennent un certain temps, mais sont assez rapides pour l' essayer en ligne!

Comment ça marche

ð«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 octets

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

Cela utilise la règle du rectangle avec 2000 rectangles, qui (au moins pour les exemples) semblent produire une réponse suffisamment précise, mais la précision pourrait facilement être augmentée si nécessaire. Il doit utiliser l'astuce 9 sinon la précision diminue pour les grandes valeurs.

Version de 73 octets qui utilise des rectangles de largeur ~ 0,001 donc cela ne fonctionne pas au-dessus de ~ 700 car Math.exp frappe Infinity:

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

golflua , 83 caractères

Je l'admets: il m'a fallu un certain temps pour comprendre l' min(I,9)astuce présentée par Alex qui permettait de calculer des nombres arbitrairement élevés parce que l'intégrale convergeait alors.

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

Un équivalent Lua non golfé serait

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 octets

Merci à @Dennis de m'avoir sauvé 18 octets!

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

Essayez-le en ligne avec des testcases!

Utilisation de la méthode du rectangle pour l'approximation. Utiliser une largeur de rectangle de 0,0001 qui me donne la précision demandée. Tronquer également les entrées supérieures à 9 pour éviter les erreurs de mémoire avec de très grandes entrées.

Perl 6, 90 55 octets

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

usage

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

Il est tard et j'ai besoin de dormir, je vais voir si je peux raccourcir ça demain.

EDIT: réussi à le raccourcir un peu après avoir vu la méthode de @DenkerAffe.

Pyth, 34 29 octets

5 octets enregistrés avec l'aide de @Dennis!

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

Essayez-le en ligne!

Explication

Même algorithme que dans ma réponse Python .

J ^ T5smcc ^ .n1d ^ ddJmcdJU * hS, Q9J # Q = entrée
J ^ T5 # définir J donc largeur du rectangle * 10 ^ 5
                       hS, Q9 # entrées tronquées supérieures 9
                 mcdJU / J # plage de zéro à entrée par étapes J
     mcc ^ .n1d ^ ddJ # calcule l'aire de chaque élément de la liste
    s # Somme toutes les zones et résultat de sortie

MATL , 26 octets

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

Cela se rapproche de l'intégrale comme une somme de Riemann. Comme l'a fait valoir Alex, nous pouvons tronquer l'intervalle d'intégration à environ 9 car les valeurs de fonction sont très petites au-delà de cela.

La valeur maximale de la fonction est inférieure à 3, donc un pas d'environ 1e-5 devrait être suffisant pour obtenir la précision souhaitée. Donc, pour l'entrée maximale 9, nous avons besoin d'environ 1e6 points.

Cela prend environ 1,5 seconde dans le compilateur en ligne, pour toute valeur d'entrée.

Essayez-le en ligne !

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 octets

J'ai pensé que je pourrais aussi bien apporter ma propre contribution. ¯ \ _ (ツ) _ / ¯ Ceci utilise l'estimation de Riemann Sum à gauche des intégrales.

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

Cela laisse la somme en haut de la pile. Le lien essayer en ligne ci-dessous a Npour fin de vous montrer le résultat.

Essayez-le en ligne!