Değeri yaklaşık olarak hesaplayacaksınız:

Girişin nerede I.

kurallar

• Herhangi bir dahili integral fonksiyon kullanamazsınız.
• Herhangi bir dahili sonsuz toplama işlevini kullanamazsınız.
• Kodunuz makul bir süre içinde yürütülmelidir (makinemde <20 saniye)
• Girişin 0'dan büyük, dilinizin üst sınırından küçük olduğunu varsayabilirsiniz.
• Herhangi bir standart geri dönüş / çıktı biçimi olabilir.

Sonuçlarınızı Wolfram | Alfa (istediğiniz girişi bağlantılı sorguyla birleştirerek doğrulama yapabilirsiniz).

Örnekler

(hadi fonksiyonu çağıralım f)

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

Cevabınız doğru olmalıdır ±.0001.

Julia, 79 77 38 bayt

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

Bu, sayısal bir değeri kabul eden ve bir kayan nokta döndüren adsız bir işlevdir. Aramak için değişkene atayın.

Buradaki yaklaşım, aşağıdaki formüle göre verilen integrali bulmak için doğru bir Riemann toplamı kullanmaktır:

Bizim durumumuzda, a = 0 ve b = I , giriş. Entegrasyon bölgesini n = 10 ⁵ ayrık porsiyonlara böldük, yani ∆ x = 1 / n = ^10-5 . Bu, toplama göre sabit olduğu için, bunu toplamın dışına çekebilir ve fonksiyon değerlendirmelerini her noktada toplayabilir ve n'ye bölebiliriz .

Bu fonksiyon şaşırtıcı derecede iyi davranmıştır (Mathematica'dan alınan arsa):

İşlev yaklaşık 9 göre yaklaşık girişler için 0 büyük değerlendirir yana, girdiyi kesecek I ise bir başka şekilde daha az, 9 ya da 9. Bu, önemli ölçüde yapmamız gereken hesaplamaları basitleştirir.

Ungolfed kod:

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

Dennis sayesinde 39 byte kurtarıldı!

Jöle, 20 19 17 bayt

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

Bu akıllı ödünç 9'da kesiğinin gelen hile @ Alexa. Yanıtını ve kullandığı sağ Riemann toplamı gelen integrali tahmin etmek.

Kesilmiş test durumları biraz zaman alıyor, ancak yeterince hızlı, Çevrimiçi deneyin!

Nasıl çalışır

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

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

Bu, (en azından örnekler için) yeterince doğru bir cevap veriyor gibi görünen 2000 dikdörtgenli dikdörtgen kuralını kullanır, ancak gerektiğinde doğruluk kolayca arttırılabilir. 9 numarayı kullanmak zorundadır, aksi takdirde büyük değerler için doğruluk düşer.

Math.exp Infinity isabet ettiği için ~ 0.001 genişliğinde dikdörtgenler kullanan 73 bayt sürümü

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

golflua , 83 karakter

Kabul edeceğim: anlamaya biraz zaman aldı min(I,9) Alex'in sunduğu keyfi yüksek sayılarla hesaplanmasına izin verdiğinin çünkü o zamana kadar bir araya geldi.

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

Yıpranmış bir Lua eşdeğeri

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 bayt

Beni 18 bayttan kurtardığı için @Dennis'e teşekkürler!

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

Test vitrinleriyle çevrimiçi olarak deneyin!

Yaklaştırma için dikdörtgen metodunu kullanmak. Bana istenen hassasiyeti veren 0.0001 dikdörtgen genişliğini kullanmak. Ayrıca, çok büyük girişlerle bellek hatalarını önlemek için girişleri daha büyük 9 daraltın.

Perl 6, 90 55 bayt

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

kullanım

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

Geç oldu ve uyumam gerekiyor, bakalım bunu yarın daha kısa sürede alabilir miyim?

EDIT: @DenkerAffe metodunu gördükten sonra biraz daha kısa tutmayı başardı.

Pyth, 34 29 bayt

@Dennis'den yardım alarak 5 Byte kurtarıldı!

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

Çevrimiçi deneyin!

açıklama

Python cevabımdakiyle aynı algoritma .

J ^ T5smcc ^ .n1d ^ ddJmcdJU * hS, Q9J # Q = giriş
J ^ T5 # set J, bu yüzden dikdörtgen genişliği * 10 ^ 5
                       hS, Q9 # daha büyük girişleri keser 9
                 mcdJU / J # J adımda sıfırdan Giriş'e
     mcc ^ .n1d ^ ddJ # listedeki her öğe için alanı hesaplar
    s # Tüm alanları ve çıktı sonuçlarını topla

MATL , 26 bayt

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

Bu, integrali bir Riemann toplamı olarak yaklaştırır. Alex’in söylediği gibi, entegrasyon aralığını yaklaşık 9 olarak kesebiliriz, çünkü fonksiyon değerleri bunun ötesinde çok küçüktür.

Fonksiyonun maksimum değeri 3'ten küçüktür, bu nedenle istenen doğruluğu elde etmek için yaklaşık 1e-5'lik bir adım yeterli olacaktır. Bu yüzden maksimum giriş 9 için yaklaşık 1e6 puana ihtiyacımız var.

Bu, herhangi bir giriş değeri için çevrimiçi derleyicide yaklaşık 1,5 saniye sürer.

Çevrimiçi deneyin !

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 bayt

Kendi katkımı da verebileceğimi düşündüm. ¯ \ _ (ツ) _ / ¯ Bu, integrallerin Sol Riemann Sum tahminini kullanır.

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

Bu, toplamı yığının üstüne bırakır. Aşağıdaki çevrimiçi deneme bağlantısının Nsonucu size gösterilecek.

Çevrimiçi Deneyin!