挑战

我受到了盗窃的午夜船员的攻击，我需要召唤Catenative Doomsday Dice Cascader来保卫自己。由于我的空间不足，因此我需要代码尽可能短。

连环世界末日骰子级联的算法如下：

首先，将“ Prime Bubble”中的六面模具滚动，结果将确定下一步进行了多少次迭代。

从六面模具开始。对于“ Prime Bubble”骰子的滚动次数，将下一个骰子的边数乘以当前骰子滚动的结果。例如，如果在您的六面骰子的第一卷上您的骰子是2，那么您的下一个骰子将具有6 * 2 = 12面。

您的目标是编写一个不带任何输入并输出最后一次压模的最终结果的函数或程序。由于这是代码高尔夫球，因此每种语言中的最低字节数为准！

例子

示例1（直接从上面的链接获取）：

The Prime Bubble rolls a 6, meaning that the Cascader will iterate six times

#1: We always start with a 6 sided die, and it rolls a 2, so the next die has 6x2=12 sides
#2: The 12 sided die rolls an 8, meaning that the third die has 12x8=96 sides
#3: The 96 sided die rolls a 35, meaning that die 4 has 96x35=3360 sides
#4: The 3360 sided die rolls a 2922, so die 5 has 3360x2922 = 9,817,920 sides
#5: The 9.8 million sided die rolls a 5,101,894, so the final die has 50,089,987,140,480 sides
#6: The 50 trillion sided die rolls a one. Hooray. 
Since the last die rolled gave a 1, your function or program should output 1.

范例＃2

The Prime Bubble rolls a 2, meaning that the Cascader will iterate twice.

#1: We always start with a 6 sided die, and it rolls a 4, so the next die has 6x4 = 24 sides
#2: The 24 sided die rolls a 14

Since the last die rolled gave a 14, your function or program should output 14.

Python 2中，76 69个字节

from random import*
R=randint
v=6;exec"p=R(1,v);v*=p;"*R(1,6)
print p

在线尝试！

Perl 6的，43 37个字节

-6字节归功于nwellnhof

{(6,{roll 1..[*] @_:}...*)[1+6.rand]}

在线尝试！

返回世界末日骰子结果的匿名代码块。

说明：

{                                   }   # Anonymous code block
 (                       )[1+6.rand]    # Take a random number from
                     ...*               # The infinite list of
  6,{roll 1..[*] @_:}                   # Cascading dice values
  6,                                    # Starting from 6
    {roll          :}                   # And choosing a random value from
          1..                           # One to
             [*] @_                     # The product of every value so far

Wolfram语言（Mathematica），43个字节

(r=RandomInteger)@{1,Nest[r@{1,#}#&,6,r@5]}

在线尝试！

J，21字节

1+[:?(*1+?)^:(?`])@6x

在线尝试！

由于FrownyFrog发现了逻辑问题，因此增加了6个字节

注意：J没有尼拉德语动词。但是，无论您给它提供什么参数，该动词都将起作用。在TIO例子中，我与调用它0，但我可以用99或者''一样好。

怎么样

• 1+ 加一...
• [:?n边模的单辊（侧面读出0到n-1），其中数n由下式确定...
• (*1+?)接受当前参数y并滚动?以产生一个介于0和之间的随机数y-1。 1+使得该1到y，包容性。最后，*创建一个J钩，它将y再次相乘。
• ^: 多次进行以上操作...
• (?`]) ?滚动初始参数，6以确定重复多少次。如果我们滚动0（对应于1Prime Bubble上的a ），则参数将不变。的]指示6，不变，将是重复(*1+?)动词的起始值，该动词确定最终掷骰的骰子值。
• @6x附加常量动词6，以便我们可以用任何东西来调用它，并且x强制J使用扩展整数计算，这对于可能的大数是需要的。

K（oK），32字节

解：

*|{x,1+1?x:(*).x}/[*a;6,a:1+1?6]

在线尝试！

以6和“ 1选择6”开头，对“ 1选择6”进行迭代：

*|{x,1+1?x:(*).x}/[*a;6,a:1+1?6] / the solution
  {             }/[n;    c     ] / iterate over lambda n times with starting condition c
                            1?6  / 1 choose 6, between 0..5 (returns a list of 1 item)
                          1+     / add 1 (so between 1..6)
                        a:       / store as 'a'
                      6,         / prepend 6, the number of sides of the first dice
                   *a            / we are iterating between 0 and 5 times, take first (*)
           (*).x                 / multi-argument apply (.) multiply (*) to x, e.g. 6*2 => 12
         x:                      / save that as 'x'
       1?                        / 1 choose x, between 0..x-1
     1+                          / add 1 (so between 1..x)
   x,                            / prepend x
*|                               / reverse-first aka 'last'

您可以通过切换扫描来查看迭代，例如

(6 3        / 1 choose 6 => 3, so perform 3 iterations
 18 15      / 1 choose (6*3=18) => 15
 270 31     / 1 choose (18*15=270) => 31
 8370 5280) / 1 choose (270*31=8730) => 5280

果冻，9 字节

6X×$5СXX

一个尼拉度链接，产生一个正整数。

在线尝试！

节省一个字节以上 6X×$6X’¤¡X

怎么样？

6X×$5СXX - Link: no arguments
6         - initialise left argument to 6
    5С   - repeat five times, collecting up as we go: -> a list of 6 possible dice sizes
   $      -   last two links as a monad = f(v):           e.g [6,18,288,4032,1382976,216315425088]
 X        -     random number in [1,v]                     or [6,6,6,6,6,6]
  ×       -     multiply (by v)                            or [6,36,1296,1679616,2821109907456,7958661109946400884391936]
       X  - random choice (since the input is now a list) -> faces (on final die)
        X - random number in [1,faces]

05AB1E，10 个字节

X6DLΩF*DLΩ

大列表内置的随机选择速度非常慢，因此如果“ Prime Bubble”滚动例如为6，可能会导致超时。

在线尝试或在线尝试并添加印刷品以查看卷。（TIO使用旧版本的05AB1E，因为它速度稍快。）

说明：

X           # Push a 1 to the stack
 6          # Push a 6 to the stack
  D         # Push another 6 to the stack
   L        # Pop the top 6, and push a list [1,2,3,4,5,6] to the stack
    Ω       # Pop and push a random item from this list (this is out Prime Bubble roll)
     F      # Loop that many times:
      *     #  Multiply the top two values on the stack
            #  (which is why we had the initial 1 and duplicated 6 before the loop)
       D    #  Duplicate this result
        LΩ  #  Pop and push a random value from its ranged list again
            # (after the loop, output the top of the stack implicitly)

果冻，9字节

6×X$X’$¡X

在线尝试！

乔纳森·艾伦的回答声称这是

节省一个字节以上 6X×$6X’¤¡X

。实际上，我们不需要进行如此大的修改。因此，这是乔纳森·艾伦（Jonathan Allan）回答的另一种方法，也是我最初的无效6人制的安息之地。:(

Perl 5，54个字节

$a=6;map$a*=$r=1+int rand$a,0..rand 6;say 1+int rand$r

在线尝试！

木炭，16字节

⊞υ⁶Ｆ⊕‽⁶⊞υ⊕‽ΠυＩ⊟υ

在线尝试！链接是详细版本的代码。说明：

⊞υ⁶

按6到预定义列表。

Ｆ⊕‽⁶

重复随机次数1到6 ...

⊞υ⊕‽Πυ

...将介于1和列表乘积之间的随机数推入列表。

Ｉ⊟υ

输出推送到列表的最后一个号码。

替代方法，也是16个字节

≔⁶θＦ‽⁶≧×⊕‽θθＩ⊕‽θ

在线尝试！链接是详细版本的代码。说明：

≔⁶θ

将边数设置为6。

Ｆ‽⁶

重复0到5次之间的随机数...

≧×⊕‽θθ

...将边数乘以从1到边数的随机数。

Ｉ⊕‽θ

打印从1到边数的随机数。

Python 3，76个字节

from random import*
r=randint
a=6
for i in" "*r(0,5):a*=r(1,a)
print(r(1,a))

在线尝试！

-2字节归功于TFeld

R，43个字节

s=sample
for(i in 1:s(k<-6))T=s(k<-k*T,1)
T

在线尝试！

k跟踪模具上的当前面数。使用T初始化为的事实1。

我尝试了其他一些方法，但是无法击败这种简单，直接的方法。

果冻，10字节

6×X$6X’¤¡X

在线尝试！

说明

       ¤   | Following as a nilad:
    6X     | - A random number between 1 and 6
      ’    | - Decrease by 1 (call this N)
6          | Now, start with 6
   $    ¡  | Repeat the following N times, as a monad
 ×         | - Multiply by:
  X        |   - A random number between 1 and the current total
         X | Finally, generate a random number between 1 and the output of the above loop

红宝石，41个字节

r=6;rand(2..7).times{r*=$s=rand 1..r};p$s

在线尝试！

说明

r=6                                 # Set dice number to 6

rand(2..7).times{               }   # Repeat X times, where X=dice roll+1
                 r*=$s=rand 1..r    # Multiply dice number by a dice roll
                                    # Save the most recent dice roll

p$s                                 # Print last dice roll (this is why
                                    #  we did the last step one extra time)

Java 10，214 93 86字节

v->{int r=6,n=0;for(var d=Math.random()*6;d-->0;n*=Math.random(),r*=++n)n=r;return n;}

在线尝试或通过其他印刷线路在线尝试以查看步骤。

intjava.math.BigInteger$6^{32}$intlongBigIntegerintBigIntegers

说明：

v->{                        // Method with empty unused parameter & integer return-type
  int r=6,                  //  The range in which to roll, starting at 6
      n=0;                  //  The roll itself (which must be initialized, therefor is 0)
  for(var d=Math.random()*6;//  Roll the Prime Bubble Dice
      d-->0                 //  Loop that many times:
      ;                     //    After every iteration:
       n*=Math.random(),    //     Roll a random dice in the range [0, n)
       r*=++n)              //     Increase `n` by 1 first with `++n`, so the range is [1,n]
                            //     And then multiply `r` by `n` for the new range
    n=r;                    //   Set `n` to `r`
  return n;}                //  After the loop, return `n` as result

PHP，59字节

$r=$q=rand(1,$s=6);while($l++<$q)$r=rand(1,$s*=$r);print$r;

扩展：

$r=$q=rand(1,$s=6);
while($l++<$q)$ 
    r=rand(1,$s*=$r);
print$r;

不知道我是否应该包含open标签。

在我的机器上，如果$s*$r太大，它会崩溃，因此$q>=5有时无法打印...，因为数字太大。不确定修复程序。

Pyth，14个字节

uhO=*|Z6GO6hO6

在线尝试！

uhO=*|Z6GO6hO6   
         O6      Random number in range [0-6)
u                Perform the following the above number of times...
           hO6   ... with starting value G a random number in range [1-6]:
    *   G          Multiply G with...
     |Z6           The value of Z, or 6 if it's the first time through (Z is 0 at program start)
   =  Z            Assign the above back into Z
  O                Random number in range [0-Z)
 h                 Increment
                 Implicit print result of final iteration

C＃（.NET Core），136字节

class A{static void Main(){var r=new System.Random();int i=r.Next(6),j=6;while(i-->0)j*=1+r.Next(j);System.Console.Write(r.Next(j)+1);}}

在线尝试！

考虑到我们喜欢这里无限整数长度的假设，我很确定这是可行的。如果必须实际处理溢出，则需要淘汰一个完全不同的类。

朱莉娅1.0，60字节

g(b=big(6),r=rand)=(for i in 1:r(0:5) b=b*r(1:b) end;r(1:b))

b=big(6)使它可以与任意大小的整数一起使用 在线尝试！

盖亚（Gaia），13个字节

:(ṛ×
6₅ṛ(↑ₓ(ṛ

在线尝试！