Herausforderung

Ich werde von der mitternächtlichen Besatzung angegriffen und muss den Catenative Doomsday Dice Cascader beschwören , um mich zu verteidigen. Da der Platz knapp ist, muss der Code so kurz wie möglich sein.

Der Algorithmus für den Catenative Doomsday Dice Cascader lautet wie folgt:

Zuerst wird der sechsseitige Würfel in der Prime Bubble gewürfelt und das Ergebnis bestimmt, wie viele Iterationen des nächsten Schritts stattfinden.

Beginnen Sie mit einem sechsseitigen Würfel. Multiplizieren Sie die Anzahl der Seiten des nächsten Würfels so oft wie der Wurf des Prime Bubble-Würfels mit dem Ergebnis des Würfels des aktuellen Würfels. Wenn zum Beispiel auf Ihrem ersten Wurf des sechsseitigen Würfels Ihr Wurf 2 ist, hat Ihr nächster Würfel 6 * 2 = 12 Seiten.

Ihr Ziel ist es, eine Funktion oder ein Programm zu schreiben, die bzw. das keine Eingaben benötigt und das Endergebnis des zuletzt gewürfelten Würfels ausgibt. Da dies Codegolf ist , gewinnt die niedrigste Byteanzahl in jeder Sprache!

Beispiele

Beispiel # 1 (direkt aus dem obigen Link entnommen):

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.

Beispiel # 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

Probieren Sie es online!

Perl 6 , 43 37 Bytes

-6 bytes dank nwellnhof

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

Probieren Sie es online!

Anonymer Codeblock, der das Doomsday-Würfelergebnis zurückgibt.

Erläuterung:

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

Probieren Sie es online!

J , 21 Bytes

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

Probieren Sie es online!

+6 Bytes dank eines von FrownyFrog entdeckten Logikproblems

HINWEIS: J hat keine niladischen Verben. Dieses Verb funktioniert jedoch gleich, egal welches Argument Sie angeben. Im TIO-Beispiel rufe ich es mit an 0, hätte aber 99oder verwenden können'' genauso gut .

Wie

• 1+ füge eins hinzu zu ...
• [:?eine einzelne Rolle eines n-seitigen Würfels (Seiten lesen 0bis n-1), wobei die Anzahl nbestimmt wird durch ...
• (*1+?)Nehmen Sie das aktuelle Argument yund rollen Sie ?, um eine Zufallszahl zwischen 0und zu erzeugen y-1. 1+das macht 1bis yeinschließlich. Zum Schluss *wird ein J-Hook erzeugt, der diesen ywiederum multipliziert .
• ^: mach das oben so oft ...
• (?`]) ?Würfeln Sie mit dem Anfangsargument, um 6zu bestimmen, wie oft wiederholt werden soll. Wenn wir rollen 0(entsprechend einem 1auf der Prime Bubble), wird das Argument unverändert durchlaufen. Das ]bedeutet, dass 6unverändert der Startwert des wiederholten (*1+?)Verbs ist, das den Würfelwert für den letzten Wurf bestimmt.
• @6xhängt das konstante Verb an 6, damit wir es mit allem aufrufen können, und xzwingt J, die erweiterte Ganzzahlberechnung zu verwenden, die wir für die möglicherweise riesigen Zahlen benötigen.

K (oK) , 32 Bytes

Lösung:

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

Probieren Sie es online!

Beginne mit 6 und "1 wähle 6", iteriere über "1 wähle 6" mal:

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

Sie können die Iterationen anzeigen, indem Sie die Taste für einen Scan umschalten , z

(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

Gelee , 9 Bytes

6X×$5СXX

Eine niladische Verknüpfung, die eine positive ganze Zahl ergibt.

Probieren Sie es online!

Speichern eines Bytes über das Offensichtliche 6X×$6X’¤¡X

Wie?

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Ω

Die Zufallsauswahl für große Listen ist ziemlich langsam. Dies kann zu einer Zeitüberschreitung führen, wenn der Prime Bubble-Wurf beispielsweise eine 6 ist.

Probieren Sie es online aus oder probieren Sie es online mit hinzugefügten Abzügen, um die Rollen zu sehen . (TIO verwendet die ältere Version von 05AB1E, da diese etwas schneller ist.)

Erläuterung:

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)

Gelee , 9 Bytes

6×X$X’$¡X

Probieren Sie es online!

Jonathan Allans Antwort behauptet, dass es so ist

Speichern eines Bytes über das Offensichtliche 6X×$6X’¤¡X

. Tatsächlich müssen wir keine so großen Änderungen vornehmen. Daher ist dies eine alternative Herangehensweise an Jonathan Allans Antwort und auch eine Ruhestätte für meinen anfangs ungültigen 6-Byte. :(

Perl 5 , 54 Bytes

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

Probieren Sie es online!

Kohle , 16 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

⊞υ⁶

Drücken Sie 6 zur vordefinierten Liste.

Ｆ⊕‽⁶

Wiederholen Sie eine zufällige Anzahl von 1 bis 6 ...

⊞υ⊕‽Πυ

... eine Zufallszahl zwischen 1 und dem Produkt der Liste in die Liste verschieben.

Ｉ⊟υ

Die zuletzt in die Liste geschobene Nummer ausgeben.

Alternativer Ansatz, auch 16 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔⁶θ

Stellen Sie die Anzahl der Seiten auf 6 ein.

Ｆ‽⁶

Wiederhole eine Zufallszahl zwischen 0 und 5 mal ...

≧×⊕‽θθ

... multiplizieren Sie die Anzahl der Seiten mit einer Zufallszahl von 1 bis zur Anzahl der Seiten.

Ｉ⊕‽θ

Drucken Sie eine Zufallszahl von 1 bis zur Anzahl der Seiten.

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

Probieren Sie es online!

-2 Bytes dank TFeld

R , 43 Bytes

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

Probieren Sie es online!

kVerfolgt die aktuelle Anzahl der Gesichter auf dem Würfel. Verwendet die Tatsache, dass Tals initialisiert wird 1.

Ich habe ein paar andere Dinge ausprobiert, konnte diesen einfachen, unkomplizierten Ansatz jedoch nicht übertreffen.

Gelee , 10 Bytes

6×X$6X’¤¡X

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online oder online mit zusätzlichen Druckzeilen aus, um die Schritte zu sehen .

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

Erläuterung:

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;

erweitert:

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

Ich bin mir nicht sicher, ob ich das offene Tag einschließen soll.

Auf meinem Computer stürzt es ab, wenn $s*$res zu groß ist, sodass es $q>=5manchmal nicht gedruckt wird ... weil die Zahlen so groß werden. Ich bin mir einer Lösung nicht sicher.

Pyth , 14 Bytes

uhO=*|Z6GO6hO6

Probieren Sie es 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);}}

Probieren Sie es online!

Ich bin mir ziemlich sicher, dass dies funktioniert, wenn man davon ausgeht, dass es sich um eine unendliche Ganzzahl handelt, die wir hier lieben. Wenn ich wirklich mit dem Überlauf fertig werden muss, muss ich eine ganz andere Klasse ausschalten.

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)Lässt es mit Ganzzahlen beliebiger Größe funktionieren Probieren Sie es online aus!

Gaia , 13 Bytes

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

Probieren Sie es online!