Diberikan bilangan real tdalam (-10^9,13)(tidak termasuk -10^9atau 13) sebagai input, output Γ(t), juga dikenal sebagai fungsi Gamma , yang didefinisikan sebagai berikut:

Anda tidak boleh menggunakan fungsi Gamma bawaan untuk menyelesaikan tugas ini, Anda juga tidak dapat menggunakan fungsi integrasi numerik atau simbolik bawaan. Output Anda harus akurat hingga 6 angka signifikan atau di dalam 10^-6nilai aktual, mana yang kurang membatasi untuk nilai yang diberikan. Fungsi Gamma bawaan Python akan digunakan untuk menentukan nilai aktual. Anda dapat mengasumsikan Γ(t)didefinisikan - yaitu, tbilangan real positif atau bilangan real negatif non-integer - dan itu |Γ(t)| ≤ 10^9. Berikut adalah program referensi yang dapat Anda gunakan untuk mendapatkan nilai aktual, menggunakan fungsi Gamma bawaan Python.

Contohnya

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

Aturan

• Ini adalah kode-golf , jadi jawaban tersingkat (dalam byte) menang.
• Celah standar dilarang.
• Input dan output dapat dilakukan dengan cara apa pun yang dianggap standar untuk bahasa Anda.
• Anda dapat menulis program lengkap, fungsi, atau apa pun yang biasanya dianggap sebagai jawaban yang valid untuk bahasa Anda

Papan peringkat

Cuplikan Stack di bagian bawah posting ini menghasilkan leaderboard dari jawaban a) sebagai daftar solusi terpendek per bahasa dan b) sebagai leaderboard keseluruhan.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

## Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda dapat menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat nama bahasa menjadi tautan yang kemudian akan muncul di cuplikan:

## [><>](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 byte

Seperti dengan jawaban TI-BASIC saya, saya belum dapat menguji ini dengan iterasi 8 ^ 10 penuh, tetapi semuanya tampak baik dengan kasus yang lebih kecil.

cu*Gc^hc1HQhcQHS^8T1Q

Penjelasan:

                            [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

Coba di sini dengan 2000 iterasi bukan 8 ^ 10.

C ++ 14, 86 85 81 byte

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

Saya tidak menghabiskan banyak waktu untuk yang satu ini. Saya hanya melihat perkiraan yang tampaknya paling mudah untuk diterapkan (dalam cara byte). Diperlukan waktu untuk menghitung nilai (karena loop adalah semua bilangan bulat positif), tetapi batasan waktu tidak ditentukan dalam tantangan. Ini adalah fungsi anonim (lambda), yang mengambil argumen apa pun (dapat dikonversi ke Tmana pow(double, T)dan operator/(T,int)dapat dipanggil) dan kembali double.

Tidak digabungkan dengan penggunaan

#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 byte

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

Ini berhenti dengan kesalahan (saat mencoba untuk membagi dengan 0), tetapi itu diperbolehkan sesuai dengan konsensus Meta . Tambahkan a .di akhir untuk program yang berhenti secara normal. Coba semua test case sekaligus. (Loop hanya mengulang 1e4 kali sehingga akan selesai lebih cepat daripada nanti.)

Penjelasan

Zereges menggunakan salah satu alternatif, definisi produk tanpa batas . Ternyata, yang lain jauh lebih setuju untuk diterapkan di Minkolang.

Ini adalah batas nsampai tak terhingga, yang berarti bahwa saya dapat menghitung keduanya n!dan (t+n)saat saya pergi. Jadi saya mengambil 1/t(karena 0!=1) dan n^tkarena itu seseorang tidak dapat dihitung secara berurutan tanpa mengetahui nilai akhir dari n. Seperti yang terjadi, karena nbatasnya, saya bisa menggunakannya dua kali. Sekali sebagai faktor dalam perhitungan dan sekali sebagai jumlah kali menjalankan loop.

Produk tak berurutan berurutan harus dimulai dengan sesuatu, biasanya 1. Dalam hal ini, itu n^t/t. Dalam tubuh loop, saya menghitung k/(t+k)dan melipatgandakannya dengan produk sejauh ini. Pada akhirnya, seluruh produk telah dihitung dan diproduksi. Ini pada dasarnya adalah apa yang program saya lakukan, dengan njawaban yang cukup tinggi cukup tepat.

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

Karena tidak ada ., ia membungkus dan memulai kembali. Namun, nsekarang menghasilkan -1karena input kosong, yang pada akhirnya mengarah pada upaya untuk membagi dengan 0, yang menghentikan program.

Julia, 141 byte

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

Ini menciptakan fungsi lambda tanpa nama yang menerima bilangan real dan mengembalikan bilangan real. Ia menggunakan perkiraan Spounge untuk menghitung Gamma.

Tidak Disatukan:

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 byte

Japt adalah versi singkat dari Ja vaScri pt . Penerjemah

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

Tentu saja, 1e9 = 1.000.000.000 iterasi berlangsung selamanya, jadi untuk pengujian, coba ganti 9dengan a 6. (1e6 akurat hingga ~ 5 angka signifikan. Menggunakan 1e8 pada input 12sudah cukup untuk mendapatkan enam angka pertama.)

Hasil uji kasus: (menggunakan presisi 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...

Bagaimana itu bekerja

         // 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 byte

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

Ini menggunakan algoritma yang sama dengan Zereges.

Peringatan: Saya belum benar-benar menguji ini dengan iterasi 1e9 penuh; berdasarkan waktu yang diambil untuk nilai yang lebih kecil, saya berharap runtime berada di urutan bulan . Namun, tampaknya konvergen, dan seharusnya tidak ada masalah dengan kesalahan pembulatan. TI menyimpan angka sebagai mengambang desimal dengan 14 digit presisi.

Python 3, 74 68 78 73 byte

Terima kasih @Mego dan @xnor

Ini adalah terjemahan dari jawaban C ++ oleh Zereges. Pada dasarnya, ini adalah definisi alternatif dari fungsi gamma, karenanya lebih akurat (dan yang hebat adalah yang menggunakan lebih sedikit byte!)

Saya minta maaf atas semua kesalahan!

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 byte

Terima kasih khusus kepada @Mego!

448 dicoret adalah (hampir) masih 448! : p

Ini didasarkan pada perkiraan Lanzcos. Golf dari sini

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 byte

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

Ini adalah terjemahan dari jawaban C ++ Zereges. Sementara jawaban Julia saya yang lain selesai secara instan, ini agak lambat. Itu menghitung kasus uji dalam beberapa detik masing-masing di komputer saya.

Tidak Disatukan:

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

Prolog, 114 byte

Ini adalah terjemahan dari jawaban C ++ Zereges.

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

Cobalah online di sini
Jalankan dengan kueri formulir:

p(12).

Menjalankannya dengan rekursi 1e9 membutuhkan waktu sekitar 15 menit.
Jika Anda menguranginya menjadi 1e6 dibutuhkan sekitar 1 detik yang membuat lebih mudah (tetapi kurang akurat) pengujian.
Menjalankannya dalam juru bahasa di komputer / laptop Anda kemungkinan besar lebih cepat bagi kebanyakan orang juga.

Mathematica, 40 byte

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