पायथन 2, 110 बाइट्स
n=input()
x=p=7*n|1
while~-p:x=p/2*x/p+2*10**n;p-=2
l=m=0
for c in`x`:
l=l*(p==c)+1;p=c
if l>m:m=l;print p*l
जाँच करने के लिए अंकों की अधिकतम संख्या स्टड से ली गई है। PyPy 5.3 के साथ लगभग 2s में 10,000 अंक खत्म हो गए।
नमूना उपयोग
$ echo 10000 | pypy pi-runs.py
3
33
111
9999
99999
999999
कुछ काम की चीज़
from sys import argv
from gmpy2 import mpz
def pibs(a, b):
if a == b:
if a == 0:
return (1, 1, 1123)
p = a*(a*(32*a-48)+22)-3
q = a*a*a*24893568
t = 21460*a+1123
return (p, -q, p*t)
m = (a+b) >> 1
p1, q1, t1 = pibs(a, m)
p2, q2, t2 = pibs(m+1, b)
return (p1*p2, q1*q2, q2*t1 + p1*t2)
if __name__ == '__main__':
from sys import argv
digits = int(argv[1])
pi_terms = mpz(digits*0.16975227728583067)
p, q, t = pibs(0, pi_terms)
z = mpz(10)**digits
pi = 3528*q*z/t
l=m=0
x=0
for c in str(pi):
l=l*(p==c)+1;p=c
if l>m:m=l;print x,p*l
x+=1
मैंने इसके लिए चुडनोव्स्की से रामानुजन 39 तक स्विच किया है। चुडनोव्स्की 100 मिलियन अंकों के तुरंत बाद मेरे सिस्टम पर मेमोरी से बाहर चला गया, लेकिन रामानुजन ने इसे केवल 38 मिनट में, 400 मिलियन तक बना दिया। मुझे लगता है कि यह एक और मामला था, विकास की धीमी दर अंत में जीत गई, कम से कम सीमित संसाधनों वाली प्रणाली पर।
नमूना उपयोग
$ python pi-ramanujan39-runs.py 400000000
0 3
25 33
155 111
765 9999
766 99999
767 999999
710106 3333333
22931752 44444444
24658609 777777777
386980421 6666666666
तेज़ अनबॉर्न जेनरेटर
समस्या विवरण में दिया गया संदर्भ कार्यान्वयन दिलचस्प है। यह एक अनबाउंड जनरेटर का उपयोग करता है, जो सीधे पाई के अंकों के लिए पेपर अनबाइंड स्पिगोट एल्गोरिदम से लिया जाता है । लेखक के अनुसार, प्रदान किए गए कार्यान्वयन "जानबूझकर अस्पष्ट" हैं, इसलिए मैंने जानबूझकर बिना किसी बाधा के लेखक द्वारा सूचीबद्ध सभी तीन एल्गोरिदमों के नए कार्यान्वयन करने का फैसला किया। मैंने रामानुजन # 39 के आधार पर एक चौथा भी जोड़ा है ।
try:
from gmpy2 import mpz
except:
mpz = long
def g1_ref():
# Leibniz/Euler, reference
q, r, t = mpz(1), mpz(0), mpz(1)
i, j = 1, 3
while True:
n = (q+r)/t
if n*t > 4*q+r-t:
yield n
q, r = 10*q, 10*(r-n*t)
q, r, t = q*i, (2*q+r)*j, t*j
i += 1; j += 2
def g1_md():
# Leibniz/Euler, multi-digit
q, r, t = mpz(1), mpz(0), mpz(1)
i, j = 1, 3
z = mpz(10)**10
while True:
n = (q+r)/t
if n*t > 4*q+r-t:
for d in digits(n, i>34 and 10 or 1): yield d
q, r = z*q, z*(r-n*t)
u, v, x = 1, 0, 1
for k in range(33):
u, v, x = u*i, (2*u+v)*j, x*j
i += 1; j += 2
q, r, t = q*u, q*v+r*x, t*x
def g2_md():
# Lambert, multi-digit
q, r, s, t = mpz(0), mpz(4), mpz(1), mpz(0)
i, j, k = 1, 1, 1
z = mpz(10)**49
while True:
n = (q+r)/(s+t)
if n == q/s:
for d in digits(n, i>65 and 49 or 1): yield d
q, r = z*(q-n*s), z*(r-n*t)
u, v, w, x = 1, 0, 0, 1
for l in range(64):
u, v, w, x = u*j+v, u*k, w*j+x, w*k
i += 1; j += 2; k += j
q, r, s, t = q*u+r*w, q*v+r*x, s*u+t*w, s*v+t*x
def g3_ref():
# Gosper, reference
q, r, t = mpz(1), mpz(180), mpz(60)
i = 2
while True:
u, y = i*(i*27+27)+6, (q+r)/t
yield y
q, r, t, i = 10*q*i*(2*i-1), 10*u*(q*(5*i-2)+r-y*t), t*u, i+1
def g3_md():
# Gosper, multi-digit
q, r, t = mpz(1), mpz(0), mpz(1)
i, j = 1, 60
z = mpz(10)**50
while True:
n = (q+r)/t
if n*t > 6*i*q+r-t:
for d in digits(n, i>38 and 50 or 1): yield d
q, r = z*q, z*(r-n*t)
u, v, x = 1, 0, 1
for k in range(37):
u, v, x = u*i*(2*i-1), j*(u*(5*i-2)+v), x*j
i += 1; j += 54*i
q, r, t = q*u, q*v+r*x, t*x
def g4_md():
# Ramanujan 39, multi-digit
q, r, s ,t = mpz(0), mpz(3528), mpz(1), mpz(0)
i = 1
z = mpz(10)**3511
while True:
n = (q+r)/(s+t)
if n == (22583*i*q+r)/(22583*i*s+t):
for d in digits(n, i>597 and 3511 or 1): yield d
q, r = z*(q-n*s), z*(r-n*t)
u, v, x = mpz(1), mpz(0), mpz(1)
for k in range(596):
c, d, f = i*(i*(i*32-48)+22)-3, 21460*i-20337, -i*i*i*24893568
u, v, x = u*c, (u*d+v)*f, x*f
i += 1
q, r, s, t = q*u, q*v+r*x, s*u, s*v+t*x
def digits(x, n):
o = []
for k in range(n):
x, r = divmod(x, 10)
o.append(r)
return reversed(o)
टिप्पणियाँ
उपरोक्त 6 कार्यान्वयन हैं: लेखक द्वारा दिए गए दो संदर्भ कार्यान्वयन (निरूपित _ref), और चार जो बैचों में शब्दों की गणना करते हैं, एक साथ कई अंक उत्पन्न करते हैं ( _md)। सभी कार्यान्वयन 100,000 अंकों की पुष्टि की गई है। जब बैच आकार चुनते हैं, तो मैंने उन मूल्यों को चुना जो धीरे-धीरे समय के साथ सटीक खो देते हैं। उदाहरण के लिए, g1_md33 पुनरावृत्तियों के साथ प्रति बैच 10 अंक उत्पन्न करता है। हालाँकि, यह केवल ~ 9.93 सही अंक उत्पन्न करेगा। जब सटीक रन आउट होता है तो चेक की स्थिति विफल हो जाएगी, एक अतिरिक्त बैच को ट्रिगर किया जाएगा। यह समय के साथ धीरे-धीरे अतिरिक्त, अनावश्यक सटीकता की तुलना में अधिक प्रदर्शन करने वाला लगता है।
- g1 (Leibniz / Euler)
एक अतिरिक्त चर jरखा जाता है, जिसका प्रतिनिधित्व करते हैं 2*i+1। संदर्भ कार्यान्वयन में लेखक ऐसा ही करता है। nअलग से गणना करना अधिक सरल (और कम अस्पष्ट) है, क्योंकि यह अगले के बजाय q, rऔर t, के वर्तमान मूल्यों का उपयोग करता है ।
- जी 2 (लैम्बर्ट)
चेक n == q/sमें काफी ढीलापन है। जो पढ़ना चाहिए n == (q*(k+2*j+4)+r)/(s*(k+2*j+4)+t), जहां jहै 2*i-1और kहै i*i। उच्च पुनरावृत्तियों में, rऔर tशब्द तेजी से कम महत्वपूर्ण हो जाते हैं। जैसा कि, यह पहले 100,000 अंकों के लिए अच्छा है, इसलिए यह संभवतः सभी के लिए अच्छा है। लेखक कोई संदर्भ कार्यान्वयन प्रदान करता है।
- g3 (गोस्पर)
लेखक का अनुमान है कि यह जाँचना अनावश्यक है कि nबाद के पुनरावृत्तियों में परिवर्तन नहीं होगा, और यह केवल एल्गोरिथ्म को धीमा करने का कार्य करता है। जबकि शायद सच है, जनरेटर ~ 13% अधिक सही अंकों से पकड़ रहा है, जो वर्तमान में उत्पन्न हुआ है, जो कुछ हद तक बेकार लगता है। मैंने चेक वापस वापस जोड़ दिया है, और 50 अंकों के सही होने तक प्रतीक्षा करें, प्रदर्शन में एक ध्यान देने योग्य लाभ के साथ, उन सभी को एक साथ पैदा कर रहा है।
- जी -4 (रामानुजन 39)
के रूप में गणना
दुर्भाग्य से, sको शून्य नहीं है, प्रारंभिक (3528 ÷) संरचना के कारण, लेकिन यह अभी भी काफी तेजी G3 से है। अभिसरण ~ 5.89 अंक प्रति शब्द है, एक समय में 3511 अंक उत्पन्न होते हैं। यदि यह बहुत अधिक है, तो प्रति 46 पुनरावृत्तियों में 271 अंक उत्पन्न करना भी एक अच्छा विकल्प है।
समय
केवल तुलना के प्रयोजनों के लिए मेरे सिस्टम पर लिया गया। टाइम्स सेकंड में सूचीबद्ध हैं। यदि कोई समय 10 मिनट से अधिक समय लेता है, तो मैंने कोई और परीक्षण नहीं चलाया।
| g1_ref | g1_md | g2_md | g3_ref | g3_md | g4_md
------------+---------+---------+---------+---------+---------+--------
10,000 | 1.645 | 0.229 | 0.093 | 0.312 | 0.062 | 0.062
20,000 | 6.859 | 0.937 | 0.234 | 1.140 | 0.250 | 0.109
50,000 | 55.62 | 5.546 | 1.437 | 9.703 | 1.468 | 0.234
100,000 | 247.9 | 24.42 | 5.812 | 39.32 | 5.765 | 0.593
200,000 | 2,158 | 158.7 | 25.73 | 174.5 | 33.62 | 2.156
500,000 | - | 1,270 | 215.5 | 3,173 | 874.8 | 13.51
1,000,000 | - | - | 1,019 | - | - | 58.02
यह दिलचस्प है कि g2अंत g3में अभिसरण की धीमी दर के बावजूद आगे निकल जाता है। मुझे संदेह है क्योंकि ऑपरेंड काफी धीमी दर से बढ़ता है, लंबे समय में जीतता है। 500,000 अंकों पर निहितार्थ की g4_mdतुलना में सबसे तेज़ प्रत्यारोपण लगभग 235x तेज है g3_ref। उस ने कहा, इस तरह से अंकों को स्ट्रीमिंग करने के लिए अभी भी एक महत्वपूर्ण ओवरहेड है। रामानुजन 39 ( अजगर स्रोत ) का उपयोग करके सीधे सभी अंकों की गणना करना लगभग 10x तेज है।
चुडानोव्स्की क्यों नहीं?
Chudnovsky एल्गोरिथ्म को एक पूर्ण परिशुद्धता वर्गमूल की आवश्यकता होती है, जिसे मैं ईमानदारी से सुनिश्चित नहीं कर सकता कि कैसे काम करना है - यह मानते हुए कि यह बिल्कुल भी हो सकता है। रामानुजन 39 इस संबंध में कुछ खास हैं। हालाँकि, विधि ऐसा प्रतीत होता है कि यह माचिन जैसे सूत्र के लिए अनुकूल हो सकता है, जैसे कि y-cruncher द्वारा उपयोग किया जाता है, ताकि यह एक खोज के लायक हो।