Biorąc pod uwagę liczbę rzeczywistą tw (-10^9,13)(bez uwzględnienia -10^9lub 13) jako dane wejściowe, wyjściowe Γ(t), znane również jako funkcja gamma , która jest zdefiniowana następująco:

Nie możesz użyć wbudowanej funkcji Gamma do rozwiązania tego zadania, ani nie możesz użyć wbudowanych liczbowych lub symbolicznych funkcji integracji. Twój wynik powinien być dokładny do 6 cyfr znaczących lub w granicach 10^-6rzeczywistej wartości, w zależności od tego, która wartość jest mniej restrykcyjna dla danej wartości. Do określenia rzeczywistej wartości zostanie wykorzystana wbudowana funkcja Gamma Pythona. Możesz założyć, że Γ(t)jest zdefiniowany - to tjest albo dodatnia liczba rzeczywista, albo niecałkowita ujemna liczba rzeczywista - i to |Γ(t)| ≤ 10^9. Oto program referencyjny, którego możesz użyć do uzyskania rzeczywistych wartości, używając wbudowanej funkcji Gamma Pythona.

Przykłady

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

Zasady

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź (w bajtach).
• Standardowe luki są zabronione.
• Dane wejściowe i wyjściowe można wykonywać w dowolny sposób uznany za standardowy dla Twojego języka.
• Możesz napisać pełny program, funkcję lub cokolwiek, co zwykle jest uważane za prawidłową odpowiedź dla twojego języka

Tabela liderów

Fragment kodu na dole tego postu generuje tabelę wyników na podstawie odpowiedzi a) jako lista najkrótszych rozwiązań dla każdego języka oraz b) jako ogólna tabela wyników.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie:

## [><>](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 bajtów

Podobnie jak w przypadku mojej odpowiedzi TI-BASIC, nie byłem w stanie przetestować tego z pełnymi iteracjami 8 ^ 10, ale wszystko wydaje się dobre w przypadku mniejszych przypadków.

cu*Gc^hc1HQhcQHS^8T1Q

Wyjaśnienie:

                            [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

Wypróbuj tutaj z 2000 iteracjami zamiast 8 ^ 10.

C ++ 14, 86 85 81 bajtów

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

Nie spędziłem na tym dużo czasu. Właśnie przyjrzałem się przybliżeniu, które wydawało się najłatwiejsze do wdrożenia (w formie bajtów). Obliczenie wartości zajmie trochę czasu (ponieważ pętla obejmuje wszystkie dodatnie liczby całkowite), ale ograniczenie czasowe nie jest określone w wyzwaniu. Jest to funkcja anonimowa (lambda), która przyjmuje dowolny argument (zamienny Tna który pow(double, T)ioperator/(T,int) można wywołać można go wywołać) i zwraca double.

Nieprzyzwyczajony do użytkowania

#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 bajtów

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

Zatrzymuje się to z błędem (przy próbie podzielenia przez 0), ale jest to dozwolone zgodnie z konsensusem Meta . Dodaj .na końcu program, który zatrzymuje się normalnie. Wypróbuj wszystkie przypadki testowe naraz. (Pętla iteruje tylko 1e4 razy, więc zakończy się wcześniej niż później).

Wyjaśnienie

Zereges użył jednej z alternatywnych, nieskończonych definicji produktu . Jak się okazuje, drugi jest znacznie łatwiejszy do wdrożenia w Minkolangu.

Jest to limit n, który idzie do nieskończoności, co oznacza, że ​​mogę obliczyć jedno n!i drugie (t+n). Więc wyjmuję 1/t(ponieważ 0!=1) i n^tponieważ tego nie można obliczyć sekwencyjnie bez znajomości wartości końcowej n. Tak się składa, ponieważ njest to limit, mogę go użyć dwa razy. Raz jako czynnik w obliczeniach i raz jako liczba uruchomień pętli.

Sekwencyjny nieskończony produkt musi zaczynać się od czegoś, zwykle 1. W tym przypadku tak jest n^t/t. W treści pętli obliczam k/(t+k)i mnożę to do tej pory z produktem. Na koniec cały produkt został obliczony i wyprodukowany. Zasadniczo tak robi mój program, nwystarczająco wysoki, aby odpowiedź była wystarczająco precyzyjna.

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

Ponieważ nie ma . , zawija się i zaczyna od nowa. Jednak nteraz produkuje, -1ponieważ dane wejściowe są puste, co ostatecznie prowadzi do próby podzielenia przez 0, co powoduje zatrzymanie programu.

Julia, 141 bajtów

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

Tworzy to nienazwaną funkcję lambda, która akceptuje liczbę rzeczywistą i zwraca liczbę rzeczywistą. To używa przybliżenie Spounge do obliczania gamma.

Nie golfowany:

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 bajtów

Japt to skrócona wersja Ja vaScri pt . Interpretator

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

Oczywiście, 1e9 = 1 000 000 000 iteracji trwa wiecznie, więc w celu przetestowania spróbuj zastąpić 9ją 6. (1e6 jest dokładny do ~ 5 cyfr znaczących. Używanie 1e8 na wejściu12 wystarcza, aby uzyskać pierwsze sześć.)

Wyniki przypadku testowego: (przy użyciu precyzji 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...

Jak to działa

         // 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 bajtów

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

Używa tego samego algorytmu co Zereges.

Zastrzeżenie: Właściwie nie testowałem tego z pełną iteracją 1e9; na podstawie czasu potrzebnego na mniejsze wartości oczekuję, że czas działania będzie rzędu miesięcy . Wydaje się jednak, że jest zbieżny i nie powinno być problemów z błędami zaokrąglania. TI przechowuje liczby jako liczby dziesiętne z 14 cyframi dokładności.

Python 3, 74 68 78 73 bajtów

Dzięki @Mego i @xnor

To jest tłumaczenie odpowiedzi C ++ przez Zereges. Zasadniczo jest to alternatywna definicja funkcji gamma, a zatem bardziej dokładna (a co jest świetne, to, że zużywa mniej bajtów!)

Przepraszam za wszystkie błędy!

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

Python, 348 448 407 390 389 bajtów

Specjalne podziękowania dla @Mego!

Przekreślona 448 to (prawie) nadal 448! : p

Jest to oparte na przybliżeniu Lanzcos. Grał w golfa stąd

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

Julia, 41 bajtów

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

To jest tłumaczenie odpowiedzi C ++ Zeregesa. Podczas gdy moja inna odpowiedź Julii kończy się natychmiast, jest to raczej powolne. Oblicza przypadki testowe w ciągu kilku sekund na moim komputerze.

Nie golfowany:

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

Prolog, 114 bajtów

To jest tłumaczenie odpowiedzi C ++ Zeregesa.

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),!.

Wypróbuj online tutaj
Uruchom go za pomocą zapytania formularza:

p(12).

Uruchomienie go z rekurencjami 1e9 zajmuje około 15 minut.
Jeśli zmniejszysz go do 1e6, zajmie to około 1 sekundy, co ułatwia (ale mniej dokładne) testowanie.
Uruchomienie go w tłumaczu na twoim komputerze / laptopie jest prawdopodobnie również szybsze dla większości ludzi.

Mathematica, 40 bajtów

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