14

मैंने कहीं हलकों के बारे में पढ़ा, और बस अब डिस्क के बारे में सीखा ( यह वास्तव में एक बहुत ही सामान्य अवधारणा है ) और कोडगोल्फ के बारे में सोचा।

आपका कार्य त्रिज्या 1 के साथ एक डिस्क पर एक बिंदु / कई बिंदुओं को यादृच्छिक करना है ।

नियम:

सभी बिंदुओं के उत्पन्न होने की समान संभावना होनी चाहिए
फ्लोटिंग पॉइंट निर्देशांक का उपयोग किया जाना चाहिए; न्यूनतम आवश्यकता दो दशमलव है (जैसे अंक (0.12, -0.45)या (0.00, -1.00)मान्य हैं)
यदि आपका प्रोग्राम वास्तव में बाउंडिंग सर्कल और उसमें उत्पन्न बिंदु (ओं) को प्रदर्शित करता है तो आपको -20 बाइट्स मिलते हैं। निर्देशांक अभी भी मान्य हैं, लेकिन प्रदर्शित नहीं किए गए हैं, और उत्पन्न छवि का आकार 201 पिक्सेल में कम से कम 201 होना चाहिए
यदि आपका प्रोग्राम स्टड पर इनपुट के रूप में उत्पन्न होने वाले अंकों की संख्या लेता है, तो आपको -5 बाइट्स मिलते हैं
यदि आप बाउंडिंग सर्कल और पॉइंट को प्लॉट नहीं करने का निर्णय लेते हैं, तो आपके प्रोग्राम को फॉर्मेट (x, y)या (x,y)स्टडआउट पर उत्पन्न पॉइंट (एस) को आउटपुट करना होगा।
यदि आप इनपुट के रूप में उत्पन्न अंक की संख्या लेने का निर्णय लेते हैं, लेकिन इसे प्लॉट करने के लिए नहीं - आपके प्रोग्राम को ऊपर या बिना एक स्थान के बीच के प्रारूप पर सभी यादृच्छिक बिंदुओं को आउटपुट करना है।

बाइट्स जीत में सबसे कम सबमिशन!

— sweerpotato
स्रोत

1

@sweerpotato हाँ, कृपया निर्दिष्ट करें कि और सर्कल के सभी बिंदु मान्य हैं। मुझे एहसास नहीं था कि तुम दोनों का मतलब है। इसके अलावा, यह सवाल ऐसा लगता है कि यह एक लोकप्रियता-प्रतियोगिता से बेहतर एक कोड-गोल्फ चुनौती फिट होगा, लेकिन यह सिर्फ मेरी राय है।

— कोल

5

" एक रचनात्मक तरीके से XYZ करें " क्लासिक बैड पॉपकॉन प्रश्न ™ है। जो एक व्यक्ति रचनात्मक मानता है वह वही है जो दूसरा व्यक्ति स्पष्ट तरीके से समझता है।

— पीटर टेलर

जिज्ञासा से बाहर, भूखंडों के लिए 201x201 पिक्सेल उत्पादन की आवश्यकता क्यों है?

— जॉनी

@ जॉन ने मुझे 201x201 पिक्सेल का सुझाव दिया क्योंकि यह आवश्यक 2 दशमलव स्थान सटीकता से मेल खाता है

— ट्राइकोप्लाक्स

क्या हम निर्देशांक को जटिल संख्या के रूप में आउटपुट कर सकते हैं? उदाहरण के लिए 0.3503082505747327+0.13499221288682994j:।

— 18

5

पायथ, 26 - 5 = 21 बाइट्स

VQp(sJ*@OZ2^.n1*yOZ.l_1)eJ

स्टड पर उत्पन्न करने के लिए निर्देशांक की संख्या लेता है, और उन्हें इस तरह से stdout पर आउटपुट करता है:

(-0.5260190768964058, -0.43631187015380823)(-0.12127959509302746, -0.08556306418467638)(-0.26813756369750996, -0.4564539715526493)

@ मार्टिनबटनर के समान एक रणनीति का उपयोग करता है, ध्रुवीय निर्देशांक और रेडी उत्पन्न करता है, सिवाय इसके कि यह जटिल घातांक का उपयोग करता है।

— orlp
स्रोत

आप pनहीं निकाल सकते , क्या आप नहीं कर सकते? यह सिर्फ आउटपुट को अलग लाइनों में बदलता है।

— पुरकाकूदरी

@ Pietu1998 यह अनुमति नहीं है, मुख्य प्रश्न पर टिप्पणी देखें।

— orlp

अच्छा ठीक है।

— पुरकाकूदरी

16

सीजेएम, 28 27 बाइट्स

PP+mr_mc\ms]1.mrmqf*"(,)".\

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

इसका परीक्षण यहां करें।

व्याख्या

PP+     e# Push 2π.
mr_     e# Get a random float between 0 and 2π, make a copy.
mc\     e# Take the cosine of one copy and swap with the other.
ms]     e# Take the sine of the other copy and wrap them in an array.
        e# This gives us a uniform point on the unit circle.
1.mr    e# Get a random float between 0 and 1.
mq      e# Take the square root. This is the random radius.
f*      e# Multiply x and y by this radius.
"(,)".\ e# Put the resulting numbers in the required format.

यह काम क्यों करता है? त्रिज्या rऔर (छोटी) चौड़ाई की एक संकीर्ण वार्षिकी पर विचार करें dr। क्षेत्र लगभग है2π*r*dr (यदि एनलस संकरा है, तो आंतरिक और बाहरी परिधि लगभग समान है, और वक्रता को नजरअंदाज किया जा सकता है, जैसे कि क्षेत्र को परिधि की लंबाई और चौड़ाई के साथ एक आयत के रूप में माना जा सकता है वलय)। तो क्षेत्र त्रिज्या के साथ रैखिक रूप से बढ़ता है। इसका मतलब यह है कि हम एक यादृच्छिक घनत्व का एक रैखिक वितरण भी चाहते हैं, ताकि एक निरंतर घनत्व प्राप्त करने के लिए (त्रिज्या के दोगुने पर, भरने के लिए दोगुना क्षेत्र है, इसलिए हम वहां दो बार अधिक से अधिक अंक चाहते हैं)।

हम 0 से 1 तक एक रैखिक यादृच्छिक वितरण कैसे उत्पन्न करते हैं? आइए पहले असतत मामले को देखें। कहते हैं, हमारे पास 4 मूल्यों का वांछित वितरण है, जैसे {0.1, 0.4, 0.2, 0.3}(जैसे हम चाहते 1हैं कि 4 गुना सामान्य हो 0, और दो बार जितना आम हो 2; हम 3तीन बार उतना ही सामान्य चाहते हैं 0):

वांछित वितरण के साथ चार मूल्यों में से एक को कैसे चुन सकते हैं? हम उन्हें ढेर कर सकते हैं, y- अक्ष पर 0 और 1 के बीच समान रूप से यादृच्छिक मूल्य चुन सकते हैं और उस बिंदु पर खंड चुन सकते हैं:

हालांकि इस पिक की कल्पना करने का एक अलग तरीका है। हम इसके स्थान पर मानों के संचय के साथ वितरण के प्रत्येक मूल्य को बदल सकते हैं:

और अब हम इस चार्ट की शीर्ष रेखा को एक फ़ंक्शन के रूप में मानते हैं और एक फ़ंक्शन f(x) = yप्राप्त करने के लिए इसे उल्टा करते हैं , जिसे हम समान रूप से यादृच्छिक रूप से लागू कर सकते हैं :g(y) = f^-1(y) = xy ∈ [0,1]

कूल, इसलिए रेडी के एक रैखिक वितरण को उत्पन्न करने के लिए इसका उपयोग कैसे किया जा सकता है? यह वह वितरण है जो हम चाहते हैं:

पहला कदम वितरण के मूल्यों को संचित करना है। लेकिन वितरण जारी है, इसलिए पिछले सभी मूल्यों पर संक्षेप के बजाय, हम से एक अभिन्न अंग लेते 0हैं r। हम आसानी से उस विश्लेषणात्मक हल कर सकते हैं :। हालाँकि, हम चाहते हैं कि इसे सामान्यीकृत किया जाए, अर्थात इसे एक स्थिर से गुणा करने के लिए यह अधिकतम मूल्य देता है , इसलिए हम वास्तव में जो चाहते हैं वह है :∫₀^r r dr = 1/2 r²1rr²

और अंत में, हम इसे एक फ़ंक्शन प्राप्त करने के लिए उलटा करते हैं [0,1], जिसमें हम एक समान मूल्य पर लागू कर सकते हैं , जिसे हम फिर से विश्लेषणात्मक रूप से कर सकते हैं: यह सिर्फ है r = √y, जहां yयादृच्छिक मूल्य है:

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

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

1

बहुत अच्छी व्याख्या!

— स्वेरापॉटो

2

मम्म तस्वीरें: डी

— बीटा डिके

12

गणितज्ञ, ६hem ४४ - २० = २४ बाइट्स

डेविड कैरर के लिए मुझे धन्यवाद देने के लिए बहुत धन्यवाद RandomPoint, जिसने 24 (!) बाइट्स को बचाया। मेथेमेटिका करता है एक अंतर्निहित सब कुछ के लिए।

Graphics@{Circle[],Point@RandomPoint@Disk[]}

यह बिंदु और बाउंडिंग सर्कल को बोनस के लिए योग्य बनाता है:

परिणाम एक सदिश छवि है, इसलिए 201x201 पिक्सेल के आकार विनिर्देश वास्तव में कोई मतलब नहीं है, लेकिन डिफ़ॉल्ट रूप से यह उससे भी बड़ा प्रस्तुत करता है।

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

कैसे के बारे में Graphics[{Circle[], Point@RandomPoint@Disk[]}]?

— डेविड सीपी

मेरे मेहमान हो। इसके अलावा, 1 बाइट बचाने के लिए ...Graphics@{Circle[], Point@RandomPoint@Disk[]}

— डेविड

@DavidCarraher बहुत बहुत धन्यवाद! :)

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

मुझे गणितज्ञ वाक्य-विन्यास का पता नहीं है, लेकिन निश्चित रूप से आप किसी अन्य बाइट को अंतरिक्ष के बाद हटाकर बचा सकते हैं ,?

— शराबी

@fluffy मैंने पहले से ही पोस्ट किए गए संस्करण में किया था

— मार्टिन

9

सीजेएम, 31 26 बाइट्स

{];'({2dmr(_}2*@mhi}g',\')

यह बार-बार साइड लंबाई 2 के एक वर्ग में यादृच्छिक बिंदुओं को उत्पन्न करके और यूनिट डिस्क के अंदर आने वाले पहले को रखकर काम करता है।

3 बाइट बंद करने के लिए @ मार्टिनबटनर को धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

{                  }g       Do:
 ];'(                         Clear the stack and push a left parenthesis.
     {      }2*               Do twice:
      2dmr                      Randomly select a Double between 0 and 2.
          (_                    Subtract 1 and push a copy.
               @              Rotate the copy of the first on top of the stack.
                mh            Compute the Euclidean norm of the vector consisting
                              of the two topmost Doubles on the stack.
                  i           Cast to integer.
                            If the result is non-zero, repeat the loop.
                     ',\    Insert a comma between the Doubles.
                        ')  Push a right parenthesis.

— डेनिस
स्रोत

8

iKe , 53 51 बाइट्स

विशेष रूप से कुछ भी नहीं है, लेकिन मुझे लगता है कि हम कम से कम एक चित्रमय समाधान होना चाहिए:

,(80+160*t@&{.5>%(x*x)+y*y}.+t:0N 2#-.5+?9999;cga;3)

भूखंड

इसे अपने ब्राउज़र में आज़माएं ।

संपादित करें: मैं ध्रुवीय निर्देशांक के वितरण को संशोधित करने के लिए @ मार्टिनबटनर के दृष्टिकोण को लागू करके दो बाइट्स को बंद कर सकता हूं। मुझे लगता है कि यह बहुत अधिक प्रत्यक्ष है:

,(80*1+(%?c){x*(cos y;sin y)}'6.282*?c:9999;cga;3)

— JohnE
स्रोत

3

यदि आप बाउंडिंग सर्कल भी बनाते हैं तो आप -20 के लिए अर्हता प्राप्त करेंगे।

— orlp

1

iKe में एक रेखापुंज-आधारित ड्राइंग मॉडल है, जो उस आवश्यकता को अनुचित बनाता है। मुझे लगता है कि एक बाउंडिंग सर्कल के एक सन्निकटन के रूप में अच्छी तरह से प्रस्तुत करने के लिए 20 से अधिक पात्रों का खर्च करना होगा।

— जॉन

7

पर्ल, 59 बाइट्स

while(($x=1-rand 2)**2+($y=1-rand 2)**2>1){};print"($x,$y)"

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

संपादित करें: गोल्फिंग की प्रक्रिया में, मुझे एक सर्कल पर यादृच्छिक अंक प्रिंट करने का एक दिलचस्प तरीका मिला ।

use Math::Trig;$_=rand 2*pi;print"(",sin,",",cos,")"

— PhiNotPi
स्रोत

7

सप्टक, 24 53 - 20 = 33 बाइट्स

polar([0:2e-3:1,rand]*2*pi,[ones(1,501),rand^.5],'.')

501 को समान रूप से-थेटा मानों के साथ-साथ एक यादृच्छिक संख्या उत्पन्न करता है और उन सभी को [0..2π] तराजू करता है। फिर सर्कल के त्रिज्या के लिए 501 1 उत्पन्न करता है, साथ ही बिंदु के लिए एक यादृच्छिक त्रिज्या और डिस्क पर एक समान वितरण सुनिश्चित करने के लिए वर्गमूल लेता है। फिर ध्रुवीय निर्देशांक के रूप में सभी बिंदुओं को प्लॉट करता है।

यहां वितरण का त्वरित प्रदर्शन है (यूनिट सर्कल के बिना):

polar(2*pi*rand(99),rand(99).^.5,'.')

— बीकर
स्रोत

5

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

अस्वीकृति विधि , 64 बाइट्स:

u=1;v=1;while u^2+v^2>1
u=rand;v=rand;end
sprintf('(%f,%f)',u,v)

प्रत्यक्ष विधि , 74 बाइट्स (मेरी गलतियों को सुधारने में मेरी मदद करने के लिए मार्टिन बंटनर का धन्यवाद):

t=rand*2*pi;r=1-abs(1-sum(rand(2,1)));sprintf('(%f,%f)',r*cos(t),r*sin(t))

— लुइस मेंडो
स्रोत

5

आर, 99 95 81-20 = 79 75 61 बाइट्स

symbols(0,0,1,i=F,asp=1,ylim=c(-1,1));points(complex(,,,runif(9),runif(9,-1)*pi))

ध्रुवीय निर्देशांक से x / y के निर्माण के लिए जटिल संख्या निर्माण का उपयोग करें। इनपुट लेना थोड़ा महंगा था और शायद ऐसा करने का एक बेहतर तरीका है। ylim ~~औरxlim~~ यह सुनिश्चित करने के पूरे चक्र साजिश रची है और है aspसुनिश्चित अंक चक्र प्रतीक के नीचे दिखाई जाती हैं।

बचत के लिए @jbaums और @flodel को धन्यवाद

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

— मिकीट
स्रोत

runif(9,0,1)के लिए सरल किया जा सकता हैrunif(9)

— 20

@jbaums, धन्यवाद ... एक ऐसी चीज जो मुझे हमेशा भूलने लगती है :)

— मिकी

14 शेव कर सकते हैं:symbols(0,0,1,i=F,asp=1,ylim=c(-1,1));points(complex(,,,runif(9),runif(9,-1)*pi))

— फ्लोडेल

@flodel बहुत बहुत धन्यवाद।

— 22

एक अन्य नन्हा बचत: के yliस्थान पर काम करता है ylim।

— जंबुम्स

4

प्रसंस्करण / जावा 141 बाइट्स -20 = 121

201 * 201 के लिए न्यूनतम आकार होने की आवश्यकता है setupक्योंकि मुझे इसकी प्रक्रिया करने की आवश्यकता है क्योंकि Processing.org से 200x200 तक की चूक हो जाती है :(

void setup(){noFill();size(201,201);}void draw(){float f=10,a=PI*2*random(),r=random();point(f+f*sin(a)*r,f+f*cos(a)*r);ellipse(f,f,f*2,f*2)}

— टिमोथी ग्रोट
स्रोत

मुझे नहीं पता था कि प्रसंस्करण / जावा की अनुमति थी, नीट!

— J Atkin

4

QBasic, 138 बाइट्स - 20 - 5 = 113

INPUT n
r=200
SCREEN 12
RANDOMIZE TIMER
CIRCLE(r,r),r
PAINT(r,r)
FOR i=1TO n
DO
x=RND*r*2
y=RND*r*2
LOOP UNTIL POINT(x,y)
PSET(x,y),1
NEXT

उपयोगकर्ता इनपुट लेता है और डिस्क और बिंदुओं को खींचता है। QB64 पर परीक्षण किया गया ।

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

— DLosc
स्रोत

3

awk - 95 - 5 = 90

{
    for(;$1--;printf"("(rand()<.5?x:-x)","(rand()<.5?y:-y)")")
        while(1<(x=rand())^2+(y=rand())^2);
}

चूंकि मैं रैंड () <5 भाग के बारे में निश्चित नहीं था, मैंने इस स्क्रिप्ट का उपयोग करते हुए, इसके साथ कुछ वितरण परीक्षण किया:

BEGIN{ srand() }
{ 
    split("0 0 0 0", s)
    split("0 0 0 0", a)

    for(i=$1; i--; )
    {
        while( 1 < r2 = ( x=rand() )^2 + ( y=rand() )^2 );

        x = rand()<.5 ? x : -x
        y = rand()<.5 ? y : -y

        ++s[ x>=0 ? y>=0 ? 1 : 4 : y>=0 ? 2 : 3 ]

        ++a[ r2>.75 ? 1 : r2>.5 ? 2 : r2>.25 ? 3 : 4]
    }

    print "sector distribution:"
        for(i in s) print "sector " i ": " s[i]/$1

    print "quarter area distribution:"
        for(i in a) print "ring " i ":   " a[i]/$1
}

जो 1e7 के इनपुट के लिए मुझे यह परिणाम देता है, जब मैंने अपनी कॉफी पर एक या दो बार बोया था:

1e7
sector distribution:
sector 1: 0.250167
sector 2: 0.249921
sector 3: 0.249964
sector 4: 0.249948
quarter area distribution:
ring 1:   0.24996
ring 2:   0.25002
ring 3:   0.250071
ring 4:   0.249949

जो मुझे लगता है कि काफी ठीक है।

थोड़ी सी व्याख्या:
थोड़ी देर के लिए स्क्रब करने के बाद, यह पता चला कि यदि आप डिस्क को चार क्षेत्रों में बराबर क्षेत्र में विभाजित करना चाहते हैं, तो आपको जिस रेडी को काटना होगा वह sqrt (1/4), sqrt (1/2) है ) और sqrt (3/4)। बिंदु के वास्तविक त्रिज्या के बाद से मैं परीक्षण sqrt (x ^ 2 + y ^ 2) होगा, मैं एक साथ सभी वर्गमूल को छोड़ सकता हूं। 1/4, 2/4, 3/4 "संयोग" से संबंधित हो सकता है कि एम। Buettner ने पहले बताया था।

— Cabbie407
स्रोत

3

एचपीपीपीएल , 146 (171-20-5) बाइट्स

EXPORT r(n)BEGIN LOCAL R,A,i,Q;RECT();Q:=118.;ARC_P(Q,Q,Q);FOR i FROM 1 TO n DO R:=√RANDOM(1.);A:=RANDOM(2*π);PIXON_P(G0,IP(Q+Q*R*COS(A)),IP(Q+Q*R*SIN(A)));END;FREEZE;END;

10000 अंकों के लिए उदाहरण (वास्तविक डिवाइस के लिए सेकंड में समय सहित):

फ़ंक्शन को स्वयं कहा जाता है r(n) । बाकी ऊपर की छवि केवल समय के उद्देश्यों के लिए है।

परिणाम (डिस्क व्यास 236 पिक्सेल है):

उपरोक्त संस्करण बिंदु निर्देशांक को संग्रहीत नहीं करता है, इसलिए मैंने एक ऐसा संस्करण लिखा है जो दो मापदंडों को लेता है r(n,p)। nबिंदुओं की संख्या है और p=0बिंदुओं को टर्मिनल पर लौटाता है, p=1बिंदुओं और डिस्क को प्लॉट करता है), यदि निर्देशांक संग्रहीत करना अनिवार्य है। यह संस्करण 283 (308-20-5) बाइट्स लंबा है:

EXPORT r(n,p)BEGIN LOCAL R,A,j,Q,x,y;Q:=118.0;CASE IF p==0 THEN print() END IF p==1 THEN RECT();ARC_P(Q,Q,Q) END END;FOR j FROM 1 TO n DO R:=√RANDOM(1.0);A:=RANDOM(2*π);x:=R*COS(A);y:=R*SIN(A);CASE IF p==0 THEN print("("+x+", "+y+")") END IF p==1 THEN PIXON_P(G0,IP(Q+Q*x),IP(Q+Q*y)) END END;END;FREEZE;END;

अनगोल्ड संस्करण:

EXPORT r(n,p)
BEGIN
LOCAL R,A,j,Q,x,y;
  Q:=118.0;
  CASE
    IF p==0 THEN print() END
    IF p==1 THEN RECT();ARC_P(Q,Q,Q) END
  END;
  FOR j FROM 1 TO n DO
    R:=√RANDOM(1.0);
    A:=RANDOM(2*π);
    x:=R*COS(A);
    y:=R*SIN(A);
    CASE
      IF p==0 THEN print("("+x+", "+y+")") END
      IF p==1 THEN PIXON_P(G0,IP(Q+Q*x),IP(Q+Q*y)) END
    END;
  END;
  FREEZE;
END;

इसके लिए टर्मिनल आउटपुट r(10,0):

r(10,1) बिंदुओं के साथ डिस्क को दिखाता है, जैसे ऊपर दिखाया गया है।

— एमएल
स्रोत

2

जावास्क्रिप्ट, 75 बाइट्स

अस्वीकृति के आधार पर:

do x=(r=()=>4*Math.random()-2)(),y=r()
while(x*x+y*y>1)
alert(`(${[x,y]})`)

प्रत्यक्ष विधि (80 बाइट्स):

alert(`(${[(z=(m=Math).sqrt((r=m.random)()))*m.sin(p=m.PI*2*r()),z*m.cos(p)]})`)

— Ypnypn
स्रोत

2

पायथन, 135 130 बाइट्स

from random import*
def r():return uniform(-1,1)
p=[]
while not p:
    x,y=r(),r()
    if x**2+y**2<=1:p=x,y
print'(%.2f, %2f)'%p

@ Jimmy23013 के सुझाव के लिए **0.5धन्यवाद हटा दिया गया (क्योंकि यह एक इकाई चक्र है, मैं अब जाँच कर रहा हूँ कि क्या x (y,) और (0, 0) के बीच की दूरी 1 ^{2 के} बराबर है । यह वही बात है)।

इसने मुझे कोष्ठकों को हटाने के लिए मुक्त कर दिया।

— जेएफ
स्रोत

मुझे लगता है कि आपको इसकी आवश्यकता नहीं है **0.5।

— jimmy23013

@ jimmy23013 धन्यवाद! हटा दिया।

— जेएफ

डिस्क पर अंक रैंडम करें