介绍

您将获得具有以下实现的随机整数生成器

• 第一次调用总是返回1。
• 第二次调用返回1到2之间的随机整数。
• 第三次调用返回1到3之间的随机整数。
• 第n次调用返回1到n之间（包括1和n）的随机整数。

根据上述函数，编写一个完全随机的随机骰子生成器，以相等的概率返回一个介于1到6（含）之间的值。

规则

• 您的程序/函数应以某种可用的形式（例如，到标准输出或作为函数返回值）得出1到6之间的一个随机整数（包括1和6）。
• 上面的升序随机数生成器可以定义为程序中的“自由”函数（即不计入字符数），也可以定义为根据需要执行的单独脚本/程序（假定状态（n）是持久性的）通话之间。
• 假设在您的程序的单个使用案例中，请求的掷骰子次数不会超过1000，并且可以将初始随机数生成器重置为11000掷骰子，以避免溢出n。
• 除了上面定义的升序随机生成器外，您的程序不得使用任何其他随机数源。您当然可以为每个骰子掷骰输出向随机数生成器请求多个随机数。
• 这是代码高尔夫球，因此如果出现平局，获胜者将是最短答案或最多选票。如果您可以使用少于1000个生成的随机数生成1000个骰子掷骰，请给自己10点效率奖励。

例

./asc-rand
1 # random integer between 1 and 1
./asc-rand
1 # random integer between 1 and 2
./asc-rand
3 # random integer between 1 and 3
./asc-rand
4 # random integer between 1 and 4

# dice-gen generates random dice based on output of asc-rand program.
./dice-gen
3
./dice-gen
6
./dice-gen
5
./dice-gen
1

J-13个字符

这与Golfscript做出了相同的假设：骰子的数量在stdin中，我们列出了要掷出的骰子。

r=:1+?  NB. free random function
r>:i.".1!:1]1

爆炸解释：

r=:1+?           NB. r(x) = 1 + a random number between 0 and n-1
           ]1    NB. input file handle
       1!:1      NB. read in a string
     ".          NB. convert to integer
 >:i.            NB. make a list of numbers, from 1 to that integer
r                NB. apply the random function

如果不能令人满意，这里是一个更长的21字符程序，可以调用它f''生成随机数，其中包含状态和所有内容。

r=:1+?  NB. free random function
c=:0
f=:3 :'r c=:1+c'

Python，31个字符

与scleaver类似，按如下方式定义生成器：

from random import randint
n=0
def r():
    global n;n+=1
    return randint(1,n)

然后一个返回骰子掷骰子的函数：

D=lambda:eval('r(),'*6)[-1]%6+1

D()在需要均匀随机骰子的任何时候致电。

斯卡拉23

def s={r;r;r;r;r;r%6+1}

方法r可以这样实现（大约）：

var cnt = 0 
val rnd = new util.Random 

def r = {
  cnt %= 1000
  cnt += 1
  rnd.nextInt (cnt)
}

粗略的测试：

scala> (1 to 6).map (i => ((1 to 600) map (_=>s)).filter (_ == i).size)
res26: scala.collection.immutable.IndexedSeq[Int] = Vector(110, 105, 91, 96, 106, 102)

每个第6次调用都应在6个值上产生相等的分布，因此我放弃了5。

GolfScript（15个字符）

假设在stdin上提供了所需的卷数，并将许多结果列出到stdout中。

# The free increasing random function
0:N;{N):N rand)}:r;

~{r{;r}5*6%)n}*

在线演示

虽然我可以使用少于1000个字符来生成1000个数字，从而获得10点奖励，但我要花掉10个以上的字符。当N是2或3的幂的倍数时，提取合适的熵的简单方法很短，因为mod 3可用的结果数仅为333 + 111 + 37 + 12 + 4 + 1 =498。因此，有必要采取抽样拒绝的方法。使用这种方法，您可以通过1000次调用来获得预期的2242次滚动r，但簿记base会产生额外的开销，并且函数名非常长。

Python 65 63

i=7
while i>5:[R()for x in range(9)];i=int(`R()`[-1])
print i+1

函数R()是升序随机数。

用法：

$ ./rollDice.py
3
$ ./rollDice.py
5

Python，56岁

r定义为：

from random import randint
n=0
def r(z):
    global n;n+=1
    return randint(1,n)

骰子生成器d：

import math;d=lambda:math.ceil(6.*r(r(r(r(r(r(0))))))/n)

用法，例如，用于100卷：

for i in range(100):print d()

Mathematica 51

r通过将全局变量设置n为1 ，可以重置随机数生成器。

n = 1; r[c_] := RandomInteger[{1, c}]

码

不在运行中以最短的代码...

h := (n++; If[n < 4 \[Or] (y = r@n) > 6 Quotient[n, 6], h, y~Mod~6 + 1])

用法

t = Table[h, {60000}];
n
SortBy[Tally[t], First]

60000卷骰子需要60031次通话h。 Tally以1-6表示细分。

60031

{{1，9923}，{2，9966}，{3，10016}，{4，10028}，{5，10009}，{6，10058}}

Perl，22或45

升序随机数生成器的实现：

my $n=0;
sub r { $n++; return 1+int(rand$n); }

产生：

#copy of the Scala solution; short code; uses 6N rolls
sub s{r;r;r;r;r;1+r%6}
#more efficient implementation, uses approximately 6+N+lnN rolls
sub roll { do{$a=r-1}while($a>$n-$n%6);return 1+(1+$a)%6 }

测试：

n号卡方
1 10001867 0.348569
2 10004853 2.355161
3 9994395 3.141602
4 10000177 0.003133
5 9999227 0.059753
6 9999481 0.026936
电话60000000 5.935154
60000000骰子掷出60000042通话至570.432735秒

JavaScript（Node.js），35字节

//random number generating function
g=1;f=()=>(1+g>1000?g++:5*Math.random())|0

i=0;while(i++<5)f();t=()=>f()%6+1|0

在线尝试！

x86操作码，15个字节

f:  mov cx, 6
    call r ; return in AX
    loop $-3
    cwd
    div word [f+1]
    inc dx
    ret ; return in DX

GolfScript，8个字节

f;3f*f(-

在线尝试！

它一次弹出生成器，然后删除结果。然后滚动f2，并将其乘以3（3或6），然后减去f3-1（0、1、2），得出（3-2、3-1、3-0）或（6-2， 6-1，6-0）W5。

Golfscript和随机函数在发布此问题之前就已存在，因此法律意见书也是存在的。

这是一次只能运行的提交。如果您需要在一次通话中多次运行它，

GolfScript，12个字节

f;3f*f-)0:i;

在线尝试！

这会将您的i呼叫重置为0，因此会相应重置。此TIO显示50个随机结果。

C（gcc），31个字节

f(i){for(i=5;i--;)c;i=~-c%6+1;}

每6个通话，产生1到6（含）之间的每个数字的概率相等。

c是#define对生成完美随机数的函数的调用。

在线尝试！