Sfida

Sono sotto attacco da parte dell'equipaggio della mezzanotte di Midnight e ho bisogno di convocare il Catenative Doomsday Dice Cascader per difendermi. Dato che ho poco spazio, ho bisogno che il codice sia il più corto possibile.

L'algoritmo per il Catenative Doomsday Dice Cascader è il seguente:

Innanzitutto, il dado a sei facce nella Prime Bubble viene lanciato e il risultato determinerà quante iterazioni del prossimo passo avvengono.

Inizia con un dado a sei facce. Per tutte le volte che il tiro del dado Prime Bubble, moltiplica il numero di lati del dado successivo per il risultato del tiro del dado corrente. Ad esempio, se sul tuo primo tiro del dado a sei facce il tuo tiro è 2, allora il tuo dado successivo avrà 6 * 2 = 12 lati.

Il tuo obiettivo è quello di scrivere una funzione o un programma che non prenda input e produca il risultato finale dell'ultimo lancio di dadi. Dal momento che questo è code-golf , vince il conteggio di byte più basso in ogni lingua!

Esempi

Esempio n. 1 (preso direttamente dal link sopra):

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.

Esempio n. 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 byte

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

Provalo online!

Perl 6 , 43 37 byte

-6 byte grazie a nwellnhof

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

Provalo online!

Blocco di codice anonimo che restituisce il risultato dei dadi del giorno del giudizio.

Spiegazione:

{                                   }   # 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 byte

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

Provalo online!

J , 21 byte

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

Provalo online!

+6 byte grazie a un problema logico rilevato da FrownyFrog

NOTA: J non ha verbi niladici. Tuttavia, questo verbo funzionerà allo stesso modo, indipendentemente dall'argomento che gli dai. Nell'esempio TIO, lo chiamo con 0, ma avrei potuto usarlo 99o ''altrettanto bene.

Come

• 1+ aggiungine uno a ...
• [:?un singolo tiro di un dado n-side (lati che leggono 0a n-1), dove il numero nè determinato da ...
• (*1+?)prendi l'argomento corrente ye tira ?per produrre un numero casuale tra 0e y-1. 1+fa che 1a y, compreso. Alla fine *crea un gancio a J, che lo moltiplicherà di ynuovo.
• ^: fai quanto sopra molte volte ...
• (?`]) ?tira l'argomento iniziale, che è 6, per determinare quante volte ripetere. Se tiriamo 0(corrispondente a a 1sulla Prime Bubble), l'argomento passerà invariato. Il ]indica che 6, invariato, sarà il valore iniziale di ripetute (*1+?)verbo che determina il valore del dado per il rotolo finale.
• @6xallega il verbo costante 6, in modo che possiamo chiamarlo con qualsiasi cosa, e le xforze J usano il calcolo intero esteso di cui abbiamo bisogno per i numeri possibilmente enormi.

K (oK) , 32 byte

Soluzione:

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

Provalo online!

Inizia con 6 e "1 scegli 6", ripeti più volte "1 scegli 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'

È possibile visualizzare le iterazioni commutando il over per una scansione , ad es

(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

Gelatina , 9 byte

6X×$5СXX

Un collegamento niladico che produce un numero intero positivo.

Provalo online!

Salvataggio di un byte sul più ovvio 6X×$6X’¤¡X

Come?

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 byte

X6DLΩF*DLΩ

La scelta casuale incorporata per elenchi di grandi dimensioni è piuttosto lenta, quindi potrebbe risultare in un timeout se il rotolo Prime Bubble è ad esempio un 6.

Provalo online o provalo online con stampe aggiunte per vedere i rotoli . (TIO utilizza la versione legacy di 05AB1E, poiché è leggermente più veloce.)

Spiegazione:

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)

Gelatina , 9 byte

6×X$X’$¡X

Provalo online!

La risposta di Jonathan Allan afferma che lo è

Salvataggio di un byte sul più ovvio 6X×$6X’¤¡X

. In effetti, non è necessario apportare una modifica così grande. Pertanto, questo è un approccio alternativo alla risposta di Jonathan Allan e, inoltre, un luogo di riposo per il mio invalido 6-byte iniziale. :(

Perl 5 , 54 byte

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

Provalo online!

Carbone , 16 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

⊞υ⁶

Premere 6 per l'elenco predefinito.

Ｆ⊕‽⁶

Ripeti un numero casuale di volte da 1 a 6 ...

⊞υ⊕‽Πυ

... spingere un numero casuale tra 1 e il prodotto dell'elenco nell'elenco.

Ｉ⊟υ

Stampa l'ultimo numero inserito nell'elenco.

Approccio alternativo, anche 16 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔⁶θ

Impostare il numero di lati su 6.

Ｆ‽⁶

Ripeti un numero casuale tra 0 e 5 volte ...

≧×⊕‽θθ

... moltiplica il numero di lati per un numero casuale da 1 al numero di lati.

Ｉ⊕‽θ

Stampa un numero casuale da 1 al numero di lati.

Python 3 , 76 byte

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

Provalo online!

-2 byte grazie a TFeld

R , 43 byte

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

Provalo online!

ktiene traccia del numero corrente di facce sul dado. Usa il fatto che Tè inizializzato come 1.

Ho provato alcune altre cose, ma non sono riuscito a battere questo approccio semplice e diretto.

Gelatina , 10 byte

6×X$6X’¤¡X

Provalo online!

Spiegazione

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

Rubino , 41 byte

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

Provalo online!

Spiegazione

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 byte

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

Provalo online o provalo online con linee di stampa aggiuntive per vedere i passaggi .

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

Spiegazione:

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 byte

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

allargato:

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

Non sono sicuro se dovrei includere il tag aperto.

Sulla mia macchina, si blocca se $s*$rè troppo grande, quindi a $q>=5volte non stampa ... perché i numeri diventano così grandi. Non sono sicuro di una correzione.

Pyth , 14 byte

uhO=*|Z6GO6hO6

Provalo online!

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 byte

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

Provalo online!

Sono abbastanza sicuro che funzioni, dato il presupposto di una lunghezza intera infinita a cui siamo affezionati qui. Se devo davvero gestire l'overflow, dovrei scartare una classe completamente diversa.

Julia 1.0 , 60 byte

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)lo fa funzionare con numeri interi di dimensioni arbitrarie Provalo online!

Gaia , 13 byte

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

Provalo online!