श्रृंखला के बारे में

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

हालांकि मेरे पास श्रृंखला के लिए विचारों का एक समूह है, लेकिन भविष्य की चुनौतियां अभी तक पत्थर में सेट नहीं हैं। यदि आपके कोई सुझाव हैं, तो कृपया मुझे संबंधित सैंडबॉक्स पोस्ट पर बताएं ।

छेद 2: एक सामान्य वितरण से संख्या

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

आपको दो गैर-नकारात्मक पूर्णांक इनपुट के रूप में लेने चाहिए : एक बीज Sऔर Nलौटने के लिए संख्याओं की मात्रा । आउटपुट Nफ्लोटिंग पॉइंट नंबरों की एक सूची होनी चाहिए , जो सामान्य 0 से वितरण और माध्य 1 से भिन्न है । जब भी आपके सबमिशन को एक ही बीज दिया जाता है तो उसे एक Sही नंबर का उत्पादन करना चाहिए। विशेष रूप से, अगर इसे एक बार साथ और एक बार साथ बुलाया जाता है, तो दो आउटपुट की पहली प्रविष्टियाँ समान होनी चाहिए। इसके अलावा, कम से कम 2 ¹⁶ विभिन्न मूल्यों को अलग-अलग अनुक्रम का उत्पादन करना चाहिए।(S, N₁)(S, N₂)min(N₁, N₂)S
आप किसी भी अंतर्निहित यादृच्छिक संख्या जनरेटर का उपयोग कर सकते हैं जिसे एक (लगभग) समान वितरण से संख्या खींचने के लिए प्रलेखित किया गया है , बशर्ते आप उस Sपर से गुजर सकते हैं और यह कम से कम 2 ¹⁶ विभिन्न बीजों का समर्थन करता है । यदि आप करते हैं, तो RNG आपके द्वारा अनुरोधित किसी भी संख्या के लिए कम से कम 2 ²⁰ विभिन्न मानों को वापस करने में सक्षम होना चाहिए ।
यदि आपकी उपलब्ध यूनिफ़ॉर्म RNG में एक छोटी रेंज है, तो यह संभव नहीं है, या बहुत कम बीजों का समर्थन करता है, तो आपको पहले बिल्ट-इन के शीर्ष पर पर्याप्त रूप से बड़ी रेंज के साथ एक समान RNG का निर्माण करना होगा या आपको अपने उपयुक्त RNG का उपयोग करना होगा। बीज। यह पृष्ठ उसके लिए सहायक हो सकता है।
यदि आप सामान्य वितरण उत्पन्न करने के लिए एक स्थापित एल्गोरिथ्म को लागू नहीं करते हैं, तो कृपया शुद्धता का प्रमाण शामिल करें। किसी भी स्थिति में, आपके द्वारा चुना गया एल्गोरिथम एक सैद्धांतिक रूप से सटीक सामान्य वितरण (अंतर्निहित PRNG या सीमित-सटीक डेटा डेटा की सीमाओं को सीमित करता है) प्राप्त करना चाहिए।
आपके कार्यान्वयन को फ्लोटिंग-पॉइंट नंबर (कम से कम 32 बिट्स वाइड) या फिक्स्ड-पॉइंट नंबर (कम से कम 24 बिट्स वाइड) का उपयोग करना चाहिए और सभी अंकगणित ऑपरेशनों को चुने हुए प्रकार की पूरी चौड़ाई का उपयोग करना चाहिए।
आपको सामान्य वितरण या गाऊसी अभिन्न से संबंधित किसी भी अंतर्निहित कार्यों का उपयोग नहीं करना चाहिए, जैसे त्रुटि फ़ंक्शन या इसका उलटा।

आप एक पूर्ण कार्यक्रम या फ़ंक्शन लिख सकते हैं और एसटीडीआईएन, कमांड-लाइन तर्क, फ़ंक्शन तर्क या प्रॉम्प्ट के माध्यम से इनपुट ले सकते हैं और रिटर्न वैल्यू के माध्यम से या एसटीडीयूएसटी (या निकटतम विकल्प) पर प्रिंट करके उत्पादन कर सकते हैं।

Sऔर Nगैर-नकारात्मक पूर्णांक होंगे, प्रत्येक 2 से कम ²⁰ । आउटपुट किसी भी सुविधाजनक, अस्पष्ट सूची या स्ट्रिंग प्रारूप में हो सकता है।

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

लीडरबोर्ड

श्रृंखला की पहली पोस्ट एक लीडरबोर्ड उत्पन्न करती है।

यह सुनिश्चित करने के लिए कि आपके उत्तर दिखाई दे रहे हैं, कृपया प्रत्येक मार्कलाइन के साथ निम्नलिखित मार्केड टेम्प्लेट का उपयोग करके प्रत्येक उत्तर को शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

(भाषा को वर्तमान में नहीं दिखाया गया है, लेकिन स्निपेट की आवश्यकता होती है और इसे पार्स किया जाता है, और मैं भविष्य में एक उप-भाषा लीडरबोर्ड जोड़ सकता हूं।)

code-golf number random

— मार्टिन एंडर
स्रोत

रुको, क्या हमें गैर-पूर्णांक-श्रेणी RNG का उपयोग करने की अनुमति है?

— मनिीप

PS 2 मौजूदा उत्तर [0, 1) फ्लोटिंग पॉइंट RNG का उपयोग करते हैं, क्या इसकी अनुमति है?

— मनिीप

@mniip हां, फ्लोटिंग-पॉइंट RNG की अनुमति है, बशर्ते कि वे एक समान, बीज योग्य हों और अलग-अलग फ़्लोट की आवश्यक संख्या को वापस करने में सक्षम हों।

— मार्टिन एंडर

8

दिल्लोग एपीएल, 33 बाइट्स

{(.5*⍨¯2×⍟?0)×1○○2×?0}¨⍳⎕⊣⎕rl←1+⎕

बॉक्स-मुलर :

⎕         ⍝ evaluated input
⎕rl←1+⎕   ⍝ set APL's random seed to 1+⎕ (S)
          ⍝   add 1 because ⎕rl←0 has special meaning: sets the seed randomly
{ }¨⍳N    ⍝ do the thing in braces N times
?0        ⍝ random number 0≤x<1
1○○2×A    ⍝ sin(2πA)
.5*⍨¯2×⍟B ⍝ sqrt(-2lnB)

— NGN
स्रोत

मुझे पूरा यकीन है कि यह किसी अन्य भाषा से नहीं पिट सकता।

— शून्य फाइबर

2

यह इस नियम को पूरा नहीं करता है: "विशेष रूप से, अगर इसे एक बार (S, N1) और एक बार (S, N2) के साथ कहा जाता है, तो दो आउटपुट की पहली न्यूनतम (N1, N2) प्रविष्टियां समान होनी चाहिए।"

— मेरिनस

@marinus धन्यवाद, निश्चित। मैं भी बदल ⎕rlगया S+1क्योंकि ⎕rl←0विशेष अर्थ है।

— ngn

आपको शायद वास्तव में इसकी आवश्यकता नहीं है +1, सभी कहते हैं कि आपको कम से कम 2 ^ 16 विभिन्न मूल्यों का समर्थन करने की आवश्यकता है। इसलिए [1..2 ^ 16] रेंज में सही तरीके से काम करना ठीक होना चाहिए।

— Marinus

S = 0 गणना को दोहराए जाने योग्य नहीं बनाता है, जो आपके द्वारा ऊपर उद्धृत नियम का उल्लंघन करता है।

— NGN

8

आर, 68 बाइट्स

function(S,N){set.seed(S);sqrt(-2*log(runif(N)))*cos(2*pi*runif(N))}

यह runif()फ़ंक्शन का उपयोग करता है , जो एक समान वितरण से यादृच्छिक विचलन उत्पन्न करता है। यादृच्छिक संख्या पीढ़ी के लिए बीज का उपयोग करके निर्दिष्ट set.seed()किया गया है, जो डिफ़ॉल्ट रूप से 2 ^ 19937-1 की अवधि के साथ मेर्सेन-ट्विस्टर एल्गोरिथ्म का उपयोग करता है।

परिणाम एक आर वेक्टर की लंबाई है जिसमें कम्प्यूटेड मानक सामान्य विचलन होते हैं।

यह बॉक्स-मुलर विधि का उपयोग करता है: दो स्वतंत्र वर्दी यादृच्छिक चर यू और वी के लिए, यहाँ छवि विवरण दर्ज करें

— एलेक्स ए।
स्रोत

यदि R में मान्य सिंटैक्स है, तो आप f=फ़ंक्शन को छोड़ सकते हैं (फ़ंक्शन को नाम देने की आवश्यकता नहीं है, अगर अनाम फ़ंक्शन आपकी भाषा में एक चीज़ हैं)।

— मार्टिन एंडर

@ मार्टिनबटनर: मैं सुझाव की सराहना करता हूं, लेकिन मेरी जानकारी के अनुसार R को यह नहीं पता होगा कि एक अनाम फ़ंक्शन के साथ क्या करना है।

— एलेक्स ए।

मैं हमेशा एक त्रुटि संदेश मिलता Error: unexpected '}' in "f=fu...अलावा, क्या आप वाकई प्राप्त कर रहे हैं एक ही पहले नंबर अगर आप फोन f(0,1)और f(0,2)?

— दोष

4

दिल्लोग एपीएल, ४२ ३४

{⎕RL←⍺⋄{(.5*⍨¯2×⍟⍺)×1○⍵×○2}/?⍵2⍴0}

यह एक ऐसा फंक्शन है जो Sइसके लेफ्ट लॉजिक के Nरूप में और राइट राईट के रूप में लेता है।

     5{⎕RL←⍺⋄{(.5*⍨¯2×⍟⍺)×1○⍵×○2}/?⍵2⍴0}10
3.019132549 ¯0.2903143175 ¯0.7353414637 1.421417015 2.327544764 ¯0.00005019747711 ¯0.9582127248 ¯0.2764568462
      ¯0.1602736853 ¯0.9912352616
     5{⎕RL←⍺⋄{(.5*⍨¯2×⍟⍺)×1○⍵×○2}/?⍵2⍴0}20
3.019132549 ¯0.2903143175 ¯0.7353414637 1.421417015 2.327544764 ¯0.00005019747711 ¯0.9582127248 ¯0.2764568462
      ¯0.1602736853 ¯0.9912352616 0.642585109 ¯0.2450019151 ¯0.415034463 0.03481768503 ¯0.4621212815 ¯0.760925979
      0.2592913013 1.884867889 ¯0.9621252731 0.3062560446

यह Dyalog APL के बिल्ट-इन रैंडम ऑपरेटर का उपयोग करके बॉक्स-मुलर ट्रांसफॉर्मेशन का कार्यान्वयन है ?, जो डिफ़ॉल्ट रूप से एक Mersenne ट्विस्टर है जो 64-बिट मान देता है, जो पर्याप्त होना चाहिए।

स्पष्टीकरण:

⎕RL←⍺: यादृच्छिक बीज को सेट करें ⍺।
?⍵2⍴0: ⍵0 और 1 के बीच यादृच्छिक संख्याओं के जोड़े उत्पन्न करते हैं ।
{... }/: प्रत्येक जोड़े के लिए निम्नलिखित फ़ंक्शन लागू करें:
- (.5*⍨¯2×⍟⍺)×1○⍵×○2: Z0मान की गणना करें ( sqrt(-2 ln ⍺)×cos(2π⍵))।

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

1

V14.0 में ?0रिटर्न 0 और 1. जो चल बिन्दु संख्या

— NGN

3

पर्ल, 67

sub f{srand$_[0];map{cos(atan2(1,1)*rand 8)*sqrt-2*log rand}1..pop}

अन्य प्रविष्टियों के रूप में बॉक्स-मुलर। fक्रम में पैरामीटर लेता है S, N।

उपयोग:

$ perl -le 'sub f{srand$_[0];map{cos(atan2(1,1)*rand 8)*sqrt-2*log rand}1..pop}print for f(5,3)'
-1.59212831801942
0.432167710756345
-0.533673305924252

— nutki
स्रोत

3

जावा, 164 161 बाइट्स

class B extends java.util.Random{B(int s,int n){super(s);for(;n-->0;System.out.println(Math.sqrt(-2*Math.log(nextDouble()))*Math.cos(2*Math.PI*nextDouble())));}}

यह फ़ंक्शन और आउटपुट के माध्यम से stdout के माध्यम से इनपुट में लेता है। यह बॉक्स-मुलर विधि का उपयोग करता है।

— नंबर एक
स्रोत

5

s=0;s++<n;-> ;n-->0;?

— फोब्र्स

1

@Geobits एक मेमने की तरह दिखता है: D

— TheNumberOne

3

कमोडोर 64 बेसिक, 76 70 63 बाइट्स

1INPUTS,N:S=R/(-S):F┌I=1TON:?S●(-2*LOG(R/(1)))*S╮(2*π*R/(1)):N─

चूंकि PETSCII चरित्र सेट में यूनिकोड में मौजूद कुछ प्रतीक नहीं हैं, इसलिए मैंने प्रतिस्थापन बनाये हैं: /= SHIFT+N, ┌= SHIFT+O, ●= SHIFT+Q, ╮= SHIFT+I, ─= =SHIFT+E

यह मानक बॉक्स-मुलर को संख्याओं को उत्पन्न करने के लिए रूपांतरित करता है; मैंने ट्रांसफ़ॉर्म का पाप (x) आधा उठाया क्योंकि कमोडोर 64 बेसिक के लिए दो-चरित्र शॉर्टकट है sin(), लेकिन इसके लिए नहीं cos()।

हालाँकि, मैनुअल बताता है कि, तर्क करने का मान RND मायने रखता है: यदि कोई ऋणात्मक संख्या पारित हो जाती है, तो यादृच्छिक संख्या जनरेटर को केवल पुनः अंकुरित नहीं किया जाता है, यह उस संख्या के साथ फिर से बीजित होता है । यह सीडिंग को अधिक सरल बनाता है: POKEपांच मेमोरी स्थानों की आवश्यकता के बजाय , मुझे केवल एक कॉल-टू-नॉट कॉल करने की आवश्यकता है RND, जो कोड को दो लाइनों / 121 बाइट्स से 1 पंक्ति / 76 बाइट्स तक कम कर देता है।

संपादित करें: छह बाइट्स को यह महसूस करके बंद कर दिया कि मैं दो INPUTबयानों को जोड़ सकता हूं , और इसके बाद TOका स्थान वैकल्पिक था।

संपादित करें: एक और सात को बंद कर दिया: कमोडोर बेसिक करता है, वास्तव में, पीआई एक अंतर्निहित निरंतर के रूप में है, और यह एक आधुनिक कीबोर्ड पर भी टाइप करने योग्य है ( SHIFT+PgDnयदि आप सोच रहे थे)।

— निशान
स्रोत

3

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

कोड के Hexdump:

60 8b 7c 24 24 33 ed 8d 75 fb 8d 46 79 f7 e2 f7
f6 8b da b3 7f 0f cb d1 eb 89 1f d9 07 d9 e8 de
e9 33 ee 75 e5 d9 ed d9 c9 d9 f1 dc c0 d9 e0 d9
fa d9 c9 d9 eb de c9 dc c0 d9 ff de c9 d9 1f 83
c7 04 e2 c6 61 c2 04 00

यहाँ स्रोत कोड है (विजुअल स्टूडियो द्वारा संकलित किया जा सकता है):

__declspec(naked) void __fastcall doit(int count, unsigned seed, float* output)
{
    _asm {
                                // ecx = count
                                // edx = seed
        // save registers
        pushad;
        mov edi, [esp + 0x24];  // edi = pointer to output
        xor ebp, ebp;           // ebp = 0
        lea esi, [ebp - 5];     // esi = 4294967291 (a prime number)

    myloop:
        // Calculate the next random number
        lea eax, [esi + 121];   // eax = 116
        mul edx;
        div esi;
        mov ebx, edx;

        // Convert it to a float in the range 1...2
        mov bl, 0x7f;
        bswap ebx;
        shr ebx, 1;

        // Convert to range 0...1 and push onto the FPU stack
        mov [edi], ebx;
        fld dword ptr [edi];
        fld1;
        fsubp st(1), st;

        // Make 2 such random numbers
        xor ebp, esi;
        jnz myloop;

        // Calculate sqrt(-2*ln(x))
        fldln2;
        fxch;
        fyl2x;
        fadd st, st(0);
        fchs;
        fsqrt;

        // Calculate cos(2*pi*y)
        fxch st(1);
        fldpi;
        fmul;
        fadd st, st(0);
        fcos;

        // Calculate and write output
        fmulp st(1), st;
        fstp dword ptr [edi];
        add edi, 4;

        // Repeat
        loop myloop

        // Return
        popad;
        ret 4;
    }
}

यहाँ मैं एक लेहमर यादृच्छिक संख्या जनरेटर का उपयोग करता हूं । यह निम्नलिखित एल्गोरिथ्म का उपयोग करता है:

x(k+1) = 116 * x(k) mod 4294967291

यहाँ 4294967291 एक बड़ी (2 ^ 32-5) अभाज्य संख्या है, और 116 एक छोटी (128 से कम; नीचे देखें) संख्या है जो इसकी आदिम जड़ है । मैंने एक आदिम जड़ को चुना जिसमें बाइनरी प्रतिनिधित्व (01110100) में शून्य और लोगों का अधिक या कम यादृच्छिक वितरण है। यह RNG 4294967290 की अधिकतम संभव अवधि है, अगर बीज नॉनजरो है।

अपेक्षाकृत छोटी संख्याएँ जो मैंने यहाँ इस्तेमाल की हैं (११६ और ४२ ९ ४1६ ,२ ९ १, जिसे -5 के रूप में भी दर्शाया जा सकता है) मुझे leaनिर्देश एन्कोडिंग का लाभ उठाने दें :

8d 46 79     lea eax, [esi+121]

यदि संख्या 1 बाइट में फिट हो सकती है, तो इसे 3 बाइट्स में इकट्ठा किया जाता है।

गुणन और विभाजन का उपयोग edxऔर eaxउनके कामकाजी रजिस्टरों के रूप में, यही वजह है कि मैंने seedफ़ंक्शन के लिए दूसरा पैरामीटर बनाया ( fastcallकन्वेंशन का उपयोग edxदूसरे पैरामीटर को पारित करने के लिए कॉल करता है)। इसके अलावा, पहला पैरामीटर पास किया गया है ecx, जो एक काउंटर रखने के लिए एक अच्छी जगह है: 1 निर्देश में एक लूप आयोजित किया जा सकता है!

e2 c6        loop myloop

एक पूर्णांक को फ्लोटिंग-पॉइंट संख्या में बदलने के लिए, मैंने एकल-सटीक फ़्लोटिंग-पॉइंट संख्याओं के प्रतिनिधित्व का शोषण किया: यदि मैंने उच्च 9 बिट्स (एक्सपोनेंट) को बिट पैटर्न पर सेट किया है 001111111, और 23 कम बिट्स को यादृच्छिक रूप से छोड़ देता हूं, तो मैं श्रेणी 1 ... 2 में एक यादृच्छिक संख्या प्राप्त करें। मैंने यहां से विचार लिया । उच्च 9 बिट्स सेट करने के लिए, मैंने कुछ बिट-फ़िडलिंग का उपयोग किया ebx:

mov ebx, edx;    xxxxxxxx|yyyyyyyy|zzzzzzzz|aaaaaaaa
mov bl, 0x7f;    xxxxxxxx|yyyyyyyy|zzzzzzzz|01111111
bswap ebx;       01111111|zzzzzzzz|yyyyyyyy|xxxxxxxx
shr ebx, 1;      00111111|1zzzzzzz|zyyyyyyy|yxxxxxxx

दो यादृच्छिक संख्याएँ उत्पन्न करने के लिए, मैंने 2 पुनरावृत्तियों के नेस्टेड लूप का उपयोग किया। मैंने इसका आयोजन किया xor:

xor ebp, esi;    first time, the result is -5
jnz myloop;      second time, the result is 0 - exit loop

फ्लोटिंग-पॉइंट कोड बॉक्स-मुलर ट्रांसफॉर्म को लागू करता है ।

— anatolyg
स्रोत

2

हास्केल, ११, १४४

import System.Random;h z=let(u,r)=random z in(cos$2*pi*fst(random r)::Float)*sqrt(-2*log u):h r;g=(.(h.mkStdGen)).take

उदाहरण का उपयोग:

*Main> g 3 0x6AE4A92CAFA8A742
[0.50378895,-0.20593005,-0.16684927]
*Main> g 6 0x6AE4A92CAFA8A742
[0.50378895,-0.20593005,-0.16684927,1.1229043,-0.10026576,0.4279402]
*Main> g 6 0xE09B1088DF461F7D
[2.5723906,-0.5177805,-1.3535261,0.7400385,3.5619608e-3,-8.246434e-2]

वापसी का प्रकार randomविवश है Float, जो random[0, 1) में एक समान फ्लोट उत्पन्न करता है। तब से यह सूची पीढ़ी के लिए कुछ व्यर्थ जादू के साथ एक simlpe बॉक्स-मुलर फार्मूला है।

— mniip
स्रोत

2

Golflua, 63 70

Golflua जानकारी और निर्देश।

\g(n,s)`_ENV,b=M,{}rs(s)~@i=1,n b[i]=q(l(r()^-2))*c(r()*pi)$~b$

मानों वाली तालिका देता है। उदाहरण में मैं उपयोग कर रहा हूं ~T.u( ), जो कि return table.unpack( )लुआ के समान है ।

> ~T.u(g(3,1234567))
0.89302672974232 0.36330401643578 -0.64762161593981
> ~T.u(g(5,1234567))
0.89302672974232 0.36330401643578 -0.64762161593981 -0.70654636393063 -0.65662878785425
> ~T.u(g(5,7654321))
0.3867923683064 -0.31758512485963 -0.58059120409317 1.2079459300077 1.1500121921242

फ़ंक्शन के वातावरण M(aka math) को सेट करके बहुत से वर्ण सहेजे गए थे ।

— mniip
स्रोत

2

एसएएस, 108

मैंने पहले से ही आर में एक उत्तर पोस्ट किया है जो इससे कम है, लेकिन पीपीसीजी पर बहुत कम एसएएस उत्तर हैं, इसलिए दूसरे को क्यों नहीं जोड़ा जाए?

%macro f(s,n);data;do i=1 to &n;x=sqrt(-2*log(ranuni(&s)))*cos(8*atan2(1,1)*ranuni(&s));put x;end;run;%mend;

कुछ सफेद स्थान के साथ:

%macro f(s, n);
    data;
        do i = 1 to &n;
            x = sqrt(-2 * log(ranuni(&s))) * cos(8 * atan2(1, 1) * ranuni(&s));
            put x;
        end;
    run;
%mend;

यह एक मैक्रो को परिभाषित करता है जिसे पसंद किया जा सकता है %f(5, 3)। मैक्रो एक डेटा चरण को निष्पादित करता है जो पूर्णांक 1 से एन तक लूप करता है, और प्रत्येक पुनरावृत्ति पर यह बॉक्स-मुलर का उपयोग करके एक यादृच्छिक सामान्य विचलन की गणना करता है और इसे putस्टेटमेंट का उपयोग करके लॉग में प्रिंट करता है ।

एसएएस में पीआई के लिए कोई बिल्ट-इन नहीं है, इसलिए हम जो सबसे अच्छा कर सकते हैं, वह इसे आर्कटिक के साथ अनुमानित करता है।

ranuni()समारोह (जिसका बहिष्कार लेकिन एक जोड़ी नए समारोह की तुलना में कम वर्ण की आवश्यकता है) एक समान वितरण से एक यादृच्छिक संख्या देता है। SAS दस्तावेज़ीकरण RNG कार्यान्वयन पर संपूर्ण विवरण नहीं देता है, इसके अलावा इसकी अवधि 2 ^ 31-2 है।

एसएएस मैक्रोज़ में, मैक्रो वैरिएबल को पूर्ववर्ती के साथ संदर्भित किया जाता है &और रन टाइम पर उनके मानों को हल करने के लिए।

जैसा कि आपने शायद देखा है, एसएएस एक कोड-गोल्फ प्रतियोगिता में शायद ही कभी वास्तविक दावेदार होता है ।

— एलेक्स ए।
स्रोत

2

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

हालांकि यह वर्तमान जावा लीडर को हराता नहीं है, मैंने गणना की एक अलग विधि दिखाने के लिए वैसे भी पोस्ट करने का निर्णय लिया। यह OpenJDK का एक गोल्फ संस्करण है nextGaussian()।

class N extends java.util.Random{N(int s,int n){super(s);for(float a,v;n-->0;System.out.println(v*Math.sqrt(-2*Math.log(a)/a)))for(a=0;a>=1|a==0;a=v*v+(v=2*nextFloat()-1)*v)v=2*nextFloat()-1;}}

लाइन ब्रेक के साथ:

class N extends java.util.Random{
    N(int s,int n){
        super(s);
        for(float a,v;
            n-->0;
            System.out.println(v*Math.sqrt(-2*Math.log(a)/a)))
                for(a=0;
                    a>=1|a==0;
                    a=v*v+(v=2*nextFloat()-1)*v)v=2*nextFloat()-1;
    }
}

— Geobits
स्रोत

2

मार्साग्लिया का उपयोग करने के लिए +1 (या सीधे-सीधे बॉक्स-मुलर का उपयोग नहीं करने के लिए);)

— मार्टिन एंडर

क्या यह मेमना नहीं हो सकता? कुछ इस तरह:

(s,n)->{java.util.Random r=new java.util.Random(s);for(float a,v;n-->0;System.out.println(v*Math.sqrt(-2*Math.log(a)/a)))for(a=0;a>=1|a==0;a=v*v+(v=2*r.nextFloat()-1)*v)v=2*r.nextFloat()-1;}

— जस्टिन

2

@Quincunx मैं, एक बाइट के लिए कर सकता था। लेकिन मैं अपने फंक्शन की घोषणाओं को अनकाउंटेड कोड में छिपाना पसंद नहीं करता, इसके बारे में मेटा पर वर्तमान सहमति जो भी हो। यह मेरे लिए एक बाइट के लायक है;)

— 2

2

टी-एसक्यूएल, 155 बाइट्स

CREATE PROC R(@S BIGINT,@N INT)AS
DECLARE @ INT=0,@K INT=8388607WHILE @<@N
BEGIN
SELECT SQRT(-2*LOG(RAND(@S*@%@K)))*COS(2*PI()*RAND(@S*9*@%@K))SET @+=1
END

EXEC RS, N के साथ प्रयोग करें क्योंकि T-SQL में कोई STD_IN नहीं है जहाँ S और N क्रमशः बीज और N हैं। S "यादृच्छिक" (RAND (बीज) एक बहुत खराब यादृच्छिक संख्या कार्यान्वयन है) दृश्यों का उत्पादन करेगा जब S> 2 ^ 16 (संभवतः उससे पहले, लेकिन मैं इसकी गारंटी नहीं दूंगा)। अब तक के अधिकांश समाधानों की तरह बॉक्स-मुलर का उपयोग करता है। 8388607 2 ^ 23-1 है, जो उम्मीद है कि 2 ^ 20 विभिन्न मूल्यों को उत्पन्न करना चाहिए।

— bmarks
स्रोत

2

पॉवरशेल, 164 बाइट्स

Param($s,$n)$q=2147483647
$a=GET-RANDOM -SETSEED $s
FOR(;$n---gt0;){$a=GET-RANDOM
$b=GET-RANDOM
[math]::SQRT(-2*[math]::LOG($a/$q))*[math]::COS(2*[math]::PI*$b/$q)}

बॉक्स-मुलर के साथ सबसे ज्यादा जवाब। पॉवरशेल के साथ बहुत अनुभवी नहीं हैं, इसलिए किसी भी मदद से गोल्फ की सराहना की जाएगी।

— bmarks
स्रोत

2

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

->n,s{include Math;srand s;n.times{p sqrt(-2*log(rand))*sin(2*rand*PI)}}

इनपुट (लैम्बडा फ़ंक्शन के रूप में):

f.(6, 12353405)

आउटपुट:

-1.1565142460805273
0.9352802655317097
1.3566720571574993
-0.9683973210257978
0.9851210877202192
0.14709635752306677

पुनश्च: मैं जानना चाहूंगा कि क्या इसे आगे बढ़ाया जा सकता है। मैं सिर्फ एक शुरुआत हूं।

— जीरो फाइबर
स्रोत

@ मार्टिनबटनर मुझे लगता है कि मैं इन दिनों बहुत अधिक सी का उपयोग कर रहा हूं। पूरी तरह से भूल गया।

— शून्य फाइबर 14

2

मतलबी, 77

पहला इनपुट होना चाहिए n, दूसरा इनपुट s।

a=input('');
rand('seed',a(2));
for i=1:a;
    (-2*log(rand))^.5*cos(2*pi*rand)
end

— flawr
स्रोत

2

ऑक्टेव, 91 96 88 बाइट्स

function r=n(s,n)rand("seed",s);x=rand(2,n);r=cos(2*pi*x(1,:)).*sqrt(-2*log(x(2,:)));end

या, व्हॉट्सएप के साथ:

function r=n(s,n)
  rand("seed",s);
  x=rand(2,n);
  r=cos(2*pi*x(1,:)).*sqrt(-2*log(x(2,:)));
end

बीज को सामने सेट करें, और बॉक्स-मुलर विधि का उपयोग करें।

NB: ऑक्टेव यादृच्छिक संख्या के सरणियों की पीढ़ी के लिए अनुमति देता है, और इन सरणियों पर मानक संचालन का उपयोग कर सकता है जो सरणी आउटपुट का उत्पादन करते हैं। .*ऑपरेटर दो सरणियों के गुणन तत्व-दर-तत्व परिणाम का उत्पादन होता है।

— dcsohl
स्रोत

मुझे लगता है कि यह शर्तों को पूरा नहीं करता है, अगर आप कॉल करते हैं n(0,1)और n(0,2)आपको अलग-अलग पहले नंबर मिलते हैं, तो क्या आप?

— दोष

बकवास, आप सही हैं। मैंने इसे ठीक कर दिया है, लेकिन इसने मुझे 5 बाइट्स

— दीं

2

पायथ, 32 बाइट्स

नए कार्यों की वजह से सुपर-कोट्स में अब किसी भी पायथन का उपयोग नहीं किया जा रहा है। फिर भी एक और बॉक्स-म्यूलर।

 .xvzVQ*@_y.lOZ2.71 2.ty*3.14OZ1

शुरुआत में वह स्थान महत्वपूर्ण है।

.xvz             Seed RNG with evaluated input
VQ               For N in second input
*                Multiplication
 @       2       Square root
   _y            Times negative 2
    .l )         Natural log
     OZ          Of random float (RNG with zero give [0, 1) float)
 .t       1      Cosine from list of trig functions
  y              Double
   *             Multiplication
    .nZ          Pi from constants list
    OZ           Random Float

ऑनलाइन इंटरप्रेटर में सीडिंग काम नहीं करता है, लेकिन यह स्थानीय संस्करण में ठीक काम करता है। ऑनलाइन दुभाषिया तय हो गया है, इसलिए यहाँ एक पर्मलिंक: पर्मलिंक है

— Maltysen
स्रोत

1

यह Pyth ( .nZ) की एक सुविधा का उपयोग करता है जिसे लागू नहीं किया गया था, जब सवाल पूछा गया था। (यह वास्तव में आज लागू किया गया था।) इसलिए यह उत्तर प्रतियोगिता का हिस्सा नहीं होना चाहिए ( meta.codegolf.stackexchange.com/questions/4867/… )।

— जक्यूब

के, मैं 32

— चार्ट

हाँ, यह बेहतर होगा। आप अभी भी आपको उत्तर के एक अलग भाग में नया समाधान दिखा सकते हैं। लेकिन आपकी प्रतिस्पर्धा का कोड पुराने पायथ के साथ काम करने वाला होना चाहिए।

— जेक्यूब

1

Btw, मुझे नहीं लगता कि 32 समाधान या तो मान्य होना चाहिए। चूंकि यह यादृच्छिक बीज का उपयोग करता है, जो केवल 5 दिन पहले जोड़ा गया था।

— जक्यूब

1

STATA, 85 बाइट्स

di _r(s)_r(n)
set se $s
set ob $n
g a=sqrt(-2*ln(runiform()))*cos(2*runiform()*_pi)
l

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

— bmarks
स्रोत

1

आर, 89 बाइट्स

मुझे पता है कि आर पहले भी हो चुका है, लेकिन मैं बॉक्स-मुलर की तुलना में एक अलग दृष्टिकोण दिखाना चाहता था जिसका उपयोग हर कोई करता है। मेरा समाधान केंद्रीय सीमा प्रमेय का उपयोग करता है ।

f=function(S,N){set.seed(S);a=1000;for(i in(1:N)){print(sqrt(12/a)*(sum(runif(a))-a/2))}}

— मीकल
स्रोत

1

मुझे डर है, केंद्रीय सीमा प्रमेय "आपके द्वारा चुने गए एल्गोरिदम को सैद्धांतिक रूप से सटीक सामान्य वितरण प्राप्त करना चाहिए" को संतुष्ट नहीं करता है। कोई फर्क नहीं पड़ता कि आप कितने समान चर जोड़ते हैं, जब तक कि राशि परिमित है, सामान्य वितरण हमेशा अनुमानित होगा। (हालांकि केंद्रीय सीमा प्रमेय एक अच्छा विचार है, मुझे इसे ठीक से नियमबद्ध करना पड़ा क्योंकि यह स्पष्ट नहीं है aकि आपके कोड में किस मूल्य का उपयोग किया जाना चाहिए जैसे कि परिणाम "उचित" है।)

— मार्टिन एंडर

1

यह एक शॉट के लायक था;)

— मीकल

1

टीआई-बेसिक, 74 बाइट्स

Prompt S,N:S→rand:For(X,1,N:0→A:0→V:0→W:While A≥1 or A=0:2rand-1→V:2rand-1→W:V²+W²→A:End:Disp VW√(Aֿ¹-2log(A:End

1      1111111   11   1111111111111111111     1111   111111   1111111   11111111111111  11    111111111   111

¹वास्तव में उलटा ऑपरेटर है।

— Ypnypn
स्रोत

1

पर्ल, 150 108 107 बाइट्स

यह Marsaglia ध्रुवीय विधि का उपयोग करता है । एफ (एस, एन) के साथ कहा जाता है।

$aकी गणना में असाइनमेंट ले जाया गया $c।

107:

sub f{srand$_[0];map{do{$c=($a=-1+2*rand)**2+(-1+2*rand)**2}until$c<1;print$a*sqrt(-2*log($c)/$c)}1..$_[1]}

हटाए गए अतिरिक्त नंबर संग्रहण और की परिभाषा $b।

108:

sub f{srand$_[0];map{do{$a=-1+2*rand,$c=$a**2+(-1+2*rand)**2}until$c<1;print$a*sqrt(-2*log($c)/$c)}1..$_[1]}

150:

sub f{srand$_[0];map{$h?$h=!print$s:do{do{$a=-1+2*rand,$b=-1+2*rand,$c=$a*$a+$b*$b}until$c<1;$d=sqrt(-2*log($c)/$c);$s=$b*$d;$h=print$a*$d;}}1..$_[1]}

— Bonsaigin
स्रोत

1

स्विफ्ट, 144 142

चतुर कुछ भी नहीं, बस यह देखना कि स्विफ्ट कैसे काम करता है।

import Foundation;func r(s:UInt32,n:Int){srand(s);for i in 0..<n{println(sqrt(-2*log(Double(rand())/0xffffffff))*sin(2*Double(rand())*M_PI))}}

मैं उम्मीद कर रहा था कि मैं (0 ... n) .map {} का उपयोग कर सकता हूं, लेकिन यह संकलक मानचित्र {} को नहीं पहचानता है जब तक कि आप एक पैरामीटर का उपयोग नहीं करते हैं।

— GoatInTheMachine
स्रोत

बेशक...? यह हैforEach कि यदि आप एक वापसी मान नहीं करना चाहते, और मैं बहुत यकीन है कि _ inअनिवार्य है

— ASCII-केवल

/0xffffffffbtw के लिए क्या है

— केवल

1

हास्केल , 97 बाइट्स

import System.Random
h(a:b:c)=sqrt(-2*log a::Float)*cos(2*pi*b):h c
f a=take a.h.randoms.mkStdGen

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

यादृच्छिक संख्याओं की अनंत सूची में बस आपका मूल बॉक्स-मुलर परिवर्तन।

— Angs
स्रोत

1

पायथन 3 , 118 बाइट्स

from random import*
from math import*
def f(s,n):seed(s);return[sqrt(-2*log(random()))*cos(tau*random())for _ in[0]*n]

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

— दाना
स्रोत

0

स्माइलबासिक, 81 बाइट्स

खैर, अब जब मैंने पहले प्रश्न का उत्तर दे दिया है, तो मुझे बाकी सब करना होगा ...

यादृच्छिक संख्या जनरेट कर रहा है सस्ता है, लेकिन RNG बोने का उपयोग करता है सबसे लंबे समय तक , भाषा में निर्मित समारोह RANDOMIZE।

DEF N S,N
RANDOMIZE.,S
FOR I=1TO N?SQR(-2*LOG(RNDF()))*COS(PI()*2*RNDF())NEXT
END

हो सकता है कि सूत्र को अनुकूलित करने का कोई तरीका हो। मैं यह नहीं देखता कि दो RNG कॉल का उपयोग करना कैसे आवश्यक है।

— 12Me21
स्रोत

यह है बॉक्स मुलर परिवर्तन के लिए दो स्वतंत्र नमूने के लिए आवश्यक

— ASCII-केवल

दिन के यादृच्छिक गोल्फ # 2: एक सामान्य वितरण से संख्या

श्रृंखला के बारे में

छेद 2: एक सामान्य वितरण से संख्या

लीडरबोर्ड

दिल्लोग एपीएल, 33 बाइट्स

आर, 68 बाइट्स

दिल्लोग एपीएल, ४२ ३४

पर्ल, 67

जावा, 164 161 बाइट्स

कमोडोर 64 बेसिक, 76 70 63 बाइट्स

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

हास्केल, ११, १४४

Golflua, 63 70

एसएएस, 108

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

टी-एसक्यूएल, 155 बाइट्स

पॉवरशेल, 164 बाइट्स

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

इनपुट (लैम्बडा फ़ंक्शन के रूप में):

आउटपुट:

मतलबी, 77

ऑक्टेव, 91 96 88 बाइट्स

पायथ, 32 बाइट्स

STATA, 85 बाइट्स

आर, 89 बाइट्स

टीआई-बेसिक, 74 बाइट्स

पर्ल, 150 108 107 बाइट्स

स्विफ्ट, 144 142

हास्केल , 97 बाइट्स

पायथन 3 , 118 बाइट्स

स्माइलबासिक, 81 बाइट्स