मोंटे कार्लो पी के अनुमानक

25

सभी को हैप्पी पि डे! बिना किसी कारण के, मैं पाई का मोंटे कार्लो अनुमानक बनाने की कोशिश कर रहा हूं जो यथासंभव कम है। क्या हम एक ट्वीट में फिट हो सकते हैं?

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

कोई ट्रिगर कार्य या पाई स्थिरांक, मोंटे कार्लो दृष्टिकोण होना चाहिए।

यह कोड गोल्फ है, इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है।

code-golf  random  pi  approximation 
— कीगन
स्रोत
2
ट्रिगर कार्यों की अनुमति है? मेरा सुझाव है कि आप उन्हें स्पष्ट रूप से प्रतिबंधित करें।
— लेवल रिवर सेंट
((0..4e9).map{rand**2+rand**2<1}.to_s.sub(/./,"$1.")
— जॉन ड्वोरक
@JanDvorak कैसे काम करने वाला है? क्या mapआप एक सरणी नहीं देते हैं trueऔर false?
— मार्टिन एंडर
@ मार्टिनबटनर आह, ओह, माफ करना। .filter{...}.sizeहालांकि काम करना चाहिए।
— जॉन ड्वोरक
@JDDvorak वास्तव में। यह वास्तव में साफ है :)
— मार्टिन एंडर

जवाबों:

17

80386 मशीन कोड, 40 38 बाइट्स

कोड के Hexdump:

60 33 db 51 0f c7 f0 f7 e0 52 0f c7 f0 f7 e0 58
03 d0 72 03 83 c3 04 e2 eb 53 db 04 24 58 db 04
24 58 de f9 61 c3

यह कोड कैसे प्राप्त करें (विधानसभा भाषा से):

    // ecx = n (number of iterations)
    pushad;
    xor ebx, ebx; // counter
    push ecx; // save n for later
myloop:
    rdrand eax; // make a random number x (range 0...2^32)
    mul eax; // calculate x^2 / 2^32
    push edx;
    rdrand eax; // make another random number y
    mul eax; // calculate y^2 / 2^32
    pop eax;
    add edx, eax; // calculate D = x^2+y^2 / 2^32 (range 0...2^33)
    jc skip; // skip the following if outside the circle
    add ebx, 4; // accumulate the result multiplied by 4
skip:
    loop myloop;
    push ebx; // convert the result
    fild dword ptr [esp]; // to floating-point
    pop eax;
    fild dword ptr [esp]; // convert n to floating-point
    pop eax;
    fdivp st(1), st; // divide

    popad;
    ret;

यह एमएस fastcallकॉलिंग कन्वेंशन (पुनरावृत्तियों की संख्या रजिस्टर में पारित किया गया है ecx) का उपयोग करते हुए एक फ़ंक्शन है । यह stरजिस्टर में परिणाम लौटाता है ।

इस कोड के बारे में मजेदार बातें:

  • rdrand - एक यादृच्छिक संख्या उत्पन्न करने के लिए सिर्फ 3 बाइट्स!
  • अंतिम डिवीजन तक यह (अहस्ताक्षरित) पूर्णांक अंकगणित का उपयोग करता है।
  • चुकता दूरी ( D) वर्ग त्रिज्या ( ) के साथ तुलना 2^32स्वचालित रूप से की जाती है - कैरी फ्लैग में परिणाम होता है।
  • गिनती को 4 से गुणा करने के लिए, यह 4 के चरणों में नमूनों की गणना करता है।
— anatolyg
स्रोत
टिप्पणी को "गणना एक्स ^ 2% 2 ^ 32"
— कोल जॉनसन
@ColeJohnson नहीं - यादृच्छिक संख्या में है eax; mulआदेश गुणकों वह खुद को और पुट में उच्च हिस्सा द्वारा edx; निम्न भाग eaxको छोड़ दिया गया है।
— अनातोलीग
11

मतलाब / ऑक्टेव, 27 बाइट्स

मुझे पता है कि पहले से ही एक मैटलैब / ऑक्टेव उत्तर है, लेकिन मैंने अपने दृष्टिकोण की कोशिश की। मैंने इस तथ्य का उपयोग किया कि 4/(1+x^2)0 और 1 के बीच का अभिन्न संबंध पी है।

mean(4./(1+rand(1,1e5).^2))
— flawr
स्रोत
एक अलग एल्गोरिथ्म हमेशा महान होता है! इसके अलावा, अधिक कुशल!
— अनातोलीग
7

आर, 40 (या 28 या 24 अन्य तरीकों का उपयोग करके)

mean(4*replicate(1e5,sum(runif(2)^2)<1))

mean(4*sqrt(1-runif(1e7)^2))

mean(4/(1+runif(1e7)^2))

पायथन 2, 56

एक और अजगर एक, अगर सुन्न की अनुमति है, लेकिन मैटलैब / ऑक्टेव के समान सुंदर है:

import numpy;sum(sum(numpy.random.rand(2,8e5)**2)<1)/2e5
— मैट
स्रोत
6

गणितज्ञ, 42 40 39 बाइट्स (या 31/29?)

मुझे 42 बाइट्स में तीन समाधान मिले हैं:

4Count[1~RandomReal~{#,2},p_/;Norm@p<1]/#&
4Tr@Ceiling[1-Norm/@1~RandomReal~{#,2}]/#&
4Tr@Round[1.5-Norm/@1~RandomReal~{#,2}]/#&

वे सभी अनाम कार्य हैं जो नमूनों की संख्या को लेते हैं और nएक तर्कसंगत सन्निकटन r लौटाते हैं। पहले वे सभी nसकारात्मक चतुर्थांश में इकाई वर्ग में अंक उत्पन्न करते हैं । फिर वे उन नमूनों की संख्या निर्धारित करते हैं जो यूनिट सर्कल के भीतर झूठ बोलते हैं, और फिर वे नमूनों की संख्या से विभाजित करते हैं और गुणा करते हैं 4। एकमात्र अंतर यह है कि वे यूनिट सर्कल के अंदर समपल्स की संख्या कैसे निर्धारित करते हैं:

  • पहले वाला Countइस शर्त के साथ उपयोग करता है कि Norm[p] < 1।
  • दूसरा वाला प्रत्येक बिंदु के मान को घटाता है 1और फिर गोल करता है। इससे यूनिट सर्कल के अंदर 1और बाहर जाने वालों की संख्या बदल जाती है 0। बाद में मैं बस उन सभी के साथ योग करता हूं Tr।
  • तीसरा अनिवार्य रूप से एक ही करता है, लेकिन से घटाता है 1.5, इसलिए मैं Roundइसके बजाय का उपयोग कर सकता हूं Ceiling।

Aaaaaand इसे लिखते समय , मेरे साथ यह हुआ कि वास्तव में एक छोटा समाधान है, अगर मैं अभी इससे घटाऊंगा 2और फिर उपयोग करूंगा Floor:

4Tr@Floor[2-Norm/@1~RandomReal~{#,2}]/#&

या यूनिकोड फ़्लोरिंग या सीलिंग ऑपरेटरों का उपयोग करके किसी अन्य बाइट को सहेजना:

4Tr@⌊2-Norm/@1~RandomReal~{#,2}⌋/#&
4Tr@⌈1-Norm/@1~RandomReal~{#,2}⌉/#&

ध्यान दें कि तीन राउंडिंग-आधारित समाधानों को एक ही बाइट्स के लिए फिर Meanसे Trऔर बिना के बिना भी लिखा जा सकता है /#।

यदि अन्य मोंटे कार्लो आधारित दृष्टिकोण ठीक हैं (विशेष रूप से, जिसे एक पीटर ने चुना है), मैं 31 बाइट्स का अभिन्न अंग का अनुमान लगाकर या 29 का उपयोग करके कर सकता हूं , इस बार एक फ्लोटिंग पॉइंट नंबर के रूप में दिया गया है:√(1-x2)1/(1+x2)

4Mean@Sqrt[1-1~RandomReal~#^2]&
Mean[4/(1+1~RandomReal~#^2)]&
— मार्टिन एंडर
स्रोत
9
आपको जीवन, ब्रह्मांड और सब कुछ के लिए तीन समाधान मिल गए हैं और आप इसे बर्बाद करने का फैसला करते हैं? विधर्म।
— seequ
2
— मार्टिन एंडर
6

CJam, 27 23 22 या 20 बाइट्स

4rd__{{1dmr}2*mhi-}*//

2 बाइट्स ने Runner112 को धन्यवाद दिया, 1 बाइट ने Sp3000 को धन्यवाद दिया

यह इनपुट के रूप में STDIN से पुनरावृति गणना लेता है।

यह जितना सीधा होता है उतना ही आगे बढ़ता है। ये प्रमुख कदम हैं:

  • इनपुट पढ़ें और मोंटे कार्लो पुनरावृत्तियों को चलाएं जो कई बार
  • प्रत्येक पुनरावृत्ति में, 0 से 1 तक दो यादृच्छिक फ़्लोट के वर्ग का योग प्राप्त करें और देखें कि क्या यह 1 से कम है
  • कुल पुनरावृत्तियों द्वारा हमें 1 से कम कितनी बार अनुपात मिला और पीआई प्राप्त करने के लिए इसे 4 से गुणा करें

कोड विस्तार :

4rd                     "Put 4 on stack, read input and convert it to a double";
   __{            }*    "Take two copies, one of them determines the iteration"
                        "count for this code block";
      {1dmr}2*          "Generate 2 random doubles from 0 to 1 and put them on stack";
              mh        "Take hypot (sqrt(x^2 + y^2)) where x & y are the above two numbers";
                i       "Convert the hypot to 0 if its less than 1, 1 otherwise";
                 -      "Subtract it from the total sum of input (the first copy of input)";
                    //  "This is essentially taking the ratio of iterations where hypot";
                        "is less than 1 by total iterations and then multiplying by 4";

इसे यहाँ ऑनलाइन आज़माएँ

यदि औसत मूल्य 1/(1+x^2)मोंटे कार्लो के रूप में माना जाता है, तो यह 20 बाइट्स में किया जा सकता है:

Urd:K{4Xdmr_*)/+}*K/

इसे यहाँ आज़माएँ

— अनुकूलक
स्रोत
2
मैंने सीजेएम उत्तर के रूप में अच्छी तरह से कोशिश की, और आपके स्कोर के तहत 2 बाइट्स में आने में कामयाब रहा। लेकिन मेरा कोड आपके जैसे ही निकला, मैं इसे एक अलग जवाब के रूप में पोस्ट करना गंदा महसूस करूंगा। वैरिएबल चॉइस और इन दो ऑप्टिमाइज़ेशन को छोड़कर सब कुछ समान था: 1dmrइसके बजाय 0 से 1 तक एक यादृच्छिक संख्या प्राप्त KmrK/करें, और जांचें कि क्या वर्गों की राशि 1 के iबजाय 1 से अधिक है 1>(मुझे लगता है कि यह विशेष रूप से चतुर था) ।
— रनर १११
@ Runer112 धन्यवाद। iचाल वास्तव में साफ है! और इसके लिए प्रलेखन की कमी लानत है1dmr
— ऑप्टिमाइज़र
5

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

from random import*;r=random;a=0;exec"a+=r()**2+r()**2<1;"*4000;print a/1e3

के साथ बाइट को बचाने के लिए 4000 नमूनों का उपयोग करता है 1e3।

— Sp3000
स्रोत
5
आप बिना किसी लागत के थोड़ी अधिक सटीकता प्राप्त कर सकते हैं ...*8000;print a/2e3।
— लॉजिक नाइट
5

कमोडोर 64 बेसिक, 45 बाइट्स

1F┌I=1TO1E3:C=C-(R/(1)↑2+R/(1)↑2<1):N─:?C/250

PETSCII प्रतिस्थापन: ─= SHIFT+E, /= SHIFT+N, ┌=SHIFT+O

पहले चतुर्थांश में 1000 अंक उत्पन्न करता है; प्रत्येक के लिए, "x ^ 2 + y ^ 2 <1" की सत्यता को एक रनिंग काउंट में जोड़ता है, फिर गणना को 250 से विभाजित करता है pi। (माइनस साइन की उपस्थिति इसलिए है क्योंकि C64 पर "सही" = -1 है।)

— निशान
स्रोत
क्या करता (1)है?
— इक्रिस्टोफ़र्सन
@echristopherson, आप इसे गलत बता रहे हैं। /यह विभाजन का प्रतीक नहीं है, यह SHIFT+Nएक कमोडोर 64 कीबोर्ड पर टाइप करके निर्मित चरित्र है । यानी के R/(1)लिए शॉर्टकट फॉर्म है RND(1)। "वर्तमान RNG बीज का उपयोग करके 0 और 1 के बीच एक यादृच्छिक संख्या का उत्पादन करें"।
— मार्क
ओह, तुम सही हो! अच्छा पुराना PETSCII ग्राफिक्स अक्षर।
— इरिस्टरोफ़र्सन
5

जे, 17 बाइट्स

रेंज में 40000फ़ंक्शन के नमूना मूल्यों के औसत मूल्य की गणना करता है ।4*sqrt(1-sqr(x))[0,1]

हाथ से 0 o.xलौटाता है sqrt(1-sqr(x))।

   1e4%~+/0 o.?4e4$0
3.14915
— randomra
स्रोत
4

> <> (मछली) , 114 बाइट्स

:00[2>d1[   01v
1-:?!vr:@>x|  >r
c]~$~< |+!/$2*^.3
 .41~/?:-1r
|]:*!r$:*+! \
r+)*: *:*8 8/v?:-1
;n*4, $-{:~ /\r10.

अब,> <> में अंतर्निहित यादृच्छिक संख्या जनरेटर नहीं है। हालांकि इसमें एक फ़ंक्शन होता है जो पॉइंटर को यादृच्छिक दिशा में भेजता है। मेरे कोड में यादृच्छिक संख्या जनरेटर:

______d1[   01v
1-:?!vr:@>x|  >r
_]~$~< |+!/$2*^__
 __________
___________ _
_____ ____ _______
_____ ____~ ______

यह मूल रूप से यादृच्छिक बिट्स उत्पन्न करता है जो एक बाइनरी नंबर बनाते हैं और फिर उस यादृच्छिक बाइनरी नंबर को दशमलव में परिवर्तित करते हैं।

बाकी वर्ग दृष्टिकोण में सिर्फ नियमित बिंदु हैं।

उपयोग: जब आप कोड चलाते हैं तो आपको नमूने की संख्या के साथ स्टैक (-पायथन इंटरप्रेटर में) को रोकना सुनिश्चित करना चाहिए, उदाहरण के लिए

pi.fish -v 1000

रिटर्न

3.164
— cirpis
स्रोत
4

मतलाब या ऑक्टेव 29 बाइट्स (दोष के लिए धन्यवाद!)

mean(sum(rand(2,4e6).^2)<1)*4

(मुझे यकीन नहीं है कि <1 ठीक है। मैंने पढ़ा कि यह होना चाहिए <= 1। लेकिन वास्तव में कितना बड़ा ड्रॉ होने की संभावना है ...)

मतलाब या ऑक्टेव 31 बाइट्स

sum(sum(rand(2,4e3).^2)<=1)/1e3
— स्टीफन
स्रोत
1
बहुत अच्छा विचार है! आप के साथ दो अतिरिक्त बाइट्स बचा सकता है mean(sum(rand(2,4e6).^2)<1)*4।
— दोष
4

जावा, 108 बाइट्स

double π(){double π=0,x,i=0;for(;i++<4e5;)π+=(x=Math.random())*x+(x=Math.random())*x<1?1e-5:0;return π;}

चार हजार पुनरावृत्तियों, प्रत्येक बार बिंदु को जोड़कर 0.001 यूनिट सर्कल के अंदर होता है। सुंदर बुनियादी सामान।

नोट: हाँ, मुझे पता है कि मैं πएक बाइट चरित्र में बदलकर चार बाइट्स बहा सकता हूँ । मुझे यह ऐसे ही पसंद है।

— Geobits
स्रोत
9999 पुनरावृत्तियों क्यों नहीं?
— ऑप्टिमाइज़र
1
@Optimizer यह योग को छोटा बनाता है। 9999 पुनरावृत्तियों के लिए, मुझे हर बार इसके बजाय अधिक सटीक संख्या जोड़नी होगी, जिससे मुझे अंक प्राप्त होंगे।
— जोबिट्स
1
आप संख्याओं के लिए "4e5" और "1e-5" का उपयोग करके एक और बाइट बचा सकते हैं और सटीकता में सुधार कर सकते हैं।
— विल्मंतस बरनौस्कास
@VilmantasBaranauskas धन्यवाद! मैं हमेशा इस बारे में भूल जाता हूं :) यह बदले में 4e9 और 1e-9 का उपयोग करने के लिए आकर्षक है, लेकिन इसमें काफी समय लगता है ...
— Geobits
प्रोटिप: जब गोल्फिंग करते हैं, तो आपको वास्तव में बाइट्स को कम करना चाहिए, न कि कृत्रिम रूप से उन्हें बढ़ाना चाहिए
— विनाशकारी नींबू
3

जावास्क्रिप्ट: 62 बाइट्स

for(r=Math.random,t=c=8e4;t--;c-=r()**2+r()**2|0);alert(c/2e4)

मैंने पिछले (अब हटाए गए) जावास्क्रिप्ट उत्तर का उपयोग किया और 5 बाइट्स का मुंडन किया।

— गुजमान टिएर्नो
स्रोत
आप क्रेडिट को ठीक से देने के लिए cfern के उत्तर से जुड़ सकते हैं ।
— जोनाथन फ्रीच
आपका उत्तर एक स्निपेट प्रतीत होता है जिसे I / O अस्वीकृत किया गया है । कृपया अपनी पोस्ट को ठीक करें या हटाएं।
— जोनाथन फ्रीच
क्षमा करें, मैं नया हूं मुझे नहीं पता था कि पिछले समाधान के लिंक को कैसे रखा जाए जो अब दिखाई देता है हटा दिया गया है। स्निपेट के बारे में: मैं पूरी तरह से सहमत हूं, लेकिन यह पिछले जावास्क्रिप्ट सॉल्यूशन का कोड था, जो मुझे भी लगता है कि यह अमान्य था। मैंने एक कार्यक्रम होने के लिए मेरा संशोधन किया।
— गुजमान टिएर्नो
हाँ; पिछला उत्तर हटा दिया गया था क्योंकि यह अमान्य था - मैंने हटाने से पहले आपके उत्तर को देखा था, इस प्रकार टिप्पणी। एक वैध जवाब प्रस्तुत करने के लिए +1; PPCG में आपका स्वागत है!
— जोनाथन फ्रेच
2

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

0{^3?^rand.*^.*+/+}2000:^*`1/('.'@

ऑनलाइन डेमो

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

विशेष रूप से नियुक्त मोंटे कार्लो विधि के लिए एक्सनोर को श्रेय ।

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

पायथन 2, 90 85 81 बाइट्स

from random import*;r=random;print sum(4.for i in[0]*9**7if r()**2+r()**2<1)/9**7

3.14120037157उदाहरण के लिए रिटर्न । नमूना गणना 4782969 (9 ^ 7) है। आप 9 ^ 9 के साथ एक बेहतर पाई प्राप्त कर सकते हैं लेकिन आपको धैर्य रखना होगा।

— तर्क नाइट
स्रोत
जब तक आप उपयोग नहीं करते हैं, तब तक आप 3 या कुछ के range(9**7)साथ बदलकर बचा सकते [0]*9**7हैं i। और सूची स्मृति मुद्दों में चलाने के लिए बहुत लंबा नहीं है।
— Sp3000
धन्यवाद। मैं छुटकारा पाना चाहता था range()लेकिन मैं उस चाल को पूरी तरह से भूल गया था।
— लॉजिक नाइट
मुझे लगता [0]9**7है कि मान्य वाक्यविन्यास नहीं है।
— १५'११ को १३:५४
तुम सही हो। मैंने खोए हुए एस्टेरिक्स को फिर से जोड़ा है (यह मेरी मेज के नीचे था)।
— लॉजिक नाइट
2

रूबी, 39 बाइट्स

p (1..8e5).count{rand**2+rand**2<1}/2e5

मुख्य आकर्षण यह है कि यह एक 8e5संकेतन का उपयोग करने में सक्षम है, जो एक ही कार्यक्रम बाइट काउंट में ~ 8e9 नमूनों तक विस्तार योग्य बनाता है।

— GreyCat
स्रोत
1

स्काला, 87 77 66 बाइट्स

def s=math.pow(math.random,2);Seq.fill(1000)(s+s).count(_<1)/250d
— कीगन
स्रोत
यदि आप के 1000साथ 8000और आप दोनों के 250dसाथ 2e4एक बाइट बचाने के लिए और 8. के ​​एक पहलू से नमूने की संख्या में वृद्धि
— डेव स्वार्ट्ज
1

शुद्ध बैश, 65 बाइट्स

for((;i++<$1*4;a+=RANDOM**2+RANDOM**2<32767**2));{ :;}
echo $a/$1

एकल कमांड-लाइन पैरामीटर लेता है जो नमूनों की संख्या देने के लिए 4 से गुणा किया जाता है। बैश अंकगणित पूर्णांक-मात्र है, इसलिए एक तर्कसंगत आउटपुट है। यह bc -lअंतिम विभाजन के लिए पाइप किया जा सकता है :

$ ./montepi.sh 10000
31477/10000
$ ./montepi.sh 10000|bc -l
3.13410000000000000000
$
— डिजिटल आघात
स्रोत
1

जो , 20 19 बाइट्स

नोट: यह उत्तर गैर-प्रतिस्पर्धात्मक है, क्योंकि संस्करण 0.1.2, जिसमें यादृच्छिकता शामिल है, इस चुनौती के बाद जारी किया गया था।

नामित फ़ंक्शन F:

:%$,(4*/+1>/+*,?2~;

बेनाम:

%$,(4*/+1>/+*,?2~;)

ये दोनों नमूना गिनती को एक तर्क के रूप में लेते हैं और परिणाम वापस करते हैं। वो कैसे काम करते है?

%$,(4*/+1>/+*,?2~;)
   (4*/+1>/+*,?2~;) defines a chain, where functions are called right-to-left
               2~;  appends 2 to the argument, giving [x, 2]
              ?     create a table of random values from 0 to 1 with that shape
            *,      take square of every value
          /+         sum rows, giving a list of (x**2+y**2) values
        1>           check if a value is less than 1, per atom
      /+             sum the results
    4*               multiply by four
%$,                  divide the result by the original parameter

उदाहरण चलता है:

   :%$,(4*/+1>/+*,?2~;
   F400000
3.14154
   F400000
3.14302
— seequ
स्रोत
1

डीसी, 59 अक्षर (व्हाट्सएप को नजरअंदाज किया जाता है)

[? 2^ ? 2^ + 1>i]su
[lx 1+ sx]si
[lu x lm 1+ d sm ln>z]sz

5k
?sn
lzx
lx ln / 4* p
q

मैंने इसे योजना 9 और ओपनबीएसडी पर परीक्षण किया है, इसलिए मुझे लगता है कि यह लिनक्स (जीएनयू?) पर काम करेगा dc।

लाइन द्वारा स्पष्टीकरण:

  1. स्टोर कोड [पढ़ने और दो फ़्लोट करने के लिए वर्ग; रजिस्टर रजिस्टर निष्पादित करें iयदि 1 रजिस्टर में उनके वर्ग के योग से अधिक हो] u।
  2. स्टोर कोड को [वृद्धि रजिस्टर xमें 1] रजिस्टर में i।
  3. स्टोर कोड [रजिस्टर रजिस्टर u, वेतन वृद्धि रजिस्टर m, और फिर रजिस्टर zरजिस्टर रजिस्टर mसे अधिक होने पर रजिस्टर निष्पादित n] रजिस्टर में z।

  5. पैमाने को 5 दशमलव बिंदुओं पर सेट करें।

  6. इनपुट की पहली पंक्ति से नमूना करने के लिए अंकों की संख्या पढ़ें।
  7. पंजीकरण रजिस्टर z।
  8. रजिस्टर x(हिट की संख्या) को रजिस्टर n(अंकों की संख्या ) से विभाजित करें, परिणाम को 4 से गुणा करें, और प्रिंट करें।
  9. बाहर निकलें।

हालाँकि, मैंने धोखा दिया:

कार्यक्रम को 0 और 1 के बीच यादृच्छिक फ़्लोट्स की आपूर्ति की आवश्यकता होती है। 

/* frand.c */
#include <u.h>
#include <libc.h>

void
main(void)
{
    srand(time(0));

    for(;;)
        print("%f\n", frand());
}

उपयोग:

#!/bin/rc
# runpi <number of samples>

{ echo $1; frand } | dc pi.dc

परीक्षण चालन:

% runpi 10000
3.14840

अब कम धोखा (100 बाइट्स) के साथ

किसी ने बताया कि मैं एक साधारण चुभन शामिल कर सकता हूं।
http://en.wikipedia.org/wiki/RANDU

[lrx2^lrx2^+1>i]su[lx1+sx]si[luxlm1+dsmln>z]sz[0kls65539*2 31^%dsslkk2 31^/]sr?sn5dksk1sslzxlxlm/4*p

Ungolfed

[
Registers:
u - routine : execute i if sum of squares less than 1
i - routine : increment register x
z - routine : iterator - execute u while n > m++
r - routine : RANDU PRNG
m - variable: number of samples
x - variable: number of samples inside circle
s - variable: seed for r
k - variable: scale for division
n - variable: number of iterations (user input)
]c
[lrx 2^ lrx 2^ + 1>i]su
[lx 1+ sx]si
[lu x lm 1+ d sm ln>z]sz
[0k ls 65539 * 2 31^ % d ss lkk 2 31 ^ /]sr
? sn
5dksk
1 ss
lzx
lx lm / 4*
p

परीक्षण चालन:

$ echo 10000 | dc pigolf.dc
3.13640
— progrider42
स्रोत
1

अजगर, १ ९

c*4sm<sm^OQ2 2*QQQQ

इनपुट के रूप में पुनरावृत्तियों की वांछित संख्या दें।

प्रदर्शन

चूंकि पायथ में "रैंडम फ्लोटिंग नंबर" फ़ंक्शन नहीं है, इसलिए मुझे सुधार करना पड़ा। कार्यक्रम इनपुट, वर्ग, रकम की तुलना में कम और इनपुट वर्ग की तुलना में दो यादृच्छिक सकारात्मक पूर्णांक चुनते हैं। इसने इनपुट के बराबर कई बार प्रदर्शन किया, फिर परिणाम 4 से गुणा किया गया और इनपुट द्वारा विभाजित किया गया।

संबंधित समाचार में, मैं शीघ्र ही Pyth में एक रैंडम फ्लोटिंग पॉइंट नंबर ऑपरेशन जोड़ूंगा। हालाँकि यह प्रोग्राम उस सुविधा का उपयोग नहीं करता है।

यदि हम व्याख्या करते हैं "परिणाम लौटाया जा सकता है या एक अस्थायी बिंदु, निश्चित बिंदु या तर्कसंगत संख्या के रूप में मुद्रित किया जा सकता है।" उदारतापूर्वक, फिर अंश के हर और भाजक को प्रिंट करना पर्याप्त होना चाहिए। उस स्तिथि में:

अजगर, १,

*4sm<sm^OQ2 2*QQQQ

यह एक समान कार्यक्रम है, जिसमें फ्लोटिंग पॉइंट डिवीजन ऑपरेशन ( c) हटा दिया गया है।

— isaacg
स्रोत
1

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

4mean(1-floor(sum(rand(4^8,2).^2,2)))

नमूनों की संख्या 65536 (= 4 ^ 8) है।

sकेवल एक तर्क के रूप में नमूनों की संख्या के साथ एक फ़ंक्शन :

s->4mean(1-floor(sum(rand(s,2).^2,2)))
— pawel.boczarski
स्रोत
1

सी, 130 बाइट्स

#include<stdlib.h>f(){double x,y,c=0;for(int i=0;i<8e6;++i)x=rand(),y=rand(),c+=x*x+y*y<1.0*RAND_MAX*RAND_MAX;printf("%f",c/2e6);}

Ungolfed:

#include <stdlib.h>
f(){
 double x,y,c=0;
 for(int i=0; i<8e6; ++i) x=rand(), y=rand(), c+=x*x+y*y<1.0*RAND_MAX*RAND_MAX;
 printf("%f",c/2e6);
}
— कार्ल नेफ
स्रोत
बेशक, आपको अभी भी व्हॉट्सएप के बिना संस्करण को पोस्ट करना चाहिए (वर्तमान संस्करण को हेडर के साथ "अनगुल्फेड / व्हॉट्सएप के साथ" या कुछ और रखें)
— विनाशकारी नींबू
@DestructibleWatermelon किया!
— कार्ल नेफ
समाधान एक नई लाइन के बिना जीसीसी में काम नहीं करता है f()। आपने किस कंपाइलर का उपयोग किया? Tio.run/##Pc49C4JAHIDx3U9xGMG9ZdYgwWkgtNbQ1BZ6L/UHO8M07hA/……
— eush774
— सीलिंगकैट
1

दरअसल , 14 बाइट्स (गैर-प्रतिस्पर्धात्मक)

`G²G²+1>`nkæ4*

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

यह समाधान गैर-प्रतिस्पर्धात्मक है क्योंकि भाषा चुनौती का सामना करती है। नमूनों की संख्या इनपुट (हार्ड-कोडेड के बजाय) के रूप में दी गई है।

स्पष्टीकरण:

`G²G²+1>`nkæ4*
`G²G²+1>`n      do the following N times:
 G²G²+            rand()**2 + rand()**2
      1>          is 1 greater?
          kæ    mean of results
            4*  multiply by 4
— मै जाऊं
स्रोत
2
क्यों होता है पतन?
— विनाशकारी नींबू
1

रैकेट 63 बाइट्स

@Matt द्वारा R भाषा उत्तर की विधि का उपयोग करना: 

(/(for/sum((i n))(define a(/(random 11)10))(/ 4(+ 1(* a a))))n)

Ungolfed:

(define(f n)
   (/
    (for/sum ((i n))
      (define a (/(random 11)10))
      (/ 4(+ 1(* a a))))
    n))

परिक्षण: 

(f 10000)

आउटपुट (अंश): 

3 31491308966059784/243801776017028125

दशमलव के रूप में: 

(exact->inexact(f 10000))

3.13583200307849
— rnso
स्रोत
1

फोरट्रान (GFortran) , 84 83 बाइट्स

CALL SRAND(0)
DO I=1,4E3
X=RAND()
Y=RAND()
IF(X*X+Y*Y<1)A=A+1E-3
ENDDO
PRINT*,A
END

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

यह कोड बहुत बुरा लिखा गया है। यह विफल हो जाएगा अगर gfortran चर को शुरू करने का फैसला करता हैA अन्य मूल्य के साथ तो 0 (जो संकलन का 50% होता है, लगभग) और, यदि A0 के रूप में आरंभ किया जाता है , तो यह हमेशा दिए गए बीज के लिए एक ही यादृच्छिक अनुक्रम उत्पन्न करेगा। फिर, पाई के लिए समान मूल्य हमेशा मुद्रित होता है।

यह एक बेहतर कार्यक्रम है:

फोरट्रान (GFortran) , 100 99 बाइट्स

A=0
DO I=1,4E3
CALL RANDOM_NUMBER(X)
CALL RANDOM_NUMBER(Y)
IF(X*X+Y*Y<1)A=A+1E-3
ENDDO
PRINT*,A
END

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

(प्रत्येक संस्करण में एक बाइट बचा; धन्यवाद पेंगुइन)।

— rafa11111
स्रोत
1
प्रत्येक संस्करण में आप 'DO I = 1,1E3' को 'DO I = 1,4E3' में बदलकर, 'A = A + 1' को 'A = A + 1E-3' में बदलकर और बदलते हुए बाइट को बचा सकते हैं। PRINT *, A / 250 'से' PRINT *, A '
— पेंगुइन
हाँ, आप निश्चित हैं! सुझाव के लिए धन्यवाद!
— rafa11111
1

जाप , 26 या 18 बाइट्स

o r_+ÂMhMr p +Mr p <1Ã*4/U

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

ऑप्टिमाइज़र के जवाब के अनुरूप , मुख्य रूप से सिर्फ जाप सीखने की कोशिश करना।
निहित इनपुट के रूप में चलाने के लिए पुनरावृत्तियों की संख्या लेता है U।

o                           Take the input and turn it into a range [0, U),
                            essentially a cheap way to get a large array.
  r_                        Reduce it with the default initial value of 0.
    +Â                      On each iteration, add one if
      MhMr p +Mr p          the hypotenuse of a random [0,1)x[0,1) right triangle
                   <1       is smaller than one.
                     Ã*4/U  Multiply the whole result by four and divide by input.

यदि 1/(1+x^2)अनुमति दी जाती है (दो अलग-अलग रैंडम के बजाय), तो हम एक ही तर्क के साथ 18 बाइट्स प्राप्त कर सकते हैं।

o r_Ä/(1+Mr pÃ*4/U
— लीख
स्रोत
1
आप खुद को करने के Mhबजाय कर्ण की गणना करके कुछ बाइट्स बचा सकते हैं xo x@MhMr Mr)<1Ã*4/U
— ;; साथ
@ETHproductions नीट, मुझे नहीं पता था कि आप इस Mhतरह का उपयोग कर सकते हैं , धन्यवाद! आपका दो-यादृच्छिक उत्तर लगभग केवल एक यादृच्छिक के साथ मेरे उत्तर के रूप में छोटा है, यह बहुत अच्छा है। मैं ध्यान xमें रखूंगा, मैं गोल्फ सामान की कोशिश करते समय बहुत कमी का उपयोग करता हूं, इसलिए यह बहुत काम आएगा।
— लीख
1

एफ #, 149 बाइट्स

open System;
let r=new Random()
let q()=
 let b=r.NextDouble()
 b*b
let m(s:float)=(s-Seq.sumBy(fun x->q()+q()|>Math.Sqrt|>Math.Floor)[1.0..s])*4.0/s

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

जहां तक ​​मैं बाहर कर सकता हूं, एफ # में इस तरह की कुल दौड़ करने के लिए संख्याओं की एक सरणी बनाने और ब्लॉक का Seq.sumByउपयोग करने की तुलना में विधि का उपयोग करने के लिए कम है for..to..do।

यह कोड क्या करता है कि यह 1 से फ्लोटिंग-पॉइंट संख्याओं का संग्रह बनाता है, संग्रह में तत्वों की संख्या के लिए sफ़ंक्शन करता है fun x->..., और परिणाम को नामांकित करता है। sसंग्रह में तत्व हैं , इसलिए यादृच्छिक परीक्षण कई sबार किया जाता है। संग्रह में वास्तविक संख्याओं को अनदेखा किया गया है ( fun x->, लेकिनx किया जाता है इसका उपयोग नहीं किया जाता है)।

इसका यह भी अर्थ है कि एप्लिकेशन को पहले सरणी बनाना और भरना है, और फिर उस पर पुनरावृति करना है। तो यह शायद एक के रूप में दो बार धीमी हैfor..to..do लूप की । और सरणी निर्माण मेमोरी के उपयोग के साथ O (f ** k) के क्षेत्र में है!

वास्तविक परीक्षण के लिए, if then elseयह कथन का उपयोग करने के बजाय यह दूरी ( q()+q()|>Math.Sqrt) की गणना करता है और इसके साथ चक्कर लगाता है Math.Floor। यदि दूरी सर्कल के भीतर है, तो इसे 0. पर गोल किया जाएगा। यदि दूरी सर्कल के बाहर है, तो यह 1. के नीचे गोल हो जाएगा।Seq.sumBy जाएगा विधि फिर इन परिणामों को कुल करेगी।

फिर ध्यान दें कि जो Seq.sumByकुल मिला है वह सर्कल के अंदर के बिंदु नहीं हैं , बल्कि इसके बाहर के बिंदु हैं। तो परिणाम के लिए यह लेता हैs (हमारा नमूना आकार) और इससे कुल घटाता है।

यह भी प्रतीत होता है कि पैरामीटर के रूप में एक नमूना आकार लेना, हार्ड-कोडिंग मूल्य से कम है। इसलिए मैं थोड़ा धोखा दे रहा हूं ...

— Ciaran_McCarthy
स्रोत
1

हास्केल, 116 114 110 96 बाइट्स

d=8^9
g[a,b]=sum[4|a*a+b*b<d*d]
p n=(sum.take(floor n)$g<$>iterate((\x->mod(9*x+1)d)<$>)[0,6])/n

क्योंकि import System.Random; r=randoms(mkStdGen 2)बहुत से अनमोल बाइट्स लेने से निपटने के लिए, मैं यादृच्छिक बधाई जनरेटर के साथ यादृच्छिक संख्याओं की एक अनंत सूची उत्पन्न करता हूं जो कुछ कहते हैं कि लगभग क्रिप्टोग्राफिक रूप से मजबूत है: x↦x*9+1 mod 8^9जो कि हल-डोबेल प्रमेय की पूरी अवधि है 8^9।

g4यदि यादृच्छिक संख्या के जोड़ के लिए यादृच्छिक संख्या बिंदु वृत्त के अंदर है तो पैदावार होती है [0..8^9-1]क्योंकि यह उपयोग किए गए सूत्र में गुणा को समाप्त करता है।

उपयोग:

> p 100000
3.14208

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

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