पमिट पाइ… ठीक है

Question

से इसे जारी रखते हुए पाई मोंटे कार्लो आकलनकर्ता इस चुनौती लगातार पाई के लिए कम से कम कोड का उत्पादन होता है। सिवाय यहां आपके कोड को हमेशा के लिए पाई के लगातार अंक का उत्पादन करना चाहिए।

यह कोड गोल्फ है, इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है सिवाय इसके कि इसे एक उचित पीसी पर 10 सेकंड से कम समय में पहले 10,000 अंकों का उत्पादन करना चाहिए और इसे कभी भी समाप्त नहीं करना चाहिए।

आप किसी भी अंतर्निहित पी या ट्रिगर कार्यों के लिए उपयोग नहीं कर सकते।

---

कोड आकार पर हार्ड सीमा को हटा दिया।

Comments

ट्वीट करने योग्य से, क्या आपका मतलब है कि कोड 140 वर्णों से कम होना चाहिए?

— यपनीपं

चरित्र की सीमा के बिना समस्या अपने आप में चुनौतीपूर्ण लगती है।

— BobTheAwesome

@BusTheAwesome लोकप्रिय मांग से चरित्र की सीमा को हटा दिया।

@ mbomb007 यह बिल्कुल स्पष्ट नहीं है कि दशमलव बिंदु को मुद्रित किया जाना चाहिए, या अंक को व्हाट्सएप द्वारा अलग नहीं किया जा सकता है। चुनौती केवल "पाई के लगातार आउटपुट" के लिए है। दशमलव डॉट एक अंक नहीं है। 3141...वह है - पाई का लगातार अंक।

— orlp

यह सबसे अच्छा होगा अगर छपी हुई संख्या पाई थी तो उदाहरण के लिए अंकों के बीच कोई जगह नहीं थी। इसे दशमलव बिंदु में शामिल किया जाए तो और भी अच्छा होगा।

Answer 1

CJam - 48

3.1o{1YAZ2*:Z#*{_2$*2$2*)/@)\}h*]:+sX2*:X>X<o1}g

यह sum के रूप में 2 * योग (के! / (2k + 1) !!) की गणना अधिक से अधिक सटीकता के साथ करता है और हर चरण में अंकों का एक गुच्छा प्रिंट करता है जहां से यह रवाना हुआ था।

आप ऑनलाइन एक संशोधित संस्करण की कोशिश कर सकते हैं जो केवल 8 (बाहरी लूप) पुनरावृत्तियों और 512 अंकों को प्रिंट करता है, या असली चीज़ के लिए जावा दुभाषिया का उपयोग करता है। मेरे लैपटॉप पर यह लगभग 6 सेकंड में 16384 अंकों का हो जाता है।

नोट: यह कार्यक्रम बहुत स्मृति-भूख है; एक बेहतर व्यवहार लेकिन थोड़ा लंबा संस्करण है:

3.1o{T2AZ2*:Z#*1{@2$+@2$*2$2*)/@)1$}g;;sX2*:X>X<o1}g

स्पष्टीकरण:

3.1o              print 3.1
{…1}g             repeat indefinitely
    1YA           push 1, 2 and 10 (Y=2, A=10)
    Z2*:Z         push Z*2 (Z=3 initially) and store back in Z
    #*            calculate 2*10^Z (2 from the formula and 10^Z for precision)
                  this is the term for k=0, and the earlier 1 represents k
    {…}h          do-while
                  at each iteration, the stack contains: terms, k, last-term
        _2$*      copy the previous term and k and multiply them
        2$2*)/    divide the previous number by 2*k+1
                  this is the current term of the series
        @)\       increment k and move it before the current term
                  the current term now serves as the loop condition
                  so the loop terminates when the term becomes 0
    *             multiply k and the last term (0), to get rid of k
    ]:+s          put all the terms in an array, add them and convert to string
                  we obtain an approximation of π*10^Z
    X2*:X         push X*2 (X=1 initially) and store back in X
    >X<o          print X digits starting from the X position

Answer 2

पायथन, 138 बाइट्स

q,r,t,i=1,180,60,2
while 1:u,y=27*i*(i+1)+6,(q*(27*i-12)+5*r)//(5*t);print(y,end="");q,r,t,i=10*q*i*(2*i-1),10*u*(q*(5*i-2)+r-y*t),t*u,i+1

Http://www.cs.ox.ac.uk/jeremy.gibbons/publications/spigot.pdf का क्रियान्वयन ।

Comments

मुझे इसे 5 मिनट तक हराया ..... :)

— माल्टीसेन

यह भी खूब रही। मैं हालांकि उम्मीद कर रहा था कि अंक सभी एक पंक्ति में होंगे। दूसरे शब्दों में, कि आउटपुट Pi की तरह दिखेगा।

@ लेम्बिक मैंने अपना जवाब बदल दिया - 7 बाइट्स लंबे समय तक, लेकिन अब सभी एक लाइन पर।

— orlp

Answer 3

गोल्फस्क्रिप्ट (81 वर्ण)

1:i:^3{3i):i*(.(*3*.@*.5*3$27i*12-*+@^*:^5*/.print^*2$5i*2-*--\10*i*2i*(*\10*.}do

ऑनलाइन डेमो (यह एक उचित डेस्कटॉप की तुलना में बहुत धीमा है, और इसमें कई बार कोड को बदलने के लिए तुच्छ कोड में परिवर्तन होता है)।

मेरे पास, निश्चित रूप से, स्पिगोट एल्गोरिथ्म का उपयोग किया गया है जिसका मैंने पहले टिप्पणी में उल्लेख किया था, लेकिन मुझे इसे अपनी संतुष्टि के लिए गोल्फ में थोड़ा समय लगा। गिबन्स के पेपर में प्रस्तुत एल्गोरिथ्म (स्यूडोकोड) है

q = 1; r = 180; t = 60; i = 2
while (true) {
    u = 3*(3*i+1)*(3*i+2)
    y = (q*(27*i-12)+5*r) / (5*t)
    print y
    r += q*(5*i-2)-y*t
    r *= 10*u
    q *= 10*i*(2*i-1)
    t *= u
    i += 1
}

ऊपर दिया गया गोल्फस्क्रिप्ट (pseudocode) के बराबर है

t = i = q = 1; r = 3
while (true) {
    u = 3*(3*i+1)*(3*i+2)
    i += 1
    r *= u
    t *= u
    y = (q*(27*i-12)+5*r) / (5*t)
    print y
    r -= y*t - q*(5*i-2)
    q *= 10*i*(2*i-1)
    r *= 10
}

जो आरंभिक और स्टैक प्रबंधन में कुछ पात्रों को बचाता है।

Answer 4

पायथ - 87 85 बाइट्स

Http://www.cs.ox.ac.uk/jeremy.gibbons/publications/spigot.pdf का एक और अनुवाद । मैं अजगर करने जा रहा था, लेकिन @orlp ने मुझे हरा दिया, इसलिए मैंने पायथ किया। एक ट्वीट में फिट करने के लिए काफी छोटा।

=H3=d1=bd=Gd#K+**hb27b6~b1=H*HK=d*dKJ/+*-*27b12G*5H*5d=H*T-H-*Jd*-*5b2G=G***GTbtybpkJ

यह प्रिंट करने के लिए आने वाले प्रिंट बफर की वजह से रुक-रुक कर कदम के साथ आउटपुट देता है end=""। मैं वर्तमान में दशमलव बिंदु को प्रिंट नहीं करता हूं क्योंकि कल्पना "लगातार अंक" कहती है। इसके कार्य जो मेरे स्कोर को मार रहे हैं।

=H3                     Set H to 3
=d1                     Set d to 1
=bd                     Set b to d which is 1
=Gd                     Set G to d which is 1
#                       Infinte Loop
  K                     Set K to
    +**hb27b6           27*b*(b+1)+6
  ~b1                   b+=1
  =H*HK                 H*=K
  =d*dK                 d*=K
  J                     Set J to
    /                   Integer division
      +*-*27b12G*5H     G*(27*b-12)+5*H
      *5d               5*d
  =H                    Set H to
    *T-H-*Jd*-*5b2G     10*(H-(J*d -G*(5*b-2)))
  =G                    Set G to
    ***GTbtyb           G*10*b*(2*b-1)
  pkJ                   Print J with the end as "", not a newline

इसे यहाँ आज़माएँ । (ध्यान दें: चूंकि ऑनलाइन दुभाषिया केवल पूर्ण परिणाम देता है, इसलिए अनंत लूप बाहर है, इसलिए यह केवल पहले 100 प्रिंट करता है। कोड आकार बढ़ाता है। अनंत को आज़माने के लिए, स्थानीय दुभाषिया डाउनलोड करें।)

समय

मेरे Google क्लाउड पर माइक्रो इंस्टेंस की गणना की गई है, ग्नू समय के अनुसार: real: 0m2.062sतो यह स्पष्ट रूप से काफी तेज है।

Answer 5

स्केल, 599 बाइट्स

नीचे दिया गया कोड Pi के अंकों के लिए एक Spigot Algorithm के परिशिष्ट 2 से पास्कल कोड का एक सीधा पोर्ट है । स्पष्ट रूप से बहुत कम गोल्फिंग अभी तक की गई है। कोड 10 सेकंड से कम में 10,000 अंक उत्पन्न करता है piSpigot(10000)और यदि किसी के पास अनंत स्मृति है तो उसे कई अंकों को उत्पन्न करने के लिए परिमाणित किया जा सकता है, लेकिन अनंत। मुझे यकीन नहीं है कि अगर यह समस्या की कमी को पूरा कर रहा है तो कृपया प्रतिक्रिया दें।

def piSpigot(n: Int): Unit = {
  val len=10*n/3
  var nines=0
  var predigit=0
  val a=Array.fill(len)(2)
  (1 to n).foreach {_=>
    var q=0
    (1 to n).reverse.foreach{i=>
      var x=10*a(i)+q*i
      a(i)=x%(2*i-1)
      q=x/(2*i-1)
    }
    a(1)=q%10
    q/=10
    if (q==9) {
      nines+=1
    } else if (q==10) {
      print(predigit+1)
      1.to(nines).foreach(_=>print(0))
      predigit=0
      nines=0
    } else {
      print(predigit)
      predigit=q
      if (nines!=0) {
        1.to(nines).foreach(_=>print(9))
        nines=0
      }
    }
  }
  println(predigit)
}
piSpigot(10000)

Comments

मुझे लगता है कि अंकों के विज्ञापन का निर्माण करने की आवश्यकता का मतलब है कि आपको एक पैरामीटर के बजाय एक स्ट्रीमिंग एल्गोरिथ्म का उपयोग करने की आवश्यकता है n। उदाहरण देखें cs.ox.ac.uk/people/jeremy.gibbons/publications/spigot.pdf

— पीटर टेलर

अनंत स्मृति और अनंत समय को अनंत संख्या का अंक देना चाहिए।

Answer 6

Befunge-98 (PyFunge), 120 बाइट्स

cf*10p'<20p11>00p1+:30p:::*+39**6+:30g39**c-00g*10gv
>:2*1-*00g*a*^
^:p02*g02p01*a*-*g02\+g01*g00-2*5g03,+*86:/*5g02+*5<

इसे ऑनलाइन आज़माएं!

यह समयबद्धता के संदर्भ में सीमा रेखा है। 10,000 अंक मेरे लैपटॉप पर लगभग 11 सेकंड लगते हैं, लेकिन मुझे यकीन है कि एक "उचित" पीसी होना चाहिए जो इसे तेजी से कर सकता है।

हालाँकि, यदि आप इसे TIO पर आज़मा रहे हैं, तो ध्यान दें कि यह 60 सेकंड की समय सीमा को हिट करने तक कुछ भी वापस नहीं करेगा, क्योंकि एल्गोरिदम को हमेशा के लिए चलते रहने के लिए डिज़ाइन किया गया है। हालांकि उस समय आपके पास 10,000 से अधिक अंक होंगे।

मैं जेरेमी गिबन्स स्पिगोट एल्गोरिथ्म का उपयोग कर रहा हूं, जो मुझे लगता है कि यहां अन्य अधिकांश उत्तरों के समान है। हालाँकि, ध्यान दें कि यह इंटरप्रेटर पर निर्भर करता है जिसमें मनमाना सटीक मेमोरी सेल होता है, और एकमात्र कार्यान्वयन जो मुझे पता है कि इसका समर्थन करता है वह है PyFunge ।

व्याख्या

cf*10p                     Initialise r to 180.
      '<20p                Initialise t to 60.
           11              Initialise i and q on the stack to 1.

>                          Start of the main loop.
 00p                       Save the current value of q in memory.
    1+:30p                 Increment i and save a copy in memory.      
          :::*+39**6+      Calculate u = 27*(i*i+i)+6.
                     :     Make a duplicate, since we'll need two copies later.

       30g39**c-00g*10gv   Calculate y = (q*(27*i-12)+5*r)/(5*t).
              /*5g02+*5<
        ,+*86:             Convert y to a character so we can output it.

*a*-*g02\+g01*g00-2*5g03   Calculate r = 10*u*(q*(i*5-2)+r-y*t)

         p01               Save the updated r.
     *g02                  Calculate t = t*u
  p02                      Save the updated t.

>:2*1-*00g*a*              Calculate q = 10*q*i*(i*2-1).
^:
             ^             Return to the start of the main loop.