Étant donné un nombre réel tdans (-10^9,13)(non compris -10^9ou 13) comme entrée, sortie Γ(t), également connue sous le nom de fonction Gamma , qui est définie comme suit:

Vous ne pouvez pas utiliser une fonction gamma intégrée pour résoudre cette tâche, ni utiliser des fonctions d'intégration numériques ou symboliques intégrées. Votre sortie doit être précise à 6 chiffres significatifs ou à l'intérieur 10^-6de la valeur réelle, la valeur la moins restrictive étant retenue. La fonction Gamma intégrée de Python sera utilisée pour déterminer la valeur réelle. Vous pouvez supposer qu'il Γ(t)est défini - c'est-à-dire qu'il s'agit d' tun nombre réel positif ou d'un nombre réel négatif non entier - et cela |Γ(t)| ≤ 10^9. Voici un programme de référence que vous pouvez utiliser pour obtenir les valeurs réelles, en utilisant la fonction Gamma intégrée de Python.

Exemples

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

Règles

• C'est le code-golf , donc la réponse la plus courte (en octets) l'emporte.
• Les failles standard sont interdites.
• L'entrée et la sortie peuvent être effectuées de la manière considérée comme standard pour votre langue.
• Vous pouvez écrire un programme complet, une fonction ou tout ce qui est normalement considéré comme une réponse valide pour votre langue

Classement

L'extrait de pile au bas de cet article génère le classement à partir des réponses a) comme une liste des solutions les plus courtes par langue et b) comme un classement général.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Comme pour ma réponse TI-BASIC, je n'ai pas pu tester cela avec les 8 ^ 10 itérations complètes, mais tout semble bien avec des cas plus petits.

cu*Gc^hc1HQhcQHS^8T1Q

Explication:

                            [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

Essayez-le ici avec 2000 itérations au lieu de 8 ^ 10.

C ++ 14, 86 85 81 octets

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

Je n'ai pas passé beaucoup de temps sur celui-ci. Je viens de regarder l'approximation qui semblait la plus simple à mettre en œuvre (à la manière des octets). Il faudra un certain temps pour calculer la valeur (puisque la boucle est sur tous les entiers positifs), mais la limitation de temps n'est pas spécifiée dans le défi. C'est une fonction anonyme (lambda), qui prend n'importe quel argument (convertible en Tsur lequel pow(double, T)et operator/(T,int)peut être appelé) et retournedouble .

Ungolfed avec l'utilisation

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

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

Cela s'arrête avec une erreur (en essayant de diviser par 0), mais cela est autorisé selon le consensus Meta . Ajoutez un .à la fin pour un programme qui s'arrête normalement. Essayez tous les cas de test en même temps.(La boucle n'itère que 1e4 fois, donc elle se terminera plus tôt que tard.)

Explication

Zereges a utilisé l'une des définitions de produits alternatives infinies . Il s'avère que l'autre est beaucoup plus facile à mettre en œuvre à Minkolang.

C'est une limite qui nva à l'infini, ce qui signifie que je peux calculer les deux n!et au (t+n)fur et à mesure. Je retire donc 1/t(parce que 0!=1) et n^tparce que celui-ci ne peut pas être calculé séquentiellement sans connaître la valeur finale de n. En l'occurrence, parce que nc'est la limite, je peux l'utiliser deux fois. Une fois comme facteur dans le calcul et une fois comme nombre de fois pour exécuter la boucle.

Un produit infini séquentiel doit commencer par quelque chose, généralement 1. Dans ce cas, c'est n^t/t. Dans le corps de la boucle, je calcule k/(t+k)et multiplie cela avec le produit jusqu'à présent. À la fin, le produit entier a été calculé et produit. C'est essentiellement ce que fait mon programme, avec nsuffisamment de précision pour que la réponse soit suffisamment précise.

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

Comme il n'y en a pas ., il s'enroule et recommence. Cependant, nproduit maintenant -1parce que l'entrée est vide, ce qui conduit finalement à tenter de diviser par 0, ce qui interrompt le programme.

Julia, 141 octets

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

Cela crée une fonction lambda sans nom qui accepte un nombre réel et renvoie un nombre réel. Il utilise l'approximation de Spounge pour calculer le gamma.

Non golfé:

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 octets

Japt est une version abrégée de Ja vaScri pt . Interprète

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

Bien sûr, 1e9 = 1 000 000 000 d'itérations prend une éternité, donc pour les tests, essayez de remplacer le 9par un 6. (1e6 est précis à ~ 5 chiffres significatifs. L'utilisation de 1e8 sur une entrée de 12suffit pour obtenir les six premiers.)

Résultats du cas de test: (en utilisant la précision 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...

Comment ça fonctionne

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

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

Celui-ci utilise le même algorithme que Zereges.

Mise en garde: je n'ai pas réellement testé cela avec les itérations 1e9 complètes; en fonction du temps pris pour des valeurs plus petites, je m'attends à ce que le temps d'exécution soit de l'ordre des mois . Cependant, il semble converger et il ne devrait pas y avoir de problème avec les erreurs d'arrondi. TI stocke les nombres sous forme de nombres décimaux avec 14 chiffres de précision.

Python 3, 74 68 78 73 octets

Merci @Mego et @xnor

Ceci est une traduction de la réponse C ++ par Zereges. Fondamentalement, il s'agit d'une autre définition de la fonction gamma, donc plus précise (et ce qui est génial, c'est qu'elle utilise moins d'octets!)

Je suis désolé pour toutes les erreurs!

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 octets

Un merci spécial à @Mego!

Un 448 barré est (presque) toujours un 448! : p

Ceci est basé sur l'approximation de Lanzcos. Golfé d' ici

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 octets

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

Ceci est une traduction de la réponse C ++ de Zereges. Alors que mon autre réponse Julia se termine instantanément, c'est plutôt lent. Il calcule les cas de test en quelques secondes chacun sur mon ordinateur.

Non golfé:

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

Prolog, 114 octets

Ceci est une traduction de la réponse C ++ de 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),!.

Essayez-le en ligne ici
Exécutez-le avec une requête du formulaire:

p(12).

L'exécuter avec 1e9 récursions prend environ 15 minutes.
Si vous le diminuez à 1e6, cela prend environ 1 seconde, ce qui rend les tests plus faciles (mais moins précis).
L'exécuter dans un interprète sur votre ordinateur / ordinateur portable est également plus rapide pour la plupart des gens.

Mathematica, 40 octets

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