Reto

Estoy siendo atacado por el larguero Midnight Crew y necesito convocar al Catenative Doomsday Dice Cascader para defenderme. Como tengo poco espacio, necesito que el código sea lo más corto posible.

El algoritmo para el Catenative Doomsday Dice Cascader es el siguiente:

Primero, se tira el dado de seis lados en la Burbuja Prime, y el resultado determinará cuántas iteraciones del próximo paso tienen lugar.

Comience con un dado de seis lados. Por tantas veces como la tirada del dado de Prime Bubble, multiplique el número de lados en el próximo dado por el resultado de la tirada del dado actual. Por ejemplo, si en su primera tirada del dado de seis lados su tirada es 2, entonces su próximo dado tendrá 6 * 2 = 12 lados.

Su objetivo es escribir una función o programa que no tome entrada y produzca el resultado final del último dado lanzado. Como se trata de un código de golf , ¡el recuento de bytes más bajo en cada idioma gana!

Ejemplos

Ejemplo # 1 (Tomado directamente del enlace de arriba):

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.

Ejemplo # 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 bytes

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

Pruébalo en línea!

Perl 6 , 43 37 bytes

-6 bytes gracias a nwellnhof

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

Pruébalo en línea!

Bloque de código anónimo que devuelve el resultado del dado del fin del mundo.

Explicación:

{                                   }   # 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 Language (Mathematica) , 43 bytes

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

Pruébalo en línea!

J , 21 bytes

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

Pruébalo en línea!

+6 bytes gracias a un problema lógico detectado por FrownyFrog

NOTA: J no tiene verbos niládicos. Sin embargo, este verbo funcionará igual sin importar el argumento que le des. En el ejemplo de TIO, lo llamo con 0, pero podría haberlo usado 99o ''igual de bien.

cómo

• 1+ agrega uno a ...
• [:?un solo rollo de una matriz de n lados (lados lectura 0a n-1), donde el número nse determina por ...
• (*1+?)toma el argumento actual yy rueda ?para producir un número aleatorio entre 0y y-1. 1+hace que 1a y, ambos inclusive. Finalmente, *crea un gancho J, que multiplicará eso ynuevamente.
• ^: hacer lo anterior muchas veces ...
• (?`]) ?tira el argumento inicial, que es 6, para determinar cuántas veces repetir. Si tiramos 0(correspondiente a a 1en Prime Bubble), el argumento pasará sin cambios. El ]indica que 6, sin cambios, será el valor inicial del (*1+?)verbo repetido que determina el valor del dado para la tirada final.
• @6xadjunta el verbo constante 6, de modo que podamos llamarlo con cualquier cosa, y xobliga a J a usar el cómputo entero extendido que necesitamos para los números posiblemente enormes.

K (oK) , 32 bytes

Solución:

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

Pruébalo en línea!

Comience con 6 y "1 elige 6", repite "1 elige 6" veces:

*|{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'

Puede ver las iteraciones cambiando la imagen para un escaneo , p. Ej.

(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

Jalea , 9 bytes

6X×$5СXX

Un enlace niládico que produce un número entero positivo.

Pruébalo en línea!

Guardar un byte sobre lo más obvio 6X×$6X’¤¡X

¿Cómo?

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 bytes

X6DLΩF*DLΩ

La elección aleatoria incorporada para listas grandes es bastante lenta, por lo que puede dar lugar a un tiempo de espera si el lanzamiento de Prime Bubble es, por ejemplo, un 6.

Pruébelo en línea o pruébelo en línea con impresiones adicionales para ver los rollos . (TIO utiliza la versión heredada de 05AB1E, ya que es un poco más rápido).

Explicación:

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)

Jalea , 9 bytes

6×X$X’$¡X

Pruébalo en línea!

La respuesta de Jonathan Allan afirma que es

Guardar un byte sobre lo más obvio 6X×$6X’¤¡X

. De hecho, no necesitamos hacer una modificación tan grande. Por lo tanto, este es un enfoque alternativo a la respuesta de Jonathan Allan y, también, un lugar de descanso para mi 6-byter inicial no válido. :(

Perl 5 , 54 bytes

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

Pruébalo en línea!

Carbón , 16 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

⊞υ⁶

Empuje 6 a la lista predefinida.

Ｆ⊕‽⁶

Repita un número aleatorio de veces de 1 a 6 ...

⊞υ⊕‽Πυ

... empuje un número aleatorio entre 1 y el producto de la lista a la lista.

Ｉ⊟υ

Salida del último número empujado a la lista.

Enfoque alternativo, también 16 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔⁶θ

Establece el número de lados en 6.

Ｆ‽⁶

Repita un número aleatorio entre 0 y 5 veces ...

≧×⊕‽θθ

... multiplique el número de lados por un número aleatorio de 1 al número de lados.

Ｉ⊕‽θ

Imprime un número aleatorio del 1 al número de lados.

Python 3 , 76 bytes

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

Pruébalo en línea!

-2 bytes gracias a TFeld

R , 43 bytes

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

Pruébalo en línea!

krealiza un seguimiento del número actual de caras en el dado. Utiliza el hecho de que Tse inicializa como 1.

Intenté algunas otras cosas, pero no pude superar este enfoque simple y directo.

Jalea , 10 bytes

6×X$6X’¤¡X

Pruébalo en línea!

Explicación

       ¤   | 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

Ruby , 41 bytes

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

Pruébalo en línea!

Explicación

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 bytes

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

Pruébelo en línea o pruébelo en línea con líneas de impresión adicionales para ver los pasos .

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

Explicación:

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 bytes

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

expandido:

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

No estoy seguro si se supone que debo incluir la etiqueta abierta.

En mi máquina, se bloquea si $s*$res demasiado grande, por lo que a $q>=5veces no se imprime ... porque los números se vuelven muy grandes. No estoy seguro de una solución.

Pyth , 14 bytes

uhO=*|Z6GO6hO6

Pruébalo en línea!

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 bytes

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);}}

Pruébalo en línea!

Estoy bastante seguro de que esto funciona, dada la suposición de longitud entera infinita que nos gusta aquí. Si realmente tengo que manejar el desbordamiento, necesitaría sacar una clase completamente diferente.

Julia 1.0 , 60 bytes

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)hace que funcione con enteros de tamaño arbitrario ¡ Pruébelo en línea!

Gaia , 13 bytes

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

Pruébalo en línea!