프로그램 / 기능은

• 정확히 하나의 정수를 출력
• 출력 어떤 긍정적 확률 정수
• 적어도 50 % 확률로 1.000.000보다 크거나 -1.000.000보다 작은 정수를 출력합니다.

출력 예 (모두 가능해야 함) :

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

설명 :

• 후행 줄 바꿈이 허용됩니다.
• 선행 0은 허용되지 않습니다.
• -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를 a 2로 바꿀 수 있습니다 . 그러나 50 % 확률에 대한 요구 사항은 1,000,000이 아닌 1,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. 따라서 사례의 약 2/3에서 더 많은 117,647 개의 단계를 거치게되며 각 1,000,000 개를 쉽게 수행 할 수 있습니다.

• (이것은 정확한 확률이 아니라는 점에 유의하십시오. 평균 8.5에 대해서는 약간의 변동이있을 것이지만 50 %에 도달하려면 117,646을 넘어 약 210,000 단계를 거쳐야합니다.)
• 의심 스러우면 9e9바이트를 추가하지 않고도 (그러나 몇 년의 런타임) 종료 확률의 분모를 쉽게 부 풀릴 수 있습니다 .

... 또는 11 바이트?

마지막으로 11 바이트 버전이 있는데, 이는 PRNG 기간에 의해 제한되지 않지만 매번 메모리가 거의 소모됩니다. 각 반복마다 하나의 난수 (타임 스탬프에 따라)를 생성하고 증가 및 종료에 모두 사용합니다. 각 반복의 결과는 스택에 남아 있으며 끝에서만 요약됩니다. 이 아이디어에 대해 Dennis에게 감사합니다.

{esmr(}h]:+

자바, 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);}

매스 매 티카-47

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

기본적으로 1500000과 같은 분산을 갖는 정규 분포를 사용하여 난수를 생성합니다. 이렇게하면 확률이 49.5015 % 인 -10 ^ 6과 10 ^ 6 사이의 정수가 생성됩니다.

파이썬 2, 75 69 바이트

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

중간에있는 while 루프가 모든 정수를 생성 할 수 있는지 확인하는 것은 사소한 일입니다 (0쪽으로 바이어스 됨). "10"은 ± 10 ^6을 초과하는 숫자의 대략 절반이 있도록 선택 됩니다.

이전 솔루션 :

파이썬 2, 44 바이트

Mathematica 솔루션을 기반으로합니다 .

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

파이썬의 float정밀도는 유한 하기 때문에 실제로 작동하지 않습니다 .

루비, 70

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

매우 큰 숫자를 생성하기 위해 String람다에서 숫자를 반환합니다 . 이것이 허용되지 않으면 8 문자를 더 세어 (for puts f[]) 함수 대신 프로그램으로 만드십시오.

설명

-1,000,000와 사이의 숫자를 생성하십시오 1,000,000. 숫자가 1크면 숫자가로 반환됩니다 String.

숫자가보다 작 으면 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에 내장 된 double float를 임의의 정밀도로 대체합니다.

펄, 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 % 등. 확률이 감소함에 따라 모든 길이가 가능합니다. 1 ~ 5 자리 숫자는 출력 사례의 약 41.5 %를 차지하고 1,000,000 (또는 -1,000,000)은 6 백만 퍼센트에 불과하므로 출력 숫자는 -1,000,000-1,000,000 범위에서 약 54.6입니다. % 그 시간의.

"0"과 "-0"은 모두 가능한 출력이므로 문제가되지 않기를 바랍니다.

펄, 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 사이의 값을 얻을 확률은 0으로 향하는 경향이 있지만 가능합니다.

참고 :이 서브 루틴은 오랫동안 실행되어 "메모리 부족!"으로 오류가 발생할 수 있습니다. 오류이지만 기술적으로 질문에 명시된 바와 같이 정수를 생성 합니다 .

펄, 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를 선택했습니다.

씨#, 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입니다.또한 선행 0을 생성하여 원래 질문이나 주석에서 허용되지 않는 것 같습니다.

펄, 62 바이트

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

나는 한 번에 숫자를 생성한다는 @Hobbs와 같은 아이디어를 가지고 있었지만 그의 코드는 0이 아닌 추가 요구 사항을 충족시키지 못했습니다. 부호 대신 첫 번째 숫자를 생성하면 문제가 해결되었습니다. 그리고 0을 인쇄하면 더 짧은 종료 방법이나 선행 -9 ~ 9를 생성하는 더 짧은 방법이 없다면 크기를 지정해야합니다.

쉘 루프에서 : while perl -e '...'; do echo;done |less

나는 이것이 문제를 만족시키기 위해 무한 RAM을 필요로하지 않는 가장 짧은 것 중 하나라고 생각합니다. 보너스로, 출력은 어떤 것에도 치우 치지 않으며 런타임은 매우 빠릅니다.

비트 조건을 사용하고 while 조건에서 문자를 저장하려고 시도했지만 이것이 더 자주 사실이라고 생각하므로 루프가 더 빨리 종료됩니다. abs (output)> 1M 생성 가능성을 유지하기 위해 다른 것들을 조정하려면 더 많은 문자가 필요합니다.

자바 스크립트 (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으로 일어날 때까지 카운터를 증분 기하 분포 A의 중앙값을 약 -1 / 로그인 ₂ (1 − 1/8 ⁸ ) ≈ 11,629,080이므로 "시간의 50 % 이상 1,000,000 이상"테스트를 충족합니다.

아아, 이렇게 생성 된 난수는 항상 엄격하게 양수입니다. 따라서 .2&(*4/음수 또는 0이 되려면 추가 부분이 필요합니다. 그것은 숫자의 두 번째로 낮은 비트 (0 또는 2)를 추출하여 -1 또는 1로 감소시키고 원래 숫자와 곱한 다음 결과를 4로 나눕니다 (제거하려면) 가장 낮은 두 비트, 이제 부호와 상관이 있으며 결과가 0이됩니다). 4로 나눈 후에도 난수의 절대 값은 여전히 ​​-1 / log ₂ ( 1-1/ ^{8 8} ) / 4 ≈ 2,907,270의 중앙값을 가지므로 여전히 50 % 테스트를 통과합니다.

자바 스크립트, 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>

알고리즘 :

• sa까지 문자열에 임의의 숫자를 계속 추가하십시오 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, it will print that number instead.

그리고 이것은 더 빠릅니다.

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] 간격에서 시작하고 첫 번째 숫자가 0이면 함수는 선행 0을 피하기 위해 종료해야합니다). 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으로 쉽게 지정할 수 있지만 예외는 있지만 첫 번째 숫자가 0이면 함수가 종료되어야합니다. 이러한 예외를 처리하기 위해 s는 s = 9-rand () % 10 * min (d * d + s + 1,1)로 지정되었고 -1로 초기화되었습니다. 첫 번째 숫자가 0이면 최소값은 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.

배쉬, 42 바이트

printf "%d\n" 0x$(xxd -p -l5 /dev/random)
OSX의 / dev / random은 임의의 바이트이며 xxd -p -l55 개의 ASCII 문자를 16 진수로 변환 printf하여 10 진수 형식으로 바꿉니다.

Pyth , 11 바이트

WOyG~ZtOT)Z

참고 :이 프로그램은 실제 컴퓨터의 메모리 오류와 충돌 할 수 있습니다. 테스트하려면 G이 코드와 같이 짧은 문자열로 바꾸어 평균 28000 정도의 숫자를 생성하십시오.

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

이 코드는 -1에서 8까지의 난수를 더하여 Z반복되며, 각 반복에서 루프를 종료 할 확률은 2 ^ -26입니다. 2 ^ -26 확률은 알파벳 ( ) O의 모든 하위 집합 집합 ( y) 에서 임의의 요소 ( )를 선택하여 얻을 수 G있습니다.

기술적 세부 사항 및 정당성 :

확률 2 ^ -26은 두 가지 사실에서 파생됩니다. y, 시퀀스에서 호출 될 때 검정력 함수이며 입력의 모든 하위 집합 목록을 구성합니다. 입력 G은 26 자 길이이므로이 전원 세트 yG에는 2 ^ 26 개의 항목이 있습니다. OyG2 ^ 26 항목에서 임의의 요소를 선택합니다. 해당 항목 중 하나 인 빈 문자열은 전달 될 때 잘못된 것으로 평가됩니다.W 은 while 루프로 . 따라서 매번 루프를 종료 할 확률은 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 %보다 큽니다. 해당 숫자 이상의 결과 중 일부는 아래의 모든 결과와 일대일로 대응할 수 있기 때문입니다. 숫자와 1/2보다 작은 상위는 1000000 미만의 숫자와 일대일로 대응할 수 있습니다. 571429 개 이상의 루프를 얻을 확률은 (1-2 ^ -26) ^ 571429입니다. (1-2 ^ -26 * 571429) 미만, 처음 571429 회 시도에서 루프를 벗어나는 예상 횟수는 99.1 %입니다. 따라서 99.1 % 이상의 시도에서 1000000 이상을 얻을 확률이 75 % 이상이므로 1000000 이상을 얻을 확률이 50 % 이상입니다.

This code relies on a behavior of O where a bug was accidentally introduced 3 days ago and was fixed today. It should work on any version of Pyth 3 from before Dec 22nd, or after today. The following code is equivalent, and has always worked:

WOyG~ZtOUT)Z

Java, 113 bytes

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

This program prints a binary number to standard output stream. You might have to wait a while because the probability of it ending the number (or it being positive) is approximately 0. The idea that the absolute value of a number generated is less than 1 million is amusing, yet possible.

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
}

Sample output: Will post when a number is done being generated.

Java (JDK), 140 127 bytes

()->{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 by sneaking more logic into the loop header - thanks to @ceilingcat

Try it online!