Дано реальне число tв (-10^9,13)(не включаючи -10^9або 13) як вхід, вихід Γ(t), також відомий як Гамма-функція , яка визначається наступним чином:

Ви не можете використовувати вбудовану функцію Gamma для вирішення цього завдання, а також не можете використовувати вбудовані числові чи символьні функції інтеграції. Вихід повинен бути точним до 6 значущих цифр або в межах 10^-6фактичного значення, залежно від того, що є менш обмежуючим для даного значення. Вбудована функція Gamma Python буде використовуватися для визначення фактичного значення. Ви можете припустити Γ(t), що визначено - тобто це tчи додатне дійсне число, чи не ціле негативне дійсне число - і це |Γ(t)| ≤ 10^9. Ось довідкова програма, яку ви можете використовувати для отримання фактичних значень, використовуючи вбудовану функцію Gamma Python.

Приклади

1 -> 1.000000
-2.5 -> -0.945309
3.14159265 -> 2.288038
-2.71828182846 -> -0.952682
12 -> 39916800.000000
0.5 -> 1.772454
8.675309 -> 20248.386956
-10.1 -> -0.000002

Правила

• Це код-гольф , тому найкоротша відповідь (у байтах) виграє.
• Стандартні лазівки заборонені.
• Введення та виведення даних можуть здійснюватися будь-яким способом, який вважається стандартним для вашої мови.
• Ви можете написати повну програму, функцію чи будь-що, що зазвичай вважається правильною відповіддю для вашої мови

Таблиця лідерів

Фрагмент стека внизу цієї публікації генерує таблицю лідерів з відповідей а) як список найкоротших варіантів для кожної мови та б) як загальну таблицю лідерів.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

## Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Якщо ви хочете включити у свій заголовок декілька чисел (наприклад, тому що ваш результат - це сума двох файлів або ви хочете окремо перерахувати штрафні санкції для перекладача), переконайтесь, що фактичний результат - це останнє число у заголовку:

## Perl, 43 + 2 (-p flag) = 45 bytes

Ви також можете зробити ім'я мови посиланням, яке з’явиться у фрагменті:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 63887; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 45941; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Pyth, 21 байт

Як і в моїй відповіді TI-BASIC, я не зміг перевірити це за допомогою повних 8 ^ 10 ітерацій, але все здається гарним у менших випадках.

cu*Gc^hc1HQhcQHS^8T1Q

Пояснення:

                            [implicit: Q=input]
                ^8T         8**10
               S^8T         [1,2,3,...,8**10]
  *Gc^hc1HQhcQH             lambda G,H:G*(1+1/H)**Q/(1+Q/H)
                   1        Base case
 u*Gc^hc1HQhcQHS^8T1        Reduce with base case 1
c                   Q       Divide by Q

Спробуйте тут з 2000 ітерацій замість 8 ^ 10.

C ++ 14, 86 85 81 байт

[](auto t){auto v=1.;for(int x=1;x<1e9;++x)v*=pow(1+1./x,t)/(1+t/x);return v/t;};

Я не витрачав багато часу на цей. Я просто подивився на наближення, яке здавалося найпростішим для реалізації (у манері байтів). Для обчислення значення знадобиться деякий час (оскільки цикл перевищує всі додатні цілі числа), але обмеження в часі не вказано в виклику. Це анонімна функція (лямбда), яка приймає будь-який аргумент (конвертований в T який pow(double, T)і operator/(T,int)можна викликати) і повертає double.

Безголовка з використанням

#include <iostream>
int main()
{
    auto r = [](auto t)
    {
        auto v = 1.;
        for (int x = 1; x < 1e9; ++x)
            v *= pow(1 + 1. / x, t) / (1 + t / x);
        return v / t;
    };
    std::cout << r(-2.71828182846); // outputs -0.952682
}

Minkolang 0,12 , 35 34 25 байт

n$zl8;dz;z$:r[i1+dz+$:*]N

Це припиняється з помилкою (при спробі розділити на 0), але це дозволено відповідно до мета-консенсусу . .В кінці додайте програму, яка нормально зупиняється. Спробуйте всі тестові справи одразу. (Цикл повторюється лише 1e4 рази, тому він закінчиться швидше, ніж пізніше.)

Пояснення

Зереги використовували одне з альтернативних, нескінченних визначень продукту . Як виявляється, інше набагато приємніше реалізовувати у Мінколангу.

Це межа, як і nдо нескінченності, це означає, що я можу обчислити і те, n!і (t+n)як я йду. Тому я виймаю 1/t(тому, що 0!=1) і n^tтому, що не можна обчислювати послідовно, не знаючи кінцевого значення n. Як це буває, оскільки nце межа, я можу використовувати її двічі. Один раз як фактор обчислення і один раз - кількість разів для запуску циклу.

Послідовний нескінченний продукт повинен починатися з чогось, як правило, 1. У цьому випадку це n^t/t. У тілі петлі я обчислюю k/(t+k)та множу це з виробом до цих пір. Зрештою, весь продукт був розрахований і виведений. Це по суті те, що робить моя програма, з nдостатньо високим рівнем відповіді, щоб відповідь була досить точною.

n                            Take number from input
 $z                          Store it in the register (this is t; retrieved with z)
   l8;                       10^8 (this is n, the limit)
      d                      n,n
       z;                    n,n^t
         z$:                 n,n^t/t
            r                Reverse stack -> n^t/t,n
             [               For loop that runs n times
              i1+            k
                 d           k,k
                  z+         k,t+k
                    $:       k/(t+k)
                      *      Multiply
                       ]N    Close for loop and output as integer

Як немає ., він загортається і починається спочатку. Однак nтепер виробляється, -1оскільки вхід порожній, що врешті-решт призводить до спроби поділу на 0, що зупиняє програму.

Джулія, 141 байт

z->(z-=1;a=90;c(k)=(k=big(k);(-1)^(k-1)/factorial(k-1)*(a-k)^(k-.5)*exp(a-k));(z+a)^(z+.5)*exp(-z-a)*(√(2π)+sum([c(k)/(z+k)for k=1:a-1])))

Це створює неназвану лямбда-функцію, яка приймає дійсне число і повертає дійсне число. Він використовує наближення Спаунжа для обчислення Гамми.

Безголовки:

function Γ(z::Real)
    # Spounge's approxmation is for Γ(z+1), so subtract 1
    z -= 1

    # Choose a number for the constant a, which determines the
    # bound on the error
    a = 90

    # Define a function for the sequence c_k
    function c(k::Integer)
        # Convert k to a BigInt
        k = big(k)
        return (-1)^(k-1) / factorial(k-1) * (a-k)^(k-1/2) * exp(a-k)
    end

    # Compute the approximation
    return (z+a)^(z+1/2) * exp(-z-a) * (√(2π) + sum([c(k)/(z+k) for k=1:a-1]))
end

Japt, 45 байт

Japt - скорочена версія Ja vaScri pt . Перекладач

$for(V=X=1;X<1e9;)$V*=(1+1/X pU /(1+U/X++;V/U

Звичайно, 1e9 = 1 000 000 000 ітерацій триває назавжди, тому для тестування спробуйте замінити на 9a 6. (1e6 точний до ~ 5 значущих цифр. Використання 1e8 на вході 12достатньо, щоб отримати перші шість.)

Результати тестових випадків: (з точністю 1e7)

       1:  1
    -2.5: -0.9453083...
      pi:  2.2880370...
      -e: -0.9526812...
      12:  39916536.5...
     0.5:  1.7724538...
8.675309:  20248.319...
   -10.1: -0.0000022...

Як це працює

         // Implicit: U = input number
$for(    // Ordinary for loop.
V=X=1;   //  Set V and X to 1.
X<1e9;)$ //  Repeat while X is less than 1e9.
V*=      // Multiply V by:
(1+1/X   //  1 plus (1 over X),
pU /     //  to the power of U, divided by
(1+U/X++ //  1 plus (U over X). Increment X by 1.
;V/U     // Output the result of (V over U).

TI-BASIC, 35 байт

Input Z
1
For(I,1,ᴇ9
Ans(1+I⁻¹)^Z/(1+Z/I
End
Ans/Z

Для цього використовується той же алгоритм, що і Зерегес.

Caveat: Я насправді цього не перевіряв за допомогою повних ітерацій 1e9; виходячи з часу, необхідного для менших значень, я очікую, що тривалість виконання буде близько місяця . Однак воно, схоже, збігається, і не повинно виникнути проблем із помилками округлення. TI зберігає числа у вигляді десяткових поплавків із 14 цифрами точності.

Пітон 3, 74 68 78 73 байт

Дякую @Mego та @xnor

Це переклад відповіді C ++ Зерегеса. В основному, це альтернативне визначення гамма-функції, отже, більш точне (і що чудово - це використання менше байтів!)

Мені шкода за всі помилки!

def g(z,v=1):
 for i in range(1,10**9):v*=(1+1/i)**z/(1+z/i)
 return v/z

Пітона, 348 448 407 390 389 байт

Особлива подяка @Mego!

Перекреслений 448 - це (майже) все ще 448! : с

Це ґрунтується на наближенні Ланкоса. Golfed з тут

from cmath import*
C=[0.9999999999998099,676.5203681218851,-1259.1392167224028,771.3234287776531,-17‌6.6150291621406,12.507343278686905,-0.13857109526572012,9.984369578019572e-6,1.5‌​056327351493116e-7]
def g(z):
 z-=1;if z.real<0.5:return pi/(sin(pi*z)*gamma(1-z))
 else:
  x=C[0]
  for i in range(1,9):x+=C[i]/(z+i)
  t=z+7.5;return sqrt(2*pi)*t**(z+0.5)*exp(-t)*x

Джулія, 41 байт

x->prod([(1+1/i)^x/(1+x/i)for i=1:1E7])/x

Це переклад відповіді Зерегеса С ++. Хоча моя інша відповідь Юлії закінчується миттєво, це досить повільно. Він обчислює тестові випадки за пару секунд на моєму комп’ютері.

Безголовки:

function f(x::Real)
    prod([(1 + 1/i)^x / (1 + x/i) for i = 1:1E7]) / x
end

Пролог, 114 байт

Це переклад відповіді Зерегеса С ++.

q(F,F,V,Z):-X is V/Z,write(X).
q(F,T,V,Z):-W is(1+1/F)**Z/(1+Z/F)*V,I is F+1,q(I,T,W,Z).
p(N):-q(1.0,1e9,1,N),!.

Спробуйте це в Інтернеті тут.
Запустіть його із запитом форми:

p(12).

Виконання його за допомогою 1е9 ​​рекурсій займає близько 15 хвилин.
Якщо зменшити його до 1e6, це потребує приблизно 1 секунди, що полегшує (але менш гостро) тестування.
Запуск його в перекладачі на вашому комп'ютері / ноутбуці, швидше за все, швидший і для більшості людей.

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

NProduct[(1+1/n)^#/(1+#/n),{n,1,∞}]/#&