เกี่ยวกับซีรี่ส์

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

แม้ว่าฉันจะมีไอเดียมากมายสำหรับชุด แต่ความท้าทายในอนาคตยังไม่เกิดขึ้น หากคุณมีข้อเสนอแนะใด ๆ โปรดแจ้งให้เราทราบเกี่ยวกับการโพสต์ Sandbox ที่เกี่ยวข้อง

Hole 4: The Bertrand Paradox

เบอร์ทรานด์ขัดแย้งเป็นปัญหาที่น่าสนใจซึ่งแสดงให้เห็นว่าวิธีการที่แตกต่างกันสำหรับการเลือกคอร์ดสุ่มในวงกลมสามารถให้ผลผลิตแตกต่างกันของการกระจายคอร์ดกึ่งกลางและความยาวของพวกเขา

ในความท้าทายนี้คุณควรจะสร้างคอร์ดสุ่มของวงกลมหน่วยโดยใช้วิธี "ขวา" คือหนึ่งที่สร้างการกระจายของคอร์ดที่ไม่เปลี่ยนแปลงภายใต้การปรับและการแปล ในบทความ Wikipedia ที่เชื่อมโยง "วิธีที่ 2" เป็นวิธีการดังกล่าว

นี่คือกฎที่แน่นอน:

• คุณควรใช้จำนวนเต็มบวกหนึ่งตัวNซึ่งระบุจำนวนคอร์ดที่ควรส่งคืน เอาต์พุตควรเป็นรายการของNคอร์ดแต่ละอันระบุเป็นสองจุดบนวงกลมหน่วยกำหนดโดยมุมขั้วของพวกเขาเป็นเรเดียน
• รหัสของคุณควรจะสามารถที่จะกลับมาอย่างน้อย 2 ²⁰ค่าที่แตกต่างกันสำหรับแต่ละสองมุม หาก RNG ที่มีของคุณมีช่วงที่มีขนาดเล็กคุณต้องแรกสร้าง RNG มีช่วงขนาดใหญ่พอที่ด้านบนของตัวเครื่องในหนึ่งหรือคุณต้องใช้ของคุณเองRNG เหมาะสม หน้านี้อาจมีประโยชน์สำหรับสิ่งนั้น
• การกระจายคอร์ดจะต้องแยกไม่ออกจากคอร์ดที่ผลิตโดย "วิธีที่ 2" ในบทความ Wikipedia ที่เชื่อมโยง หากคุณใช้อัลกอริทึมที่แตกต่างในการเลือกคอร์ดโปรดระบุหลักฐานความถูกต้อง ไม่ว่าอัลกอริทึมใดที่คุณเลือกที่จะใช้มันจะต้องสามารถสร้างคอร์ดที่ถูกต้องใด ๆ ในวงกลมได้ในทางทฤษฎี (ยกเว้นข้อ จำกัด ของ PRNG หรือประเภทข้อมูลที่มีความแม่นยำ จำกัด )
• การดำเนินงานของคุณควรจะใช้อย่างใดอย่างหนึ่งและกลับจำนวนจุดลอยตัว (อย่างน้อย 32 บิตกว้าง)หรือหมายเลขจุดคงที่ (อย่างน้อย 24 บิตกว้าง)และดำเนินการทางคณิตศาสตร์ทุกคนควรจะมีความถูกต้องภายในที่มากที่สุด 16 ULP

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นและรับอินพุตผ่าน STDIN (หรือทางเลือกที่ใกล้เคียงที่สุด) อาร์กิวเมนต์บรรทัดคำสั่งหรืออาร์กิวเมนต์ฟังก์ชันและสร้างเอาต์พุตผ่าน STDOUT (หรือทางเลือกที่ใกล้เคียงที่สุด), ค่าส่งคืนของฟังก์ชันหรือพารามิเตอร์

ผลลัพธ์อาจอยู่ในรูปแบบรายการหรือรูปแบบสตริงใดก็ได้ตราบใดที่ตัวเลขแต่ละตัวมีความแตกต่างอย่างชัดเจน

นี่คือรหัสกอล์ฟดังนั้นการส่งที่สั้นที่สุด (เป็นไบต์) ชนะ และแน่นอนว่าการส่งสั้นที่สุดต่อผู้ใช้จะเข้าสู่กระดานผู้นำโดยรวมของซีรีย์ด้วย

การแสดง

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

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

ลีดเดอร์บอร์ด

โพสต์แรกของซีรีส์สร้างกระดานผู้นำ

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มต้นทุกคำตอบด้วยบรรทัดแรกโดยใช้เทมเพลต Markdown ต่อไปนี้:

# Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัว ตัวอย่างเช่น

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

(ภาษาไม่ปรากฏในปัจจุบัน แต่ตัวอย่างข้อมูลต้องการและแยกวิเคราะห์และฉันอาจเพิ่มกระดานผู้นำแบบแยกภาษาในอนาคต)

รหัสเครื่อง 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

มันใช้อัลกอริทึม (แก้ไขเล็กน้อย) ที่ Wikipedia อธิบาย ในรหัสปลอม:

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เป็นลบ (นี้เกิดขึ้นเพียงครั้งเดียวเท่านั้น)

Pyth, 25 23 22 ไบต์

พอร์ตของคำตอบ C ++ 11 ของ rcrmn นี่เป็นครั้งแรกที่ฉันใช้ Pyth และฉันสนุกมาก!

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

รุ่น 23 ไบต์:

VQJ*y.n0O0K.tOZ4+JK-JKd

ตัดไบต์ด้วยการเปลี่ยนโปรแกรมให้ใช้การพับ + ผลรวมและตั้งค่า J เป็น tuple โดยลบ K

เดิม:

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

ตัดออก 2 ไบต์ด้วย @orlp

คำอธิบาย:

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

Julia, 48 ไบต์

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

วิธีนี้ใช้อัลกอริธึมวิธีที่ 2 เหมือนกับคำตอบส่วนใหญ่ มันสร้างฟังก์ชั่นแลมบ์ดาที่รับอินพุตจำนวนเต็มและส่งคืนอาร์เรย์ nx 2 f=n->...เรียกว่าให้มันชื่อเช่น

คำอธิบาย Ungolfed +:

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)มันเป็นผลมาจากการ

Pyth, 22 ไบต์

พอร์ตของคำตอบ C ++ ฉันมีวิธีแก้ปัญหาอีก 23 ไบต์ (ตอนนี้ 22!) แต่มันเกือบจะเป็นสำเนาของคำตอบแบบ pyth ของ @ kirbyfan64sos พร้อมการเพิ่มประสิทธิภาพดังนั้นฉันต้องคิดนอกกรอบเล็กน้อยและอย่างสร้างสรรค์ (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

สำหรับ refence นี้เป็นโซลูชันอื่นของฉันที่ทำงานในลักษณะเดียวกัน: VQKy*.nZOZJ.tOZ4,+KJ-KJ

IDL, 65 ไบต์

เห็นได้ชัดว่านี่เป็นอัลกอริทึมเดียวกับ @rcrmn แม้ว่าฉันจะได้รับมันอย่างอิสระก่อนที่จะอ่านคำตอบของพวกเขา

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

ฟังก์ชัน randomu ของ IDL ใช้ Mersenne Twister ซึ่งมีระยะเวลา 2 ¹⁹⁹³⁷ -1

แก้ไข: ฉันวิ่ง 1,000 คอร์ดผ่าน visualizer ด้านบนนี่เป็นภาพหน้าจอของผลลัพธ์:

C ++ 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<<';';}}

นี่คือการนำอัลกอริทึมที่ถูกต้องมาใช้โดยตรงจากหน้าวิกิพีเดีย ปัญหาหลักในการเล่นกอล์ฟคือชื่อที่ยาวมาก ๆ ที่คลาสเครื่องกำเนิดไฟฟ้าแบบสุ่มมี แต่ในทางตรงกันข้ามกับ rand ดี ol 'อย่างน้อยก็เหมือนกันอย่างถูกต้อง

คำอธิบาย:

#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
    }
}

APL, 46 ไบต์

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

โปรแกรม APL ครั้งแรกของฉัน! แน่นอนว่ามันสามารถปรับปรุงได้อย่างมาก (เนื่องจากขาดความเข้าใจโดยรวมของฉันเกี่ยวกับ APL) ดังนั้นข้อเสนอแนะใด ๆ ก็น่าอัศจรรย์ สิ่งนี้จะสร้างฟังก์ชั่น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) มากกว่า (x + y, xy) ความโศกเศร้ามากมาย

Java, 114 ไบต์

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

การใช้งานพื้นฐานในจาวา ใช้เป็นนิพจน์แลมบ์ดา

ตัวอย่างการใช้งาน

Ruby, 72 ไบต์

กอล์ฟครั้งแรกของฉันที่นี่! ฉันใช้รหัสเดียวกันกับทุกคนฉันหวังว่าไม่เป็นไร

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

Java, 115 123

นี่เป็นพื้นฐานเหมือนกับคนอื่น ๆ ส่วนใหญ่ แต่ฉันต้องการคะแนน Java สำหรับหลุมนี้ดังนั้นที่นี่จะไป:

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();}

ตัวอย่างคอร์ด 1,000 ตัวอย่างสามารถพบได้ที่pastebin ต่อไปนี้เป็นห้าครั้งแรกจากการวิ่งหนึ่งครั้ง:

8.147304676211474 3.772704020731153
8.201346559916786 3.4066194978900106
4.655131524088468 2.887965593766409
4.710707820868578 3.8493686706403984
3.3839198612642423 1.1604092552846672

CJam, 24 22 ไบต์

คล้ายกับอัลกอริทึมอื่นนี่คือเวอร์ชันใน CJam

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

อินพุต 1,000 สร้างการกระจายแบบ:

มันทำงานอย่างไร

อัลกอริทึมเป็นเพียง 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 ไบต์ด้วย Martin!

ลองที่นี่

Python 3, 144 117 bytes

(ขอบคุณ Blckknght สำหรับ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))]

จากเอกสาร Python:

Python ใช้ Mersenne Twister เป็นตัวสร้างคอร์ มันสร้างความแม่นยำ 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)]

และอื่น ๆ

การแสดง

Perl, 60

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

R, 60 56 53 49 ไบต์

เพิ่ม 4 ไบต์พิเศษด้วย @JayCe และเปลี่ยนเป็นฟังก์ชัน

ใช้สูตรพื้นฐานเดียวกับสูตรอื่น R ใช้วิธี Mersenne-Twister ตามค่าเริ่มต้น แต่สามารถตั้งค่าวิธีอื่นได้ ส่งออกรายการคั่นด้วยช่องว่าง

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

ลองออนไลน์!

SmileBASIC ขนาด 62 ไบต์

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