गामा फंक्शन गोल्फ

17

एक वास्तविक संख्या को देखते हुए tमें (-10^9,13)(सहित नहीं -10^9या 13इनपुट, आउटपुट के रूप में) Γ(t), भी रूप में जाना जाता गामा फ़ंक्शन , जो इस प्रकार परिभाषित किया गया है:

गामा फ़ंक्शन परिभाषा

आप इस कार्य को हल करने के लिए एक अंतर्निहित गामा फ़ंक्शन का उपयोग नहीं कर सकते हैं, और न ही आप अंतर्निहित संख्यात्मक या प्रतीकात्मक एकीकरण कार्यों का उपयोग कर सकते हैं। आपका आउटपुट 6 महत्वपूर्ण आंकड़ों या 10^-6वास्तविक मूल्य के भीतर होना चाहिए , जो भी दिए गए मूल्य के लिए कम प्रतिबंधात्मक है। वास्तविक मूल्य का निर्धारण करने के लिए पायथन के अंतर्निहित गामा फ़ंक्शन का उपयोग किया जाएगा। आप मान सकते हैं Γ(t)कि परिभाषित किया गया है - जो कि tएक सकारात्मक वास्तविक संख्या है या एक गैर-पूर्णांक नकारात्मक वास्तविक संख्या - और वह है |Γ(t)| ≤ 10^9। यहाँ एक संदर्भ कार्यक्रम है जिसका उपयोग आप पायथन के अंतर्निहित गामा फ़ंक्शन का उपयोग करके वास्तविक मूल्यों को प्राप्त करने के लिए कर सकते हैं।

उदाहरण

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

नियम

  • यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।
  • मानक खामियों को मना किया जाता है।
  • इनपुट और आउटपुट आपकी भाषा के लिए मानक माना जाता है।
  • आप एक पूर्ण कार्यक्रम, एक फ़ंक्शन, या ऐसी कोई भी चीज़ लिख सकते हैं जिसे आम तौर पर आपकी भाषा के लिए मान्य उत्तर माना जाता है

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) a) प्रति भाषा सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

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

कोड स्निपेट दिखाएं

code-golf  math  calculus 
— मै जाऊं
स्रोत
1
ऐसी है कि टी के लिए स्पष्ट सीमा प्रदान करें | गामा (टी) | <10 ^ 9
— flawr
लिंक एक संदर्भ कार्यान्वयन नहीं है, ...
— सर्गियोल
@sergiol ने इसे रीवार्ड किया
— Mego

जवाबों:

2

पायथ, 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

8 ^ 10 के बजाय 2000 पुनरावृत्तियों के साथ इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत
10

सी ++ 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
}
— Zereges
स्रोत
@ यह निश्चित रूप से है! धन्यवाद।
— Zereges
तो ओ -10 ^ 9 और 10 ^ 9 के लिए आपको क्या मूल्य मिलता है? मैं पहली बार जानना चाहता हूं कि मेरे उत्थान से पहले आपका सामान कितना अच्छा काम करता है।
— दोष
@Mego Microsoft संकलक को किसी भी प्रकार की आवश्यकता नहीं है।
— Zereges
@ मायेगोMicrosoft (R) C/C++ Optimizing Compiler Version 19.00.23026 for x86
— Zereges
@flawr माइन प्रोग्राम 0 के लिए आउटपुट करता है, gamma(-10e9)लेकिन ओपी ने कहा, केवल पैरामीटर, जिसके लिए गामा फ़ंक्शन परिभाषित किया गया है, पर विचार किया जा सकता है। gamma(10e9)रिटर्न inf, जबकि अजगर के अंतर्निहित गामा फ़ंक्शन वास्तविक मूल्य निर्धारित करने के लिए इस्तेमाल किया जाएगा कहते हैंOverflowError: math range error
— Zereges
7

मिंकोलंग 0.12 , 35 34 25 बाइट्स

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

यह एक त्रुटि के साथ रुकता है (0 से विभाजित करने की कोशिश पर), लेकिन इसे मेटा सहमति के अनुसार अनुमति दी जाती है । .एक कार्यक्रम के लिए अंत में जोड़ें जो सामान्य रूप से रुकता है। एक बार में सभी परीक्षण मामलों की कोशिश करो। (लूप केवल 1e4 बार पुनरावृत्ति करता है, इसलिए यह बाद में होने के बजाय जल्द ही समाप्त हो जाएगा।)

व्याख्या

Zereges ने वैकल्पिक, अनंत उत्पाद परिभाषाओं में से एक का उपयोग किया । जैसा कि यह पता चला है, अन्य Minkolang में लागू करने के लिए बहुत अधिक उत्तरदायी है।

गूलर समारोह के यूलर का वैकल्पिक सूत्रीकरण

यह एक सीमा है जैसा 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 से विभाजित करने का प्रयास करता है, जो कार्यक्रम को रोक देता है।

— एलेंडिया स्ट्राटन
स्रोत
5

जूलिया, 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])))

यह एक अनाम लंबो फ़ंक्शन बनाता है जो एक वास्तविक संख्या को स्वीकार करता है और एक वास्तविक संख्या देता है। यह गामा की गणना करने के लिए स्पांज के सन्निकटन का उपयोग करता है ।

Ungolfed:

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
— एलेक्स ए।
स्रोत
बहुत, बहुत देर से गोल्फ, लेकिन z->(z-=1;a=90;c(k)=(k=big(k);(-1)^~-k/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)))137 बाइट्स के लिए काम करना चाहिए (कम से कम जूलिया 0.6 में)
— श्री एक्सकोडर
3

जाप, 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 पुनरावृत्तियों को हमेशा के लिए ले जाता है, इसलिए परीक्षण के लिए, 9ए के साथ प्रतिस्थापित करने का प्रयास करें 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).
— ETHproductions
स्रोत
3

टीआई-बेसिक, 35 बाइट्स

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

यह Zereges के समान एल्गोरिथ्म का उपयोग करता है।

कैविएट: मैंने वास्तव में पूर्ण 1e9 पुनरावृत्तियों के साथ इसका परीक्षण नहीं किया है; छोटे मूल्यों के लिए लिए गए समय के आधार पर, मुझे उम्मीद है कि रनटाइम महीनों के क्रम पर होगा । हालांकि, यह अभिसरण प्रतीत होता है, और गोलाई त्रुटियों के साथ कोई समस्या नहीं होनी चाहिए। दशमलव के रूप में TI स्टोर संख्या को सटीकता के 14 अंकों के साथ तैरता है।

— lirtosiast
स्रोत
आप यह परीक्षण नहीं किया ?!
— तन्माथ
1
@TanMath मैं करूंगा, लेकिन मुझे अगले महीने अंतिम परीक्षा के लिए अपने कैलकुलेटर की आवश्यकता है।
— lirtosiast
3

पायथन 3, 74 68 78 73 बाइट्स

धन्यवाद @Mego और @xnor

यह Zereges द्वारा C ++ उत्तर का अनुवाद है। मूल रूप से, यह गामा फ़ंक्शन की एक वैकल्पिक परिभाषा है, इसलिए अधिक सटीक (और जो महान है वह कम बाइट्स का उपयोग करता है!)

मुझे सभी गलतियों के लिए खेद है!

def g(z,v=1):
 for i in range(1,10**9):v*=(1+1/i)**z/(1+z/i)
 return v/z
— TanMath
स्रोत
1
+1सीमा पर कोई फर्क नहीं पड़ता है जब आप अरबों साथ काम कर रहे। इसके अलावा, आपको यह निर्दिष्ट करना चाहिए कि यह पायथन 3 है - आपको from __future__ import divisionइस तथ्य से निपटने के लिए फ्लोट डिवीजन और कुछ टेराबाइट रैम की आवश्यकता होगी जो कि rangeपायथन 2 में एक सूची देता है। प्लस, आप 1.0s को 1s से बदल सकते हैं और 4 से दाढ़ी बना सकते हैं। बाइट्स।
— मेगो
2
@ तन्माथ: एक्सोर ^है, क्या आपका मतलब एक्सप्रेशन के **रूप में नहीं है ?
— jermenkoo
3
int(1e9)बस है 10**9, और आपको आसपास के परगनों की आवश्यकता नहीं है (1+1/i)**z।
— xnor
3

पायथन, 348 448 407 390 389 बाइट्स

@Mego के लिए विशेष धन्यवाद!

एक पार किया हुआ 448 (लगभग) अभी भी एक 448 है! : p

यह लैंजकोस सन्निकटन पर आधारित है। से 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
— TanMath
स्रोत
1
कृपया व्हाट्सएप (पहले और बाद के रिक्त स्थान = = और import *उदाहरण के लिए) को हटाते हुए, एक-वर्ण फ़ंक्शन नाम का उपयोग करके , अपनी सबमिशन को गोल्फ में दर्ज करें। यह भी ध्यान दें कि आपको केवल वास्तविक इनपुट का समर्थन करने की आवश्यकता है।
— lirtosiast
@ThomasKwa मैंने इसे संपादित किया है। मेरा मूल संस्करण काम नहीं आया, यहाँ एक नया है।
— तन्माथ
@Mego का संपादन ...
— TanMath
यह पुनरावर्ती त्रुटि का कारण बनता है - इसे ठीक करने z-=1;के gammaलिए पहली पंक्ति में निकालें । तुम भी नाम बदलने चाहिए gammaकरने के लिए gबाइट्स की बचत होती है के लिए और के साथ संघर्ष के नामकरण से बचने के लिए cmath.gamma। इसके अलावा बाहरी अग्रणी शून्य को गिराएं।
— मेगो
1

जूलिया, 41 बाइट्स

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

यह Zereges 'C ++ उत्तर का अनुवाद है। जबकि मेरे अन्य जूलिया का जवाब तुरंत खत्म हो जाता है, लेकिन यह धीमा है। यह मेरे कंप्यूटर पर एक-दो सेकंड में परीक्षण के मामलों की गणना करता है।

Ungolfed:

function f(x::Real)
    prod([(1 + 1/i)^x / (1 + x/i) for i = 1:1E7]) / x
end
— एलेक्स ए।
स्रोत
1

प्रोलॉग, 114 बाइट्स

यह Zereges 'C ++ उत्तर का अनुवाद है।

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

1e9 रिक्रिएशन के साथ इसे चलाने में लगभग 15 मिनट लगते हैं।
यदि आप इसे घटाकर 1e6 कर देते हैं तो इसमें लगभग 1 सेकंड लगता है, जो आसान (लेकिन कम तीखे) परीक्षण के लिए बनाता है।
कंप्यूटर / लैपटॉप पर दुभाषिया में इसे चलाने से अधिकांश लोगों के साथ-साथ अधिकांश लोगों के लिए भी तेजी से होने की संभावना है।

— Emigna
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.