चुनौती

मैं सबसे बड़े मध्यरात्रि क्रू द्वारा हमले के अधीन हूं और मुझे खुद का बचाव करने के लिए कैटेनेटिव डूमसडे डाइस कैसकेडर को बुलाने की जरूरत है । चूंकि मैं अंतरिक्ष में कम हूं, मुझे कोड जितना संभव हो उतना छोटा होना चाहिए।

कैटेनेटिव डूमसडे डाइस कैसकेडर के लिए एल्गोरिथ्म इस प्रकार है:

सबसे पहले, प्राइम बबल में छह पक्षीय मर जाते हैं, और परिणाम यह निर्धारित करेगा कि अगले चरण के कितने पुनरावृत्तियां होती हैं।

एक छह पक्षीय मरने के साथ शुरू करो। प्राइम बबल डाई के रोल के रूप में कई बार, वर्तमान डाई के रोल के परिणामस्वरूप अगले डाई पर पक्षों की संख्या गुणा करें। उदाहरण के लिए, यदि छह-पक्षीय मरने वाले आपके पहले रोल में आपका रोल 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.

code-golf random

— Bazinga_9000
स्रोत

4

अधिकतम उत्पादन क्या है? यदि प्रत्येक रोल में अधिकतम पक्ष होता है? मुझे लगता है कि यह 7958661109946400884391936 = ((((6 ^ 2) ^ 2) ^ 2) ^ 2) ^ 2 = 6 ^ (2 ^ 5) = 6 ^ 32

— Kjetil S.

6

@KjetilS। वास्तव में, और उस आउटपुट की संभावना

होनी चाहिए

\frac{1}{6 * \prod_{i = 0}^{5} (6^{2^{i}})} = \frac{1}{6 \times 6 \times 6^{2} \times 6^{4} \times 6^{8} \times 6^{16} \times 6^{32}} = \frac{1}{2155416739906037495048372267884096782336}

$\frac{1}{6*\prod_{i=0}^5(6^{2^i})}=\frac{1}{6\times 6\times 6^2\times 6^4\times 6^8\times 6^{16}\times 6^{32}}=\frac{1}{2155416739906037495048372267884096782336}$

— जोनाथन एलन

3

क्या यह यादृच्छिक होना चाहिए? प्रश्न में यादृच्छिकता के बारे में कुछ भी उल्लेख नहीं है?

— गेहूं जादूगर

10

@ श्रीकोटिलिज्म'ओज़िक डाइस-रोलिंग का मतलब यादृच्छिकता है।

— mbomb007

6

@ SriotchilismO'Zaic xkcd.com/221

— Neyt

8

पायथन 2 , 76 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— चास ब्राउन
स्रोत

8

पर्ल 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

— मजाक कर रहा है
स्रोत

7

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— attinat
स्रोत

5

जे , 21 बाइट्स

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

इसे ऑनलाइन आज़माएं!

+6 बाइट्स FrownyFrog द्वारा स्पॉट की गई एक तर्क समस्या के लिए धन्यवाद

नोट: J का कोई निलेडिक क्रिया नहीं है। हालाँकि, यह क्रिया समान रूप से काम करेगी चाहे आप इसे कितना भी तर्क दें। TIO उदाहरण में, मैं इसके साथ कॉल कर रहा हूं 0, लेकिन मैं इस्तेमाल 99कर सकता हूं या ''बस।

किस तरह

1+ एक जोड़ें ...
[:?एक n तरफा मरने की एक एकल रोल (पक्षों को पढ़ने 0के लिए n-1), जहां संख्या nसे निर्धारित होता है ...
(*1+?)वर्तमान तर्क ले yऔर रोल ?के बीच एक यादृच्छिक संख्या के उत्पादन के लिए 0और y-1। 1+कि बनाता है 1करने के लिए y, समावेशी। अंत में *एक जे हुक बनाता है, जो कि yफिर से गुणा करेगा ।
^: इसके बाद के संस्करण कई बार ...
(?`]) ?प्रारंभिक तर्क को रोल करें, जो है 6, यह निर्धारित करने के लिए कि कितनी बार दोहराना है। यदि हम रोल करते हैं 0( 1प्राइम बबल पर), तो तर्क अपरिवर्तित से गुजरेगा। ]जो इंगित करता है 6, अपरिवर्तित, बार-बार की प्रारंभिक मूल्य होगा (*1+?)क्रिया है कि अंतिम रोल के लिए मरने मूल्य निर्धारित करता है।
@6xनिरंतर क्रिया को संलग्न करता है 6, जिससे हम इसे किसी भी चीज़ के साथ कॉल कर सकते हैं, और xJ को विस्तारित पूर्णांक गणना का उपयोग करने के लिए बाध्य करता है, जिसे हमें संभवतः बड़ी संख्या के लिए आवश्यक है।

— जोनाह
स्रोत

in this case 0 executes the previous verb once, 1 twice, etcऐसा क्यों है?

— FrownyFrog

क्योंकि मैंने एक गलती की :( जल्द ही ठीक हो जाएगा।

— योना

अब तय हो गया। धन्यवाद।

— योना

4

के (ओके) , 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

— streetster
स्रोत

1

(*).x-> */xऔर { }/[*a;6,a:1+1?6]->a{ }/6,a:*1+1?6

— ngn

4

जेली , 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]

— जोनाथन एलन
स्रोत

अच्छा लगा। मैं अपने 'स्पष्ट' उत्तर से आगे बढ़ने का एक तरीका सोचने की कोशिश कर रहा था, लेकिन सभी पासा पैदा करने और फिर यादृच्छिक रूप से एक को चुनने के बारे में नहीं सोचा।

— निक कैनेडी

हे, मुझे याद आया कि आप लगभग उसी सटीक उत्तर को पोस्ट करेंगे!

— जोनाथन एलन

3

05AB1E , 10 बाइट्स

X6DLΩF*DLΩ

बड़ी सूचियों के लिए रैंडम पसंद बिल्ट काफी धीमा है, इसलिए परिणाम हो सकता है यदि प्राइम बबल रोल उदाहरण 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)

— केविन क्रूज़सेन
स्रोत

3

जेली , 9 बाइट्स

6×X$X’$¡X

इसे ऑनलाइन आज़माएं!

जोनाथन एलन का जवाब दावा करता है कि यह है

अधिक स्पष्ट पर एक बाइट की बचत 6X×$6X’¤¡X

। वास्तव में, हमें इतना बड़ा संशोधन करने की आवश्यकता नहीं है। इसलिए, यह जोनाथन एलन के उत्तर के लिए एक वैकल्पिक दृष्टिकोण है, और, मेरे शुरुआती अमान्य 6-बायटर के लिए एक आराम स्थान भी है। :(

— आउटग्रॉफर को एरिक करें
स्रोत

2

पर्ल 5 , 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

यह एक रैंड बहुत अधिक है, आपको बस $ r कहना चाहिए

— ग्रैमी

2

चारकोल , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

⊞υ⁶

पूर्वनिर्धारित सूची में 6 पुश करें।

Ｆ⊕‽⁶

1 से 6 तक के समय की एक यादृच्छिक संख्या दोहराएं ...

⊞υ⊕‽Πυ

... सूची के लिए 1 और सूची के उत्पाद के बीच एक यादृच्छिक संख्या धक्का।

Ｉ⊟υ

अंतिम संख्या को सूची में धकेल दिया गया।

वैकल्पिक दृष्टिकोण, 16 बाइट्स भी

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⁶θ

पक्षों की संख्या 6 पर सेट करें।

Ｆ‽⁶

0 और 5 बार के बीच एक यादृच्छिक संख्या दोहराएं ...

≧×⊕‽θθ

... पक्षों की संख्या को यादृच्छिक संख्या से 1 की संख्या से गुणा करें।

Ｉ⊕‽θ

एक यादृच्छिक संख्या को 1 से लेकर पक्षों की संख्या तक प्रिंट करें।

— नील
स्रोत

2

पायथन 3 , 76 बाइट्स

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

इसे ऑनलाइन आज़माएं!

टीएफएल के लिए -2 बाइट्स धन्यवाद

— HyperNeutrino
स्रोत

1

आयात को बदलकर -2 बाइट्स

— TFeld

@TFeld धन्यवाद [भराव]

— हाइपरनेट्रिनो

2

आर , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

kमरने पर चेहरे की वर्तमान संख्या पर नज़र रखता है। इस तथ्य का उपयोग करता है कि के Tरूप में आरंभिक है 1।

मैंने कुछ अन्य चीजों की कोशिश की, लेकिन इस सरल, सरल दृष्टिकोण को नहीं हरा सका।

— रॉबिन राइडर
स्रोत

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

— निक केनेडी
स्रोत

1

रूबी , 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)

— मूल्य स्याही
स्रोत

1

जावा 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

— केविन क्रूज़सेन
स्रोत

वह समाधान पोस्ट करें जो आपके प्रतिस्पर्धी समाधान के रूप में BigInteger नहीं करता है।

— स्टैकस्टक

2^{32}

$2^{32}$ int

मैं देखूंगा कि क्या मुझे इसके बारे में मेटा पर कुछ भी मिल सकता है।

— स्टैकस्टक

1

ओपी कहते हैं कि पूर्णांक आकार सीमाओं के बारे में चिंता न करें। intप्रकार का उपयोग करें ।

— स्टैकस्टक

1

@ स्टैकस्टक डन, और इस प्रक्रिया में 7 बाइट्स को गोल किया। :)

— केविन क्रूज़सेन

0

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;

यकीन नहीं होता कि मैं खुले टैग को शामिल करने वाला हूं।

मेरी मशीन पर, अगर $s*$rयह बहुत बड़ा है, तो यह दुर्घटनाग्रस्त हो जाता है, इसलिए यह $q>=5कभी-कभी प्रिंट नहीं करता है ... क्योंकि संख्या इतनी बड़ी हो जाती है। एक निश्चित का नहीं।

— ईख
स्रोत

0

अजगर , 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

— सोक
स्रोत

0

सी # (.NET कोर) , 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);}}

इसे ऑनलाइन आज़माएं!

मुझे पूरा यकीन है कि यह अनंत पूर्णांक लंबाई की धारणा को देखते हुए काम करता है। अगर मुझे वास्तव में अतिप्रवाह को संभालना है, तो मुझे एक पूरी तरह से अलग वर्ग का भंडाफोड़ करना होगा।

— Stackstuck
स्रोत

System.ArgumentOutOfRangeException: 'maxValue' must be greater than zero

6^{32}

$6^{32}$ intlongBigIntegers

@ केविनक्रूजसेन हाँ, यह मेरी टिप्पणी का पूरा बिंदु है।

— स्टैकस्टक

0

जूलिया 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)यह मनमाने आकार के पूर्णांक के साथ काम करता है इसे ऑनलाइन आज़माएं!

— gggg
स्रोत

0

गैया , 13 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत

होमस्टॉक के कैटेनेटिव डूमसडे डाइस कैस्केडर को लागू करें

चुनौती

उदाहरण

पायथन 2 , 76 69 बाइट्स

पर्ल 6 , 43 37 बाइट्स

स्पष्टीकरण:

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 43 बाइट्स

जे , 21 बाइट्स

किस तरह

के (ओके) , 32 बाइट्स

जेली , 9 बाइट्स

कैसे?

05AB1E , 10 बाइट्स

जेली , 9 बाइट्स

पर्ल 5 , 54 बाइट्स

चारकोल , 16 बाइट्स

पायथन 3 , 76 बाइट्स

आर , 43 बाइट्स

जेली , 10 बाइट्स

व्याख्या

रूबी , 41 बाइट्स

जावा 10, 214 93 86 बाइट्स

PHP , 59 बाइट्स

अजगर , 14 बाइट्स

सी # (.NET कोर) , 136 बाइट्स

जूलिया 1.0 , 60 बाइट्स

गैया , 13 बाइट्स