โปรแกรม / ฟังก์ชั่นของคุณควร

• เอาท์พุทว่าหนึ่งจำนวนเต็ม
• เอาต์พุตจำนวนเต็มใด ๆ ที่มีความน่าจะเป็นบวก
• เอาท์พุทจำนวนเต็มมากกว่า 1.000.000 หรือน้อยกว่า -1.000.000 อย่างน้อยกับความน่าจะเป็น 50%

ตัวอย่างผลลัพธ์ (ต้องเป็นไปได้ทั้งหมด):

59875669123
12
-42
-4640055890
0
2014
12
24
-7190464664658648640055894646646586486400558904644646646586486400558904646649001

ชี้แจง:

• อนุญาตให้ใช้ตัวแบ่งบรรทัดต่อท้าย
• ไม่อนุญาตศูนย์นำหน้า
• -0 ได้รับอนุญาต

รหัสที่สั้นที่สุดชนะ

CJam, 16 14 13 ไบต์

0{Kmr(+esmr}g

สิ่งนี้จะทำงานเป็นเวลานานมากเนื่องจากใช้การประทับเวลาปัจจุบัน (ตามลำดับ 10 ¹² ) เพื่อพิจารณาว่าลูปควรยุติหรือไม่ ฉันใช้สิ่งนี้เป็นข้อเสนอเนื่องจากสั้นที่สุด แต่มีทางเลือก 14 ไบต์สองทางซึ่งมีข้อดีของตัวเอง:

0{esmr(+esmr}g

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

ด้านล่างเป็นรุ่นที่เทียบเท่าที่ใช้3e5แทนการประทับเวลา และ20สำหรับช่วงแรก (เช่นการส่ง 13 ไบต์) มันเร็วกว่ามากและเป็นไปตามกฎทั้งหมด มันเป็นกรณีที่มีข้อ จำกัด ในการรับความน่าจะเป็น 50% สำหรับตัวเลขที่มากกว่า 1,000,000 ขณะที่ยังคงรันไทม์ที่เหมาะสมและมีขนาดรหัสเล็ก คำอธิบายและเหตุผลทางคณิตศาสตร์อ้างอิงถึงรุ่นนี้:

0{Kmr(+3e5mr}g

โดยปกติจะใช้เวลาสองสามวินาทีในการเรียกใช้ คุณสามารถแทนที่5ด้วย a 2เพื่อให้ทำงานได้เร็วขึ้น แต่จากนั้นความต้องการของความน่าจะเป็น 50% จะได้รับเพียง 1,000 แทนที่จะเป็น 1,000,000

ฉันเริ่มต้นที่ 0 จากนั้นฉันก็มีลูปที่ฉันมีความน่าจะเป็น 1 / (3 * 10 ⁵ ) ภายในลูปนั้นฉันเพิ่มจำนวนเต็มแบบสุ่มระหว่าง -1 ถึง 18 (รวม) เพื่อผลรวมสะสมของฉัน มีความเป็นไปได้ที่ จำกัด (แม้ว่าจะเล็ก) ว่าจำนวนเต็มแต่ละค่าจะถูกส่งออกโดยที่จำนวนเต็มบวกจะมีโอกาสมากกว่าจำนวนลบ (ฉันไม่คิดว่าคุณจะเห็นค่าลบในช่วงชีวิตของคุณ) การแยกความน่าจะเป็นเล็ก ๆ น้อย ๆ ออกและการเพิ่มเวลาส่วนใหญ่ (และการบวกมากกว่าการลบ) ทำให้มั่นใจได้ว่าเราจะไปได้กว่า 1,000,000

0              "Push a 0.";
 {          }g "Do while...";
  Kmr          "Get a random integer in 0..19.";
     (         "Decrement to give -1..18.";
      +        "Add.";
       3e5mr   "Get a random integer in 0..299,999. Aborts if this is 0.";

การให้เหตุผลทางคณิตศาสตร์บางอย่าง:

• ในแต่ละขั้นตอนเราเพิ่ม 8.5 โดยเฉลี่ย
• ในการรับ 1,000,000 เราต้องการ 117,647 ขั้นตอนเหล่านี้

• ความน่าจะเป็นที่เราจะทำน้อยกว่าจำนวนก้าวนี้คือ

  sum(n=0..117,646) (299,999/300,000)^n * 1/300,000
  

  ซึ่งประเมิน0.324402ว่า ดังนั้นในประมาณสองในสามของกรณีเราจะใช้ขั้นตอนเพิ่มเติม 117,647 ขั้นและแต่ละ 1,000,000 อย่างง่ายดาย

• (โปรดทราบว่านี่ไม่ใช่ความน่าจะเป็นที่แน่นอนเนื่องจากจะมีความผันผวนของค่าเฉลี่ย 8.5 แต่เพื่อให้ได้ 50% เราต้องไปได้ดีกว่า 117,646 ถึงประมาณ 210,000 ขั้นตอน)
• หากมีข้อสงสัยเราสามารถทำให้ตัวหารของความน่าจะเป็นจุดสิ้นสุดสิ้นสุดลงได้อย่างง่ายดาย9e9โดยไม่ต้องเพิ่มไบต์ใด ๆ (แต่เป็นปีรันไทม์)

... หรือ 11 ไบต์?

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

{esmr(}h]:+

Java, 133 149

void f(){String s=x(2)<1?"-":"";for(s+=x(9)+1;x(50)>0;s+=x(10));System.out.print(x(9)<1?0:s);}int x(int i){return new java.util.Random().nextInt(i);}

ตัวอย่างผลลัพธ์

-8288612864831065123773
0
660850844164689214
-92190983694570102879284616600593698307556468079819964903404819
3264

Ungolfed

void f() {
    String s = x(2)<1 ? "-" : "";       // start with optional negative sign
    s+=x(9)+1;                          // add a random non-zero digit
    for(; x(50)>0; )                    // with a 98% probability...
        s+=x(10)                        // append a random digit
    System.out.print(x(9)<1 ? 0 : s);   // 10% chance of printing 0 instead
}

int x(int i) {
    return new java.util.Random().nextInt(i);
}

คำตอบเก่า (ก่อนการเปลี่ยนกฎ)

void f(){if(Math.random()<.5)System.out.print('-');do System.out.print(new java.util.Random().nextInt(10));while(Math.random()>.02);}

Mathematica - 47

Round@RandomVariate@NormalDistribution[0,15*^5]

โดยทั่วไปเพียงแค่สร้างหมายเลขสุ่มโดยใช้การแจกแจงแบบปกติที่มีความแปรปรวนเท่ากับ 1,500,000 สิ่งนี้จะสร้างจำนวนเต็มระหว่าง -10 ^ 6 ถึง 10 ^ 6 โดยมีความน่าจะเป็น 49.5015%

Python 2 75 69 ไบต์

from random import*;s=0;j=randrange
while j(12):s=s*9+j(-8,9)
print s

มันเป็นเรื่องเล็กน้อยที่จะตรวจสอบว่าวงในขณะที่อยู่ตรงกลางสามารถสร้างจำนวนเต็มทั้งหมด (แม้ว่าจะเอนเอียงไปทางศูนย์) "12" ได้รับการแต่งตั้งดังกล่าวว่ามีประมาณครึ่งหนึ่งของตัวเลขเกิน± 10 6

วิธีแก้ปัญหาที่เก่ากว่า:

Python 2, 44 ไบต์

ขึ้นอยู่กับวิธีการแก้ปัญหา Mathematica

from random import*;print int(gauss(0,8**7))

ไม่ได้ผลเพราะ Python floatมีความแม่นยำแน่นอนเท่านั้น

ทับทิม, 70

f=->{m=10**6
r=rand -m..m
r<1?(r>-5e5??-:'')+r.to_s+f[][/\d+/]:r.to_s}

เพื่อให้สามารถสร้างตัวเลขที่มีขนาดใหญ่มากได้ฉันกำลังส่งคืนหมายเลขเป็นStringจากแลมบ์ดา หากไม่ได้รับอนุญาตให้นับ 8 ตัวอักษรพิเศษ (สำหรับputs f[]) เพื่อทำให้เป็นโปรแกรมแทนฟังก์ชั่น

คำอธิบาย

สร้างตัวเลขระหว่างและ-1,000,000 1,000,000ถ้าจำนวนหรือสูงกว่าจำนวนจะถูกส่งกลับเป็น1String

หากตัวเลขต่ำกว่า1ฟังก์ชั่นจะถูกเรียกซ้ำเพื่อส่งกลับตัวเลขนอกช่วงหมายเลข เพื่อให้แน่ใจว่าตัวเลขที่ติดลบยังสามารถสร้างการ-จะนำหน้าไปยังที่เกิดถ้าจำนวนแรกคือมากกว่าString-500,000

ฉันหวังว่าฉันเข้าใจการท้าทายอย่างถูกต้อง!

R, 38

library(Rmpfr)
round(rnorm(1,2e6,1e6))

ดึงจากการแจกแจงแบบเกาส์ด้วยค่าเฉลี่ย 2,000,000 สุ่มเลือกและส่วนเบี่ยงเบนมาตรฐาน 1,000,000 ดังนั้นประมาณ 2/3 ของการจับรางวัลจะอยู่ภายใน 1,000,000 และ 3,000,000 การกระจายไม่มีขอบเขตดังนั้นในทางทฤษฎีสิ่งนี้สามารถสร้างจำนวนเต็มใด ๆ แพคเกจ Rmpfr แทนที่ R ของสองในตัวลอยด้วยความแม่นยำโดยพลการ

Perl, 53 ตัวอักษร

print"-"if rand>.5;do{print int rand 10}while rand>.1

แน่นอนฉันไม่เห็นเหตุผลที่จะทำงานกับจำนวนเต็มเมื่อพิมพ์ :)

มีความน่าจะเป็นที่เท่ากันในการพิมพ์ตัวเลขที่มีหรือไม่มีเครื่องหมาย "-"

พิมพ์ตัวเลข 1 หลัก 10% ของเวลา, ตัวเลข 2 หลัก 9% ของเวลา, ตัวเลข 3 หลัก 8.1% ของเวลา, ตัวเลข 4 หลัก 7.29% ของเวลา, ตัวเลข 5 หลัก 6.56% ของเวลา, ตัวเลข 6 หลัก 5.9% ของเวลา, ฯลฯ ความยาวใด ๆ ที่เป็นไปได้ด้วยความน่าจะลดลง ตัวเลขหนึ่งถึงห้าหลักคิดเป็น 41.5% ของจำนวนคดีที่ส่งออกและจำนวน 1,000,000 (หรือ -1,000,000) เพียง 6 ล้านส่วนหนึ่งของเปอร์เซ็นต์ดังนั้นจำนวนเอาต์พุตจะอยู่นอกช่วง -1,000,000 ถึง 1,000,000 ประมาณ 54.6 % ของเวลา

ทั้ง "0" และ "-0" เป็นเอาต์พุตที่เป็นไปได้ซึ่งฉันหวังว่าจะไม่มีปัญหา

Perl, 114 Chars

use Math::BigInt;sub r{$x=Math::BigInt->new(0);while(rand(99)!=0){$x->badd(rand(2**99)-2**98);}print($x->bstr());}

ชำรุด:

use Math::BigInt;               -- include BigIntegers
  sub r{                        -- Define subroutine "r"
    $x=Math::BigInt->new(0);    -- Create BigInteger $x with initial value "0"
      while(rand(99)!=0){       -- Loop around until rand(99) equals "0" (may be a long time)
        $x->badd(               -- Add a value to that BigInt
          rand(2**99)-2**98);   -- Generate a random number between -2^98 and +2^98-1
        }print($x->bstr());}    -- print the value of the BigInt

ความน่าจะเป็นที่ได้ค่าระหว่าง -1.000.000 ถึง 1.000.000 นั้นพุ่งเข้าหาศูนย์แต่ก็เป็นไปได้

หมายเหตุ: รูทีนย่อยนี้อาจทำงานเป็นเวลานานและเกิดข้อผิดพลาดด้วย "Out of Memory!" ข้อผิดพลาด แต่ในทางเทคนิคการสร้างใด ๆจำนวนเต็มตามที่ระบุไว้ในคำถาม

Perl, 25

sub r{rand(2**99)-2**98;}

สร้างจำนวนเต็มแบบสุ่มภายในช่วง +/- 2 ^ 99

ชำรุด

sub r{                    -- Define subroutine "r"
     rand(2**99)          -- Generate a random integer between 0 and 2^99
                -2**98;}  -- Subtract 2^98 to get negative values as well

ทดสอบด้วย 1 ล้านตัวอย่าง:

~5 are inside the range of +/-1.000.000
~999.995 are outside that range
= a probability of ~99,99% of generating an integer outside that range.
Compare that number to the probability of 2.000.000 in 2^99: It is approx. the same.

ตรงตามกฎทั้งหมด:

• 1 จำนวนเต็ม
• จำนวนเต็มใด ๆ ที่เป็นไปได้
• อย่างน้อย 50% (ในกรณีของฉัน 99,99%) ของจำนวนเต็มที่สร้างทั้งหมดอยู่นอกช่วง +/- 1.000.000

วิธีนี้ใช้งานได้เนื่องจากตัวสร้างตัวเลขสุ่มที่อยู่ภายใต้กำหนดความน่าจะเป็นเท่ากับทุกบิตที่สร้างขึ้นดังนั้นการทำเช่นนั้นกับจำนวนเต็มที่สร้างขึ้น
จำนวนเต็มทุกตัวมีความน่าจะเป็น 1/2 ^ 99 ที่จะสร้าง

แก้ไข:

ฉันต้องเพิ่มเลขชี้กำลังเพื่อสร้างจำนวนเต็มที่มากขึ้น ฉันเลือก 99 เพราะมันจะทำให้รหัสสั้นที่สุดเท่าที่จะเป็นไปได้

ค#, 126 107 ไบต์

string F(){var a=new System.Random();var b=a.Next(-1E6,1E6+1)+"";while(a.Next(1)>0)b+=a.Next(10);return b;}

Ungolfed:

string F()
{
    System.Random rand = new System.Random();
    string rtn = rand.Next(-1E6, 1E6 + 1) + "";
    while (rand.Next(1) > 0)
         rtn += a.Next(10);
    return rtn;
}

โอกาสในการสร้างจำนวนnคือ 1/2 ^ (n-10) ซึ่งมากกว่า 0 สำหรับค่าบวก n ทั้งหมดและ 1/2 สำหรับ n = 11นอกจากนี้ยังสร้างศูนย์นำหน้าซึ่งดูเหมือนจะไม่ได้รับอนุญาตในคำถามต้นฉบับหรือความคิดเห็นใด ๆ

Perl, 62 ไบต์

print $n=int rand(20)-10;while($n&&rand>.1){print int rand 10}

ฉันมีความคิดเช่นเดียวกับ @Hobbs ที่จะสร้างตัวเลขในแต่ละครั้ง แต่รหัสของเขาไม่ตรงตามข้อกำหนดที่ไม่ได้เพิ่มศูนย์ การสร้างดิจิตแรกแทนที่จะเป็นแค่สัญญาณที่แก้ไขนั้น และหากไม่มีวิธีที่สั้นกว่าในการออกถ้าเราพิมพ์ศูนย์หรือวิธีที่สั้นกว่าในการสร้างผู้นำ -9 ถึง 9 สิ่งนี้ควรทำเพื่อขนาด

ในเปลือกวง: while perl -e '...'; do echo;done |less

ฉันคิดว่านี่เป็นหนึ่งในระยะสั้นที่ไม่ต้องใช้ RAM แบบไม่มีที่สิ้นสุดเพื่อแก้ปัญหา โบนัสไม่ได้มีอคติต่อสิ่งใดเลยและรันไทม์นั้นรวดเร็วมาก

ฉันพยายามใช้ bitwise และบันทึกตัวละครในขณะที่อยู่ในสภาพ แต่ฉันคิดว่าสิ่งนี้จบลงด้วยความเป็นจริงมากขึ้นดังนั้นการวนซ้ำจึงจบลงเร็วกว่า จะต้องใช้ตัวอักษรเพิ่มเติมเพื่อปรับสิ่งอื่น ๆ เพื่อตอบโต้เพื่อรักษาความน่าจะเป็นของการสร้าง abs (เอาต์พุต)> 1M

Javascript (73)

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

b=Math.round;c=Math.random;x=0;while(b(c()*99)){x*=b(c())?2:-2;x+=b(c())}

ความน่าจะเป็นที่จะได้จำนวนเต็ม> = 2^1(หรือ <= -(2^1)) เท่ากับโอกาสที่ลูปจะวิ่ง 2 ครั้ง (98/99)^2โอกาสที่จะเกิดขึ้นว่าเป็น โอกาสที่จะได้หมายเลขที่มากกว่า2^20(หรือ <= -(2^20)) จึงเป็น(98/99)^21 = 0.80881% นี่คือทฤษฎีและคาดว่า Math.random จะสุ่มอย่างแท้จริง เห็นได้ชัดว่าไม่ใช่

ตัวอย่างการทดสอบรหัสนี้ นอกจากนี้ในแบบอ่านเพิ่มเติม

var interval = 0;
var epic_unicorns = 0;
var unicorns = 0;

function gimmerandom() {
  var b = Math.round;
  var c = Math.random;
  var x = 0;
  while( b(c()*99) ) {
    x *= b(c()) ? 2 : -2;
    x += b(c());
  }
  return x;
}

function randomcount() {
  var a = gimmerandom();
  if( a <= -1000000 || a >= 1000000 ) {
    epic_unicorns++;
  }
  unicorns++;
  updatedisplay();
}

function updatedisplay() {
  $('#num_of_epicunicorns').text( epic_unicorns );
  $('#num_of_unicorns').text( unicorns );
  var perc = unicorns > 0 ? Math.round( (epic_unicorns / unicorns) * 1000 ) / 10 : 0;
  $('#perc_of_unicorns').text( perc );
}

$('#a').on( 'click', function() {
  clearInterval( interval );
  interval = setInterval( randomcount, 10 );
} );

$('#b').on( 'click', function() {
  clearInterval( interval );
} );

$('#c').on( 'click', function() {
  epic_unicorns = 0;
  unicorns = 0;
  updatedisplay();
} );

updatedisplay();
  

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<span id="num_of_epicunicorns"></span> / <span id="num_of_unicorns"></span> (<span id="perc_of_unicorns"></span>%) were larger than 1.000.000 or less than 1.000.000.

<br><br>
<input type="button" id="a" value="Start"> 
<input type="button" id="b" value="Stop"> 
<input type="button" id="c" value="Reset">

GolfScript ขนาด 20 ไบต์

0{)8.?rand}do.2&(*4/

ใช่แล้วอันนี้ก็ช้าเหมือนกัน

เมื่อเปรียบเทียบกับภาษาอย่าง CJam และ Pyth แล้ว GolfScript ได้รับความทุกข์ทรมานจากคำหลักที่สร้างตัวเลขสุ่ม ( rand) เพื่อเอาชนะแต้มต่อนี้ฉันต้องหาวิธีที่จะใช้มันเพียงครั้งเดียว

รหัสนี้ทำงานโดยการเลือกหมายเลขสุ่มซ้ำ ๆ กันระหว่าง 0 ถึง 8 ⁸ −1 = 16,777,215 รวมและเพิ่มจำนวนตัวนับจนกระทั่งตัวเลขสุ่มเกิดขึ้นเป็น 0 ค่าตัวนับผลลัพธ์มีการกระจายทางเรขาคณิตโดยมีค่ามัธยฐานประมาณ -1 / log ₂ (1 - 1/8 ⁸ ) ≈ 11,629,080 ดังนั้นมันจึงผ่านการทดสอบ "มากกว่า 1,000,000 อย่างน้อย 50% ของเวลา"

อนิจจาตัวเลขสุ่มที่สร้างจึงเป็นบวกอย่างเคร่งครัดเสมอ ดังนั้น.2&(*4/จำเป็นต้องมีส่วนเสริมเพื่อให้มันกลายเป็นลบหรือเป็นศูนย์ มันทำงานได้โดยการแยกบิตที่ต่ำที่สุดที่สองของจำนวน (ซึ่งก็คือ 0 หรือ 2), การลดลงเพื่อให้มันเป็น -1 หรือ 1, คูณมันกับจำนวนเดิมและหารผลลัพธ์ด้วย 4 (เพื่อกำจัด บิตต่ำสุดสองบิตซึ่งสัมพันธ์กับเครื่องหมายและอนุญาตให้ผลลัพธ์กลายเป็นศูนย์) แม้หลังจากหารด้วย 4 แล้วค่าสัมบูรณ์ของตัวเลขสุ่มยังคงมีค่ามัธยฐานของ -1 / log ₂ (1 - 1/8 ⁸ ) / 4 ≈ 2,907,270 ดังนั้นจึงยังคงผ่านการทดสอบ 50%

JavaScript, 81 ไบต์

รหัสนี้เป็นไปตามกฎทั้งหมด:

• เอาต์พุตจำนวนเต็มใด ๆ ที่มีความน่าจะเป็นบวก
• จำนวนเต็มเอาต์พุตที่อยู่นอกช่วง +/- 1000000 โดยมีความน่าจะเป็นอย่างน้อย 50%
• ไม่มีการนำหน้า0ในผลลัพธ์

อัลกอริธึมทำงานด้วยความซับซ้อนของเวลาของO (log ₁₀ n)ดังนั้นมันจึงคืนค่าจำนวนเต็มเกือบทันที

for(s="",r=Math.random;r()>.1;s+=10*r()|0);r(s=s.replace(/^0*/,"")||0)<.5?"-"+s:s

สิ่งนี้ถือว่าเป็นสภาพแวดล้อม REPL ลองใช้รหัสข้างบนในคอนโซลของเบราว์เซอร์ของคุณหรือใช้ส่วนย่อยของสแต็คด้านล่าง:

D.onclick = function() {
  for(s="", r=Math.random;r()>.1; s+=10*r()|0);
  P.innerHTML += (r(s=s.replace(/^0*/,"") || 0) <.5 ?"-" + s : s) + "<br>"
}

<button id=D>Generate a random number</button><pre id=P></pre>

อัลกอริทึม :

• ให้ท้ายตัวเลขสุ่มสตริงจนกว่าsMath.random() > 0.1
• ขึ้นอยู่กับMath.random() > 0.5ทำให้จำนวนลบ (โดยเตรียมสตริงsด้วย-)

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

สมการนี้โดย @nutki อธิบายค่าสูงสุดของเปอร์เซ็นต์การหยุดโอกาสตามเงื่อนไขข้างต้น:

1 - 50%^(1/6) ≈ 0.11

ดังนั้น 0.1 จึงอยู่ในช่วงที่สามารถตอบสนองกฎทั้งสามข้อของคำถามได้

TI-BASIC ขนาด 14 ไบต์

1-2int(2rand:randNorm(AnsE6,9

คล้ายกับคำตอบ R ของ @ ssdecontrol สิ่งนี้ดึงมาจากการแจกแจงแบบเกาส์ด้วยค่าเฉลี่ย -1,000,000 หรือ 1,000,000 การสุ่มเลือกและการเบี่ยงเบนมาตรฐาน 9 การแจกแจงนั้นไม่มีขอบเขตดังนั้นในทางทฤษฎีแล้วสิ่งนี้สามารถสร้างจำนวนเต็มใด ๆ

คำอธิบาย :

1-2int(2rand     - get a random integer 0 or 1, then multiply by 2 and subtract 1
:                - this gives the number 1 or -1 (with equal probability) to Ans
randNorm(AnsE6,9 - displays Gaussian distribution with mean (Ans * 1,000,000) and std. dev. 9

Bash, 66

LANG=C sed -r '/^-?(0|[1-9][0-9]*)$/q;s/.*/5000000/;q'</dev/random

มันเกือบจะพิมพ์ 5000000 แต่ถ้าพบหมายเลขที่ถูกต้อง/dev/randomมันจะพิมพ์หมายเลขนั้นแทน

และอันนี้เร็วกว่า:

LANG=C sed -r '/^-?(0|[1-9][0-9]*)$/q;s/.*/5000000/;q'</dev/urandom

C ++, 95 ไบต์

void f(){int d=-18,s=-1;while(s<9){d=(rand()%19+d+9)%10;cout<<d;s=9-rand()%10*min(d*d+s+1,1);}}

ขยาย:

void f() {
    int d=-18,s=-1;
    while(s<9) {
        d=(rand()%19+d+9)%10;
        cout<<d;
        s=9-rand()%10*min(d*d+s+1,1);
    }
}

คำอธิบาย:

ฟังก์ชั่นยังคงพิมพ์เลขสุ่มต่อเนื่องจนกว่าสวิตช์มูลค่าสุ่มจะใช้ค่าที่ต้องการเพื่อหยุดฟังก์ชั่น d คือตัวแปรที่เก็บค่าของตัวเลขถัดไปที่จะพิมพ์ s คือตัวแปรสวิตช์ที่รับค่าจำนวนเต็มแบบสุ่มในช่วงเวลา [0, 9] ถ้า s == 9 จะไม่มีการพิมพ์ตัวเลขอีกต่อไปและ funtion จะสิ้นสุดลง

ตัวแปร d และ s ถูกเตรียมใช้งานเพื่อให้การดูแลเป็นพิเศษกับเลขตัวแรก (รับจากช่วง [-9, 9] และถ้าตัวเลขตัวแรกเป็นศูนย์ฟังก์ชันจะต้องจบเพื่อหลีกเลี่ยงเลขศูนย์นำหน้า) ค่าของ d สามารถกำหนดเป็น d = rand ()% 10 แต่หลักแรกไม่สามารถเป็นลบได้ d ถูกกำหนดแทนเป็น d = (rand ()% 19 + d + 9)% 10 และเริ่มต้นที่ -18 ดังนั้นค่าแรกของ d จะอยู่ในช่วงตั้งแต่ [-9, 9] และค่าถัดไปจะอยู่ในช่วงตั้งแต่ [0 , 9].

ตัวแปร s มีช่วงแบบสุ่มจาก [0, 9] และถ้า s เท่ากับ 9 ฟังก์ชันจะสิ้นสุดดังนั้นหลังจากพิมพ์ตัวเลขแรกแล้วเลขถัดไปจะถูกพิมพ์ด้วยความน่าจะเป็น 90% (สมมติว่า rand () สุ่มอย่างแท้จริงและ เพื่อให้เป็นไปตามเงื่อนไขที่สาม) s สามารถถูกกำหนดให้เป็น s = rand ()% 10 ได้อย่างง่ายดายอย่างไรก็ตามมีข้อยกเว้นหากตัวเลขตัวแรกเป็นศูนย์ฟังก์ชันจะต้องสิ้นสุด เพื่อจัดการกับข้อยกเว้นดังกล่าว s ได้รับมอบหมายเป็น s = 9-rand ()% 10 * นาที (d * d + s + 1,1) และเริ่มต้นเป็น -1 หากตัวเลขแรกคือศูนย์นาทีจะส่งกลับ 0 และ s จะเท่ากับ 9-0 = 9 การมอบหมายตัวแปรของ s จะอยู่ในช่วงตั้งแต่ [0, 9] เสมอดังนั้นข้อยกเว้นสามารถเกิดขึ้นได้ที่หลักแรกเท่านั้น

ลักษณะ (สมมติว่า rand () เป็นแบบสุ่มอย่างแท้จริง)

• จำนวนเต็มถูกพิมพ์เป็นตัวเลขด้วยหลักโดยมีความน่าจะเป็นคงที่ 90% ของการพิมพ์ตัวเลขอื่นหลังจากพิมพ์ตัวเลขสุดท้าย

• 0 เป็นจำนวนเต็มที่มีโอกาสสูงสุดในการพิมพ์โดยมีความน่าจะเป็นประมาณ 5.2%

• ความน่าจะเป็นที่จะพิมพ์จำนวนเต็มตามช่วงเวลา [-10 ^ 6, 10 ^ 6] มีค่าประมาณ 44% (การคำนวณไม่ได้เขียนไว้ที่นี่)

• จำนวนเต็มบวกและลบจะถูกพิมพ์ด้วยความน่าจะเป็นเดียวกัน (~ 47.4%)

• ไม่ใช่พิมพ์ตัวเลขทั้งหมดที่มีความน่าจะเป็นเหมือนกัน ตัวอย่างเช่น: ในระหว่างการพิมพ์จำนวนเต็มถ้าตัวเลขสุดท้ายเป็น 5 ตัวเลข 3 จะมีโอกาสที่จะพิมพ์ถัดไปเล็กน้อย โดยทั่วไปหากตัวเลขสุดท้ายคือ d ตัวเลข (d + 18)% 10 จะมีโอกาสที่จะถูกพิมพ์ออกมาเล็กน้อยในครั้งต่อไป

ตัวอย่างผลลัพธ์ (การประมวลผล 10 ครั้ง)

-548856139437
7358950092214
507
912709491283845942316784
-68
-6
-87614261
0
-5139524
7

Process returned 0 (0x0)   execution time : 0.928 s
Press any key to continue.

Bash, 42 ไบต์

printf "%d\n" 0x$(xxd -p -l5 /dev/random)
/ dev / random บน OSX เป็นเพียงการสุ่มไบต์และxxd -p -l5แปลง 5 ของอักขระ ASCII ให้printfเป็นเลขฐานสิบหกและเปลี่ยนเป็นรูปแบบทศนิยม

Pyth , 11 ไบต์

WOyG~ZtOT)Z

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

pyth -c 'WOy"abcdefghijklm"~ZtOUT)Z'

โค้ดนี้วนZซ้ำเพิ่มจำนวนสุ่มจาก -1 ถึง 8 ถึงโดยมีความน่าจะเป็น 2 ^ -26 ในการออกจากลูปในการทำซ้ำแต่ละครั้ง ความน่าจะเป็น 2 ^ -26 นั้นได้มาจากการเลือกองค์ประกอบแบบสุ่ม ( O) ของชุดย่อยทั้งหมด ( y) ของตัวอักษร ( G)

รายละเอียดทางเทคนิคและเหตุผล:

ความน่าจะเป็นที่ 2 -26 มาจากข้อเท็จจริงสองประการ: yเมื่อเรียกตามลำดับคือฟังก์ชั่นตั้งค่าพลังงานจะสร้างรายการของชุดย่อยทั้งหมดของอินพุต เนื่องจากอินพุตGมีความยาว 26 อักขระชุดไฟนี้yGจึงมีรายการ 2 ^ 26 OyGเลือกองค์ประกอบแบบสุ่มจากรายการ 2 ^ 26 หนึ่งในรายการเหล่านั้นคือสตริงว่างจะประเมินว่าเป็นเท็จเมื่อผ่านไปWยังลูป while ดังนั้นจึงมีความน่าจะเป็น 2 ^ -26 ในการออกจากลูปในแต่ละครั้ง

ในจำนวนคงที่ของลูปวนรอบ K ความน่าจะเป็นที่จะได้หมายเลข K * 3.5 + m และรับ K * 3.5 - ม. เท่ากันเนื่องจากแต่ละลำดับของการเพิ่มที่ประสบความสำเร็จหนึ่งครั้งสามารถกลับด้านได้ -1 -> 8, 0 -> 7 เป็นต้นเพื่อให้บรรลุเป้าหมายอื่น ๆ นอกจากนี้ตัวเลขที่ใกล้เคียงกับ K * 3.5 จะมีแนวโน้มชัดเจนกว่าตัวเลขที่อยู่ไกลออกไป ดังนั้นถ้า K> 2000000 / 3.5 = 571428.5 ความน่าจะเป็นที่จะได้ตัวเลขมากกว่า 1000000 นั้นสูงกว่า 75% เพราะผลลัพธ์บางส่วนที่อยู่เหนือหมายเลขนั้นสามารถใส่ลงในการติดต่อแบบตัวต่อตัวกับผลลัพธ์ทั้งหมดที่อยู่ด้านล่าง ตัวเลขและน้อยกว่าครึ่งบนสามารถใส่ลงในการติดต่อแบบหนึ่งต่อหนึ่งกับผู้ที่มีค่าต่ำกว่า 1000000 ความน่าจะเป็นที่จะได้ลูป 571429 อย่างน้อยคือ (1-2 ^ -26) ^ 571429 ซึ่งไม่ใช่ น้อยกว่า (1-2 ^ -26 * 571429) จำนวนครั้งที่คาดว่าจะออกจากลูปในการลอง 571429 ครั้งแรกซึ่งเป็น 99.1% ดังนั้นในการทดสอบ 99.1% หรือมากกว่านั้นมีโอกาส 75% หรือมากกว่าที่จะได้รับอย่างน้อย 1000000 ดังนั้นจึงมีโอกาสมากกว่า 50% ที่จะได้รับมากกว่า 1000000

รหัสนี้ขึ้นอยู่กับพฤติกรรมOที่มีข้อผิดพลาดเกิดขึ้นเมื่อ 3 วันก่อนและได้รับการแก้ไขแล้ว ควรทำงานกับ Pyth 3 ทุกรุ่นตั้งแต่ก่อนวันที่ 22 ธันวาคมหรือหลังจากวันนี้ รหัสต่อไปนี้เทียบเท่าและทำงานได้เสมอ:

WOyG~ZtOUT)Z

Java, 113 ไบต์

void g(){String a=Math.random()>0?"10":"01";for(;Math.random()>0;)a+=(int)(Math.random()*2);System.out.print(a);}

โปรแกรมนี้พิมพ์เลขฐานสองไปยังเอาต์พุตสตรีมมาตรฐาน คุณอาจต้องรอสักครู่เนื่องจากความน่าจะเป็นที่จะสิ้นสุดตัวเลข (หรือเป็นบวก) มีค่าประมาณ 0 ความคิดที่ว่าค่าสัมบูรณ์ของตัวเลขที่สร้างขึ้นมีค่าน้อยกว่า 1 ล้านคนก็น่าขบขัน แต่ก็เป็นไปได้

Ungolfed:

void g(){
    String a=Math.random()>0?"10":"01";             //Make sure there are no trailing zeroes.
    for(;Math.random()>0;)a+=(int)(Math.random()*2);//Add digits
    System.out.print(a);                            //Print
}

ตัวอย่างผลลัพธ์: จะโพสต์เมื่อสร้างหมายเลขเสร็จแล้ว

Java (JDK) , 140 127 ไบต์

()->{int i;var o=System.out;for(o.print(i=(int)(19*Math.random())-10);i!=0&Math.random()<.9;)o.print((int)(11*Math.random()));}

-13 bytes โดยย่องตรรกะมากขึ้นในส่วนหัวของห่วง - ขอบคุณ @ceilingcat

ลองออนไลน์!