∫ approximatif ((e ^ x) / (x ^ x)) dx


24

Vous devez approximer la valeur de:

entrez la description de l'image ici

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.


@ThomasKwa Maximum pour votre langue. Je vais l'ajouter à la question.
Addison Crump

Wolfram Alpha dit que le dernier tour à5.92228
Neil

@Neil oo Très bien alors, a dû mal saisir. Merci!
Addison Crump

7
Je vais attribuer 200 répétitions à la réponse valide la plus courte en TI-BASIC qui s'exécute en moins de 20 secondes sur WabbitEmu à une vitesse de 100%.
lirtosiast

@lirtosiast Si vous avez toujours l'intention de suivre cette prime, vous devriez la publier ici à la place.
Addison Crump

Réponses:


10

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:

latex

Dans notre cas, a = 0 et b = I , l'entrée. Nous divisons la région d'intégration en n = 10 5 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):

parcelle mathématique

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!


N'est-ce pas aussi équivalent à: $ \ frac {t \ sum_ {k = 0} ^ {n} (f (a + kt) + f (a + (k + 1) t))} {2} $? Cela semble un peu plus simple d'un algorithme à utiliser.
Addison Crump

10^4peut être écrit comme 1e4.
Rainer P.

@VoteToClose A fini par adopter une approche différente
Alex A.

@RainerP. Hé, c'est vrai. Merci.
Alex A.

La valeur asymptotique de l'intégrale est de 6,39981 $ ... $. La valeur 6,39981 $ ... - 10 ^ {- 4} $ est d'abord atteinte à $ I = 7,91399 ... $, vous pouvez donc tronquer à 8 $ au lieu de 9 $ pour gagner un peu de temps.
Eric Towers

9

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.

Oh d'accord. La règle de gauche est la façon dont il est fait référence dans les classes AP Calculus. : P Coolio.
Addison Crump

Je ne connais pas ce nom, mais la règle de gauche utilise probablement les points d'extrémité gauche. Mon code utilise les bons.
Dennis

2
(~ -.-) ~ C'est une forme de règle à remettre. xD
Addison Crump

4

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

2

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)

Et par "un certain temps", je veux dire environ 10 minutes. Et c'est entièrement parce que je n'ai pas lu le commentaire d'Alex qui l'explique, je l'ai juste vu dans le code.
Kyle Kanos

2

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.


2

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.


1
J'aime la façon dont il dit $ h * t là-dedans. : D
Addison Crump

2

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


Vous pouvez enregistrer quelques octets en attribuant Jà ^T5et la multiplication permutation avec division par J. En outre, la troncature peut être effectuée avec hS,Q9.
Dennis

@Dennis Merci, je n'y ai pas pensé. De plus, l'astuce de tri est sympa, je cherchais juste min^^
Denker

2

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

2

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!

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.