15

यह http://programmers.blogoverflow.com/2012/08/20-contputial-programming-opinions/ से आता है

"यह देखते हुए कि पाई को फ़ंक्शन का उपयोग करके अनुमान लगाया जा सकता है 4 * (1 - 1/3 + 1/5 - 1/7 + ...) अधिक सटीकता प्रदान करने वाले अधिक शब्दों के साथ, एक फ़ंक्शन लिखें जो 5 दशमलव स्थानों की सटीकता के लिए Pi की गणना करता है। "

ध्यान दें, अनुमान ऊपर दिए गए अनुक्रम की गणना करके किया जाना चाहिए।

code-golf pi

— ओपन स्कूल
स्रोत

8

आपको शायद कुछ और नियम जोड़ने चाहिए, अन्यथा आपको जवाब मिलेंगे (अजगर)p=lambda:3.14159

— मैट

1

क्या आपने codegolf.stackexchange.com/questions/506/… देखा है , जो बहुत समान है? इस समस्या के लिए बहुत कम से कम, ट्रिगर फ़ंक्शंस पर प्रतिबंध लगाया जाना चाहिए क्योंकि वे इस QBIC कार्यक्रम जैसे तुच्छ समाधानों की अनुमति देते हैं: INT? (4E5 * ATN (1)) / 1E5

— कृपया 17

मुझे लगता है कि आपको यह आवश्यक होना चाहिए कि एल्गोरिथम क्रमिक सन्निकटन में से एक हो: आप जितनी लंबी गणना करेंगे, आप उतने ही करीब आएंगे।

— डेविड एक्स

@DavidCarraher, हालांकि यह गणितीय रूप से अपरिहार्य है इस श्रृंखला का उपयोग करते हुए, एक संख्यात्मक विश्लेषणात्मक दृष्टिकोण से यह अत्यधिक संदिग्ध है। धीरे-धीरे एकांतर रूप से परिवर्तित श्रृंखला महत्व के नुकसान के लिए एक पोस्टर चाइल्ड है।

— पीटर टेलर

2

ड्यूप, लेकिन यह इतना पुराना है कि यह यहाँ नहीं है: stackoverflow.com/q/407518/12274

— JB

10

जावास्क्रिप्ट, 46 58 56 45 बाइट्स

ईएस 6 अपडेट : यह पता चलता है कि हमारे पास अब और सुविधाएँ उपलब्ध हैं जिन्हें पाँच साल बीत चुके हैं।

let f=(i=0,a=0)=>i>1e6?a:f(i+4,a+8/-~i/(i+3))

यह संस्करण ( 45 बाइट्स; हां, letआवश्यक है) सिद्धांत में ईएस 6 सख्त मोड में काम करता है । व्यवहार में, आप इसे V8 (जैसे नोड के साथ) में चला सकते हैं --use-strict --harmony-tailcalls; उचित Tailcalls सुविधा व्यापक रूप से अभी तक लागू नहीं है, अफसोस। हालाँकि, यह निर्दिष्ट व्यवहार है, इसलिए यह ठीक होना चाहिए।

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

a=>{for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

एकल पैरामीटर के लिए नाम का चुनाव वास्तव में मायने नहीं रखता है, लेकिन हम वैश्विक नामों के प्रदूषण को कम करने के लिए हमारे द्वारा उपयोग किए जाने वाले नामों में से एक को चुन सकते हैं।

function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

यह संस्करण एक फ़ंक्शन अभिव्यक्ति है; fयदि आप इसे नाम देना चाहते हैं तो दो अक्षर (जैसे " ") जोड़ें । यह संस्करण ग्लोबर्स को देखता है aऔर i; इसे रोका जा सकता है अगर हमने a,iपैरामीटर सूची में " " जोड़ा है ।

घटाव की आवश्यकता को दरकिनार करने के लिए एल्गोरिथ्म के एक सुधारित संस्करण का उपयोग करता है।

 1/1 - 1/3  +   1/5 - 1/7   +    1/9 - 1/11  + ...
(3/3 - 1/3) + (7/35 - 5/35) + (11/99 - 9/99) + ...
    2/3     +      2/35     +       2/99     + ...
  2/(1*3)   +    2/(5*7)    +     2/(9*11)   + ...

यहाँ इस समायोजन के बिना "सादा" संस्करण है:

function(){for(a=0,i=1;i<1e6;i+=2)a+=[,4,,-4][i%4]/i;return a}

जो 64 62 अक्षरों में देखता है।

सुझाव से 4*पहले छुटकारा पाने के लिए @ardnew का धन्यवाद return।

इतिहास

function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}     // got rid of `i+=4`; restructured
// Old versions below.
function(){for(a=0,i=1;i<1e6;i+=4)a+=8/i/-~-~i;return a}    // got rid of `4*`
function(){for(a=0,i=1;i<1e6;i+=4)a+=2/i/-~-~i;return 4*a}

— जुगनू
स्रोत

ऊ बहुत अच्छा काम, घटाव बाहर फैक्टरिंग।

— अगस्त्य

1

महान काम, लेकिन एक उचित कार्य के रूप में लिखा जाना चाहिए

— ardnew

@ardnew: धन्यवाद, जब मैंने समस्या का विवरण पढ़ा तो मुझे वह विवरण याद आ गया होगा। मैंने इसे अपडेट किया है, और अब यह एक कॉल करने योग्य फ़ंक्शन एक्सप्रेशन (लंबो) है; निश्चित नहीं है कि यह अनुमति है या यदि इसे कोई नाम दिया जाना है। अगर ऐसा है, तो यह वैसे भी दो अतिरिक्त अक्षर हैं।

— FireFly

1

@ पूरी तरह से आप भी बदल a+=2/i/-~-~i;return 4*aसकते हैंa+=8/i/-~-~i;return a

— 22525 में

@ardnew: ओह, कमाल; ऐसा नहीं सोचा था। : D

— FireFly

8

पायथन 59 बाइट्स

print reduce(lambda x,p:p/2*x/p+2*10**999,range(6637,1,-2))

यह 1000 अंकों को प्रिंट करता है; आवश्यकता से थोड़ा अधिक 5. निर्धारित पुनरावृत्ति का उपयोग करने के बजाय, यह इसका उपयोग करता है:

pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + ...)))))

6637(अंतरतम भाजक) के रूप में तैयार किया जा सकता:

अंक * 2 * लॉग ₂ (10)

इसका तात्पर्य एक रेखीय अभिसरण से है। प्रत्येक गहरी पुनरावृत्ति पीआई के एक और बाइनरी बिट का उत्पादन करेगी ।

यदि , हालांकि, आप टैन ^{-1 की} पहचानका उपयोग करने पर जोर देते हैं, तो एक समान अभिसरण प्राप्त किया जा सकता है, यदि आप समस्या के बारे में थोड़ी गंभीरता से विचार नहीं करते हैं। आंशिक रकम पर एक नज़र रखना:

4.0, 2.66667, 3.46667, 2.89524, 3.33968, 2.97605, 3.28374, ...

यह स्पष्ट है कि प्रत्येक शब्द अभिसरण बिंदु के दोनों ओर आगे और पीछे कूदता है; श्रृंखला में प्रत्यावर्तन अभिसरण है। इसके अतिरिक्त, प्रत्येक शब्द पिछले शब्द की तुलना में अभिसरण बिंदु के करीब है; यह अपने अभिसरण बिंदु के संबंध में बिल्कुल नीरस है। इन दोनों गुणों के संयोजन का तात्पर्य है कि किन्हीं दो पड़ोसी शब्दों के अंकगणितीय माध्य स्वयं के किसी भी शब्द की तुलना में अभिसरण बिंदु के अधिक निकट हैं। आपको मेरा क्या मतलब है इसका एक बेहतर विचार देने के लिए, निम्नलिखित छवि पर विचार करें:

आंशिक रकम

बाहरी श्रृंखला मूल है, और आंतरिक श्रृंखला पड़ोसी की प्रत्येक शर्तों का औसत निकालकर पाई जाती है। एक उल्लेखनीय अंतर। लेकिन जो वास्तव में उल्लेखनीय है, वह यह है कि इस नई श्रृंखला में वैकल्पिक अभिसरण भी है, और इसके अभिसरण बिंदु के संबंध में बिल्कुल एकरस है। इसका मतलब है कि इस प्रक्रिया को बार-बार, एड nauseum पर लागू किया जा सकता है।

ठीक है। पर कैसे?

कुछ औपचारिक परिभाषाएँ। चलो पी ₁ (एन) हो n ^वें पहले अनुक्रम की अवधि, पी ₂ (एन) हो n ^वें दूसरे क्रम की अवधि, और इसी तरह पी _{कश्मीर} (एन) n ^वें की अवधि कश्मीर ^वें ऊपर परिभाषित अनुक्रम ।

पी ₁ = [पी ₁ (1), पी ₁ (2), पी ₁ (3), पी ₁ (4), पी ₁ (5), ...]

पी ₂ = [(पी ₁ (1) + पी ₁ (2)) / 2, (पी ₁ (2) + पी ₁ (3)) / 2, (पी ₁ (3) + पी ₁ (4) / / 2, (पी ₁ (4) + पी ₁ (5)) / 2, ...]

पी ₃ = [(पी ₁ (1) + 2 पी ₁ (2) + पी ₁ (3)) / 4, (पी ₁ (2) + 2 पी ₁ (3) + पी ₁ (4)) / 4, (पी ₁ (3) + 2P ₁ (4) + P ₁ (5)) / 4, ...]

पी ₄ = [(पी ₁ (1) + 3 पी ₁ (2) + 3 पी ₁ (3) + पी ₁ (4)) / 8, (पी ₁ (2) + 3 पी ₁ (3) + 3 पी ₁ (4) + पी ₁ (5)) / 8, ...]

आश्चर्य नहीं कि ये गुणांक बिल्कुल द्विपद गुणांक का अनुसरण करते हैं, और पास्कल के त्रिभुज की एकल पंक्ति के रूप में व्यक्त किया जा सकता है। चूंकि पास्कल के त्रिभुज की एक मनमानी पंक्ति गणना करने के लिए तुच्छ है, एक मनमाने ढंग से 'गहरी' श्रृंखला पाई जा सकती है, बस पहली n आंशिक रकम लेकर, पास्कल त्रिकोण की k ^वीं पंक्ति में संबंधित शब्द से प्रत्येक को गुणा करें और 2 से विभाजित करें। ^{के -1} ।

इस तरह, पूर्ण 32-बिट फ़्लोटिंग पॉइंट प्रिसिजन (~ 14 दशमलव स्थान) को केवल 36 पुनरावृत्तियों के साथ प्राप्त किया जा सकता है, जिस बिंदु पर आंशिक रकम दूसरे दशमलव स्थान पर भी परिवर्तित नहीं हुई है। यह स्पष्ट रूप से गोल्फ नहीं है:

# used for pascal's triangle
t = 36; v = 1.0/(1<<t-1); e = 1
# used for the partial sums of pi
p = 4; d = 3; s = -4.0

x = 0
while t:
  t -= 1
  p += s/d; d += 2; s *= -1
  x += p*v
  v = v*t/e; e += 1

print "%.14f"%x

यदि आप मनमानी परिशुद्धता चाहते थे, तो इसे थोड़ा संशोधन के साथ प्राप्त किया जा सकता है। यहां एक बार फिर से 1000 अंकों की गणना की जा रही है:

# used for pascal's triangle
f = t = 3318; v = 1; e = 1
# used for the partial sums of pi
p = 4096*10**999; d = 3; s = -p

x = 0
while t:
  t -= 1
  p += s/d; d += 2; s *= -1
  x += p*v
  v = v*t/e; e += 1

print x>>f+9

P का प्रारंभिक मान 2 ¹⁰ बड़ा शुरू होता है , जो कि s / d के पूर्णांक विभाजन के प्रभावों का प्रतिकार करता है क्योंकि d बड़ा हो जाता है, जिससे अंतिम कुछ अंक परिवर्तित नहीं हो पाते हैं। एक बार फिर यहां देखें 3318:

अंक * लॉग ₂ (10)

Iteratations की समान संख्या पहले एल्गोरिथ्म के रूप में (आधा कर दिया क्योंकि टी द्वारा कम हो जाती है 1 के बजाय 2 प्रत्येक यात्रा)। एक बार फिर, यह एक रैखिक अभिसरण को इंगित करता है: प्रति पुनरावृत्ति पीआई का एक बाइनरी बिट । दोनों मामलों में, 3318 पुनरावृत्तियों को पीआई के 1000 अंकों की गणना के लिए आवश्यक है , क्योंकि 5 की गणना करने के लिए 1 मिलियन पुनरावृत्तियों की तुलना में थोड़ा बेहतर कोटा है।

— Primo
स्रोत

यह मेरे समाधान से बहुत बेहतर है:4 * sum(1/(1+i*2) if not i%2 else -1/(1+i*2) for i in xrange(places*10**(places)))

— आरोन हॉल

1

यह मेरे दृष्टिकोण से बहुत मिलता-जुलता है , जो आपके एक अलग रूप में होता है। मेरा, में, के रूप में k → ∞, f(-1,k)अपने Euler- राशि दृष्टिकोण।

— बस सुंदर कला

1

बहुत ही शांत; भयानक विश्लेषण और स्पष्टीकरण, धन्यवाद।

— जेरेमी रेडक्लिफ

बस एक छोटी सी बात है। क्या आपके बाद इसका मतलब नहीं था P_1 = ..., P_2 = ..., P_3 = ..., P_4 = ..., "... kthपास्कल की त्रिभुज की पंक्ति में संबंधित शब्द से प्रत्येक को गुणा करें , और विभाजित करके 2^{k-1}।", nthपंक्ति के बजाय और 2^{n-1}?

— जेरेमी रेडक्लिफ

@jeremyradcliff मैंने किया, हाँ। सुधारों के लिए धन्यवाद।

— Primo

5

गणितज्ञ 42 39 34 33 31 26 32

आर्किमिडीज के दृष्टिकोण 26 वर्ण

N@#*Sin[180 Degree/#]&

इनपुट 822 होने पर यह कसौटी पर पहुँचता है।

प्रश्न: क्या कोई जानता है कि उसने 180 डिग्री के पाप की गणना कैसे की? मैं नही।

लाइबनिज का दृष्टिकोण (ग्रेगरी की श्रृंखला) 32 वर्ण

यह वही कार्य है जिसे समस्या पॉज़िशन ने एक उदाहरण के रूप में दिया है। यह लगभग डेढ़ मिलियन पुनरावृत्तियों में कसौटी पर पहुंचता है।

N@4Sum[(-1)^k/(2k+1),{k,0,10^6}]

माधव-लीबनिज दृष्टिकोण 37 वर्ण

यह भिन्नता कुछ और वर्णों का उपयोग करती है लेकिन केवल 9 पुनरावृत्तियों में कसौटी पर खरा उतरती है!

N@Sqrt@12 Sum[(-1/3)^k/(2k+1),{k,0,9}]

— DavidC
स्रोत

उन सभी को समस्या की परिभाषा में दिए गए एल्गोरिदम द्वारा इसकी गणना की जाती है?

— अनुचर

@acolyte Leibniz 'दृष्टिकोण (अब पहले सूचीबद्ध) वास्तव में समस्या के वर्णन में वर्णित एक है। यह बहुत धीमा है। इस पर थोड़ी सी भिन्नता (माधव-लीबनीज) बहुत जल्दी परिवर्तित हो जाती है।

— 20

180 ° का सीन बहुत आसान है। यह 180 ° / N है जो N के लिए सामान्य संदिग्धों के बाहर मुश्किल हो सकता है।

— JB

कृपया समझाएं, @ जेबी को मापने के लिए मुश्किल?

— डेविड सीएपी

यह प्रविष्टि "32" बताई जानी चाहिए क्योंकि केवल लीबनिज़ का दृष्टिकोण आवश्यकताओं को पूरा करता है (दिए गए कोड में वर्णों को गिनते हुए, मुझे 34 मिलते हैं, लेकिन दोनों रिक्त स्थान सुरक्षित रूप से हटाए जा सकते हैं, वास्तव में 32 की लंबाई दे सकते हैं)।

— celtschk

4

एपीएल (14)

4×-/÷1-⍨2×⍳1e6

— मारीनस
स्रोत

1

13,--/4÷1-2×⍳1e6

— टाइमटेक

4

जावा (67 वर्ण)

float r(){float p=0,s=4,i=1E6f;while(--i>0)p+=(s=-s)/i--;return p;}

ध्यान दें कि यह सही क्रम में संख्याओं को जोड़कर महत्व की हानि से बचाता है।

— पीटर टेलर
स्रोत

यह पूरी तरह से सी कोड भी है। अगर सी के रूप में तैनात है, तो आप को बदल सकता है while(--i>0)करने के लिए while(i--)और 2 वर्ण को बचाने

— ardnew

1

@ardnew, सच है, लेकिन सी के साथ खेलने के लिए और भी कई दिलचस्प ट्रिक्स हैं ...

— पीटर टेलर

4

हास्केल, 32

foldr(\k->(4/(2*k+1)-))0[0..8^7]

GHCi> foldr (\ k -> (4 / (2 * k + 1) -)) 0 [0..8 ^ 7]
3.141593130426724

एक फ़ंक्शन नाम गिना जा रहा है

34

π=foldr(\k->(4/(2*k+1)-))0[0..8^7]

— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत

3

आर - 25 चार्ट

sum(c(4,-4)/seq(1,1e6,2))

— flodel
स्रोत

3

सी (जीसीसी) (44 वर्ण)

float p(i){return i<1E6?4./++i-p(++i):0;}

यह 41 वर्ण है, लेकिन इसे भी संकलित करना होगा -O2 पूंछ पुनरावृत्ति को खत्म करने के लिए अनुकूलक प्राप्त करने के लिए जाना है। यह उस आदेश के संबंध में अपरिभाषित व्यवहार पर भी निर्भर करता है जिसमें ++निष्पादित किया जाता है; यह इंगित करने के लिए बदसूरत करने के लिए धन्यवाद। मैंने 64-बिट लिनक्स के तहत gcc 4.4.3 के साथ परीक्षण किया है।

ध्यान दें कि जब तक ऑप्टिमाइज़र भी राशि को पुनः प्राप्त नहीं करता है, तब तक यह सबसे छोटी संख्या से जोड़ देगा, इसलिए यह महत्व की हानि से बचा जाता है।

के रूप में बुलाओ p()।

— पीटर टेलर
स्रोत

आपका पुनरावर्ती कॉल है q(), नहीं p()। और मुझे नहीं लगता कि -O2इसे गिना जाना चाहिए (लेकिन यदि आप इसे गिनते हैं, तो आवश्यक स्थान के कारण यह 4 वर्ण है)।

— 14

इसके अलावा: 1. gcc 4.1.1 पुनरावृत्ति का अनुकूलन नहीं करता है (और मुझे नहीं लगता कि यह कैसे हो सकता है), इसलिए स्टैक ओवरफ्लो होता है। 2. इसे कहा जाना चाहिए p(0)। 3. एक चार से बचाओ return++i...। 4. दो ++iअपरिभाषित व्यवहार करता है।

— 15

@ यूगोरेन, आपकी टिप्पणी के लिए धन्यवाद। क्रम में: q- जो मुझे नाम बदलने के बाद दोबारा जांचना सिखाएगा। मुझे लगता है कि मैं -O23 वर्णों के रूप में गिनती में सामान्य अभ्यास का पालन कर रहा हूं , लेकिन यदि आप चाहें तो हम इसे मेटा पर खोल सकते हैं; meta.codegolf.stackexchange.com/questions/19 एकमात्र प्रासंगिक चर्चा है जो मुझे मिल सकती है। मैंने gcc का संस्करण जोड़ा है जो मैं उपयोग कर रहा हूँ, और जो मुझे इसे कॉल करने की अनुमति देता है p()। चार को बचाने से ऑप्टिमाइज़र बंद हो जाता है और सीगफॉल्ट देता है। मैं स्पष्ट करूँगा कि मैं अपरिभाषित व्यवहार का उपयोग कर रहा हूँ, जैसा कि meta.codegolf.stackexchange.com/questions/21 के

— पीटर टेलर

मैंने झंडे के बारे में मेटा सवाल का जवाब जोड़ा। के बारे में p()- क्या आप सुनिश्चित हैं कि p()किसी भी संदर्भ से कॉल करने से काम चलेगा? या यह सिर्फ वही है जो आपके परीक्षण में स्टैक पर हुआ था?

— ugoren

@ यूगोरेन, शायद मैं लगातार भाग्यशाली रहा। यहां तक कि अगर मैं इसे दो बार एक पंक्ति में कहता हूं, तब भी दूसरा सही मूल्य देता है। जीसीसी p()बनाम के लिए थोड़ा अलग कोड का उत्पादन लगता है p(0), लेकिन मुझे नहीं पता कि यह किस व्यवहार का दस्तावेज है और मैं वास्तव में सी प्रोग्रामर नहीं हूं।

— पीटर टेलर

3

जे, 26 चरस

~~+ / + / _ 2 ((4 _4) और%)>: +: i.100~~

अनुक्रम के 100 आइटम से 1e6 आइटम तक ले जाया गया। इसके अलावा अब यह एक कोड टैग किया गया है और इसे ब्राउज़र से कंसोल में त्रुटियों के बिना कॉपी किया जा सकता है।

+/+/_2((4 _4)&%)\>:+:i.1e6

— FFTW
स्रोत

3

-/4%>:2*i.1e6- 13 वर्ण। (मुझे इस बात का एहसास कराने के लिए #jsoftware में b_jonas का शुक्रिया कि -/बारी-बारी से हस्ताक्षर करने के लिए एक राशि की गणना करने के लिए काम करता है। [ऐसा इसलिए है क्योंकि J में सभी ऑपरेटर समान पूर्वता और सही-सहयोगी हैं, इसलिए -/ 1 2 3 4<=> 1 - (2 - (3 - 4))<=> 1 - 2 + 3 - 4])

— FireFly

यह साफ-सुथरा और दोगुना भयानक है। या यहां तक कि 2 ^ 10 अधिक भयानक!

— fftw

@ पूरी तरह से सुंदर है

— जोनाह

2

जावास्क्रिप्ट - 33 वर्ण

p=x=>4*(1-(x&2))/x+(x>1?p(x-2):0)

कॉल p एक सकारात्मक विषम संख्या गुजर xऔर इसके साथ पाई की गणना करेगा (x-1)/2शर्तों।

— MT0
स्रोत

2

रूबी - 82 वर्ण

def f(n,k=n)k>0?(f(n,k-1)+f(n+1,k-1))/2:n<0?0:f(n-1,0)+(-1)**n/(2*n+1.0)end;4*f(9)

कोशिश करो : https://repl.it/LQ8w

दृष्टिकोण दिए गए श्रृंखला का उपयोग परोक्ष रूप से एक संख्यात्मक त्वरण दृष्टिकोण का उपयोग करता है। परिणामी उत्पादन है

pi ≈ 3.14159265161

बनाम

pi = 3.14159265359

इसके साथ शुरू होता है

f(n,0) = 1/1 - 1/3 + 1/5 - ... + ((-1)**n)/(2*n+1)

और फिर, चूंकि यह वैकल्पिक है, हम उपयोग करके अभिसरण को तेज कर सकते हैं

f(n,1) = (f(n,0) + f(n+1,0))/2

और यह बार-बार लागू होता है:

f(n,k) = (f(n,k-1) + f(n+1,k-1))/2

और सादगी के लिए, f(n) = f(n,n)।

रूबी - 50 वर्ण

यदि आप वास्तव में लंबे समय तक चलने में कोई आपत्ति नहीं करते हैं, तो आप बस उपयोग कर सकते हैं

def f(n)n<0?0:f(n-1)+(-1)**n/(2*n+1.0)end;4*f(1e7)

या

a=0;for k in 0..1e7 do a+=(-1)**k/(2*k+1.0)end;4*a

— सिंपल ब्यूटीफुल आर्ट
स्रोत

1

C, 69 वर्ण

float p,b;void main(a){b++<9e6?p+=a/b++,main(-a):printf("%f\n",4*p);}

बिना कमांड लाइन के मापदंडों के साथ चलाएं (ताकि a 1 को प्रारंभ किया )।
अनुकूलन के साथ संकलित किया जाना चाहिए।
void mainअजीब और गैर-मानक है, लेकिन चीजों को काम करता है। इसके बिना, पुनरावृत्ति को वास्तविक कॉल के रूप में लागू किया जाता है, जिससे स्टैक ओवरफ्लो होता है। एक विकल्प जोड़ रहा हैreturn ।
4*यदि तीन कमांड लाइन मापदंडों के साथ चल रहे हैं, तो दो वर्णों को बचाया जा सकता है।

— ugoren
स्रोत

आप इसे छोटा कर सकते हैं int main(a)या फिर main(a), जीसीसी केवल एक चेतावनी देता है। और यह void mainवैसे भी एक चेतावनी देगा , और शायद इसलिए भी कि आपके पास केवल एक तर्क है main।

— nyuszika7h

1

क्लोजर - 79 वर्ण

(fn [](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

यह बिना तर्कों के एक फ़ंक्शन बनाता है जो एक फ्लोट की गणना करेगा जो पांच दशमलव स्थानों पर पाई को सही ढंग से अनुमानित करता है। नोट इस नहीं बाँध है कि इस तरह के रूप में एक नाम करने के लिए समारोह pi, इस कोड को किसी के साथ जगह में मूल्यांकन किया जाना चाहिए ताकि evalके रूप में (<code>)या एक नाम जो मामले में समाधान है करने के लिए बाध्य

(defn p[](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

82 वर्णों के लिए

के बारे में

(defn nth-term-of-pi [n] (* (Math/pow -1 n) (/ 1.0 (+ 1 n n))))
(defn pi [c] (* 4 (apply + (map nth-term-of-pi (range c)))))
(def  pi-accuracy-constant (loop [c 1000] (if (< (pi c) 3.14159) (recur (inc c)) c)))
; (pi pi-accuracy-constant) is then the value of pi to the accuracy of five decimal places

— arrdem
स्रोत

1

PHP - 56 55 वर्ण

<?for($j=$i=-1;1e6>$j;){$p+=($i=-$i)/($j+=2);}echo$p*4;

मुझे नहीं पता कि मैं एल्गोरिथ्म नियम को तोड़े बिना इसे बहुत छोटा कर सकता हूं।

— TwoScoopsofPig
स्रोत

1

इस बारे में 45 के लिए कैसे? <?for(;1e6>$j;)$p+=($i=-$i|4)/~-$j+=2;echo$p;

— प्रिमो

मैं उस के साथ आने की कोशिश कर रहा था, लेकिन काम करने के लिए बिटवाइज़ ऑप्स नहीं मिल सका। सलाह के लिये धन्यवाद!

— TwoScoopsofPig

आप 1 वर्ण को बचाने के लिए अंतिम अर्धविराम निकाल सकते हैं।

— nyuszika7h

1

पर्ल - 43 39 चार्ट

अनाम सबरूटीन्स पर नियम सुनिश्चित नहीं हैं, लेकिन @ FireFly की श्रृंखला निर्माण का उपयोग करके यहां एक और कार्यान्वयन है

sub{$s+=8/((4*$_+2)**2-1)for 0..1e6;$s}

~~sub p{$s+=(-1)**$_*4/(2*$_+1)for 0..1e6;$s}~~

— ardnew
स्रोत

0

जावा - 92 84 चार्ट

मैं अब तक पीटर टेलर के परिणाम को नहीं हरा सकता, लेकिन यहाँ मेरा है:

double d(){float n=0,k=0,x;while(n<9E5){x=1/(1+2*n++);k+=(n%2==0)?-x:x;}return 4*k;}

Ungolfed संस्करण:

double d() {
    float n = 0, k = 0, x;
    while (n < 9E5) {
        x = 1 / (1 + 2 * n++);
        k += (n % 2 == 0) ? -x : x;
    }
    return 4 * k;
}

संपादित करें: टर्नरी ऑपरेटर का उपयोग करके कुछ वर्ण सहेजे गए।

— Averroes
स्रोत

0

पायथन - 56 वर्ण

मेह, मेरा अजगर-फू काफी मजबूत नहीं है। मैं कोई और शॉर्टकट नहीं देख सकता था, लेकिन शायद अधिक अनुभवी गोल्फर को यहां ट्रिम करने के लिए कुछ मिल सकता है?

t=s=0
k=i=1
while t<1e6:t,s,i,k=t+1,k*4./i+s,i+2,-k

— chucksmash
स्रोत

आप फ्लोट डिवीजन ( 4.-> 4) के लिए एक बाइट को बचाने के लिए पायथन 3 का उपयोग कर सकते हैं । अन्य समाचारों में, मुझे सिर्फ एक मामला मिला जहां पायथन 3 वास्तव में कोड गोल्फ में अजगर 2 को हराता है!

— nyuszika7h 15

0

रूबी - 54 वर्ण

def a()p=0;1000000.times{|i|p+=8/(4*i*(4*i+2))};p;end;

मेरा पहला प्रयास कंसोल पर है

def a()i=1;p=0;while i<2**100 do p+=8/(i*(i+2));i+=4;end;p;end;

63 वर्ण।

— Perello
स्रोत

आप def a;इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं def a()।

— nyuszika7h 15

अंतिम अर्धविराम को हटाकर एक और।

— nyuszika7h

0

पर्ल (76 वर्ण)

$y=1e4;for$x(0..1e4-1){$y--while sqrt($x**2+$y**2)>1e4;$a+=$y}print 4*$a/1e8

(परिणाम: 3.14159052)

कम से कम संभव समाधान नहीं है, लेकिन शायद दिलचस्प है। यह एक ज्यामितीय है। मैं एक सर्कल के तहत क्षेत्र की गणना करता हूं।

मुझे एक और मज़ेदार तरीका मिला, लेकिन यह वास्तव में धीमा है। यह एक वर्ग में असतत बिंदुओं की संख्या को गिनता है जो एक चौथाई वृत्त से नीचे हैं और इससे पाई की गणना करते हैं:

$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2

यह कमांड लाइन तर्क के रूप में पुनरावृत्तियों की संख्या की अपेक्षा करता है। यहां आप देख सकते हैं कि रन टाइम सटीकता से कैसे संबंधित है। ;)

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 100
3.1796
real    0m0.011s
user    0m0.005s
sys 0m0.003s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 1000
3.14552
real    0m0.354s
user    0m0.340s
sys 0m0.004s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 10000
3.14199016
real    0m34.941s
user    0m33.757s
sys 0m0.097s

— memowe
स्रोत

0

k (25 वर्ण)

~~4 * + /% (i # 1 -1) '1 + 2 ! मैं: 1000000~~

थोड़ा छोटा:

+/(i#4 -4)%1+2*!i:1000000

— skeevey
स्रोत

0

पायथन (49)

print 4*sum((-1)**i/(2*i+1.)for i in range(9**6))

3.14159 453527

— arshajii
स्रोत

0

CJam - 21

1e6{WI#4d*I2*)/}fI]:+

दी गई श्रृंखला की बहुत सीधी गणना।
CJam http://sf.net/p/cjam है

— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत

0

जूलिया - 30 वर्ण

sum(4./[1:4:1e6] - 4./[3:4:1e6])

— Milktrader
स्रोत

0

एसक्यूएल, 253 बाइट्स

DECLARE @B int=3, @A varchar(max), @C varchar(max)='1'
WHILE @B<100000
BEGIN
SELECT @C=@C+(select case when (@B-1)%4=0 then'+'else'-'end)+
(SELECT cast(cast(1.0/@B as decimal(9,8)) as varchar(max)))
SELECT @B=@B+2
END
EXECUTE('SELECT 4*('+@C+')')

मैं एक एसक्यूएल फिडेल प्रदान करता हूं, लेकिन यह बहुत सारे छोरों को 1/3 1/5 1/7 आदि अंशों को खोजने के लिए गहराई से जाता है और त्रुटियां देता है। हालाँकि, यदि आप बदलते @B<100000हैं 1000तो यह चलता है (स्पष्ट रूप से सटीकता की समान संख्या नहीं)।

— phroureo
स्रोत

0

Befunge, 129 बाइट्स

p08p109p^v*86%+55:<$$$<
\$\>:#,_@>+\55+/:#^_"."
v>p"~"/:"~"%08p"~"/00p:2\4%-*"(}"
8^90%"~":+2:+g90*+g80*<
>*:**\/+>"~~"00g:"~"`!|

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

मामले में कोई भी सोच रहा है, यह एक हाथी है।

Cartoon elephant

— जेम्स होल्डरनेस
स्रोत

5 दशमलव तक पि की गणना करें

जावास्क्रिप्ट, 46 58 56 45 बाइट्स

इतिहास

पायथन 59 बाइट्स

गणितज्ञ 42 39 34 33 31 26 32

एपीएल (14)

जावा (67 वर्ण)

हास्केल, 32

34

आर - 25 चार्ट

सी (जीसीसी) (44 वर्ण)

जावास्क्रिप्ट - 33 वर्ण

रूबी - 82 वर्ण

रूबी - 50 वर्ण

C, 69 वर्ण

क्लोजर - 79 वर्ण

के बारे में

PHP - 56 55 वर्ण

पर्ल - 43 39 चार्ट

जावा - 92 84 चार्ट

पायथन - 56 वर्ण

पर्ल (76 वर्ण)

k (25 वर्ण)

पायथन (49)

CJam - 21

जूलिया - 30 वर्ण

एसक्यूएल, 253 बाइट्स

Befunge, 129 बाइट्स