ฉันอ่านเกี่ยวกับแวดวงที่ไหนสักแห่งและตอนนี้เพิ่งเรียนรู้เกี่ยวกับแผ่นดิสก์ ( จริงๆแล้วมันเป็นแนวคิดที่ธรรมดามาก ) และคิดถึง codegolf

งานของคุณคือการสุ่มจุด / หลายจุดบนแผ่นดิสก์ด้วยรัศมี 1

กฎ:

• คะแนนทั้งหมดจะต้องมีความน่าจะเป็นเท่ากับที่จะสร้าง
• ต้องใช้พิกัดจุดลอย ข้อกำหนดขั้นต่ำคือทศนิยมสองตำแหน่ง (เช่นคะแนน(0.12, -0.45)หรือ(0.00, -1.00)ถูกต้อง)
• คุณจะได้รับ -20 ไบต์หากโปรแกรมของคุณแสดงวงกลมที่มีขอบเขตและจุดที่สร้างขึ้นจริง ๆ พิกัดยังต้องใช้งานได้ แต่ไม่แสดงและภาพที่สร้างจะต้องมีขนาดอย่างน้อย 201 คูณ 201 พิกเซล
• คุณได้รับ -5 ไบต์หากโปรแกรมของคุณใช้จำนวนคะแนนที่จะสร้างเป็นอินพุตใน stdin
• หากคุณตัดสินใจที่จะไม่พล็อตวงกลมขอบและจุด (s) โปรแกรมของคุณจะต้องส่งออกจุดที่สร้างขึ้นในรูปแบบ(x, y)หรือ(x,y)stdout
• หากคุณตัดสินใจที่จะใช้จำนวนคะแนนที่สร้างขึ้นเป็นอินพุต แต่ไม่ต้องพล็อตโปรแกรมของคุณจะต้องส่งออกคะแนนสุ่มทั้งหมดในรูปแบบที่ระบุข้างต้นโดยมีหรือไม่มีช่องว่างหนึ่งช่องในระหว่าง

การส่งสั้นที่สุดในหน่วยไบต์ชนะ!

Pyth, 26 - 5 = 21 ไบต์

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

ใช้จำนวนพิกัดเพื่อสร้างบน stdin และส่งออกเป็น stdout ดังนี้:

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

ใช้กลยุทธ์ที่คล้ายกับ @ MartinBüttnerสร้างพิกัดเชิงขั้วและรัศมียกเว้นใช้การยกกำลังเชิงซ้อน

CJam, 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):

จะเลือกหนึ่งในสี่ค่าด้วยการแจกแจงที่ต้องการได้อย่างไร เราสามารถวางซ้อนกันเลือกค่าสุ่มอย่างสม่ำเสมอระหว่าง 0 ถึง 1 บนแกน y และเลือกส่วนที่จุดนั้น:

มีวิธีอื่นในการมองภาพการเลือกนี้ เราสามารถแทนที่การแจกแจงแต่ละค่าด้วยการสะสมของค่าจนถึงจุดนั้น:

และตอนนี้เราถือว่าบรรทัดบนสุดของแผนภูมินี้เป็นฟังก์ชันf(x) = yและกลับด้านเพื่อรับฟังก์ชั่นซึ่งเราสามารถนำไปใช้กับค่าสุ่มอย่างสม่ำเสมอใน:g(y) = f-1(y) = xy ∈ [0,1]

เยี่ยมมากแล้วจะใช้ประโยชน์จากสิ่งนี้เพื่อสร้างการกระจายตัวเชิงเส้นของรัศมีได้อย่างไร นี่คือการกระจายที่เราต้องการ:

ขั้นตอนแรกคือการสะสมค่าของการกระจาย แต่การกระจายอย่างต่อเนื่องดังนั้นแทนที่จะข้อสรุปมากกว่าค่าก่อนหน้านี้ทั้งหมดเราใช้เวลาหนึ่งจากการ0 เราสามารถแก้วิเคราะห์ว่าr อย่างไรก็ตามเราต้องการให้สิ่งนี้เป็นมาตรฐานคือการคูณมันด้วยค่าคงที่สิ่งนี้จะทำให้เกิดมูลค่าสูงสุดดังนั้นสิ่งที่เราต้องการคือ:∫0r r dr = 1/2 r21rr2

และสุดท้ายเรากลับด้านนี้เพื่อรับฟังก์ชั่นที่เราสามารถนำไปใช้กับค่าเครื่องแบบ[0,1]ซึ่งเราสามารถทำการวิเคราะห์ได้อีกครั้ง: มันแค่r = √yไหนโดยที่yเป็นค่าสุ่ม:

นี่เป็นเทคนิคที่มีประโยชน์พอสมควรซึ่งสามารถใช้เพื่อสร้างการแจกแจงแบบง่าย ๆ ได้อย่างแน่นอน (ใช้ได้กับการแจกแจงใด ๆ แต่สำหรับขั้นตอนที่ซับซ้อนสองขั้นตอนสุดท้ายอาจต้องได้รับการแก้ไขเชิงตัวเลข) อย่างไรก็ตามฉันจะไม่ใช้มันในกรณีพิเศษนี้ในรหัสการผลิตเนื่องจากสแควร์รูทไซน์และโคไซน์มีราคาแพงห้าม: การใช้อัลกอริทึมที่ใช้การปฏิเสธนั้นโดยเฉลี่ยเร็วกว่ามากเพราะต้องการเพียงการเพิ่มและการคูณเท่านั้น

Mathematica, 68 44 - 20 = 24 ไบต์

ขอบคุณมากสำหรับ David Carraher ที่บอกให้ฉันรู้RandomPointซึ่งช่วยประหยัด 24 (!) ไบต์ Mathematicaไม่มีในตัวสำหรับทุกอย่าง

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

จุดนี้จะพล็อตและวงกลมล้อมรอบเพื่อรับโบนัส:

ผลที่ได้คือภาพเวกเตอร์ดังนั้นขนาดสเปคของ 201x201 พิกเซลไม่สมเหตุสมผลจริงๆ แต่โดยปกติแล้วมันจะแสดงผลที่ใหญ่กว่านั้น

CJam, 31 26 ไบต์

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

สิ่งนี้ทำงานโดยการสร้างจุดสุ่มซ้ำ ๆ ในความยาวด้าน 2 และรักษาจุดแรกที่อยู่ภายในแผ่นดิสก์ยูนิต

ขอบคุณ @ MartinBüttnerสำหรับการเล่นกอล์ฟ 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.

iKe , 53 51 ไบต์

ไม่มีอะไรพิเศษเป็นพิเศษ แต่ฉันคิดว่าเราควรมีโซลูชันกราฟิกอย่างน้อยหนึ่งรายการ:

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

ลองใช้ในเบราว์เซอร์ของคุณเบราว์เซอร์ของคุณ

แก้ไข: ฉันสามารถโกนสองไบต์ได้โดยใช้วิธีการของ @ MartinBüttnerเพื่อแก้ไขการกระจายตัวของพิกัดเชิงขั้ว ฉันคิดว่ามันค่อนข้างตรงไปกว่า:

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

Perl, 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,")"

ระดับเสียงคู่, 24 53 - 20 = 33 ไบต์

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

สร้างค่า theta ที่มีระยะห่างเท่า ๆ กัน 501 ค่าบวกหนึ่งตัวเลขสุ่มและปรับขนาดทั้งหมดเป็น [0..2π] จากนั้นสร้าง 501 1 สำหรับรัศมีวงกลมบวกรัศมีสุ่มสำหรับจุดนั้นและนำสแควร์รูทเพื่อให้แน่ใจว่ามีการกระจายอย่างสม่ำเสมอทั่วแผ่นดิสก์ จากนั้นทำการแปลงจุดทั้งหมดเป็นพิกัดเชิงขั้ว

นี่คือการสาธิตการกระจายอย่างรวดเร็ว (โดยไม่ต้องวงกลมหน่วย):

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

Octave / Matlab, 74 64 bytes

วิธีการปฏิเสธ 64 ไบต์:

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

วิธีโดยตรง 74 ไบต์ (ขอบคุณ Martin Büttnerที่ช่วยฉันแก้ไขข้อผิดพลาดสองข้อ):

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

R, 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 เพื่อการประหยัด

ลองที่นี่

กำลังดำเนินการ / Java 141 bytes-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)}

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

นี่เป็นกลยุทธ์ "โยนลูกดอกที่ดีที่สุดและรักษากลยุทธ์" สิ่งที่จับได้คือ "สิ่งที่แท่ง" ไม่ได้ถูกกำหนดทางคณิตศาสตร์ แต่เป็นภาพกราฟิก: แผ่นดิสก์สีขาวถูกพล็อตบนพื้นหลังสีดำและจากนั้นจุดที่สร้างแบบสุ่มจะถูกปฏิเสธจนกว่าพวกเขาจะไม่ดำ จุดต่างๆนั้นจะถูกวาดด้วยสีน้ำเงิน (แม้ว่ามันจะยากที่จะบอกเมื่อพวกมันเป็นพิกเซลเดียว - คลิกที่ภาพเพื่อขยาย)

awk - 95 - 5 = 90

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

เนื่องจากฉันไม่แน่ใจเกี่ยวกับ rand () <. 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 ชี้ให้เห็นก่อนหน้านี้

HPPPL , 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;

ตัวอย่าง 10,000 คะแนน (รวมเวลาในหน่วยวินาทีสำหรับอุปกรณ์จริง):

ฟังก์ชั่นของตัวเองถูกเรียกโดย 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) แสดงแผ่นดิสก์ที่มีจุดตามที่แสดงด้านบน

JavaScript, 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)]})`)

Python ขนาด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

ลบคำ**0.5ขอบคุณของ@ jimmy23013 (เพราะมันเป็นวงกลมหน่วยฉันกำลังตรวจสอบว่าระยะทางกำลังสองระหว่าง (x, y) และ (0, 0) เท่ากับ 1 ²นี่คือสิ่งเดียวกัน)

สิ่งนี้ยังทำให้ฉันเอาวงเล็บออกด้วย