งาน

กำหนดให้เป็นจำนวนเต็มบวกnน้อยกว่าที่2^30ระบุไว้เป็นอินพุตในวิธีที่คุณเลือกรหัสของคุณควรส่งออกจำนวนเต็มแบบสุ่มระหว่าง0และnรวม หมายเลขที่คุณสร้างควรจะเลือกอย่างสม่ำเสมอโดยการสุ่ม นั่นคือแต่ละค่าจาก0ถึงnต้องเกิดขึ้นกับความน่าจะเป็นที่เท่ากัน (ดูกฎและคำเตือน)

กฎและคำเตือน

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

• คุณจะต้องกำหนดว่าถ้าแหล่งข้อมูลที่สุ่มคุณกำลังใช้เป็นชุดแล้วรหัสของคุณอย่างถูกต้องออกผลลัพธ์เป็นจำนวนเต็มสุ่มเครื่องแบบจากไป0n
• อาร์กิวเมนต์ใด ๆ เมื่อเรียกใช้ฟังก์ชันสุ่มในตัวหรือไลบรารีต้องเป็นค่าคงที่ นั่นคือพวกเขาจะต้องเป็นอิสระอย่างสมบูรณ์จากค่าอินพุต
• รหัสของคุณอาจสิ้นสุดลงด้วยความน่าจะเป็น 1แทนที่จะรับประกันได้ว่าจะยุติ

หมายเหตุ

• randInt(0,n) ไม่ถูกต้องเนื่องจากรับอินพุตเป็นอาร์กิวเมนต์สำหรับฟังก์ชัน builtin หรือ library
• rand()%nจะไม่ให้หมายเลขสุ่มที่เหมือนกันโดยทั่วไป เป็นตัวอย่างที่กำหนดโดย betseg ถ้าintmax == 15และn = 10แล้วคุณจะมีโอกาสมากขึ้นที่จะได้รับมากกว่า0-56-10
• floor(randomfloat()*(n+1)) จะไม่ให้ตัวเลขสุ่มแบบทั่วไปโดยทั่วไปเนื่องจากจำนวน จำกัด ของค่าจุดลอยตัวที่เป็นไปได้ที่แตกต่างกันระหว่าง 0 ถึง 1

x86 เครื่องจักรด้วย rdrandคำสั่ง 10 ไบต์

BITS 64

_try_again:

 rdrand eax
jnc _try_again

 cmp eax, edi
ja _try_again

 ret

รหัสเครื่อง

0FC7F0 73FB 39F8 77F7 C3

การป้อนข้อมูลที่อยู่ในการลงทะเบียนและการส่งออกในrdi สิ่งนี้เป็นไปตามSYS V AMD64 ABIดังนั้นโค้ดจึงใช้งานฟังก์ชัน C ได้อย่างมีประสิทธิภาพrax

unsigned int foo(unsigned int max); 

ด้วย ints 32 บิต

คำสั่งrdrandนั้นอธิบายโดย Intel

RDRANDส่งคืนตัวเลขสุ่มที่จัดหาโดยตัวสร้างบิตแบบสุ่มที่มีความปลอดภัยและเข้ารหัสแบบกำหนดค่าได้ DRBG DRBG ถูกออกแบบมาเพื่อตอบสนองความNIST SP 800-90Aมาตรฐาน

การจัดการกับ CSRNG นั้นเป็นการบอกเป็นนัยว่าการแจกแจงมีความเหมือนกันโดยอ้างข้อความ NIST SP 800-90A:

หมายเลขสุ่มคืออินสแตนซ์ของตัวแปรสุ่มที่ไม่เอนเอียงคือผลผลิตที่ผลิตโดยกระบวนการสุ่มที่กระจายแบบสม่ำเสมอ

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

เนื่องจากeaxเป็น 32 บิตrdrandส่งคืนตัวเลขระหว่าง 0 ถึง 2 ³² -1 ดังนั้นสำหรับทุก ๆnใน [0, 2 ³² -1] จำนวนการทำซ้ำที่คาดหวังคือ 2 ³² / (n + 1) ซึ่งกำหนดไว้สำหรับnทั้งหมดใน [0, 2 ³⁰ )

เยลลี่ , 7 6 ไบต์

⁴!!X%‘

ขอบคุณ @JonathanAllan สำหรับการตีกอล์ฟ 1 ไบต์!

ไม่สามารถรันบน TIO ได้เพราะ(16!)! เป็นขนาดใหญ่จำนวน

มันทำงานอย่างไร

⁴!!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 ไบต์

ขึ้นอยู่กับเดนนิสคำตอบของวุ้น

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

ฉันจะไม่แนะนำให้ใช้สิ่งนี้จริง ๆ 2e9!เป็นจำนวนมาก ...

มันจะสั้นที่สุดในการสร้างจำนวนมากที่สามารถหารด้วยอินพุตที่เป็นไปได้ทั้งหมดและแผนที่ผลลัพธ์ไปยังช่วงที่ต้องการด้วยโมดูโลแบบง่าย

การสุ่มตัวอย่างการปฏิเสธ 34 ไบต์

วิธีเก่าของฉันที่นำไปสู่รหัสที่ค่อนข้างน่าสนใจมากขึ้น:

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

การสุ่มตัวอย่างการปฏิเสธพื้นฐาน เราเริ่มต้นผลลัพธ์ที่13! (ซึ่งมีขนาดใหญ่กว่าอินพุตสูงสุด2 ³⁰ ) จากนั้นแทนที่มันซ้ำ ๆ ด้วยจำนวนเต็มแบบสุ่มระหว่าง0ถึง13! ตราบใดที่ค่ามีค่ามากกว่าอินพุต

Brachylogขนาด 9 ไบต์

≥.∧13ḟṙ|↰

ลองออนไลน์!

วิธีนี้ใช้13!ในคำตอบของ Martin Ender ( 13ḟน้อยกว่าหนึ่งไบต์2^₃₀)

ṙมีการใช้random_between/3งานซึ่งเมื่อขุดแหล่งที่มาการใช้งานrandom_float/0ที่เชื่อมโยงกับrandom/1ที่ใช้อัลกอริทึม Mersenne Twister ซึ่งเป็นชุดสำหรับวัตถุประสงค์ของเรา

คำอธิบาย

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

Prolog (SWI) , 38 ไบต์

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

ทำงานโดยการสุ่มตัวอย่างการปฏิเสธ

สร้างตัวเลขสุ่มระหว่าง0ถึง2 ^ 31-1 = 2147483647จนกระทั่งพบน้อยกว่าหนึ่งหรือเท่ากับอินพุต

ฉันรู้สึกราวกับว่าฉันสามารถใช้การตัดแทนสิ่งอื่นได้ แต่ฉันไม่สามารถมองเห็นได้

เขาวงกต 63 ไบต์

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

(ขอบคุณ @MartinEnder สำหรับความช่วยเหลือเกี่ยวกับการเล่นกอล์ฟอย่างหนักที่นี่)

เขาวงกตเป็นภาษา 2D และแหล่งที่มาของการสุ่มเท่านั้นที่อยู่ในสถานการณ์เช่นนี้:

   x
  "<)
 " "
 " "

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

   "
 "<)
 " "
 " "

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

โดยเฉพาะอย่างยิ่งสิ่งที่โปรแกรมดังกล่าวข้างต้นไม่สามารถใช้คุณลักษณะการสุ่มเพื่อสร้างตัวเลข 100 บิต (100 ตามที่ระบุไว้#00ที่นี่) <= nและยังคงวนรอบจนกว่าจะสร้างตัวเลข

สำหรับการทดสอบมันอาจจะช่วยในการใช้#0"แทนตัวเลข 10 บิตโดย"เป็นเส้นทางแบบไม่ใช้งาน ลองออนไลน์!

คำอธิบายหยาบ:

 ?            <--- ? 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 ไบต์

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

แก้ไข: อัปเดตเพื่อหลีกเลี่ยงรูปแบบที่ต้องห้าม

แก้ไข 2: บันทึก 2 ไบต์ขอบคุณ @ JonathanAllan

แก้ไข 3: จ่าย 2 ไบต์สำหรับโซลูชันที่ทำงานได้อย่างสมบูรณ์ - ขอบคุณอีกครั้ง @JonathanAllan

แก้ไข 4: ลบf=แล้วบันทึก 2 ไบต์

แก้ไข 5: บันทึกอีก 1 ไบต์ขอบคุณ @ JonathanAllan

แก้ไข 6: บันทึกอีก 2 ไบต์ขอบคุณ @ JonathanAllan

โดยตอนนี้ความผิด git จะชี้มาที่ฉันสำหรับสิ่งที่ไม่ดีและ JonathanAllan สำหรับสิ่งที่ช่วย

แก้ไข 7: เมื่อฝนตกจะเท - อีก 2 ไบต์

แก้ไข 8: และอีก 2 ไบต์

Python 2 , 61 ไบต์

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

หลอกสุ่มเลือกจำนวนเต็มระหว่าง0และkสำหรับค่าทั้งหมดของkระหว่าง0และ2 ³¹ - 2จากนั้นใช้เวลาจำนวนเต็มสอดคล้องกับk = n

แบตช์ 64 ไบต์

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

%random%ให้สุ่ม 15 บิตเท่านั้นดังนั้นฉันต้องรวมตัวเลขสุ่มสองตัว ลูปจนกว่าจะมีการสุ่มค่าอยู่ในช่วงที่ต้องการดังนั้นช้าต่ำn; 98 ไบต์สำหรับรุ่นที่เร็วกว่า:

@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 ไบต์

ขอบคุณ@AdmBorkBorkและ@Suever ที่บอกวิธีปิดใช้งานแคช TIO

`30WYrqG>}2M

ลองออนไลน์!.

นี้จะใช้วิธีการปฏิเสธ : สร้างจำนวนเต็มสุ่มจาก0ไปและทำซ้ำในขณะที่มันเกินกว่าการป้อนข้อมูล2^30-1 nนี้มีการประกันเพื่อยุติกับความน่าจะ1แต่จำนวนเฉลี่ยของการทำซ้ำเป็น2^30/nและเพื่อให้มันใช้เวลานานมากอย่างมีนัยสำคัญมีขนาดเล็กกว่าn2^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 ไบต์

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

สร้างจำนวนเต็มในช่วง[0 ... 2 ^k - 1]ที่kเป็นที่เล็กที่สุดจำนวนเต็มเช่นที่2 ^kมีค่ามากกว่าn ซ้ำจนกว่าผลที่ตกอยู่ใน[0 ... n]

ทำไม?

สิ่งนี้อยู่บนพื้นฐานของสมมติฐานต่อไปนี้:

• ภายในค่าจำนวนเต็มแบบหลอกเทียมที่สร้างขึ้นโดยเอ็นจิน JS เพื่อป้อนข้อมูลMath.random()มีความสม่ำเสมอในช่วงเวลาใด ๆ[0 ... 2 ^k -1] (ด้วยk <32 )

• เมื่อคูณด้วยพลังงานที่แน่นอน 2 ค่าลอย IEEE 754 ที่ส่งคืนโดยMath.random()จะยังคงเหมือนกันในช่วงเวลาดังกล่าว

หากใครสามารถยืนยันหรือปฏิเสธสมมติฐานเหล่านี้ได้โปรดแจ้งให้เราทราบในความคิดเห็น

การสาธิต

Generates 1 million values in [0 ... 2] and displays the outcome statistics.

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 bytes

/dev/urandom based solution

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

Will read unsigned 32 bit integers from /dev/urandom, and filter them out with awk until it finds one within a given range, then sed q will abort the pipe.

Haskell, 70 bytes

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

Not a very efficient algorithm but it works. It generates an infinite list of integers (or floats if needed, because of Haskell's type system) bounded by [0,2^30] and takes the first one less than or equal to n. For small n this can take a long time. The random numbers should be uniformly distributed, as specified in the documentation for randomR so all numbers in the interval [0,2^30] should have the same probability (1/(2^30+1)) therefore all the numbers in [0,n] have the same probability.

Alternate Version:

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

This version is terrible but it saves a whole byte. randoms uses an arbitrary range defined by the type to generate an infinite list of numbers. This may include negatives so we need to map it with abs to force them positive (or zero). This is extremely slow for any values of n that aren't absurdly large. EDIT: I realized later that this version isn't uniformly distributed because the probability of getting 0 is worse than the other numbers due to the use of abs. To produce some number m the generator could produce m or -m but in the case of 0 only 0 itself will work, therefore its probability is half of the other numbers.

Jelly, 9 bytes

⁴!Ẋ’>Ðḟ⁸Ṫ

Try it online! - code above wont run on TIO since a range of size 16! must be built first (not to mention the fact that they then need to be shuffled and then filtered!), so this is the same thing on a much smaller scale, repeated 30 times for an input of 3 with a bound of 10.

How?

⁴!Ẋ’>Ðḟ⁸Ṫ - 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.

Note: it would be over a thousand time more efficient for the same byte-count if ȷ⁵ would do what one would naively expect and return ten to the ten, but that is not the case since the ⁵ is not evaluated as a literal ten to be used by the number literal ȷ... but rather two separate literals are parsed, ȷ with it's default exponent of three yielding one thousand, and ⁵ yielding ten.

JDK 9 on jshell, 75 59 bytes

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

Usage

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

• -16 bytes: Thanks Jakob!
• Assumes that we consider jshell to be a valid runtime environment.
• jshell itself, as a runtime environment, doesn't require explicit imports for core libraries and doesn't require semicolons.
• Returns an OptionalInt. Rules don't specify that return type must be a primitive and I'm considering an OptionalInt to be a valid representation of the result.

PHP, 30 bytes

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

Run with echo <N> | php -Rn '<code>'.

picks a random number between 0 and getrandmax() (2**31-1 on my 64 bit machine);
repeats while that is larger than the input.

This may take a while ... my AMD C-50 (1 GHz) needed between 0.3 and 130 seconds for N=15.

A faster way for average N (46 bytes):

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

or

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

takes N+1 random integers, sums them up and takes the modulo with N+1.
The C-50 needs approx. 8 seconds for 1 million runs.

An invalid solution for 19 bytes:

echo rand(0,$argn);

PowerShell, 35 bytes

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

Try it online!

Another rejection sampling method. This is an infinite for loop, setting the value of $a to be a Random integer between 0 and 1gb (= 1073741824 = 2^30), and keeps looping so long as that integer is -greaterthan the input $args. Once the loop is complete, we just put $a on the pipeline and output is implicit.

Note: This will take a long time if the input is a small number.

Python 2, 72 69 bytes

-3 bytes thanks to xnor (override the id built-in as a variable)

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

Try it online!

randrange(2**30) produces a pseudo-uniformly distributed number (Mersenne Twister 2^19937-1) from the range [0,2³⁰). Since n is guaranteed to be below 2³⁰ this can simply be called repeatedly until it is not greater than the input. It will take a long expected time for very low values of n, but usually works within the a minute even for inputs as low as 50.

Perl 6, 29 bytes

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

Inspired by Martin Ender's Mathematica solution.

Generates a lazy infinite sequence of random integers between 0 and 2^30-1, and takes the first one that is between 0 and the input.

Try it online!

05AB1E, 11 bytes

žIÝ.rDI›_Ϥ

Try it online!

Explanation

ž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

As the list [0 ... 2147483648] is too large for TIO, the link uses 1.000.000 instead.

Alternate (on average) much faster 11 byte solution

[žIÝ.RD¹›_#

Try it online

Explanation

[             # 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))
}