Функція Пі - це розширення факторіалу над реалами (або навіть складними числами). Для цілих чисел n , Π (n) = n! , але для отримання визначення над реалами ми визначаємо його за допомогою інтеграла:

У цьому виклику ми перетворимо функцію Π .

Давши дійсне число z ≥ 1 , знайдіть додатне x таке, що Π (x) = z . Ваша відповідь повинна бути точною щонайменше 5 знаків після коми.

Приклади:

120 -> 5.0000
10 -> 3.39008
3.14 -> 2.44815
2017 -> 6.53847
1.5 -> 1.66277

Математика, 17 15 27 байт

FindInstance[#==x!&&x>0,x]&

Результат виглядає так {{x -> n}}, де nрішення, яке може бути дозволено.

Pyth, 4 байти

.I.!

Програма, яка приймає введення числа і друкує результат.

Тестовий набір

Як це працює

.I.!    Program. Input: Q
.I.!GQ  Implicit variable fill
.I      Find x such that:
  .!G    gamma(x+1)
     Q   == Q
        Implicitly print

MATL , 13 байт

1`1e-5+tQYgG<

Для цього використовується лінійний seach в кроках, 1e-5починаючи з 1. Так це страшенно повільно, і час вичерпається в онлайн-компіляторі.

Щоб перевірити це, наступне посилання замінює 1e-5вимогу точності на 1e-2. Спробуйте в Інтернеті!

Пояснення

1        % Push 1 (initial value)
`        % Do...while
  1e-5   %   Push 1e-5
  +      %   Add
  t      %   Duplicate
  QYg    %   Pi function (increase by 1, apply gamma function)
  G<     %   Is it less than the input? If so: next iteration
         % End (implicit)
         % Display (implicit)

GeoGebra , 25 байт

NSolve[Gamma(x+1)=A1,x=1]

Введений у вхід CAS і очікує введення числа у комірці електронної таблиці A1. Повертає одноелементний масив форми {x = <result>}.

Ось gif виконання:

Як це працює

Nумерно Solveнаступне рівняння:, Gamma(x+1)=A1із початковим значенням x=1.

MATLAB, 59 байт

@(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))

Це анонімна функція, яка знаходить мінімізатор різниці у квадраті між функцією Pi та її введення, починаючи з 1, з дуже малим допуском (заданим eps), щоб досягти бажаної точності.

Тестові приклади (запущені на Matlab R2015b):

>> @(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))
ans = 
    @(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))
>> f = ans; format long; f(120), f(10), f(3.14), f(2017)
ans =
   5.000000000000008
ans =
   3.390077650547032
ans =
   2.448151165246967
ans =
   6.538472664321318

Ви можете спробувати його в Інтернеті в Octave, але, на жаль, деяким результатам не вистачає необхідної точності.

J, 86 33 байт

((]-(-~^.@!)%[:^.@!D.1])^:_>:)@^.

Використовує метод Ньютона з журналом Pi, щоб уникнути переповнення.

Це попередня версія, яка обчислює журнал Gamma, використовуючи наближення Стірлінга. Розмір кроків (1e3) та кількість термінів у журналі Gamma (3) можна збільшити для можливо більшої точності за рахунок продуктивності.

3 :'(-(k-~g)%%&1e3(g=:((%~12 _360 1260 p.&:%*:)+-+^~-&^.%:@%&2p1)@>:)D:1])^:_>:k=:^.y'

Ще одна версія, яка обчислює коефіцієнти термінів на льоту

3 :'(-((-^.y)+g)%%&1e3(g=:((%~(((%1-^@-)t:%]*<:)+:>:i.3)p.%@*:)+(*^.)-]+-:@^.@%&2p1)@>:)D:1])^:_>:^.y'

Спробуйте в Інтернеті! і щоб побачити умови, що збігаються .

Пояснення

((]-(-~^.@!)%[:^.@!D.1])^:_>:)@^.  Input: float y
(                            )@^.  Operate on log(y)
                           >:        Increment, the initial guess is log(y)+1
 (                     )^:_          Repeat until convergence starting with x = log(y)+1
                      ]                Get x
               ^.@!                    The log Pi verb
             [:    D.1                 Approximate its first derivative at x
       ^.@!                            Apply log Pi to x
     -~                                Subtract log(y) from it
            %                          Divide it by the derivative
  ]-                                   Subtract it from x and use as next value of x

Математика, 21 байт

FindRoot[#-x!,{x,1}]&

FindRoot застосовує метод Ньютона внутрішньо, коли є початкове значення.

Два способи нижче застосовують метод Ньютона безпосередньо.

Альтернативно за допомогою FixedPoint 45 байт

FixedPoint[#-(#!-y)/Gamma'[#+1]&,Log[y=#]+1]&

Більш точна реалізація методу Ньютона для вирішення цього питання, оскільки Mathematica може обчислити похідну безпосередньо, а не наближати її.

Використання правил для заміни повторно було б коротшим, але існує обмеження (65536) на кількість повторень, які він може виконати, які можуть бути вражені, тоді як FixedPointне має обмеження.

Альтернативно з використанням правил, 38 байт

Log[y=#]+1//.x_->x-(x!-y)/Gamma'[x+1]&

Желе , 34 байти

Ḋ!Æl_®
ȷİ‘×;µ!ÆlI÷I÷@Ç_@ḊḢ
Æl©‘ÇÐĿ

Спробуйте в Інтернеті! або Перегляньте проміжні значення під час їх сходження .

Реалізація комбінації J методу Ньютона та наближення похідної (семантичний метод) для обчислення зворотного значення Π ( n ).

Він вирішує для зворотного log ( Π ( n )) замість цього, щоб уникнути переповнення.

Це починається з початкової здогадки x ₀ = y +1, де y = log ( Π ( n )). Потім воно ітераціює до зближення, використовуючи x _{n +1} = x _n - (log ( Π ( x _n )) - y ) / (log (( Π (1.001 * x _n )) - log ( Π ( x _n )))) / (0,001 * х _п )).

PARI / GP, 30 байт

x->solve(t=1,x+1,gamma(t+1)-x)

Знаходить рішення між 1і x+1. На жаль, xнедостатньо великий, як верхня межа для введення 1.5.

Математика, 26 байт

Ще одне рішення Mathematica!

Розв’язання рівнянь завжди можна перетворити на проблему мінімізації.

NArgMin[{(#-x!)^2,x>0},x]&

Знаходить аргумент, який мінімізує різницю між лівою та правою сторонами рівняння.

Використання NArgMin, а не NMinimize, примушує результат вивести просто бажаний результат, а не звичайний багатослівний вихід на основі правил (і це економить байт!)

С з libm, 111

Оновлення - фіксовано для введення 1.5.

f(double *z){double u=2**z,l=0,g=u,p=0;for(;log(fabs(g-p))>-14;)p=g,g=(u+l)/2,u=tgamma(g+1)>*z?g:(l=g,u);*z=g;}

gamma(x+1)є монотонно зростаючою функцією над відповідним діапазоном, shis - це лише бінарний пошук, поки різниця між послідовними значеннями не буде невеликою. Початкова нижня межа є, 0а початкова верхня межа - 2*x.

Вхід і вихід здійснюється через вказівник на подвійний переданий функції.

Я впевнений, що це можна пограти в гольф глибше - зокрема, я не думаю, що мені потрібні 4 місцеві парні, але поки що я не бачу простого способу зменшити це.

Спробуйте в Інтернеті - будує (пов'язує з libm) і працює в баш-скрипті.

Легко незворушний:

f(double *z){
    double u=2**z,l=0,g=u,p=0;
    for(;log(fabs(g-p))>-14;){
        p=g;
        g=(u+l)/2;
        u=tgamma(g+1)>*z?g:(l=g,u);*z=g;
    }
}