แรงบันดาลใจจากการสุ่มด้วยมือของคุณผูก :

เป้าหมาย

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

1. ให้เวลาและหน่วยความจำไม่ จำกัด โปรแกรมของคุณจะต้องส่งออกสตริง 1s และ 0s ตลอดไป
2. โปรแกรมของคุณจะต้องส่งออกมากกว่า 1,000 บิตสุ่มในเวลาประมาณหนึ่งนาทีบนเครื่องที่เหมาะสม หากข้อกำหนดนี้เป็นไปไม่ได้ฉันจะลดให้น้อยลง
3. สตริงของบิตสามารถทำซ้ำได้ แต่ความยาวของส่วนการทำซ้ำต้องมากกว่า 1,000 บิต
4. สตริงของบิตต้องผ่านการทดสอบแบบสุ่มมากที่สุด (อธิบายไว้ด้านล่าง) เท่าที่จะทำได้
5. โปรแกรมจะต้องไม่รับอินพุตใด ๆ จากแหล่งภายนอกหรือใช้ฟังก์ชั่นใด ๆ ในตัวแรนด์ ()
6. เนื่องจากข้อกำหนดข้างต้นโปรแกรมจะต้องส่งออกสตริงที่แน่นอนของบิตในแต่ละครั้งที่รัน

การทดสอบแบบสุ่ม # 1

สตริงของบิตเทียมจะต้องไม่มีรูปแบบที่ชัดเจนใด ๆ เมื่อตรวจสอบด้วยสายตา

การทดสอบแบบสุ่ม # 2 (อาจมีการเปลี่ยนแปลงตามความคิดเห็น)

สตริงของบิตต้องมีการแจกแจงเท่ากับ 1 และ 0 การทดสอบนี้ (และสิ่งอื่น ๆ ด้วย) กระแสของบิตจะถูกแบ่งออกเป็นกลุ่มที่มี 3 101|111|001บิตยาวเช่น

จากกลุ่มทั้งหมดเหล่านี้ 1/8 ของพวกเขาควรมีสาม 1s และไม่มี 0s, 3/8 ของพวกเขาควรมีสอง 1 วินาทีและหนึ่ง 0, 3/8 ของพวกเขาควรมีหนึ่ง 1 และสอง 0s และ 1/8 ของพวกเขาควรจะไม่มี 1 และสาม 0

การทดสอบแบบสุ่ม # 3

"การทำงาน" ถูกกำหนดให้เป็นชุดลำดับของบิตที่ทุกคนมีค่าเดียวกัน สตริง1001001110มีขนาดการรันสามขนาด 1 ( 1..1.....0), ขนาดรันสองขนาด 2 ( .00.00....) และขนาดรันหนึ่งขนาด 3 ( ......111.) ขอให้สังเกตว่าการทำงานไม่ทับซ้อนกัน

จากสตริงของบิตสุ่ม 1,000 บิตควรมีขนาดประมาณ 250 การไหลของ 1, 125 การวิ่งของขนาด 2, 62 การวิ่งของขนาด 3, ฯลฯ โดยทั่วไปสำหรับขนาดรัน R ควรมี1000/(2**(R+1))ขนาดของการวิ่งประมาณนั้น

การทดสอบแบบสุ่ม # 4

840 บิตแรกแบ่งออกเป็นสองส่วนเท่า ๆ กันละ 420 บิต แต่ละบิตในครึ่งแรกจะถูกเปรียบเทียบกับบิตที่เกี่ยวข้องในครึ่งหลัง สองบิตควรจับคู่ประมาณห้าสิบเปอร์เซ็นต์ของเวลา

นี่คือซอร์สโค้ดของโปรแกรม Perl ที่ดำเนินการทดสอบ 2 ถึง 4 ณ ตอนนี้มันต้องการให้สตริงของบิตไม่มีช่องว่างใด ๆ

เวลาเกณฑ์การชนะอย่างมีวัตถุประสงค์!

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

C, 61

main(s,n){for(n=1u<<31;putchar((s%=n)/(n/2)&1|48);s*=65539);}

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

ออกไป หัว -c840
$ ./a.out | หัว -c840 | perl tester.pl
การทดสอบ 2: 1 (1) 2.93333333333333 (3) 3.1 (3) 0.96666666666666667 (1)
การทดสอบ 3: 214 99 71 24 7 5 1 1 2 2
ทดสอบ 4: 0.49523809523809580

ระยะเวลาคือ2²⁹

Mathematica 78 53 ตัวอักษร

ตัวเลขของการแทนเลขฐานสองของ Pi ดูเหมือนจะทำงานราวกับว่ามันถูกสร้างขึ้นอย่างโกลาหลแม้ว่าจะไม่ได้พิสูจน์ก็ตาม

รูทีนแบบง่าย ๆ ต่อไปนี้จะคืนค่าเป็นเลขฐานสองของ pi ซึ่งสอดคล้องกับdหลักทศนิยม:

f[d_]:=ToString@FromDigits@RealDigits[N[Pi,d],2][[1]]

การใช้

หากเราขอสำเนาทศนิยม Pi คู่ 301 หลักเราจะได้รับ 1,000 หลักไบนารี

f[301]
StringLength[%]

(* out *)
1100100100001111110110101010001000100001011010001100001000110100110001001100011001100010100010111000000011011100000111001101000100101001000000100100111000001000100010100110011111001100011101000000001000001011101111101010011000111011000100111001101100100010010100010100101000001000011110011000111000110100000001001101110111101111100101010001100110110011110011010011101001000011000110110011000000101011000010100110110111110010010111110001010000110111010011111110000100110101011011010110110101010001110000100100010111100100100001011011010101110110011000100101111001111110110001101111010001001100010000101110100110100110001101111110110101101011000010111111111101011100101101101111010000000110101101111110110111101110001110000110101111111011010110101000100110011111101001011010111010011111001001000001000101111100010010110001111111100110010010010010100001100110010100011110110011100100010110110011110111000010000000000111110010111000101000010110001110111111000001011001100011011010010010000011011000011100011

1000 (* characters *)

เนื่องจาก Pi เป็นจำนวนอตรรกยะจึงไม่มีคาบ อย่างไรก็ตามจะมีข้อ จำกัด ในทางปฏิบัติเนื่องจากฮาร์ดแวร์ตัวหนึ่งกำลังทำงานอยู่

ทดสอบ 1 ดูดีสำหรับฉัน

ทดสอบ 2

d=301;
Partition[RealDigits[N[Pi,d],2][[1]],{3}];
Tally[%]
(* out *)
{{{1,1,0},35},{{0,1,0},45},{{0,0,0},41},{{1,1,1},40},
{{0,1,1},50},{{1,0,1},32},{{1,0,0},43},{{0,0,1},47}}

ตรวจสอบอย่างละเอียดเพิ่มเติม:

d=10^6;
Partition[RealDigits[N[Pi,d],2][[1]],{3}];
Tally[%]

{{{1,1,0},138565},{{0,1,0},138146},{{0,0,0},138260},{{1,1,1},138427},
{{0,1,1},139119}, {{1,0,1},138404},{{1,0,0},137926},{{0,0,1},138462}}

ทดสอบ 3: รัน

d=10^6;
res3=SortBy[Tally@Split@RealDigits[N[Pi,d],2][[1]],Last]/.{a_,b_}:> {Length[a],b}
ListPlot[res3 ,AxesLabel-> {"Run Length","Runs"},AxesOrigin->{0,0}]

ฉันวิ่งไปเป็นจำนวนมากเพื่อตรวจสอบการกระจายการวิ่งอย่างเป็นระบบ ในเลขฐานสองประมาณ 3 ล้านหลักมี 830k จำนวน 1, 416k จำนวน 2, 208k จำนวน 3, 104k จำนวน 4, ฯลฯ

ทดสอบ 4: การจับคู่ข้อมูลครึ่งแรกและครึ่งหลัง

การแข่งขันเป็น 212 กรณีของ 0 และ 2; ไม่ตรงกันเป็น 208 กรณีที่ผลรวมของตัวเลขที่เกี่ยวข้องคือ 1

d=301;
Tally[Plus@@Partition[Take[RealDigits[N[Pi,d],2][[1]],840],420]]

(* out *)
{{1,208},{0,108},{2,104}}

การจับเวลา

ใช้เวลาน้อยกว่าสองวินาทีในการคำนวณเลขฐาน 3321928 (ตรงกับทศนิยม 10 ^ 6 หลัก)

(r=f[10^6]);//AbsoluteTiming
StringLength[r]

(*out*)
{1.785928,Null}    
3321928

Python 90

g=[19]
print(''.join("01"[(g.append((11*g[-1]+13)%1024)or g[-1])>512]for i in range(1000)))

gคือค่าเมล็ดพันธุ์ การสุ่มตัวอย่างแบบสุ่มแสดงการแจกแจงแบบปกติอย่างน่าทึ่งการสุ่มตัวอย่างแบบสุ่มของตัวอย่างหมายความว่าให้ค่าเฉลี่ย0.506และส่วนเบี่ยงเบนมาตรฐานของ AA .0473(ขนาดตัวอย่าง 1,000) น่าเสียดายที่การสุ่มนั้นมีความไวสูงต่อเมล็ดเริ่มต้น เมล็ดในรหัสข้างบนให้การสุ่มที่ดีที่สุดแก่ฉัน: p

UPDATE

มาดูกันว่าโค้ดนี้มีการทดสอบของ OP อย่างไร:

ทดสอบ # 1

อันนี้เป็นอัตนัยเล็กน้อย ... แต่มันดูแปลกสำหรับฉัน

ทดสอบ # 2

สาม 1 ของ: 0.141
สอง 1 ของ: 0.371
หนึ่ง 1: 0.353
ศูนย์ 1 ของ: 0.135

ทดสอบ # 3

ทำงานตามขนาด:

8: 11
7: 3
6: 7
5: 13
4: 32
3: 67
2: 119
1: 216

ทดสอบ # 4

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

Haskell 74 58

main=print$iterate(read.take 9.show.(^3))7>>=show.(`mod`2)

ขอบคุณshionaสำหรับการทำให้เข้าใจง่าย ผล:

/ pseudorandom | หัว -c 1,000

./pseudorandom | หัว -c 1,000 | ทดสอบ perl

ทดสอบ 2: 0.96666666666666667 (1) 2.4 (3) 3.3 (3) 1.33333333333333 (1)

ทดสอบ 3: 260 108 66 33 15 11 5 2

ทดสอบ 4: 0.495238095238095

นี่ยังเป็นเครื่องกำเนิดไฟฟ้าแบบหลอกหลอกที่น่ากลัว (คล้ายกับที่ใช้โดย von-Neuman) สำหรับผู้ที่ไม่ทราบconcatMap == (=<<) == flip . (>>=)(สำหรับรายการ)

คำถามนี้เทียบเท่ากับ "ใช้การเข้ารหัสแบบสตรีม" ดังนั้นฉันจึงใช้ RC4 เนื่องจากมันค่อนข้างง่าย

ฉันไม่ใช้คีย์และปล่อยบิตแรก 100000 บิตเพราะจุดเริ่มต้นของ RC4 นั้นค่อนข้างเอนเอียงเล็กน้อยโดยเฉพาะเมื่อฉันข้ามการกำหนดเวลาคีย์ แต่ฉันคาดหวังว่ามันจะผ่านการทดสอบของคุณแม้จะไม่มีสิ่งนั้น (บันทึกรหัส 20 อักขระ)

โดยทั่วไปแล้วจะส่งออกเต็มไบต์ต่อรอบ แต่การแปลงเป็นไบนารี่ค่อนข้างน่าเกลียดใน C # ดังนั้นฉันก็ทิ้งทุกอย่างยกเว้นบิตที่สำคัญน้อยที่สุด

var s=Enumerable.Range(0,256).ToArray();
byte i=0,j=0;
for(int k=0;;k++)
{
    i++;
    j+=(byte)s[i];
    var t=s[i];s[i]=s[j];s[j]=t;
    if(k>99999)
        Console.Write(s[i]+s[j]&1);
}

หรือไม่มีช่องว่าง:

var s=Enumerable.Range(0,256).ToArray();byte i=0,j=0;for(int k=0;;k++){i++;j+=(byte)s[i];var t=s[i];s[i]=s[j];s[j]=t;if(k>99999)Console.Write(s[i]+s[j]&1);}

C #, 156 chars ทำงานในโหมดคำสั่งของ LinqPad สำหรับโปรแกรม C # แบบเต็มให้เพิ่มแผ่นความร้อนปกติ

เราสามารถใช้ crypto primitives (Cheater solution):

var h=SHA256.Create();for(BigInteger i=0;;i++){Console.Write(h.ComputeHash(i.ToByteArray())[0]%2);}

(C #, 99 ตัวอักษรทำงานในโหมดคำสั่งของ LinqPad สำหรับคอมไพเลอร์ C # ปกติคุณจะต้องเพิ่มส่วนของแผ่นสำเร็จรูปเล็กน้อย)

ผลลัพธ์ของฟังก์ชั่นแฮ็คเข้ารหัสข้อมูลนั้นถูกออกแบบมาให้แยกไม่ออกจากข้อมูลสุ่มดังนั้นฉันคาดว่ามันจะผ่านการทดสอบแบบสุ่มทั้งหมด (ตายยากขึ้น ... ) คุณโยนมันทิ้ง แต่ฉันขี้เกียจเกินกว่าจะทดสอบได้

C, 52 ตัวอักษร

main(a){for(a=1;putchar(48+a%2);a=a/2^-(a%2)&576);}

นี่คือ LFSR 10 บิตผลการทดสอบ:

$ ./a.out |head -c 1000 | perl randtest.pl
Test 2: 1.13333333333333 (1) 2.86666666666667 (3) 3.16666666666667 (3) 0.833333333333333 (1)
Test 3:  251 122 64 32 16 8 4 2  1
Test 4: 0.466666666666667

Sage / หลาม

โปรแกรมนี้พิมพ์ขวาสุดตัวเลขไบนารีที่มีร่วมกันทุกหอยกสูงพอในรูปแบบ 3 ^{3 3 3 .} . สำหรับทุกสิ่งที่เคยถูกสร้าง feasibly เหล่านี้เป็นตัวเลขไบนารีขวาสุดของจำนวนของเกรแฮม ลำดับหลักไม่มีที่สิ้นสุดและไม่เป็นงวด

m = 1; x = 3; last = 0
while True:
    m *= 2; x = pow(3,x,m); l = len(bin(x))
    print '1' if l > last else '0',
    last = l

สำหรับ 1,000 หลักนี้ใช้เวลาน้อยกว่า 2 วินาที อย่างไรก็ตามเวลาจะเพิ่มขึ้นเร็วกว่าเชิงเส้นในจำนวนหลัก

ผลการทดสอบการใช้โปรแกรม OP ที่มี

Test 2: 1.26666666666667 (1) 3.16666666666667 (3) 2.8 (3) 0.766666666666667 (1)
Test 3:  268 126 61 30 20 7 2  1 1
Test 4: 0.466666666666667

(ดูตัวเลขที่ถูกที่สุดของ G สุ่มหรือไม่สำหรับมากกว่า 32,000 หลักและการทดสอบทางสถิติเพิ่มเติม)

Java, 371 317

อ้างอิงจาก 128 LFSR (บิต taps มาจากxilinx app note 52 )

แก้ไข:ฉันไม่พอใจกับการใช้ BigInteger ดังนั้นรุ่นนี้จึงไม่ บันทึกตัวละครบางตัว ผลผลิตอาจจะสุ่มน้อยลงเล็กน้อยเนื่องจากฉันไม่สามารถนึกถึงวิธีการ 'เริ่มต้น' ที่ดี

รหัสใหม่:ข้อโต้แย้ง: BITS_TO_PRINT

class R{public static void main(String[]a){int L=65536;int[]v={0,128,126,101,99};int[]b=new int[L];for(int x=0;x<L;x++)b[x]=(x*x)&1;for(int i=0;i<Integer.parseInt(a[0])+L;i++){if(1!=(b[v[1]]^b[v[2]]^b[v[3]]^b[v[4]]))b[v[0]]=1;else b[v[0]]=0;if(i>L)System.out.print(b[v[0]]);for(int j=0;j<5;j++)v[j]=(v[j]-1)&(L-1);}}}

รุ่นเก่า: อาร์กิวเมนต์: SEED, BITS_TO_PRINT

import java.math.BigInteger;class R{public static void main(String[]a){BigInteger v=new BigInteger(a[0]);BigInteger m=new BigInteger("ffffffffffffffffffffffffffffffff",16);for(int i=Integer.parseInt(a[1]);i>0;i--){v=v.shiftLeft(1);if(!(v.testBit(128)^v.testBit(126)^v.testBit(101)^v.testBit(99))){v=v.setBit(0);}v=v.and(m);java.lang.System.out.print(v.testBit(0)?1:0);}}}

เวอร์ชันใหม่:เอาต์พุตตัวอย่างบิต = 100:

011001100111000110010100100111011100100111000111001111110110001001100000100111111010111001100100011

JavaScript - 1ms ถึง 2ms สำหรับ 1000 pseudo-random bits (139ms ถึง 153ms สำหรับ 100000 bits)

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

var getDeterministicPseudoRandString = function(length){
    var randString = '';

    var i = 2;
    var prevRand = '';

    outerLoop:
    while(randString.length < length){
        var nextRand, nextFullRand = Math.sqrt(i++).toString(2).substring(1).replace('.', '');
        nextRand = nextFullRand;
        for(var j = prevRand.length; j > 0; j--){
            var replaceString = prevRand.substring(0, j);

            nextRand = nextFullRand;

            if(nextFullRand.indexOf(replaceString) == 0){
                if(j == prevRand.length && j > 30){
                    //start i over at 2
                    console.log('max i reached: ' + i);

                    i = 2;
                    continue outerLoop;
                } else {
                    nextRand = nextFullRand.replace(replaceString, '');
                }

                break;
            }
        }
        prevRand = nextFullRand;

        randString += nextRand;
    }

    return randString.substring(0, length);//Return the substring with the appropriate length
};

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

หลาม

import hashlib
x=''
while 1:
    h=hashlib.sha512()
    h.update(x)
    x=h.digest()
    print ord(x[0])%2

ควรมีระยะเวลาประมาณ 2 ^ 512

Perl 44 ไบต์

ฉันรู้ว่านี่ไม่ใช่โค้ดกอล์ฟ แต่ฉันเป็นแฟนตัวยงของฟังก์ชันบิตกำลังสองอย่างง่ายเช่น:

$x=1/7;print substr($x*=4-4*$x,9,1)%2while 1

ช่วงเวลานั้นยาวกว่า 3 พันล้านครั้ง แต่ฉันใช้พื้นที่ดิสก์หมดเพื่อคำนวณเพิ่ม