คุณจะต้องประมาณค่าของ:

Iในกรณีที่การป้อนข้อมูลของคุณ

กฎระเบียบ

• คุณไม่สามารถใช้ฟังก์ชันอินทิกรัลในตัวได้
• คุณไม่สามารถใช้ฟังก์ชั่นการสรุปรวมในตัว
• รหัสของคุณจะต้องทำงานในเวลาที่เหมาะสม (<20 วินาทีในเครื่องของฉัน)
• คุณอาจคิดว่าการป้อนข้อมูลมีค่ามากกว่า 0 แต่น้อยกว่าขีด จำกัด บนของภาษาของคุณ
• อาจเป็นรูปแบบของการส่งคืน / เอาต์พุตมาตรฐาน

คุณสามารถตรวจสอบผลลัพธ์ได้ที่Wolfram | อัลฟ่า (คุณสามารถตรวจสอบได้โดยเชื่อมข้อมูลที่คุณต้องการให้ตรงกับแบบสอบถามที่เชื่อมโยง

ตัวอย่าง

(เรียกฟังก์ชั่นนี้กันเถอะf)

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

±.0001คำตอบของคุณควรจะถูกต้อง

Julia, 79 77 38 ไบต์

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

นี่เป็นฟังก์ชั่นนิรนามที่ยอมรับค่าตัวเลขและส่งคืนค่าทศนิยม หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

วิธีการที่นี่คือการใช้ผลรวม Riemann ที่ถูกต้องเพื่อประมาณค่าอินทิกรัลซึ่งกำหนดโดยสูตรต่อไปนี้:

ในกรณีของเราa = 0 และb = Iอินพุต เราแบ่งภูมิภาคของการรวมเข้าn = 10 ⁵ส่วนที่ไม่ต่อเนื่องดังนั้นΔ x = 1 / n = 10 -5 ตั้งแต่นี้เป็นอย่างต่อเนื่องเมื่อเทียบกับจำนวนเงินที่เราสามารถดึงนอกของทุนนี้และก็สรุปผลการประเมินผลการทำงานในแต่ละจุดและหารด้วยn

ฟังก์ชั่นนี้มีความประพฤติดีอย่างน่าประหลาดใจ

เนื่องจากฟังก์ชันประเมินค่าเกือบเป็น 0 สำหรับอินพุตที่มากกว่า 9 เราจึงตัดอินพุตเป็นฉันถ้าฉันน้อยกว่า 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 ไบต์ขอบคุณเดนนิส!

เยลลี่, 20 19 17 ไบต์

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

นี้ยืมฉลาดตัดที่ 9เคล็ดลับจาก@ Alexa. ของคำตอบและใช้ผลรวม Riemann ที่เหมาะสมในการประมาณหนึ่งที่สอดคล้องกัน

กรณีทดสอบที่ถูกตัดทอนใช้เวลาครู่หนึ่ง แต่เร็วพอที่จะลองออนไลน์!

มันทำงานอย่างไร

ð«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 ไบต์

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 byte version ที่ใช้ความกว้างของสี่เหลี่ยมจัตุรัส ~ 0.001 ดังนั้นมันจึงใช้ไม่ได้กับ 700 เพราะ Math.exp ใช้ 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 ตัวอักษร

ฉันจะยอมรับว่า: มันต้องใช้เวลาสักพักกว่าจะได้รู้ว่า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)

Lua ที่ไม่ได้รับการเคารพจะเป็นเช่นนั้น

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 ไบต์

ขอบคุณ @Dennis ที่ช่วยฉัน 18 ไบต์!

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

ลองใช้งานแบบออนไลน์ด้วยชุดทดสอบ!

การใช้วิธีสี่เหลี่ยมผืนผ้าสำหรับการประมาณ ใช้สี่เหลี่ยมมุมฉาก 0.0001 ซึ่งให้ความแม่นยำตามที่ฉันต้องการ ตัดทอนอินพุตที่มากกว่า 9 เพื่อป้องกันข้อผิดพลาดของหน่วยความจำด้วยอินพุตที่ใหญ่มาก

Perl 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

Pyth, 34 29 ไบต์

บันทึก 5 ไบต์ด้วยความช่วยเหลือจาก @Dennis!

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

ลองออนไลน์!

คำอธิบาย

ขั้นตอนวิธีการเช่นเดียวกับในคำตอบของฉันหลาม

J ^ T5smcc ^ .n1d ^ ddJmcdJU * hS, Q9J # Q = อินพุต
J ^ T5 # set J กว้างสี่เหลี่ยมผืนผ้า * 10 ^ 5
                       hS, Q9 # ตัดอินพุตให้ใหญ่กว่า 9
                 mcdJU / J # มีช่วงจากศูนย์ถึงอินพุตในขั้นตอน J
     mcc ^ .n1d ^ ddJ # คำนวณพื้นที่สำหรับแต่ละองค์ประกอบในรายการ
    s # รวมทุกพื้นที่และผลลัพธ์ผลลัพธ์

MATL , 26 ไบต์

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

สิ่งนี้ใกล้เคียงกับอินทิกรัลว่าเป็นผลรวมของรีมันน์ ตามที่โต้แย้งโดย Alex เราสามารถตัดช่วงเวลาการรวมที่ประมาณ 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

Vitsy, 39 ไบต์

คิดว่าฉันอาจให้การสนับสนุนด้วยเช่นกัน ¯ \ _ (ツ) _ / ¯นี่ใช้การประมาณผลรวมของ Riemann ทางซ้ายของอินทิกรัล

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ที่สิ้นสุดเพื่อแสดงผลลัพธ์

ลองออนไลน์!