अनुमानित ∫ ((e ^ x) / (x ^ x)) dx

Question

आप का मान अनुमानित करने के लिए हैं:

कहाँ अपने इनपुट है I।

नियम

• आप किसी भी अंतर्निहित अभिन्न कार्यों का उपयोग नहीं कर सकते हैं।
• आप किसी भी अंतर्निहित अनंत योग कार्यों का उपयोग नहीं कर सकते हैं।
• आपके कोड को उचित समय में निष्पादित होना चाहिए (मेरी मशीन पर 20 सेकंड)
• आप मान सकते हैं कि इनपुट 0 से अधिक है, लेकिन आपकी भाषा की ऊपरी सीमा से कम है।
• यह मानक रिटर्न / आउटपुट का कोई भी रूप हो सकता है।

आप अपना परिणाम वुल्फराम पर सत्यापित कर सकते हैं | अल्फा (आप लिंक किए गए क्वेरी में अपने इच्छित इनपुट को संक्षिप्त करके सत्यापित कर सकते हैं)।

उदाहरण

(चलो समारोह कहते हैं f)

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

आपका उत्तर सटीक होना चाहिए ±.0001।

Comments

@ThomasKwa अधिकतम अपनी भाषा के लिए। मैं इसे प्रश्न में जोड़ दूँगा।

— एडिसन क्रम्प

वोल्फ्राम अल्फा अंतिम एक राउंड कहता है5.92228

— नील

@Neil oo ठीक है, तो गलत किया जाना चाहिए। धन्यवाद!

— एडिसन क्रम्प

मैं TI-BASIC में सबसे कम वैध उत्तर के लिए 200 प्रतिनिधि पुरस्कार दूंगा जो <20 सेकंड में WabbitEmu पर 100% की गति से निष्पादित होता है।

— lirtosiast

@lirtosiast यदि आप अभी भी इस इनाम के बाद का इरादा कर रहे हैं, तो आपको इसे यहां पोस्ट करना चाहिए ।

— एडिसन क्रम्प

Answer 1

जूलिया, 79 77 38 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो एक संख्यात्मक मान को स्वीकार करता है और एक फ्लोट देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

यहाँ दृष्टिकोण समरूपता का अनुमान लगाने के लिए एक सही रीमैन योग का उपयोग करना है, जो निम्न सूत्र द्वारा दिया गया है:

हमारे मामले में, एक = 0 और बी = I , इनपुट। हम एकीकरण के क्षेत्र को n = 10 ⁵ असतत भागों में विभाजित करते हैं , इसलिए 1 x = 1 / n = 10 ^-5 । चूंकि यह योग के लिए एक निरंतर सापेक्ष है, हम इसे योग के बाहर खींच सकते हैं और बस प्रत्येक बिंदु पर फ़ंक्शन मूल्यांकन को जोड़ सकते हैं और एन के साथ विभाजित कर सकते हैं ।

समारोह आश्चर्यजनक रूप से अच्छी तरह से व्यवहार किया गया है (गणित से भूखंड):

चूंकि फ़ंक्शन लगभग 9 से अधिक इनपुट के लिए लगभग 0 का मूल्यांकन करता है, हम इनपुट को काटते हैं I यदि मैं 9 से कम है, या 9 अन्यथा। यह गणना को सरल बनाता है जो हमें महत्वपूर्ण रूप से करना है।

अघोषित कोड:

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 बाइट्स बचाए गए!

Comments

क्या यह भी समान नहीं है: $ \ frac {t \ sum_ {k = 0} ^ {n} (f (a + kt) + f (a + (k + 1) t)} {2} $? यह एक एल्गोरिथ्म का उपयोग करने के लिए थोड़ा सरल लगता है।

— एडिसन क्रम्प

10^4के रूप में लिखा जा सकता है 1e4।

— रेनर पी।

@VoteToClose

— एलेक्स ए।

@RainerP। हेह, ठीक है। धन्यवाद।

— एलेक्स ए।

अभिन्न का स्पर्शोन्मुख मूल्य $ 6.39981 ... $ है। मूल्य $ 6.39981 ... - 10 ^ {- 4} $ पहली बार $ I = 7.91399 ... $ पर प्राप्त किया जाता है, इसलिए आप थोड़ा समय बचाने के लिए $ 9 $ के बजाय $ 8 $ में काट सकते हैं।

— एरिक टावर्स

Answer 2

जेली, 20 19 17 बाइट्स

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

यह @ अलेक्सा के उत्तर से 9 चाल में चतुर ट्रंकट को उधार लेता है , और संबंधित अभिन्न का अनुमान लगाने के लिए एक सही रिमैन योग का उपयोग करता है ।

काटे गए परीक्षण के मामलों में थोड़ा समय लगता है, लेकिन ऑनलाइन प्रयास करने पर यह काफी तेज़ होता है !

यह काम किस प्रकार करता है

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

Comments

ओह ठीक है। बाएं हाथ का नियम यह है कि इसे एपी पथरी कक्षाओं में कैसे संदर्भित किया जाता है। : पी कूलियो।

— एडिसन क्रम्प

मैं उस नाम से परिचित नहीं हूं, लेकिन बाएं हाथ का नियम शायद बाएं छोर का उपयोग करता है। मेरा कोड सही का उपयोग करता है।

— डेनिस

(~ -.-) ~ यह कुछ नियम के रूप में है। xD

— Addison Crump

Answer 3

ईएस 7, 78 बाइट्स

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

यह 2000 आयतों के साथ आयत नियम का उपयोग करता है, जो (उदाहरण के लिए कम से कम) पर्याप्त रूप से सटीक उत्तर का उत्पादन करते प्रतीत होते हैं, लेकिन यदि आवश्यक हो तो सटीकता को आसानी से बढ़ाया जा सकता है। इसे 9 चाल का उपयोग करना होगा अन्यथा सटीकता बड़े मूल्यों के लिए बंद हो जाती है।

73 बाइट संस्करण जो चौड़ाई ~ 0.001 के आयतों का उपयोग करता है इसलिए यह ~ 700 से ऊपर काम नहीं करता है क्योंकि Math.exp हिट इन्फिनिटी:

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

Answer 4

गोल्फलुआ , 83 वर्ण

मैं इसे स्वीकार करता हूं: min(I,9)एलेक्स ने जो चाल पेश की, उसने मनमाने ढंग से उच्च संख्या की गणना करने की अनुमति दी, क्योंकि इंटीग्रल तब तक अभिसरण कर चुका था ।

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

एक असभ्य लूआ समकक्ष होगा

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)

Comments

और "थोड़ी देर" से मेरा मतलब लगभग 10 मिनट है। और यह पूरी तरह से था क्योंकि मैंने वास्तव में एलेक्स की टिप्पणी को नहीं पढ़ा था जो इसे समझाता है, बस इसे कोड में देखा था।

— काइल कानोस

Answer 5

पायथन 2, 94 76 बाइट्स

मुझे 18 बाइट्स बचाने के लिए @ डेनिस का धन्यवाद!

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

Testcases के साथ इसे ऑनलाइन आज़माएं!

सन्निकटन के लिए आयत विधि का उपयोग करना। 0.0001 की आयत चौड़ाई का उपयोग करना, जो मुझे मांग की गई सटीकता देता है। बहुत बड़ी इनपुट के साथ मेमोरी त्रुटियों को रोकने के लिए इनपुट्स को अधिक से अधिक 9 से कम करना।

Answer 6

पर्ल 6, 90 55 बाइट्स

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

प्रयोग

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

देर हो चुकी है और मुझे सोने की ज़रूरत है, मैं देखूंगा कि क्या मुझे कल कोई छोटा मिल सकता है।

संपादित करें: यह @DenkerAffe की विधि को देखने के बाद इसे थोड़ा छोटा करने में कामयाब रहा।

Comments

मुझे पसंद है कि यह वहां $ h * t कैसे कहता है। : D

— Addison Crump

Answer 7

अजगर, 34 29 बाइट्स

@ डेनिस की कुछ मदद से 5 बाइट्स बचाए!

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

इसे ऑनलाइन आज़माएं!

व्याख्या

मेरे पाइथन उत्तर में समान एल्गोरिथ्म ।

J ^ T5smcc ^ .n1d ^ ddJmcdJU * hS, Q9J # Q # इनपुट
J ^ T5 # सेट J तो आयत चौड़ाई * 10 ^ 5
                       hS, Q9 # ट्रंकट इनपुट अधिक से अधिक 9
                 mcdJU / J # की सीमा शून्य से इनपुट तक J चरणों में है
     mcc ^ .n1d ^ ddJ # सूची में प्रत्येक तत्व के लिए क्षेत्र की गणना करें
    s # सभी क्षेत्रों और आउटपुट परिणाम

Comments

आप विभाजन के साथ गुणा Jकरने ^T5और स्वैप करने के लिए असाइन करके कुछ बाइट्स बचा सकते हैं J। इसके अलावा, ट्रंकेशन के साथ किया जा सकता है hS,Q9।

— डेनिस

@ डेनिस थैंक्स, उस बारे में नहीं सोचा था। इसके अलावा छँटाई चाल अच्छी है, मैं बस min^ ^ के लिए खोज कर रहा था

— Denker

Answer 8

MATL , 26 बाइट्स

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

यह अभिन्न को रीमैन योग के रूप में दर्शाता है। जैसा कि एलेक्स ने तर्क दिया है, हम लगभग 9 पर एकीकरण अंतराल को कम कर सकते हैं क्योंकि फ़ंक्शन मान उस से परे बहुत छोटे हैं।

फ़ंक्शन का अधिकतम मूल्य 3 से कम है, इसलिए वांछित सटीकता प्राप्त करने के लिए लगभग 1e-5 का एक चरण पर्याप्त होना चाहिए। तो अधिकतम इनपुट 9 के लिए हमें लगभग 1e6 अंक चाहिए।

किसी भी इनपुट वैल्यू के लिए ऑनलाइन कंपाइलर में लगभग 1.5 सेकंड का समय लगता है।

इसे ऑनलाइन आज़माएं !

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

Answer 9

विटसी, 39 बाइट्स

सोचा कि मैं भी अपना योगदान दूं। ¯ \ _ (ツ) _ / the यह इंटीग्रल्स के बाएं-हाथ रीमैन योग का उपयोग करता है।

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

यह योग को ढेर के शीर्ष पर छोड़ देता है। Nआपको परिणाम दिखाने के लिए नीचे दिए गए ऑनलाइन लिंक को आज़माएं ।

इसे ऑनलाइन आज़माएं!