您的程序/功能应

• 输出正好一个整数
• 输出具有正概率的任何整数
• 至少以50％的概率输出大于1.000.000或小于-1.000.000的整数。

输出示例（必须全部输出）：

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字节的提交）。它不仅速度更快，而且符合所有规则。在保持合理的运行时间和较小的代码量的同时，获得超过1,000,000个数字的50％概率是一种极限情况。此版本的说明和数学依据：

0{Kmr(+3e5mr}g

这通常需要几秒钟来运行。您可以将替换为5，2以使其运行更快。但是，对于50％概率的要求只能满足1000，而不是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百万步。

• （请注意，这并不是确切的概率，因为这些平均值8.5会有一些波动，但是要达到50％，我们需要远远超过117,646到约210,000步。）
• 如有疑问，我们可以很容易地将终止概率的分母放大，9e9而无需添加任何字节（但需要运行年限）。

...或11个字节？

最后，有一个11字节的版本，它也不受PRNG周期的限制，但是每次都会耗尽内存。每次迭代仅生成一个随机数（基于时间戳），并将其用于递增和终止。每次迭代的结果都保留在堆栈中，并且仅在最后累加。感谢Dennis的想法：

{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

不打高尔夫球

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]

基本上只使用正态分布生成随机数，方差等于1500000。这将产生-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

检查中间的while循环是否可以生成所有整数（尽管偏向零）是微不足道的。选择“ 12”使得大约一半的数字超过±10 ⁶。

较旧的解决方案：

Python 2，44字节

基于Mathematica解决方案。

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

真的不起作用，因为Python float仅具有有限的精度。

Ruby，70岁

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

为了使产生非常大的数字成为可能，我String从lambda 返回该数字作为a 。如果不允许这样做，请额外加上8个字符（用于puts f[]），以使其成为程序而不是函数。

说明

在-1,000,000和之间生成一个数字1,000,000。如果数字大于1或等于该数字，则将其作为返回String。

如果数字小于1，则将递归调用该函数以返回数字范围之外的数字。为了确保也可以生成负数，如果初始数大于-，则在结果前添加a 。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

当然，我看不出有任何理由去工作打印一个当整数:)

打印带有或不带有前导“-”的数字的可能性相同。

打印10％时间的1位数字，9％时间的2位数字，8.1％时间的3位数字，7.29％时间的4位数字，5位数字可能是6.56％的时间，六位数的数字是5.9％的时间，依此类推。任何长度都是可能的，概率降低。一到五位数字占输出案例的约41.5％，而数字1,000,000（或-1,000,000）仅占百分之一的百分之六，因此输出数字将超出-1,000,000到1,000,000的范围（约54.6） ％ 的时间。

“ 0”和“ -0”都是可能的输出，我希望这不是问题。

Perl，114个字符

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之间的可能性趋于零 但可能。

注意：此子例程可能会运行很长时间，并显示错误消息“内存不足！”。错误，但从技术上讲，它会生成问题中所述的任何整数。

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

经过一百万个样本的测试：

~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是因为它使代码尽可能短。

C＃， 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;}

取消高尔夫：

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），对于所有正数n都大于0，对于n = 11则为1/2。还会创建前导零，这在原始问题或其任何注释中似乎都不允许出现。

Perl，62个字节

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

我的想法与@Hobbs相同，一次生成一个数字，但他的代码不满足添加的无前导零的要求。生成第一个数字而不只是符号就解决了这一问题。并且，除非我们打印零时有更短的退出方式，或者生成前导-9到9的更短方式，否则应该按尺寸进行输出。

在shell循环中： while perl -e '...'; do echo;done |less

我认为这是最短的一种，不需要无限的RAM即可解决问题。另外，输出不会偏向任何事物，并且运行时非常快。

我尝试使用按位并在while条件中保存字符，但是我认为这种情况更常见，因此循环会更快结束。将需要更多字符来调整其他内容以应对该问题，以保持产生abs（output）> 1M的可能性。

Java语言（73）

此解决方案使用，你可以建设一批有基础ñ由先前数乘以与ñ并增加在基础的一个数字ñ。我们还有一个附加功能..?..:..，可以创建所有负整数。以下代码应在浏览器控制台中进行测试。

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之间和⁸ = 16777215包容-1，递增计数器，直到随机数碰巧是0。将所得的计数器值具有几何分布与中值约-1 /日志₂（1 − 1/8 ⁸）≈11,629,080，因此它满足“至少50％的时间超过1,000,000”的测试。

las，如此生成的随机数始终严格为正。因此，.2&(*4/需要额外的部分以使其变为负数或零。它的工作原理是提取数字的第二个最低位（因此为0或2），将其递减以使其为-1或1，再乘以原始数字，然后将结果除以4（以摆脱最低的两位，现在与符号相关，并且还允许结果变为零）。即使将其除以4，随机数的绝对值的中值仍为-1 / log ₂（1 − 1/8 ⁸）/ 4≈2,907,270，因此仍通过50％的测试。

JavaScript，81个字节

该代码满足所有规则：

• 输出任何具有正概率的整数
• 以至少50％的概率输出超出+/- 1000000范围的整数
• 没有领先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>

算法：

• 继续在字符串上附加随机数字，s直到出现Math.random() > 0.1。
• 基于Math.random() > 0.5，使数字为负（通过在字符串前面s加上-）。

该算法并非在所有整数上都有统一的分布。具有较高数字位数的整数比较低数字整数的可能性较小。在每个for循环迭代中，我有10％的机会会停在当前位数。我只需要确保超过50％的时间在6位数字后停止即可。

@nutki的以下等式解释了基于上述条件的停止机会百分比的最大值：

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

因此，0.1完全可以满足问题的所有三个规则。

TI-BASIC， 14个字节

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

与@ssdecontrol的R答案类似，它来自均值-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

巴什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，则不再打印任何数字，并且功能结束。

初始化变量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 * min（d * d + s + 1,1），并将其初始化为-1。如果第一个数字为零，则最小值将返回0，而s将等于9-0 = 9。变量的赋值始终在[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)
OSX上的/ dev / random只是随机字节，xxd -p -l5并将5个ascii字符转换为十六进制，然后printf将其转换为十进制格式。

Pyth，11个字节

WOyG~ZtOT)Z

注意：该程序在任何实际计算机上可能会因内存错误而崩溃。要对其进行测试，请尝试G使用较短的字符串替换，例如此代码，该字符串生成的平均数字约为28000：

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

该代码循环，将-1到8的随机数相加Z，每次重复出现退出循环的概率为2 ^ -26。通过选择字母（）O的所有子集（y）的集合中的随机元素（），可获得2 ^ -26的概率G。

技术细节和理由：

概率2 ^ -26从两个事实得出：y当在序列上调用时，是幂集函数，a构造输入的所有子集的列表。由于输入G长度为26个字符，因此此幂设置yG具有2 ^ 26个条目。OyG从2 ^ 26个条目中选择一个随机元素。这些条目中的一个，即空字符串，当传递给Wwhile循环时，将被视为虚假。因此，每次退出循环都有2 ^ -26的概率。

在任何固定数目的循环周期K中，获得数K * 3.5 + m和获得K * 3.5-m的概率是相等的，因为获得一个总数的加数的每个序列都可以颠倒，-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。

此代码依赖于O3天前意外引入并在今天已修复的错误的行为。从12月22日之前或今天以后，它应该可以在任何版本的Pyth 3上运行。以下代码是等效的，并且一直有效：

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。生成的数字的绝对值小于一百万的想法很有趣，但是可能。

取消高尔夫：

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
}

样本输出：将在生成数字后发布。

爪哇（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

在线尝试！