दिन के यादृच्छिक गोल्फ # 4: बर्ट्रेंड विरोधाभास

Question

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

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

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

छेद 4: बर्ट्रेंड विरोधाभास

बर्ट्रेंड विरोधाभास एक दिलचस्प समस्या यह है, जो पता चलता है एक सर्कल में यादृच्छिक chords उठा chords, उनके मध्य बिन्दुओं और उनके लंबाई के विभिन्न वितरण उपज कर सकते हैं के लिए कैसे अलग अलग तरीकों।

इस चुनौती में आपको "सही" विधि का उपयोग करके यूनिट सर्कल के यादृच्छिक chords उत्पन्न करने वाले हैं, अर्थात एक जो chords का वितरण पैदा करता है जो स्केलिंग और अनुवाद के तहत अपरिवर्तनीय है। लिंक किए गए विकिपीडिया लेख में, "विधि 2" एक ऐसी विधि है।

यहाँ सटीक नियम हैं:

• आपको एक सकारात्मक पूर्णांकN लेना चाहिए जो निर्दिष्ट करता है कि कितने chords को लौटाया जाना चाहिए। आउटपुट को Nकॉर्ड की एक सूची होनी चाहिए , प्रत्येक को यूनिट सर्कल पर दो बिंदुओं के रूप में निर्दिष्ट किया गया है, जो कि रेडियन में उनके ध्रुवीय कोण द्वारा दिए गए हैं।
• आपका कोड दो कोणों में से प्रत्येक के लिए कम से कम 2 ²⁰ विभिन्न मूल्यों को वापस करने में सक्षम होना चाहिए । यदि आपके उपलब्ध आरएनजी में एक छोटी सी सीमा है, तो आपको पहले बिल्ट-इन एक के ऊपर पर्याप्त रूप से बड़ी रेंज के साथ एक आरएनजी का निर्माण करना होगा या आपको अपने उपयुक्त आरएनजी को लागू करना होगा । यह पृष्ठ उसके लिए सहायक हो सकता है।
• लिंक का विकिपीडिया लिंक विकिपीडिया में "विधि 2" द्वारा निर्मित एक से अप्रभेद्य होना चाहिए। यदि आप chords चुनने के लिए एक अलग एल्गोरिथ्म लागू करते हैं, तो कृपया शुद्धता का प्रमाण शामिल करें। आप जो भी एल्गोरिदम लागू करने का चयन करते हैं, वह सैद्धांतिक रूप से यूनिट सर्कल में किसी भी मान्य कॉर्ड को उत्पन्न करने में सक्षम होना चाहिए (अंतर्निहित PRNG या सीमित-सटीक डेटा प्रकारों की सीमाओं को छोड़कर)।
• आपके कार्यान्वयन को फ़्लोटिंग-पॉइंट नंबरों (कम से कम 32 बिट्स वाइड) या फिक्स्ड-पॉइंट नंबर्स (कम से कम 24 बिट्स वाइड) का उपयोग करना चाहिए और सभी 16 मिथक के भीतर सभी अंकगणितीय ऑपरेशन सटीक होने चाहिए ।

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

आउटपुट किसी भी सुविधाजनक सूची या स्ट्रिंग प्रारूप में हो सकता है, जब तक कि व्यक्तिगत संख्या स्पष्ट रूप से अलग-अलग हो और उनकी कुल संख्या हमेशा समान हो।

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

दृश्य

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

function draw() {
  document.getElementById("output").innerHTML = svg
}

function drawLines() {
  lines = document.getElementById("lines").value;
  var e = prefix;
  //e += '<circle cx="' + offset + '" + cy="' + offset + '" r="' + radius + '" stroke="black" fill="white"/>';
  lines = lines.match(/-?(?:\d*\.\d+|\d+\.\d*|\d+(?!\.))/g);
  for (i = 0; i < lines.length; i+=2)
  {
    t1 = parseFloat(lines[i]);
    t2 = parseFloat(lines[i+1]);
    x1 = Math.cos(t1);
    y1 = Math.sin(t1);
    x2 = Math.cos(t2);
    y2 = Math.sin(t2);
    e += '<path stroke="black" stroke-opacity="0.2" d="M ' + (x1 * radius + offset) + ' ' + (y1 * radius + offset) + ' L ' + (x2 * radius + offset) + ' ' + (y2 * radius + offset) + '"/>';
  }
  e += suffix;
  svg = e;
  draw();
}
var prefix = '<svg height="450" width="450">',
  suffix = "</svg>",
  scale = 0.95,
  offset = 225,
  radius = scale*offset,
  svg = "";

svg {
  position: absolute;
}

Paste line specifications here
<br>
<input id="lines" type="textarea" size="60" oninput='drawLines()' />
<br>
<br>
<div id="output"></div>

विधि 1 के साथ उत्पन्न उदाहरण डेटा।

विधि 2 के साथ उत्पन्न उदाहरण डेटा ।

विधि 3 के साथ उत्पन्न उदाहरण डेटा।

लीडरबोर्ड

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

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

# Language Name, N bytes

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

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

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

Answer 1

IA-32 मशीन कोड, 54 बाइट्स

कोड के Hexdump:

68 00 00 00 4f 0f c7 f0 50 db 04 24 58 d8 34 24
f7 d9 78 f1 d9 c0 dc c8 d9 e8 de e1 d9 fa d9 c9
d9 f3 dc c0 d9 eb de ca d8 c1 dd 1a dd 5a 08 83
c2 10 e2 d1 58 c3

यह विकिपीडिया द्वारा वर्णित एक (थोड़ा संशोधित) एल्गोरिथ्म का उपयोग करता है। छद्म कोड में:

x = rand_uniform(-1, 1)
y = rand_uniform(-1, 1)
output2 = pi * y
output1 = output2 + 2 * acos(x)

मैं सीमा का उपयोग करता हूं -1...1क्योंकि इस रेंज में यादृच्छिक संख्याओं को बनाना आसान है: rdrandअनुदेश एक पूर्णांक बनाता है -2^31और 2^31-1, जिसे आसानी से 2 ^ 31 से विभाजित किया जा सकता है।

मुझे 0...1अन्य यादृच्छिक संख्या (x) के लिए सीमा का उपयोग करना चाहिए , जिसे में खिलाया गया है acos; हालांकि, नकारात्मक भाग सकारात्मक भाग के साथ सममित है - नकारात्मक संख्याएं जीवा उत्पन्न करती हैं जिनकी अवधि पीआई रेडियन से अधिक है, लेकिन बर्ट्रेंड विरोधाभास को दर्शाने के उद्देश्य से, इससे कोई फर्क नहीं पड़ता।

चूंकि 80386 (या x87) निर्देश सेट में कोई समर्पित नहीं है acos निर्देश , मुझे केवल atanनिर्देश का उपयोग करके गणना व्यक्त करनी थी :

acos(x) = atan(sqrt(1-x^2)/x)

यहाँ स्रोत कोड है जो ऊपर मशीन कोड उत्पन्न करता है:

__declspec(naked) void __fastcall doit1(int n, std::pair<double, double>* output)
{
    _asm {
        push 0x4f000000;        // [esp] = float representation of 2^32

    myloop:
        rdrand eax;             // generate a random number, -2^31...2^31-1
        push eax;               // convert it
        fild dword ptr [esp];   // to floating-point
        pop eax;                // restore esp
        fdiv dword ptr [esp];   // convert to range -1...1
        neg ecx;
        js myloop;              // do the above 2 times

        // FPU stack contents:  // x           | y
        fld st(0);              // x           | x   | y
        fmul st(0), st;         // x^2         | x   | y
        fld1;                   // 1           | x^2 | x | y
        fsubrp st(1), st;       // 1-x^2       | x   | y
        fsqrt;                  // sqrt(1-x^2) | x   | y
        fxch;                   // x           | sqrt(1-x^2) | y
        fpatan;                 // acos(x)     | y
        fadd st, st(0);         // 2*acos(x)   | y
        fldpi;                  // pi          | 2*acos(x) | y
        fmulp st(2), st;        // 2*acos(x)   | pi*y
        fadd st, st(1);         // output1     | output2
        fstp qword ptr [edx];   // store the numbers
        fstp qword ptr [edx + 8];

        add edx, 16;            // advance the output pointer
        loop myloop;            // loop

        pop eax;                // restore stack pointer
        ret;                    // return
    }
}

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

Comments

IA32 असेंबली का उपयोग करने के लिए मुझे यह उत्तर पसंद है! बस कहने के लिए: यह कड़ाई से 386 मशीन कोड नहीं है 80386 के रूप में स्पष्ट रूप से निर्देश नहीं है और न ही एक एफपी

— कोप्रोसेसर

हाँ, IA32 एक बेहतर नाम है। विशिष्ट पर्याप्त लेकिन शायद एक से अधिक 80386. सही

— anatolyg

Answer 2

पायथ, २५ २३ 22 बाइट्स

Rcrmn के C ++ 11 उत्तर का एक पोर्ट। यह पायथ का मेरा पहला उपयोग है, और मैंने बहुत मज़ा किया है!

VQJ,*y.n0O0.tOZ4,sJ-FJ

23-बाइट संस्करण:

VQJ*y.n0O0K.tOZ4+JK-JKd

फोल्ड + sums का उपयोग करने के लिए प्रोग्राम को बदलकर एक बाइट काटें और K को हटाकर एक tuple में J सेट करें।

मूल:

VQJ**2.n0O0K.tO0 4+JK-JKd

@Orlp की बदौलत 2 बाइट काट दिए।

स्पष्टीकरण:

VQ                         loop as many times as the input number
  J,                       set J to the following tuple expression
    *y.n0O0                2 * .n0 (pi) * O0 (a random number between 0 and 1)
            .tOZ4          .tOZ 4 (acos of OZ (a random number))
                 ,sJ-FJ    print the sum of J and folding J using subtraction in parenthesis, separated by a comma, followed by another newline

Comments

पायथ टिप्स: के *2_रूप में ही है y_। वैरिएबल Zशुरू में 0 है, इसलिए आप .tO0 4लिखकर अंतरिक्ष को हटा सकते हैं .tOZ4।

— orlp

मैं 25 बाइट्स गिन रहा हूं ...

— माल्टीसेन

इसके अलावा, आप आउटपुट को बेहतर रूप से प्रारूपित कर सकते हैं,+JK-JK

— माल्टसेन

@ मैलेटेन दोनों ने तय किया। धन्यवाद!

— kirbyfan64sos

@orlp के बारे में मेरे पास कोई सुराग नहीं था yऔर मैं भूल गया था Z। फिक्स्ड; धन्यवाद!

— kirbyfan64sos

Answer 3

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

n->(x=2π*rand(n);y=acos(rand(n));hcat(x+y,x-y))

यह विधि 2 एल्गोरिथ्म का उपयोग करता है, जैसे अधिकांश उत्तर अब तक। यह एक लंबो फ़ंक्शन बनाता है जो पूर्णांक इनपुट लेता है और एक nx 2 सरणी देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=n->...।

असंगठित + स्पष्टीकरण:

function f(n::Int64)
    # The rand() function returns uniform random numbers using
    # the Mersenne-Twister algorithm

    # Get n random chord angles
    x = 2π*rand(n)

    # Get n random rotations
    y = acos(rand(n))

    # Bind into a 2D array
    hcat(x+y, x-y)
end

मुझे वास्तव में पसंद है कि विज़ुअलाइज़ेशन कैसे दिखते हैं, इसलिए मैं एक को शामिल करूंगा। इसका परिणाम है f(1000)।

Answer 4

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

C ++ उत्तर का एक पोर्ट। मेरे पास एक और 23 बाइट समाधान था (अब 22!), लेकिन यह लगभग अनुकूलन के साथ @ kirbyfan64sos के pyth उत्तर की एक प्रति थी, इसलिए मुझे बॉक्स के बाहर थोड़ा सोचना पड़ा और रचनात्मक रूप से (ab) फोल्ड ऑपरेटर का उपयोग करना पड़ा।

m,-Fdsdm,y*.nZOZ.tOZ4Q

ध्यान दें कि यह अभी शुरू होने के बाद गुना ऑपरेटर में बग के कारण काम नहीं करता है reduce2। मैं एक पुल अनुरोध में डाल रहा हूँ।

m             Map    
 ,            Tuple of
  -Fd         Fold subtraction on input
  sd          Fold addition on input
 m      Q     Map over range input
  ,           Tuple           
   y          Double
    *         Product
     .nZ      Pi
     OZ       [0, 1) RNG
  .t  4       Acos
    OZ        [0, 1) RNG

इसके लिए यह मेरा दूसरा उपाय था जो उसी तरह से काम करता है: VQKy*.nZOZJ.tOZ4,+KJ-KJ

Comments

आपने मेरे उपयोगकर्ता नाम को गलत बताया ... :(

— kirbyfan64sos

@ kirbyfan64sos derp। क्षमा करें;)

— माल्टसेन

Answer 5

आईडीएल, 65 बाइट्स

स्पष्ट रूप से यह @rcrmn के समान एल्गोरिथ्म है, भले ही मैंने उनके उत्तर को पढ़ने से पहले इसे स्वतंत्र रूप से प्राप्त किया हो।

read,n
print,[2,2]#randomu(x,n)*!pi+[-1,1]#acos(randomu(x,n))
end

आईडीएल के रैंडमू फंक्शन मेर्सन ट्विस्टर का उपयोग करता है, जिसकी अवधि 2 ^{19937 है} -1 है।

संपादित करें: मैंने विज़ुअलाइज़र के माध्यम से 1000 कोर्ड्स चलाए, यहाँ परिणाम का एक स्क्रीनशॉट है:

Answer 6

सी ++ 11, 214 बाइट्स

#include<random>
#include<iostream>
#include<cmath>
int main(){using namespace std;int n;cin>>n;random_device r;uniform_real_distribution<> d;for(;n;--n){float x=2*M_PI*d(r),y=acos(d(r));cout<<x+y<<' '<<x-y<<';';}}

इसलिए यह अधिकार का सीधा क्रियान्वयन है विकिपीडिया पृष्ठ से एल्गोरिदम । यहां गोल्फिंग में मुख्य समस्या ओह-सो-फ्रैकिंग-लंबे नाम हैं जो यादृच्छिक जनरेटर कक्षाएं हैं। लेकिन, अच्छे राजभाषा 'रैंड के विपरीत, यह कम से कम ठीक से एक समान है।

स्पष्टीकरण:

#include<random>
#include<iostream>
#include<cmath>
int main()
{
    using namespace std;
    int n;
    cin>>n; // Input number
    random_device r; // Get a random number generator
    uniform_real_distribution<> d;   // Get a uniform distribution of 
                                     // floats between 0 and 1
    for(;n;--n)
    {
        float x = 2*M_PI*d(r),       // x: Chosen radius angle
              y = acos(d(r));        // y: Take the distance from the center and 
                                     // apply it an inverse cosine, to get the rotation

        cout<<x+y<<' '<<x-y<<';';    // Print the two numbers: they are the rotation
                                     // of the radius +/- the rotation extracted from
                                     // the distance to the center
    }
}

Comments

वह कारक M_PI_2संदिग्ध लग रहा है। मुझे लगता है कि इसके बजाय 1 होना चाहिए।

— अनातोलीगैस

हाँ, पूरी तरह से सही है, अब इसे ठीक करने जा रहा है! आपका बहुत बहुत धन्यवाद!

— रोरलर्क

Answer 7

एपीएल, 46 बाइट्स

f←{U←⍵ 2⍴∊{(○2×?0)(¯1○?0)}¨⍳⍵⋄⍉2⍵⍴∊(+/U)(-/U)}

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

आप इसे ऑनलाइन आज़मा सकते हैं !

स्पष्टीकरण:

f←{ ⍝ Create the function f which takes an argument ⍵

    ⍝ Define U to be an ⍵ x 2 array of pairs, where the first
    ⍝ item is 2 times a random uniform float (?0) times pi (○)
    ⍝ and the second is the arccosine (¯1○) of another random
    ⍝ uniform float.

    U ← ⍵ 2 ⍴ ∊{(○2×?0)(¯1○?0)}¨⍳⍵

    ⍝ Create a 2 x ⍵ array filled with U[;1]+U[;2] (+/U) and
    ⍝ U[;1]-U[;2] (-/U). Transpose it into an ⍵ x 2 array of
    ⍝ chord point pairs and return it.

    ⍉ 2 ⍵ ⍴ ∊(+/U)(-/U)
}

नोट: मेरा पिछला 19-बाइट समाधान अमान्य था क्योंकि यह (x + y, xy) के बजाय (x, y) वापस लौटा था। दुःख मिटता है।

Answer 8

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

n->{for(;n-->0;){double a=2*Math.PI*Math.random(),b=Math.acos(Math.random());System.out.println(a+b+" "+(a-b));}};

जावा में बुनियादी कार्यान्वयन। लंबोदर अभिव्यक्ति के रूप में उपयोग करें।

उदाहरण उपयोग

Comments

क्या आप Mathकहीं स्टोर करके आकार कम नहीं कर सकते ? या कुछ और? (Im जावा प्रोग्रामर नहीं)

— Ismael Miguel

@IsmaelMiguel कि एक अतिरिक्त 2 वर्ण खर्च होंगे।

— TheNumberOne

क्षमा करें: / यह Mathदिखाता है कि समय की संख्या को कम करने की कोशिश करना आकर्षक है । समस्या को हल करने के लिए किसी अन्य कोड को उत्पन्न करने के लिए एक कोड का उपयोग करने के बारे में मेटा क्या कहता है?

— इस्माईल मिगुएल

@IsmaelMiguel यह उचित खेल है, हालांकि मुझे आश्चर्य होगा कि क्या आप वास्तव में गोल्फिंग की तुलना में मेटागॉल्फिंग में बेहतर हैं।

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

Answer 9

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

यहाँ मेरा पहला गोल्फ! मैंने सभी के समान कोड का उपयोग किया, मुझे आशा है कि यह ठीक है

gets.chomp.to_i.times{puts"#{x=2*Math::PI*rand},#{x+2*Math.acos(rand)}"}

Answer 10

जावा, 115 १२३

यह मूल रूप से अन्य लोगों के समान है, लेकिन मुझे इस छेद के लिए जावा स्कोर की आवश्यकता है, इसलिए यहां यह जाता है:

void i(int n){for(double x;n-->0;System.out.println(x+2*Math.acos(Math.random())+" "+x))x=2*Math.PI*Math.random();}

1000 नमूना chords pastebin में पाए जा सकते हैं , यहाँ एक रन से पहले पाँच हैं:

8.147304676211474 3.772704020731153
8.201346559916786 3.4066194978900106
4.655131524088468 2.887965593766409
4.710707820868578 3.8493686706403984
3.3839198612642423 1.1604092552846672

Answer 11

सीजेम, 24 22 बाइट्स

अन्य एल्गोरिदम के समान, यहाँ CJam में एक संस्करण है।

{2P*mr_1dmrmC_++]p}ri*

1000 का इनपुट वितरण का उत्पादन करता है जैसे:

यह काम किस प्रकार करता है

एल्गोरिदम बस है x = 2 * Pi * rand(); print [x, x + 2 * acos(rand())]

{                 }ri*        e# Run this loop int(input) times
 2P*mr                        e# x := 2 * Pi * rand()
      _                       e# copy x
       1dmr                   e# y := rand()
           mC                 e# z := acos(y)
             _++              e# o := x + z + z
                ]             e# Wrap x and o in an array
                 p            e# Print the array to STDOUT on a new line

अद्यतन : 2 बाइट्स मार्टिन को धन्यवाद बचा लिया!

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

Answer 12

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

(ब्लैंकनथ को धन्यवाद lambda पॉइंटर के )

दूसरों के समान विधि का उपयोग करना:

import math as m;from random import random as r;f=lambda n:[(x,x+2*m.acos(r()))for x in(2*m.pi*r()for _ in range(n))]

पायथन प्रलेखन से:

पाइथन कोर जनरेटर के रूप में मेर्सेन ट्विस्टर का उपयोग करता है। यह 53-बिट सटीक फ़्लोट्स का उत्पादन करता है और इसकी अवधि 2 ¹⁹⁹³⁷ -1 है।

उत्पादन

>>> f(10)
[(4.8142617617843415, 0.3926824824852387), (3.713855302706769, 1.4014527571152318), (3.0705105305032188, 0.7693910749957577), (1.3583477245841715, 0.9120275474824304), (3.8977143863671646, 1.3309852045392736), (0.9047010644291349, 0.6884780437147916), (3.333698164797664, 1.116653229885653), (3.0027328050516493, 0.6695430795843016), (5.258167740541786, 1.1524381034989306), (4.86435124286598, 1.5676690324824722)]

और इसी तरह।

दृश्य

Comments

यदि आप फ़ंक्शन के लिए एक लैम्ब्डा का उपयोग करते हैं और एक सूची समझ (एक आंतरिक जनरेटर अभिव्यक्ति के साथ) वापस कर सकते हैं, तो आप लगभग 20 बाइट्स बचा सकते हैं:f=lambda n:[(x,x+2*m.acos(r()))for x in(2*m.pi*r()for _ in range(n))]

— ब्लैंकनाथ

आह, मैं मूल रूप से एक मेमना था। मुझे लगता है मैं सूची समझ पर दोहरीकरण के बारे में नहीं सोचा था। धन्यवाद! @ ब्लेकथन

— जैच गेट्स

आयातों के साथ फ़िडिंग

— Triggernometry

Answer 13

पर्ल, 60

#!perl -l
use Math::Trig;print$x=2*pi*rand,$",$x+2*acos rand for 1..<>

Answer 14

आर, ६० ५६ ५३ 49 बाइट्स

@JayCe के लिए अतिरिक्त 4 बाइट्स और इसे फ़ंक्शन में बदलने के लिए धन्यवाद।

दूसरों के समान मूल सूत्र का उपयोग करना। R डिफ़ॉल्ट रूप से Mersenne-Twister विधि का उपयोग करता है, लेकिन दूसरों को सेट किया जा सकता है। एक अंतरिक्ष अलग सूची उत्पादन करता है।

function(n,y=acos(runif(n)))runif(n)*2*pi+c(y,-y)

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

Comments

हाय मिकी, आप इसे एक फ़ंक्शन बनाने और x को परिभाषित नहीं करके 4 बाइट्स बचा सकते हैं ।

— JayCe

@JayCe यह एक बहुत अच्छा धन्यवाद है

— मिकी

Answer 15

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

INPUT N
FOR I=1TO N
X=PI()*2*RNDF()Y=ACOS(RNDF())?X+Y,X-Y
NEXT