다음의 값을 근사해야합니다.

귀하의 입력이 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.

줄리아, 79 77 38 바이트

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

이것은 숫자 값을 받아들이고 float를 반환하는 익명 함수입니다. 호출하려면 변수에 지정하십시오.

여기서의 접근 방식은 적분을 근사하기 위해 올바른 Riemann 합계를 사용하는 것입니다.

우리의 경우, 입력 은 a = 0이고 b = I 입니다. 적분 영역을 n = 10 ⁵ 이산 부분 으로 나누 므로 ∆ x = 1 / n = 10 ^-5 입니다. 이것은 합계에 대한 상수이므로, 이것을 합계 밖으로 끌어 내고 각 지점에서 함수 평가를 간단히 합산하고 n으로 나눌 수 있습니다.

이 기능은 놀랍게도 잘 동작합니다 (Mathematica의 도표) :

함수가 9에 대한보다 거의 입력을위한 공에 더 큰 평가하기 때문에, 우리는로 입력을 절단 I를 하면 나는 그렇지 미만 9 또는 9입니다. 이를 통해 우리가해야 할 계산이 간단 해집니다.

Ungolfed 코드 :

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 덕분에 39 바이트를 절약했습니다!

젤리, 20 19 17 바이트

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

이것은 @AlexA.의 답변 에서 9 트릭으로 영리한 잘림을 빌려 오른쪽 적 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 트릭을 사용해야합니다. 그렇지 않으면 큰 값의 정확도가 떨어집니다.

Math.exp가 Infinity에 도달하므로 너비가 ~ 0.001 인 사각형을 사용하는 73 바이트 버전은 ~ 700 이상에서 작동하지 않습니다.

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)Alex가 제시 한 트릭을 알아내는 데 시간이 걸렸다 .

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

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

파이썬 2, 94 76 바이트

저를 18 바이트 절약 해 주신 @Dennis에게 감사드립니다!

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보다 큰 입력을 자릅니다.

펄 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 바이트

@Dennis의 도움으로 5 바이트를 절약했습니다!

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

온라인으로 사용해보십시오!

설명

내 파이썬 답변 과 같은 알고리즘 .

J ^ T5smcc ^ .n1d ^ ddJmcdJU * hS, Q9J # Q = 입력
J ^ T5 # J를 사각형 너비 * 10 ^ 5로 설정
                       hS, Q9 # 9보다 큰 입력 자르기
                 mcdJU / J # 범위는 0에서 J 단계의 입력까지
     mcc ^ .n1d ^ ddJ # 목록의 각 요소에 대한 면적 계산
    s # 모든 영역 합계 및 출력 결과

MATL , 26 바이트

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

이것은 Riemann 합계로 적분을 근사합니다. 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 바이트

나는 내 자신의 공헌도 줄 수 있다고 생각했다. ¯ \ _ (ツ) _ / ¯ 이것은 적분의 왼손 리만 합 추정값을 사용합니다.

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는 결과를 보여주기 위해 끝에 있습니다.

온라인으로 사용해보십시오!