Görev

Seçtiğiniz herhangi bir şekilde giriş olarak belirtilenden ndaha düşük bir pozitif tamsayı verildiğinde 2^30, kodunuzun 0ve n, dahil olmak üzere rasgele bir tamsayı vermesi gerekir . Ürettiğiniz sayı rastgele eşit şekilde seçilmelidir . Bu, her bir değer 0için neşit olasılıkla cereyan etmesi gerekmektedir (Kurallar ve belgesine bakınız).

Kurallar ve Uyarılar

Kodunuz, kendi dilinizde ya da aynı şekilde rastgele olduğunu iddia eden standart kitaplığın içindeki herhangi bir rasgele sayı üreticisinin aslında tek tip olduğunu varsayabilir. Bu, kullandığınız rasgele kaynağın kalitesi hakkında endişelenmenize gerek yok. Ancak,

• Kullanmakta olduğunuz rastgele kaynağın tek tip olması durumunda, kodunuzun doğrudan tek biçimli bir rasgele tamsayı ürettiğini 0belirlemeniz gerekir n.
• Bir yerleşik veya kitaplık rastgele işlevini çağırırken herhangi bir argüman sabit olmalıdır. Bu, girdi değerinden tamamen bağımsız olmaları gerektiğidir.
• Kodunuz, sonlandırılması garanti edilmek yerine olasılık 1 ile sona erebilir.

notlar

• randInt(0,n) girişi yerleşik veya kütüphane işlevine bir argüman olarak aldığı için geçerli değil.
• rand()%nolacak değil genel olarak tekdüze rasgele sayı verir. Betseg tarafından verilen Örnek olarak, eğer intmax == 15ve n = 10o zaman almak için çok daha muhtemel olacaktır 0-5daha 6-10.
• floor(randomfloat()*(n+1)) ayrıca, genel olarak 0 ve 1 arasındaki muhtemel farklı kayan nokta değerlerinin sonlu sayısından dolayı tek tip rastgele bir sayı vermeyecektir.

x86 komutlu makineler rdrand, 10 bayt

BITS 64

_try_again:

 rdrand eax
jnc _try_again

 cmp eax, edi
ja _try_again

 ret

makine kodu

0FC7F0 73FB 39F8 77F7 C3

Giriş kayıt defterinde rdive çıkış ise giriş rax.
Bu, SYS V AMD64 ABI'ye saygılıdır, böylece kod etkin bir C işlevi uygular.

unsigned int foo(unsigned int max); 

32-bit ints ile.

Talimat rdrandIntel tarafından açıklanmıştır.

RDRANDşifreli olarak güvenli, deterministik rastgele bit üretici DRBG tarafından sağlanan rasgele sayıları döndürür. DRBG, NIST SP 800-90A standardını karşılayacak şekilde tasarlanmıştır .

CSRNG ile ilgili olarak, NIST SP 800-90A’dan alıntı yaparak, yine de dağılımın tek biçimli olduğu açıktır:

Rastgele bir sayı, tarafsız bir rastgele değişkenin bir örneğidir, yani, düzgün dağılmış bir rastgele işlem tarafından üretilen çıktı .

Prosedür rastgele bir sayı oluşturur ve eğer girdiden kesinlikle katı değilse, döndürülür.
Aksi takdirde, işlem tekrarlanır.

Bu yana eax, 32-bit, rdrand0 ve 2 arasında bir sayı döndürür ³² bu yüzden her için, -1 n içinde [0, 2 ³² -1] beklenen yineleme sayısı 2 ³² / (n + 1) Tüm için tanımlandığı gibidir , n [0, 2 ³⁰ ] 'da.

Jöle , 7 6 bayt

⁴!!X%‘

1 byte'lık golf için @JonathanAllan'a teşekkürler!

TIO'da çalıştırılamaz çünkü (16!)! çok büyük bir sayı.

Nasıl çalışır

⁴!!X%‘  Main link. Argument: n

⁴       Set the return value to 16.
 !!     Compute (16!)!.
   X    Pseudo-randomly choose an integer between 1 and (16!)!.
        Since (16!)! is evenly divisible by any k ≤ 2**30, it is evenly divisible
        by n+1.
    %‘  Take the result modulo n+1.

Mathematica, 29 bayt

Dennis'in Jelly cevabına dayanarak .

RandomInteger[2*^9!-1]~Mod~#&

Aslında bu çalıştırmayı tavsiye etmem. 2e9!oldukça büyük bir sayıdır ...

Mümkün olan tüm girdiler tarafından bölünebilen büyük bir sayı üretmek için en kısa olduğu ve sonuçta basit bir modülo ile istenen aralığın sonucunu belirlediği görülmektedir.

Reddetme Örneklemesi, 34 bayt

Biraz daha ilginç bir koda neden olan eski yaklaşımım:

13!//.x_/;x>#:>RandomInteger[13!]&

Temel ret örneklemesi. Çıkışı 13'e çıkardık! (bu maksimum giriş 2 ^30'dan daha büyüktür ) ve sonra tekrar tekrar 0 ila 13 arasında rasgele bir tamsayı ile değiştirin ! değer girişten büyük olduğu sürece.

Brachylog , 9 bayt

≥.∧13ḟṙ|↰

Çevrimiçi deneyin!

Bu 13!Martin Ender'in cevabındaki gibi kullanır ( 13ḟbir bayttan küçük 2^₃₀).

ṙkullanılarak gerçekleştirilir random_between/3kaynağını kazma zaman, kullanım ki, random_float/0bağlantılı random/1olan bizim için üniform Mersenne twister algoritması kullanır.

açıklama

≥.           Input ≥ Output
  ∧          And
   13ḟṙ      Output = rand(0, 13!)
       |     Else
        ↰    Call recursively with the same input

Prolog (SWI) , 38 bayt

X*Y:-Z is 2^31,random(0,Z,Y),Y=<X;X*Y.

Reddetme örneklemesiyle çalışır.

Girdiden küçük veya eşit bir sayı bulunana kadar 0 ile 2 ^ 31-1 = 2147483647 arasında rasgele bir sayı oluşturun .

Öteki yerine bir kesim kullanabilmem gerektiğini hissediyorum, ancak nasıl olduğunu göremiyorum.

Labirent , 63 bayt

 ?
 #00}__""*_
 ;    #"  _
{-{=  } "><)
!{ : ;"({ +
@  }}:  >`#

(Burada ağır golf oynamaya yardımcı olduğu için @MartinEnder'e teşekkürler.)

Labirent, 2B dilidir ve tek rastgele kaynağı şu şekildedir:

   x
  "<)
 " "
 " "

Talimat göstergesinin üstünde xve aşağı doğru hareket ettiğini varsayalım . Bir sonraki aşamada, <eğer yığının tepesi 0 ise (bu her zaman yukarıdaki gerçek programda olduğu gibi) mevcut satırı 1 değerinde değiştirir:

   "
 "<)
 " "
 " "

Talimat işaretçisi şimdi < aşağı doğru hareket ediyor. Bir kavşakta, Labyrinth yığının tepesine göre döner - negatif sola, pozitif sağa ve sıfır ileri gider. Yığının tepesi bu noktada hala sıfırsa, yol olmadığından ileri veya geri hareket edemeyiz, bu nedenle Labyrinth, eşit olasılıkla sola veya sağa çevirme arasında rasgele hareket eder.

Temel olarak yukarıdaki programın yaptığı şey, 100 bit sayılar üretmek için rastgelelık özelliğini kullanmaktır (100 ile #00 burada ) üretene kadar döngülemeye devam<= n .

Test için, büyük olasılıkla #0"10 bitlik sayılar yerine bunun kullanılması muhtemelen" no-op yolu . Çevrimiçi deneyin!

Kaba açıklama:

 ?            <--- ? is input and starting point
 #0"}__""*_   <--- * here: first run is *0, after that is *2 to double
 ;    #"  _
{-{=  } "><)  <--- Randomness section, +0 or +1 depending on path.
!{ : ;"({ +        After <, the >s reset the row for the next inner loop.
@  }}:  >`#

 ^    ^
 |    |
 |    The " junction in this column checks whether the
 |    100-bit number has been generated, and if not then
 |    continue by turning right into }.
 |
 Minus sign junction here checks whether the generated number <= n.
 If so, head into the output area (! is output as num, @ is terminate).
 Otherwise, head up and do the outer loop all over again.

Python, 61 bayt

from random import*
lambda n,x=2.**30:int(randrange(x)*-~n/x)

Düzenleme: Yasaklı formu önlemek için güncellendi

Edit2: 2 bayt kaydedildi, teşekkürler @ JonathanAllan

Edit3: Tamamen işlevsel bir çözüm için 2 byte ödedi - tekrar teşekkürler @JonathanAllan

Düzen4: Kaldırıldı f= , 2 bayt kaydediliyor

Edit5: @ sayesinde 1 bayt daha kaydedildi JonathanAllan

Düzenleme6: @ JonathanAllan sayesinde 2 bayt daha kaydedildi

Şimdilik, git suçlama bana kötü şeyler, JonathanAllan yardımcı olacaklar için işaret ederdi.

Düzenleme7: Yağmur yağdığında, dökülür - başka bir 2 bayt

Edit8: Ve başka 2 bayt

Python 2,61 bayt

from random import*
lambda n:map(randrange,range(1,2**31))[n]

Sözde rastgele arasındaki tam sayıları tercih 0 ve k tüm değerleri için k arasında 0 ve 2 ³¹ - 2 , daha sonra tekabül eden bir tam sayı alır k = n .

Toplu iş, 64 bayt

@set/ar=%random%*32768+%random%
@if %r% gtr %1 %0 %1
@echo %r%

%random%sadece 15 bit rasgelelik veriyor, bu yüzden iki rasgele sayıyı birleştirmem gerekiyor. Rastgele değer istenen aralıkta olana kadar döngüler, çok düşük için yavaş n; Daha hızlı sürüm için 98 bayt:

@set/a"n=%1+1,m=~(3<<30)/n*n,r=%random%*32768+%random%
@if %r% geq %m% %0 %1
@cmd/cset/a%r%%%%n%

MATL , 12 bayt

@AdmBorkBork ve @Suever'a , TIO önbelleğini nasıl devre dışı bırakacağımı söyledikleri için teşekkürler .

`30WYrqG>}2M

Çevrimiçi deneyin! .

Bu kullanan reddi yöntem bir rasgele bir tamsayı oluşturur: 0için 2^30-1bu giriş üzerinde iken, ve tekrar n. Bu olasılıkla sona ermesi garantilidir 1, ancak ortalama yineleme sayısı şudur 2^30/nve bundan nönemli ölçüde daha küçükler için çok uzun sürer 2^30.

`         % Do...while
  30W     %   Push 2^30
  Yr      %   Random integer from 1 to 2^30
  q       %   Subtract 1
  G>      %   Does it exceed the input? If so: next iteration. Else: exit
}         % Finally (execute right before exiting the loop)
  2M      %   Push the last generated integer
          % End (implicit). Display (implicit)

JavaScript (ES6), 55 54 bayt

f=(n,m=1)=>m>n?(x=Math.random()*m|0)>n?f(n):x:f(n,m*2)

Aralığındaki tamsayıları oluşturur [0 ... 2 ^k - 1] , k şekildedir tamsayıdır küçük olan 2 ^K daha büyüktür , n . Sonuç [0 ... n] içine düşene kadar tekrar eder .

Niye ya?

Bu, aşağıdaki varsayımlara dayanmaktadır:

• Dahili olarak, JS motorunun beslemesi Math.random()için üretilen sözde rasgele tamsayı değerleri , herhangi bir aralıkta [0 ... 2 ^k -1] ( k <32 ile ) aynıdır .

• Kesin güç 2 ile çarpıldığında, geri getirilen IEEE 754 Math.random()değişken değerleri bu aralıklar boyunca hala aynıdır.

Herhangi biri bu hipotezleri onaylayabilir veya çürütebilirse, lütfen yorumlarda bana bildirin.

gösteri

[0 ... 2] 'de 1 milyon değer üretir ve sonuç istatistiklerini görüntüler.

f=(n,m=1)=>m>n?(x=Math.random()*m|0)>n?f(n):x:f(n,m*2)

for(i = 0, stat = []; i < 1000000; i++) {
  r = f(2);
  stat[r] = (stat[r] || 0) + 1;
}
console.log(stat.join` `)

Bash (+ coreutils), 44 bayt

/ dev / urandom tabanlı çözüm

od -w4 -vtu4</d*/ur*|awk '($0=$2)<='$1|sed q

İmzasız 32 bit tam sayıları okuyacak /dev/urandomve awkbelirli bir aralıkta bir tane bulana kadar bunları filtreleyecek , sonra sed qboruyu iptal edecek.

Haskell, 70 bayt

import System.Random
g n=head.filter(<=n).randomRs(0,2^30)<$>getStdGen

Çok verimli bir algoritma değil, işe yarıyor. [0,2 ^ 30] ile sınırlandırılmış sonsuz bir tamsayı listesi (veya gerekirse Haskell'in tipi sistemi nedeniyle yüzer) oluşturur ve birincisini n'den küçük veya ona eşittir. Küçük n için bu uzun zaman alabilir. Rastgele sayılar için, rastgele R belgelerinde belirtildiği gibi rastgele sayılar dağıtılmalıdır, bu nedenle [0,2 ^ 30] arasındaki tüm sayılar aynı olasılıkta olmalıdır (1 / (2 ^ 30 + 1)); 0, n] aynı olasılığa sahiptir.

Alternatif Sürüm:

import System.Random
g n=head.filter(<=n).map abs.randoms<$>getStdGen

Bu sürüm korkunç ama bütün bayttan tasarruf sağlıyor. randomsSonsuz sayıların listesini oluşturmak için türün tanımladığı keyfi bir aralığı kullanır Bu, negatifleri içerebilir, bu yüzden absonları pozitif (veya sıfır) zorlamak için haritalandırmamız gerekir . Bu, çok büyük olmayan n değerleri için son derece yavaştır. EDIT : Daha sonra bu versiyonun düzgün dağılmadığını fark ettim çünkü 0 alma olasılığı kullanımdan dolayı diğer numaralardan daha kötü abs. Bir sayı üretmek miçin jeneratör üretebilir mveya -mancak 0 olması durumunda sadece 0 kendisi çalışacaktır, bu nedenle olasılığı diğer sayıların yarısıdır.

Jöle , 9 bayt

⁴!Ẋ’>Ðḟ⁸Ṫ

Çevrimiçi deneyin! - yukarıdaki kod, 16 boyutundan beri TIO'da çalışmayacak! önce inşa edilmeleri gerekir (karıştırılmaları ve sonra filtrelenmeleri gerektiği gerçeğinden bahsetmemeliler!), bu yüzden aynı şey daha küçük bir ölçekte, 10'luk bir giriş ile 3'lük bir giriş için 30 kez tekrarlandı.

Nasıl?

⁴!Ẋ’>Ðḟ⁸Ṫ - Main link: n
⁴         - 16
 !        - factorial: 20922789888000
  Ẋ       - shuffle random: builds a list of the integers 1 through to 16! inclusive and
          - returns a random permutation via Python's random.shuffle (pretty resource hungry)
   ’      - decrement (vectorises - a whole pass of this huge list!)
     Ðḟ   - filter out if: (yep, yet another pass of this huge list!)
    >     -     greater than
       ⁸  -     left argument, n
        Ṫ - tail: return the rightmost remaining entry.

Not:ȷ⁵ Birinin ondan onuna dönmesini bekler ve ona geri döndürürse , aynı bayt sayısı için binin üzerinde bir zaman daha verimli olacaktır, ancak bu, ⁵kullanılması gereken değişmez on olarak değerlendirilmediği için durum böyle değildir. değişmez sayısına göre, ȷ...ancak iki ayrı değişmez ayrıştırılır, ȷvarsayılan üçe bin bin, ⁵üstelik on verir.

Jshell üzerinde JDK 9, 75 59 bayt

n->(new Random()).ints(0,1<<30).dropWhile(x->x>n).findAny()

kullanım

((IntFunction)(n->(new Random()).ints(0,1<<30).dropWhile(x->x>n).findAny())).apply(<n>)

• -16 bytes: Teşekkürler Jakob!
• Jshell'i geçerli bir çalışma zamanı ortamı olarak kabul ettiğimizi varsayar.
• Çalışma zamanı ortamı olarak jshell, çekirdek kütüphaneler için açık bir ithalat gerektirmez ve noktalı virgül gerektirmez.
• Bir döndürür OptionalInt. Kurallar, dönüş türünün ilkel olması gerektiğini belirtmez OptionalIntve sonucun geçerli bir temsili olduğunu düşünüyorum.

PHP, 30 bayt

    while($argn<$n=rand());echo$n;

İle koş echo <N> | php -Rn '<code>' .

0 ile getrandmax()(64 bit makinemde 2 ** 31-1) rastgele bir sayı seçiyor ;
girişden daha büyükken tekrar eder.

Bu olabilir almak bir süre ... benim AMD C-50 için 0.3 ve 130 saniye arasında gerekli (1 GHz)N=15 .

Ortalama için daha hızlı bir yol N( 46 bayt ):

for(;++$i<$x=1+$argn;)$n+=rand()%$x;echo$n%$x;

veya

for(;++$i<$x=1+$argn;$n%=$x)$n+=rand();echo$n;

alır N+1 onları özetliyor, rasgele tamsayılar ve birlikte modulo alır N+1.
C-50'nin yakl. 1 milyon koşu için 8 saniye.

19 bayt için geçersiz bir çözüm :

echo rand(0,$argn);

PowerShell , 35 bayt

for(;($a=Random 1gb)-gt"$args"){}$a

Çevrimiçi deneyin!

Başka bir ret örnekleme yöntemi. Bu, sonsuz fordeğerini ayarlama, döngü $abir olmak Randomtamsayı arasında 0ve 1gb( = 1073741824 = 2^30), ve bu kadar uzun tamsayı olduğu döngü devam -greater than girişi $args. Döngü tamamlandıktan sonra, sadece$a boru hattını ve çıktı kapalıdır.

Not: Girdi küçük bir sayı ise, bu uzun zaman alacaktır .

Python 2 , 72 69 bayt

Xnor sayesinde -3 bayt ( idyerleşik olarak değişken olarak geçersiz kıl )

from random import*
n=input()
while id>n:id=randrange(2**30)
print id

Çevrimiçi deneyin!

randrange(2**30)[0,2 ³⁰ ] aralığından sahte olarak dağılmış bir sayı (Mersenne Twister 2 ^19937-1 ) üretir . Yana aşağıda olması sağlanır 2 ³⁰ o girdi büyüktür olmayana kadar basitçe tekrar tekrar çağrılabilir bu. Çok düşük değerler için uzun süre beklenen bir zaman alacaktır , ancak 50 dakikaya kadar olan girişler için bile bir dakika içinde çalışır.nn

Perl 6 , 29 bayt

{first 0..$_,^2**30 .roll(*)}

Martin Ender'in Mathematica çözümünden ilham aldı .

0 ile 2 ^ 30-1 arasında tembel bir sonsuz rasgele tamsayı dizisi oluşturur ve birincisini 0 ile girdi arasında alır.

Çevrimiçi deneyin!

05AB1E , 11 bayt

žIÝ.rDI›_Ϥ

Çevrimiçi deneyin!

açıklama

žIÝ          # push the inclusive range [0 ... 2^31]
   .r        # get a random permutation (pythons random.shuffle)
     D       # duplicate this list
      I      # push input
       ›_Ï   # keep only elements from the list not greater than input
          ¤  # take the last one

Liste [0 ... 2147483648]TIO için çok büyük olduğundan, bağlantı 1.000.000yerine kullanılır.

Alternatif (ortalama) çok daha hızlı 11 bayt çözüm

[žIÝ.RD¹›_#

Çevrimiçi deneyin

açıklama

[             # start loop
 žIÝ          # push the inclusive range [0 ... 2^31]
    .R        # pick a random integer (pythons random.chiose)
      D       # duplicate
       ¹      # push input
        ›_#   # break if random number is not greater than input
              # implicitly output top of stack (the random number)

Python 2, 89 bytes

l=range(2**31)
import random
random.shuffle(l)
n=input()
print filter(lambda x:x<=n,l)[0]

Explanation

L=range(2**31)      # Create a list from 0 to 2^31 exclusive. Call it <L>.
import random       # Import the module <random>.
random.shuffle(L)   # Use 'shuffle' function from <random> module,
                    # to shuffle the list <L>.
n=input()           # Take the input -> <n>.

print
    filter(         # Create a new sequence,
    lambda x:x<=n   # where each element is less than or equal to <n>.
    ,L)             # from the list <L>.
    [0]             # Take the first element.

This is very inefficient, as it creates 2^31 integers, shuffles and filters them.

I see no point in sharing a TIO link, where it's creating such large lists, so here is a TIO link for n = 100.

Try it online!

Java 8, 84 83 80 71 62 bytes

n->{int r;for(;(r=(int)(Math.random()*(1<<30)))>n;);return r;}

-1 byte thanks to @OliverGrégoire.
-3 bytes thanks to @Jakob.
-9 bytes converting Java 7 to Java 8.
-9 bytes by changing java.util.Random().nextInt(1<<30) to (int)(Math.random()*(1<<30)).

Explanation:

Try it here.

n->{        // Method with integer parameter and integer return-type
  int r;    //  Result-integer
  for(;(r=(int)(Math.random()*(1<<30)))>n;);
            //  Loop as long as the random integer is larger than the input
            //  (the random integer is in the range of 0 - 1,073,741,824 (2^30))
  return r; //  Return the random integer that is within specified range
}           // End method

NOTE: May obviously take very long for small inputs.

Example output:

407594936

Python 3, 51 bytes

Here is a python solution with an unorthodox random source.

print(list(set(map(str,range(int(input())+1))))[0])

Try it online!

So to break this down.

int(input())+1

Gets the input number, and adds 1 to it.

set(range(...))

Creates the set {0, 1, 2, 3, 4, ... n} for all possible results.

print(list(...)[0])

Takes the set, converts it to list, and grabs the first item.

This works because in Python 3, the order of set() is established by PYTHONHASHSEED (can't be obtained but is established on script execution).

Admittedly, I am guessing that this is a uniform distribution, as the hash() value is randomly assigned and I am looking at randomly picking the value with a specific hash(), rather then just returning the hash(input()) itself.

If anyone knows whether this is a uniform distribution, or how I could test that, please comment.

C#, 57 bytes

n=>{int x=n+1;while(x>n)x=new Random().Next();return x;};

Anonymous function which returns an integer between 0 and n inclusive.

The smaller the input number, the longer the time to return a random value.

Full program:

using System;

class RandomNumber
{
    static void Main()
    {
        Func<int, int> f =
        n=>{int x=n+1;while(x>n)x=new Random().Next();return x;};

        // example
        Console.WriteLine(f(100000));
    }
}

Bash + coreutils, 20 bytes

Golfed

seq 0 $1|shuf|sed 1q

shuf - generate random permutations

Shuf will use the following code: to generate permutations:

permutation = randperm_new (randint_source, head_lines, n_lines);

which ends up in randint_genmax

/* Consume random data from *S to generate a random number in the range
0 .. GENMAX.  */

randint
randint_genmax (struct randint_source *s, randint genmax) 
{
      ...

      randread (source, buf, i);

      /* Increase RANDMAX by appending random bytes to RANDNUM and
         UCHAR_MAX to RANDMAX until RANDMAX is no less than
         GENMAX.  This may lose up to CHAR_BIT bits of information
         if shift_right (RANDINT_MAX) < GENMAX, but it is not
         worth the programming hassle of saving these bits since
         GENMAX is rarely that large in practice.  */
      ...
}

which, in turn, will read a few bytes of the random data from the low-level source of randomness:

/* Consume random data from *S to generate a random buffer BUF of size
   SIZE.  */

void
randread (struct randread_source *s, void *buf, size_t size)
{
  if (s->source)
    readsource (s, buf, size);
  else
    readisaac (&s->buf.isaac, buf, size);
}

i.e. at the low-level, there is no direct dependency between the shuf input value and the data read from the source of randomness (aside from computing the required byte buffer capacity).

SmileBASIC, 38 bytes

INPUT N@L
R=RND(1<<30)ON N<=R GOTO@L?R

Generates random numbers until it gets one that is smaller than the input.

Ruby, 23 15 23 32 29 bytes

->n{1while n<q=rand(2**30);q}

How it works:

• 1while [...]; executes the statement at least once: 1 before while acts as a nop
• Get a random number in the range 0..2^30-1 (lower than 2^30, as specified)
• Repeat if the number is higher than the input parameter (Could take some time when n is small)

Ohm, 26 bytes

IΩ
D31º#╬D0[>?D-+∞;,

Explanation:

IΩ                 ■Main wire
IΩ                 ■Call wire below

D31º#╬D0[>?D-+∞;,  ■"Real main" wire
D                  ■Duplicate input
 31º#╬D            ■Push random_int in [0..2^31] twice
       0[          ■Push input again
         >?    ;   ■If(random_int > input){
           D-+     ■  remove the random_int
              ∞    ■  recursion
               ;   ■}
                ,  ■Print random_int

Go, 63 61 bytes

import."math/rand"
var n=0;func R(){q:=n;for;q<n+1;n=Int(){}}

Use it like this:

func main() {
    n = 5000
    R()
    print(n)
}

Test it live at the go playground

Golang, 84 78 71 bytes

import."math/rand"
func R(n int)int{q:=n+1;for;q>=n;q=Int(){};return q}

Simple rejection sampling.

Note: since the math/rand seed is a constant 1, the caller must seed unless a constant result is desired.

Test: https://play.golang.org/p/FBB4LKXo1r No longer practically testable on a 64-bit system, since it's returning 64-bit randomness and using rejection testing.

package main

import "fmt"
import "time"

/* solution here *//* end solution */

func main() {
    Seed(time.Now().Unix())
    fmt.Println(R(1073741823))
}