12

एक सकारात्मक पूर्णांक को देखते हुए n उत्पादन पहले की राशि n का आंशिक भाग के दशमलव अंकों के π ^एन ।

उदाहरण इनपुट और आउटपुट:

1 → 1
2 → 14
3 → 6
4 → 13
5 → 24
50 → 211
500 → 2305
5000 → 22852

में निर्मित के अंकों की गणना कार्यों π या तो घात श्रृंखला का मूल्यांकन या जारी रखा अंशों की अनुमति नहीं है। मानक खामियां लागू होती हैं। इनपुट / आउटपुट एक सुविधाजनक प्रारूप (स्टड, स्टडआउट, फंक्शन इन / आउटपुट, आदि) में हो सकता है।

बाइट्स में सबसे छोटा कोड जीतता है।

— orlp
स्रोत

क्या अन्य ट्रिगर फ़ंक्शंस हैं जिनका उपयोग पाई की गणना करने के लिए किया जा सकता है, लेकिन जरूरी नहीं कि सीधे, जैसे आर्कटिक या काल्पनिक लघुगणक पर प्रतिबंध लगाया गया हो? इसके अलावा, वहाँ n के लिए एक ऊपरी सीमा है कि यह बाद में विफल हो सकता है?

— FryAmTheEggman

@FryAmTheEggman यदि वे ट्रिगर फ़ंक्शंस पाई के मनमाने अंकों की गणना कर सकते हैं, तो हाँ वे प्रतिबंधित हैं। आपके कार्यक्रम को किसी भी n के लिए सिद्धांत रूप में काम करना चाहिए , लेकिन रनटाइम या मेमोरी बहुत अधिक हो जाने पर इसे माफ कर दिया जाता है।

— orlp

4

पायथन - 191 बाइट्स

t=i=1L;k=n=input();f=2000*20**n;A=range(n+1)
for k in range(2,n):A=[(A[j-1]+A[j+1])*j>>1for j in range(n-k+1)];f*=k
while k:k=(1-~i*n%4)*f/A[1]/i**n;t+=k;i+=2
print sum(map(int,`t`[-n-4:-4]))

~ 4x तेज संस्करण - 206 बाइट्स

t=i=1L;k=n=input();f=2000*20**n;A=[0,1]+[0]*n
for k in range(1,n):
 f*=k
 for j in range(-~n/2-k+1):A[j]=j*A[j-1]+A[j+1]*(j+2-n%2)
while k:k=(1-~i*n%4)*f/A[1]/i**n;t+=k;i+=2
print sum(map(int,`t`[-n-4:-4]))

इनपुट स्टड से लिया गया है। N = 5000 के लिए आउटपुट दूसरी स्क्रिप्ट (या पहले के साथ 60s) के साथ लगभग 14s लेता है।

नमूना उपयोग:

$ echo 1 | python pi-trunc.py
1

$ echo 2 | python pi-trunc.py
14

$ echo 3 | python pi-trunc.py
6

$ echo 4 | python pi-trunc.py
13

$ echo 5 | python pi-trunc.py
24

$ echo 50 | python pi-trunc.py
211

$ echo 500 | python pi-trunc.py
2305

$ echo 5000 | python pi-trunc.py
22852

उपयोग किया गया सूत्र निम्नलिखित है:

$\pi^n=2^{n+1}\frac{(n-1)!}{A_{n-1}}c_n$

जहां एक _n है n ^वें अदल-बदल कर संख्या है, जो औपचारिक रूप से आकार के एक सेट पर बारी क्रमपरिवर्तन की संख्या के रूप में परिभाषित किया जा सकता है n (: यह भी देख A000111 )। वैकल्पिक रूप से, अनुक्रम को स्पर्शरेखा संख्याओं और सेकेंड संख्याओं ( A _2n = S _n , A _{2n + 1} = T _n ) की संरचना के रूप में परिभाषित किया जा सकता है , उस पर बाद में।

छोटा सुधार कारक c _n तेजी से 1 में परिवर्तित होता है क्योंकि n बड़ा हो जाता है, और इसके द्वारा दिया जाता है:

$c_n=\sum\limits_{_{k=0}}^{_\infty}{\left(\frac{(-1)^k}{2k+1}\right)^n}$

के लिए n = 1 , का मूल्यांकन करने के लिए इस मात्रा में लाइबनिट्स श्रृंखला । लगभग ^½ 10 π के रूप में , आवश्यक शब्दों की संख्या की गणना इस प्रकार की जा सकती है:

$\frac{1}{2}\left[1+\left(10^{\frac{3n}{2}+3}\right)^{\frac{1}{n}}\right]$

जो कि 17 में परिवर्तित (गोल) हो जाता है , हालांकि n के छोटे मानों में काफी अधिक की आवश्यकता होती है।

ए _एन की गणना के लिए कई एल्गोरिदम हैं, और यहां तक कि एक स्पष्ट सूत्र भी है, लेकिन वे सभी एन द्वारा द्विघात हैं । मैंने मूल रूप से सेडेल के एल्गोरिथ्म के कार्यान्वयन को कोडित किया था , लेकिन यह व्यावहारिक होने के लिए बहुत धीमा हो जाता है। प्रत्येक पुनरावृत्ति को संग्रहीत करने के लिए एक अतिरिक्त शब्द की आवश्यकता होती है, और बहुत तेज़ी से परिमाण में वृद्धि होती है ( ओ (एन ² ) का "गलत" प्रकार )।

पहली स्क्रिप्ट मूल रूप से नूथ और बकहोल्त्ज़ द्वारा दिए गए एल्गोरिथ्म के कार्यान्वयन का उपयोग करती है :

सभी को = 1. एन के लिए टी _{1, के} = 1 दें

T के बाद के मान पुनरावृत्ति संबंध द्वारा दिए गए हैं:

T _{n + 1, k} = 1/2 [ (k - 1) T _{n, k-1} + (k + 1) T _{n, k + 1} ]

एक _n को तब T _{n, 1} द्वारा दिया जाता है

(यह भी देखें: A185414 )

हालांकि स्पष्ट रूप से नहीं कहा गया है, यह एल्गोरिथ्म एक साथ स्पर्शरेखा संख्याओं और सेकंड संख्याओं की गणना करता है। दूसरी स्क्रिप्ट ब्रेंट और ज़िमरमन द्वारा इस एल्गोरिथ्म की भिन्नता का उपयोग करती है , जो कि n की समता के आधार पर या तो T या S की गणना करती है । सुधार n / 2 से द्विघात है , इसलिए ~ 4x गति में सुधार है।

— Primo
स्रोत

1

आपके उत्तर के पीछे के गणित की उत्कृष्ट व्याख्या।

— लॉजिक नाइट

3

पायथन 2, 246 बाइट्स

मैंने द्विघात अभिसरण के साथ गणना quad पर मेरे उत्तर के लिए एक समान दृष्टिकोण लिया है । अंतिम पंक्ति पाई की Nth शक्ति लेती है और अंकों को बताती है। N = 5000 परीक्षण में एक मिनट का समय लगता है।

from decimal import*
d=Decimal
N=input()
getcontext().prec=2*N
j=d(1)
h=d(2)
f=h*h
g=j/h
a=j
b=j/h.sqrt()
t=j/f
p=j
for i in bin(N)[2:]:e=a;a,b=(a+b)/h,(a*b).sqrt();c=e-a;t-=c*c*p;p+=p
k=a+b
l=k*k/f/t
print sum(map(int,`l**N`.split('.')[1][:N]))

कुछ परीक्षण:

$ echo 1 | python soln.py
1
$ echo 3 | python soln.py
6
$ echo 5 | python soln.py
24
$ echo 500 | python soln.py
2305
$ echo 5000 | python soln.py
22852

अनगोल्ड कोड:

from decimal import *
d = Decimal

N = input()
getcontext().prec = 2 * N

# constants:
one = d(1)
two = d(2)
four = two*two
half = one/two

# initialise:
a = one
b = one / two.sqrt()
t = one / four
p = one

for i in bin(N)[2:] :
    temp = a;
    a, b = (a+b)/two, (a*b).sqrt();
    pterm = temp-a;
    t -= pterm*pterm * p;
    p += p

ab = a+b
pi = ab*ab / four / t
print sum(map(int, `pi ** N`.split('.')[1][:N]))

— तर्क नाइट
स्रोत

लाइन 8, आप बदल सकते हैं a=jऔर p=jकरने के लिए a=p=jiirc। शायद।

— एलियास बेनेवेदेस

धन्यवाद। इस कोड के लिए और अधिक गोल्फिंग अनुकूलन हैं, लेकिन यह दशमलव के बिना एक एल्गोरिथ्म का उपयोग करके फिर से लिखे बिना प्रतिस्पर्धी नहीं होगा।

— लॉजिक नाइट

1

अजगर, ३३

s<>j^u+/*GHhyHy^TyQr*TQ0ZQT_y*QQQ

Isaacg द्वारा इस उत्तर के आधार पर । शायद और अधिक गोल्फ हो सकता है। धीरे।

s<>j            Digit sum of...
  ^                 
    u               Evaluate pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + ...))))
      +
        /
          *GH
          hyH
        y^TyQ       Except we generate a large integer containing 2n digits,
                    rather than a fraction.
      r*TQ0         Experimentally verified that 10*n iterations will give enough
                    precision for 2n digits (# digits correct grows faster than 2n).
      Z
    Q               To the nth power.
  T_y*QQQ         Get the last 2n^2 digits (all the fractional digits) and get the
                  first n fractional digits.

— orlp
स्रोत

1

इस उत्तर को सही ठहराने के लिए वास्तव में कम से कम पर्याप्त स्पष्टीकरण की आवश्यकता है कि यह सही उत्तर पाने के लिए पर्याप्त अंकों की गणना करता है।

— पीटर टेलर

@PeterTaylor मैं कल एक स्पष्टीकरण जोड़ूंगा, बस बिस्तर पर जाने के बारे में।

— orlp

प्रत्येक पुनरावृत्ति एक सही बिट उत्पन्न करता है ( परिशिष्ट A देखें )। 2 एन अंकों को ~ 6.64n पुनरावृत्तियों की आवश्यकता होनी चाहिए।

— प्रिमो

कम्प्यूटिंग नुकीले अंकों पीएम की शक्तियों की रकम

पायथन - 191 बाइट्स

पायथन 2, 246 बाइट्स

अजगर, ३३