31

आपका कार्य एक प्रोग्राम बनाना है जो एक पूर्णांक में होता है n > 1, और एक एकल- nमरते हुए रोल का आउटपुट देता है । हालांकि, यह पासा पासा विस्फोट के नियमों का पालन करता है ।

जब आप मर को रोल करते हैं, तो जांच लें कि आपने क्या मूल्य रोल किया है। यदि आपको इस तरह की मृत्यु के लिए अधिकतम मिला (एक मानक डी 4 पर जो 4, या 6 एक डी 6, आदि पर होगा), फिर से रोल करें और उस कुल में नया रोल जोड़ें। जब तक आप अधिकतम संख्या को रोल नहीं करते, तब तक प्रत्येक रोल कुल में जुड़ता रहता है। हालांकि यह अंतिम संख्या अभी भी जोड़ा गया है।

आपके कार्यक्रम को एक पूर्णांक में ले जाना चाहिए n, और nविस्फोटित-मरते हुए रोल को रोल करना चाहिए । यहां एक उदाहरण वितरण है यह दिखाने के लिए कि इसके लिए क्या देखना चाहिए n=4। ध्यान दें कि आपको कभी भी किसी भी गुणक का उत्पादन नहीं करना चाहिए n, क्योंकि वे हमेशा विस्फोट करेंगे।

आप मान सकते हैं कि आपके द्वारा की गई किसी भी पुनरावृत्ति के लिए स्टैक का आकार अनंत है, और आपके यादृच्छिक फ़ंक्शन को यादृच्छिकता (अंतर्निहित यादृच्छिक जनरेटर या समय / तिथि ) के लिए हमारे मानकों को पूरा करना होगा । आपका रैंडम फ़ंक्शन भी यथासंभव समान होना चाहिए, बनाम एक ज्यामितीय वितरण जैसा कुछ, क्योंकि ये ऐसे पासे हैं जिनके बारे में हम बात कर रहे हैं।

code-golf random

— Rɪᴋᴇʀ
स्रोत

1

क्या कार्यक्रम सही होना चाहिए? क्या इसके वितरण में कुछ बेहद कम राशि की कमी हो सकती है?

— माल्टीसेन

टू: राइकर; रे: @ माल्टीसेन की टिप्पणी ऊपर; या बहुत अधिक राशि?

— आर्टेमिस मोनिका

2

@ArtemisFowl यादृच्छिकता के लिए हमारे मानक देखें। इसके अलावा, यहाँ ।

— R

36

x86 मशीन कोड (इंटेल आइवी ब्रिज के लिए और बाद में), 17 बाइट्स

31 C9 0F C7 F0 31 D2 F7 F6 42 01 D1 39 F2 74 F2 C3

कोड के उपरोक्त बाइट्स एक फ़ंक्शन को परिभाषित करते हैं जो एक विस्फोट मरने की नकल करता है। यह एक एकल इनपुट लेता है ESI, जो रजिस्टर में पारित किया गया है , जो मरने की अधिकतम संख्या को दर्शाता है। यह ECXरजिस्टर में एकल मान लौटाता है , जो रोल का परिणाम है।

आंतरिक रूप से, यह यादृच्छिक संख्या उत्पन्न करने के लिए RDRANDअनुदेश का उपयोग करता है । यह एक यादृच्छिक संख्या जनरेटर (RNG) का उपयोग करता है जो इंटेल आइवी ब्रिज प्रोसेसर और बाद में हार्डवेयर में बनाया गया है (कुछ AMD CPU भी इस निर्देश का समर्थन करते हैं)।

फ़ंक्शन का तर्क अन्यथा बहुत सीधा है। उत्पन्न यादृच्छिक संख्या को मानक तकनीक ( (rand % dieSize) + 1) का उपयोग करके वांछित सीमा के भीतर झूठ बोलने के लिए बढ़ाया जाता है , और फिर यह देखने के लिए जांच की जाती है कि क्या यह एक विस्फोट का कारण बन सकता है। अंतिम परिणाम एक संचायक रजिस्टर में रखा जाता है।

यहाँ एक एनोटेट संस्करण है जो असेंबली लैंग्वेज मेंमिक्स दिखा रहा है:

           unsigned int RollExplodingDie(unsigned int dieSize)
31 C9        xor     ecx, ecx    ; zero-out ECX, which accumulates the final result
           Roll:
0F C7 F0     rdrand  eax         ; generate a random number in EAX
31 D2        xor     edx, edx    ; zero-out EDX (in preparation for unsigned division)
F7 F6        div     esi         ; divide EDX:EAX by ESI (the die size)
                                 ;   EAX receives the quotient; EDX receives the remainder
42           inc     edx         ; increment the remainder
01 D1        add     ecx, edx    ; add this roll result to the accumulator
39 F2        cmp     edx, esi    ; see if this roll result should cause an explosion
74 F2        jz      Roll        ; if so, re-roll; otherwise, fall through
C3           ret                 ; return, with result in ECX register

मैं थोड़ा धोखा दे रहा हूं । सभी मानक x86 कॉलिंग कन्वेंशन EAXरजिस्टर में एक फ़ंक्शन का परिणाम लौटाते हैं । लेकिन, सच मशीन कोड में, कोई कॉलिंग कन्वेंशन नहीं हैं। आप इनपुट / आउटपुट के लिए किसी भी रजिस्टर का उपयोग कर सकते हैं। ECXआउटपुट रजिस्टर के उपयोग से मुझे 1 बाइट बचाई गई। यदि आप उपयोग करना चाहते हैं EAX, तो XCHG eax, ecxनिर्देश के तुरंत पहले 1-बाइट अनुदेश डालें ret। इस अदला-बदली के मूल्यों EAXऔर ECXरजिस्टर, प्रभावी ढंग से से परिणाम को कॉपी ECXमें EAX, और trashing ECXके पुराने मूल्य के साथ EAX।

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

यहाँ बराबर समारोह सी में लिखित, का उपयोग कर आंतरिक जीसीसी, बजना, और आईसीसी द्वारा समर्थित उत्पन्न करने के लिए अनुदेश:__builtin_ia32_rdrand32_stepRDRAND

#include <immintrin.h>

unsigned int RollExplodingDie(unsigned int dieSize)
{
    unsigned int result = 0;
Roll:
    unsigned int roll;
    __builtin_ia32_rdrand32_step(&roll);
    roll    = ((roll % dieSize) + 1);
    result += roll;
    if (roll == dieSize)   goto Roll;
    return result;
}

दिलचस्प है, ध्वज के साथ जीसीसी -Osइसे लगभग उसी मशीन कोड में बदल देता है । यह EDIइसके बजाय इनपुट लेता है ESI, जो पूरी तरह से मनमाना है और कोड के बारे में कुछ भी नहीं बदलता है। EAXजैसा कि मैंने पहले उल्लेख किया है, इसमें परिणाम वापस करना चाहिए , और यह MOVतुरंत पहले ऐसा करने के लिए अधिक कुशल (लेकिन बड़ा) निर्देश का उपयोग करता है RET। नहीं तो वही। यह हमेशा मजेदार होता है जब प्रक्रिया पूरी तरह से प्रतिवर्ती होती है: विधानसभा में कोड लिखें, इसे C में लिखें, इसे C कंपाइलर के माध्यम से चलाएं, और अपनी मूल असेंबली को वापस प्राप्त करें!

— कोडी ग्रे
स्रोत

12

पायथन 2 , 66 64 61 बाइट्स

-3 बाइट्स xnor के लिए धन्यवाद

f=lambda n,c=0:c%n or c+f(n,randint(1,n))
from random import*

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

पिछले रोल में संग्रहीत किया गया है c, हमें इसे एक चर में संग्रहीत किए बिना कई बार एक्सेस करने की अनुमति देता है, जिसे पायथन लैम्ब्डा में नहीं किया जा सकता है। प्रत्येक पुनरावृत्ति, हम जांचते हैं कि क्या हमने पासा विस्फोट किया था।

cशून्य से आरंभिक होता है, इसलिए c%nवहां गलत है। अगले पुनरावृत्तियों में, यह केवल गलत होगा यदि विस्फोट पासा लुढ़का हुआ था।

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

f=lambda n:randint(1,n)%n or n+f(n)
from random import*

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

मेरा अन्य जवाब थोड़ा अतिरंजित लगता है, क्योंकि यह काम करने के लिए भी प्रतीत होता है ... मैं इसे वैसे भी छोड़ दूँगा।

— अरबो
स्रोत

2

पुनरावर्ती कार्य जहां टूटने की स्थिति यादृच्छिकता पर आधारित होती है, हमेशा स्टैक ओवरफ्लो का एक गैर-शून्य मौका होगा। सांख्यिकीय रूप से महत्वहीन मौका है, लेकिन अभी भी ...

— mypetlion

3

आमतौर पर, स्टैक आकार को मेरे अनुभव में कोड गोल्फिंग चुनौतियों में अनंत माना जाता है। जैसे ही स्टैक का आकार अनंत तक बढ़ जाता है, स्टैक ओवरफ्लो की संभावना जल्दी से शून्य में परिवर्तित हो जाती है।

— अर्बो

अपनी टिप्पणी में टाइप करने से पहले ArBo do @mypetlion करें ताकि आप उपयोगकर्ता को पिंग कर सकें

— MilkyWay90

1

मुझे लगता है कि c*(c<n)हो सकता है c%n।

— xnor

@xnor बेशक, मैं एक बेवकूफ हूँ ...

— ArBo

12

आर , 39 बाइट्स

n=scan();n*rgeom(1,1-1/n)+sample(n-1,1)

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

स्पष्टीकरण: यह समाधान पुनरावर्तन से बचता है / जबकि लूप सीधे विस्फोटों की संख्या के वितरण की गणना करता है जो घटित होंगे। चलो $n$ मरने पर भुजाओं की संख्या हो। आप एक रोलिंग के रूप में सफलता निरूपित हैं $n$ और विफलता कुछ और रोलिंग के रूप में है, तो आप संभावना है $\frac1n$ सफलता का। विस्फोटों की कुल संख्या पहली विफलता से पहले सफलताओं की संख्या है। यह एक $\mathrm{Geometric}\left(1-\frac{1}{n}\right)$ वितरण (विकिपीडिया पृष्ठदेखें, जो सफलता को परिभाषित करता है और दूसरे तरीके से विफलता)। प्रत्येक विस्फोटकुल में $n$ लाता है। अंतिम रोल $\mathrm{Uniform}(1,2,\ldots,n-1)$ वितरण के बाद आता है जिसे हम कुल में जोड़ते हैं।

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

बहुत अच्छा! बेतरतीब चुनौतियों के लिए बिलियन डिस्ट्रीब्यूशन से प्यार होगा !

— Giuseppe

sampleयादृच्छिकता के लिए मानकों को पूरा करता है , इसके पूर्वाग्रह को देखते हुए ?

— शीआन

@ शीआन सुंदर यकीन है कि यह करता है : यह असतत यादृच्छिक चर के लिए निर्मित यादृच्छिक जनरेटर है।

— रॉबिन राइडर

मुझे पता है, मुझे पता है, लेकिन मेरे द्वारा डाले गए लिंक की जांच करें: जो विवेक निहित है sample एकरूपता की कमी की वजह से होने वाला जो अधिकतम संभावना को 1.03 तक न्यूनतम संभावना का अनुपात देता है ... चौंकाने वाला, है ना ?!

— शीआन

जी हां, यह चौंकाने वाला है। लेकिन तब फिर से, कितनी बार आप प्रयोग करते हैं sampleसाथ

m \approx 2^{31}

$m\approx 2^{31}$ ? ;-)

— रॉबिन राइडर

9

पर्ल 6 , 26 बाइट्स

{sum {roll 1..$_:}...*-$_}

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

व्याख्या

{                        } # Anonymous block
                  ...      # Sequence constructor
     {roll 1..$_:}         #   Next elem is random int between 1 and n
                           #   (Called as 0-ary function with the original
                           #   $_ for the 1st elem, then as 1-ary function
                           #   with $_ set to the previous elem which
                           #   equals n.)
                     *-$_  #   Until elem not equal to n (non-zero difference)
 sum                       # Sum all elements

— nwellnhof
स्रोत

2

अच्छा, मेरा खुद का समाधान था{sum roll(*,1..$_)...$_>*}

— जो किंग

9

जे , 16 11 बाइट्स

(+$:)^:=1+?

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

व्याख्या

टी एल; डॉ 1+? । मर रोल करता है, (+$:)^:=केवल तब ही दोहराता है जब यह इनपुट के बराबर होता है।

समारोह 4 क्रियाओं की एक ट्रेन है:

             ┌─ + 
         ┌───┴─ $:
  ┌─ ^: ─┴─ =     
  │               
──┤      ┌─ 1     
  └──────┼─ +     
         └─ ?

एक ट्रेन है जब 2 या अधिक क्रियाओं को समतल किया जाता है। यहाँ, उत्तर प्रपत्र का हैf g h j :

(+$:)^:=  1  +  ?
    f     g  h  j

तथाकथित "4-ट्रेन" को एक हुक और एक कांटा के रूप में रखा गया है:

f g h j   ⇔   f (g h j)

इस प्रकार, उत्तर इसके बराबर है:

(+$:)^:= (1 + ?)

हुक: `(f g) x`और`x (f g) y`

दो क्रियाओं का एक विमुद्रीकरण (एक-तर्क) हुक, एक तर्क दिया x, निम्नलिखित समानता रखती है:

(f g) x   ⇔   x f (g x)

उदाहरण के लिए, का (* -) 5मूल्यांकन करता है5 * (- 5) , जो मूल्यांकन करता है _25।

इसका मतलब है कि हमारी 4-ट्रेन, हुक fऔर (g h j), के बराबर है:

(f (g h j)) x   ⇔   x f ((g h j) x)

लेकिन fयहाँ क्या करता है? पॉवर संयोजन (+$:)^:=का उपयोग करके दो क्रियाओं का एक संयोजन है : एक और हुक ( ) और एक क्रिया ( )। नोट है कि यहाँ है dyadic -यह दो तर्क है ( और )। इसलिए हमें यह देखना होगा कि कैसे व्यवहार किया जाए। शक्ति संयोजन एक क्रिया और या तो एक क्रिया या एक संज्ञा लेता है (एक संज्ञा सिर्फ डेटा का एक टुकड़ा है) और कई बार लागू होता है। उदाहरण के लिए, ले लो । निम्नलिखित समानताएं रखती हैं:^:(+$:)=fx(g h j) x^:f^:ofof oo = 3

(f^:3) x     ⇔   f (f (f x))
x (f^:3) y   ⇔   x f (x f (x f y))

यदि oएक क्रिया है, तो शक्ति संयुग्मन केवल oतर्कों पर मूल्यांकन करेगा और पुनरावृत्ति गणना के रूप में संज्ञा परिणाम का उपयोग करेगा।

हमारे क्रिया के लिए, oहै =, समानता क्रिया। यह 0विभिन्न तर्कों के लिए और 1समान तर्कों के लिए मूल्यांकन करता है । हम (+$:)समान तर्क के लिए एक बार हुक दोहराते हैं और अलग-अलग लोगों के लिए समय नहीं देते हैं। स्पष्टीकरण के लिए अंकन की आसानी के लिए, चलो y ⇔ ((g h j) x)। याद रखें कि हमारा शुरुआती हुक इसके बराबर है:

x   (+$:)^:=   ((g h j) x)
x   (+$:)^:=   y

संयोजन का विस्तार, यह हो जाता है:

x ((+$:)^:(x = y)) y

अगर xऔर yसमान हैं, तो यह बन जाता है:

x (+$:)^:1 y   ⇔   x (+$:) y

अन्यथा, यह बन जाता है:

x (+$:)^:0 y   ⇔   y

अब, हमने monadic forks को देखा है। यहाँ, हमारे पास एक डाईडिक कांटा है:

x (f g) y   ⇔   x f (g y)

इसलिए, जब xऔर yजैसा हो, हमें मिलता है:

x (+$:) y   ⇔   x + ($: y)

क्या है $:? यह पूरी क्रिया को संदर्भित करता है और पुनरावृत्ति की अनुमति देता है। इसका मतलब यह है कि, जब xऔर y are the same, we apply the verb toy and addx` इसके लिए।

फोर्क्स: `(g h j) x`

अब, भीतर का कांटा क्या करता है? यह yहमारे आखिरी उदाहरण में था। तीन क्रियाओं के एक अद्वैत कांटे के लिए, एक तर्क दिया जाता है x, निम्नलिखित तुल्यता पकड़:

(g h j) x   ⇔   (g x) h (j x)

यह अगले उदाहरण के लिए, हम क्रियाओं नाम दिया SUM, DIVIDEऔर LENGTHहै, जो कि आप क्या लगता है वे हो सकता है। यदि हम तीनों को एक कांटा बनाते हैं, तो हम प्राप्त करते हैं:

(SUM DIVIDE LENGTH) x   ⇔   (SUM x) DIVIDE (LENGTH x)

यह कांटा औसत के लिए मूल्यांकन करता है x(मानकर xसंख्याओं की एक सूची है)। जे में, हम वास्तव में इसे उदाहरण के रूप में लिखेंगे +/ % #।

कांटे के बारे में एक आखिरी बात। जब सबसे बाईं ओर "टाइन" (ऊपर हमारे प्रतीकात्मक मामले में g) एक संज्ञा है, तो इसे उस मान को लौटाने वाले एक स्थिर फ़ंक्शन के रूप में माना जाता है।

इस सब जगह के साथ, अब हम उपरोक्त कांटा समझ सकते हैं:

(1 + ?) x   ⇔   (1 x) + (? x)
            ⇔   1 + (? x)

? $[0,x)$ $[1, x]$

यह सब एक साथ डालें

इन सभी बातों को देखते हुए, हमारी क्रिया इसके समकक्ष है:

((+$:)^:=1+?) x   ⇔   ((+$:)^:= 1 + ?) x
                  ⇔   ((+$:)^:= (1 + ?)) x
                  ⇔   x ((+$:)^:=) (1 + ?) x
                  ⇔   x ((+$:)^:=) (1 + (? x))
                  ⇔   x (+$:)^:(x = (1 + (? x))
(let y = 1 + (? x))
if x = y          ⇒   x + $: y
otherwise         ⇒   y

यह वांछित कार्यक्षमता व्यक्त करता है।

— कोनोर ओ ब्रायन
स्रोत

1

(+$:)^:=1+?

— ngn

@ng धन्यवाद! शामिल।

— कॉनर ओ'ब्रायन

7

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

X+ß}¥=¡

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

पुनरावृत्ति का उपयोग करता है। प्रोग्राम को फिर से चलाता है ( ß) और जोड़ता है ( +) अगर ( ¡) यादृच्छिक संख्या ( X) =प्रोग्राम इनपुट के बराबर ( ) है। कार्यक्रम इनपुट पर कार्य }करता है ßऔर उपभोग करने के लिए एक लिंक में ¥जोड़ता है ।+ß}¡

यहां n = 6 के लिए 1000 आउटपुट का वितरण जो मैंने इस कार्यक्रम का उपयोग करके एकत्र किया । अजगर / matplotlib के साथ साजिश रची।

यहाँ एक semilog प्लॉट पर n = 3 से 5000 डेटा पॉइंट दिए गए हैं जो कि (लगभग?) घातांक वितरण को दर्शाता है।

— dylnan
स्रोत

अच्छे प्लॉट्स! आपको मिलने वाला वितरण एक ज्यामितीय वितरण है ( मेरे आर उत्तर देखें ), जो घातीय वितरण के साथ निकटता से संबंधित है।

— रॉबिन राइडर

6

पायथ - 12 11 बाइट्स

कार्यात्मक का उपयोग करता है। मुझे ऐसा लग रहा है कि ऐसा कोई उत्‍तर उत्‍तर होना चाहिए जो सिर्फ वितरण का अनुकरण करता हो।

-.W!%HQ+hOQ

-         (Q)         Subtract Q. This is because we start Z at Q to save a char
 .W                   While, functionally
  !                   Logical not. In this case, it checks for 0
   %HQ                Current val mod input
  +     (Z)           Add to current val
   h                  Plus 1
    OQ                Random val in [0, input)

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

— Maltysen
स्रोत

4

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

import random as r,math
lambda n:int(-math.log(r.random(),n))*n+r.randint(1,n-1)

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

— लिन
स्रोत

1

वहाँ विफलता के लिए एक मामूली मौका है अगर r.random()लौटने के लिए होता है 0. 1-r.random(), हालांकि काम करना चाहिए।

— nwellnhof

हालांकि तकनीकी रूप से वह मौका 0 है

— क्विंटेक

1

एक दुर्लभ मामला जहां import ... as _सबसे छोटा है!

— xnor

@xnor वास्तव में! केवल दूसरी बार मुझे याद है कि मेरा एक जवाब में जीतना यहाँ है

— लिन

4

05AB1E , 10 बाइट्स

[ILΩDIÊ#}O

इसे ऑनलाइन आज़माएं या सूचियों को सत्यापित करें ।

10 बाइट्स वैकल्पिक:

[LΩDˆÊ#}¯O

इसे ऑनलाइन आज़माएं या सूचियों को सत्यापित करें ।

हालांकि मुझे शीर्ष एक और पसंद है क्योंकि इसमें 'शब्द' मिला DIÊ, जो चुनौती के अनुकूल है।

स्पष्टीकरण:

[         # Start an infinite loop:
 IL       #  Create a list in the range [1, input]
   Ω      #  Pop and push a random value from this list
    D     #  Duplicate it
     IÊ   #  If it's NOT equal to the input:
       #  #   Stop the infinite loop
}O        # After the loop: sum all values on the stack
          # (which is output implicitly as result)

[         # Start an infinite loop
 L        #  Create a list in the range [1, (implicit) input]
  Ω       #  Pop and push a random value from this list
   Dˆ     #  Add a copy to the global_array
     Ê    #  If it's NOT equal to the (implicit) input:
      #   #   Stop the infinite loop
}¯        # After the loop: push the global_array
  O       # Pop and push its sum
          # (which is output implicitly as result)

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

उपयोग करने का एक तरीका .Γया कुछ सोचने की कोशिश कर रहा था।

— जादू ऑक्टोपस मूत्र

3

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

R@#//.x_/;x~Mod~#==0:>x+R@#&
R=RandomChoice@*Range

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

— J42161217
स्रोत

3

आर , 47 42 बाइट्स

function(n){while(!F%%n)F=F+sample(n,1)
F}

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

ArBo के दृष्टिकोण का श्रेय ।

रॉबिन राइडर की तुलना में अभी भी एक बाइट , उसके ऊपर जाएं!

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

दिलचस्प है, मैंने इसे if46 बाइट्स के लिए एक पुनरावर्ती के लिए फिर से तैयार किया , लेकिन एक रोल पर 52 प्राप्त करना समाप्त कर दिया जो n = 4 के साथ संभव नहीं होना चाहिए, इसलिए मुझे नहीं पता कि क्या कोई अजीब कम पुनरावृत्ति सीमा होती है, लेकिन मैं लगता है कि यह छोटी गाड़ी हो सकती है। इसे ऑनलाइन आज़माएं!

— क्रिमिनल

मैंने एक पुनरावर्ती की कोशिश की और 54 बाइट समाधान प्राप्त किया। तो 44 के लिए तुम्हारा कुछ इसी तरह की कोशिश की ऑनलाइन कोशिश करो!

— आरोन हेमैन

3

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

->n,s=0{s+=x=1+rand(n);x<n||redo;s}

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

— मोनिका iamnotmaynard को बहाल करें
स्रोत

xचर को गिराकर एक बाइट को बचाएं : इसे ऑनलाइन आज़माएं!

— बेंज़ 2240

3

एपीएल (डायलॉग यूनिकोड) , 15 14 बाइट्स

{×r←?⍵:r⋄⍵+∇⍵}

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

— NGN
स्रोत

3

हास्केल , 77 76 बाइट्स

import System.Random
f x=randomRIO(1,x)>>=(x!)
x!y|y<x=pure y|0<1=(y+)<$>f x

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

एक बाइट के लिए हत्या करने के लिए धन्यवाद।

अगर <|>प्रस्तावना में होते, तो हम बेहतर कर सकते थेMonadComprehensions :

हास्केल , गैर-प्रतिस्पर्धी, 66 बाइट्स

import System.Random
f x=do y<-randomRIO(1,x);[y|y<x]<|>(y+)<$>f x

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

— dfeuer
स्रोत

1

यदि आप एक infix फ़ंक्शन के रूप में g को परिभाषित करते हैं तो आप एक बाइट बचा सकते हैं।

— हत्यारे

1

@killmous, धन्यवाद। पहली नज़र में मुझे लगा कि यह वही या बुरा होगा, लेकिन यह बेहतर है।

— २१:०१

3

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

f=lambda n:random()*n//1or n+f(n)
from random import*

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

ArBo के उत्तरor से शॉर्ट-सर्किटिंग विचार का उपयोग करता है । अभिव्यक्ति से एक संख्या जनरेट करने के लिए के साथ, के एक रोल की जगह लेने । उस नंबर ले जाता है, को छोड़कर अगर यह शून्य (Falsey) है पर यह करने के लिए जारी है ।random()*n//10n-10norn+f(n)

— XNOR
स्रोत

ऐसा लगता है कि आपका जवाब पहले से ही था जब मैंने अपने छोटे में संपादित किया था ... मैंने यह नहीं देखा, लेकिन अगर आप चाहते हैं कि मैं इसे हटा दूं क्योंकि यह काफी समान है।

— अरबो

@ArBo बिल्कुल नहीं, स्वतंत्र रूप से दोहराए गए उत्तर ठीक हैं ।

— xnor

3

जाप , 13 बाइट्स

ö)g@¶°X?X+ß:X

कोशिश करो

पोर्ट ऑफ़ अरनल्ड का जवाब । एक पुनरावर्ती कॉल करने के तरीके का पता लगाना;)

स्थानांतरित जेएस:

// U: Implicit input
// ö: generate a random number [0,U)
(U.ö())
  // g: run the result through a function
  .g(function(X, Y, Z) {
    // increment the result and compare to input
    return U === (++X)
      // if they are the same, roll again and add to current roll
      ? (X + rp())
      // if they are different, use current roll
      : X
   })

— दाना
स्रोत

1

N.g(f):) का बहुत अच्छा उपयोग

— झबरा

इस चक्रव्यूह में छुरा घोंपा और 12 बाइट्स के साथ समाप्त हो गया, लेकिन मैं इसे पोस्ट नहीं करना चाहता क्योंकि मुझे आपका समाधान बहुत पसंद है!

— झबरा

इसे एक अलग उत्तर के रूप में पोस्ट करें :)

— dana

यह छोटा हो सकता है, लेकिन यह आपकी तुलना में बहुत बदसूरत है: नरक में एक नरक है: petershaggynoble.github.io/Japt-Interpreter/…

— झबरा

मैं देख रहा हूँ - हाँ, मैं प्रदूषित न करने के तरीके के साथ आने की कोशिश कर रहा था U। एक पंक्ति को छोड़ना भी काम करने लगता है। यह एक अच्छी चाल है :)

— dana

3

जाप , 12 बाइट्स

यह दाना के घोल से कम हो सकता है, लेकिन यह बहुत बदसूरत है। मैं केवल इसे पोस्ट कर रहा हूं क्योंकि यह हमेशा के लिए लगता है क्योंकि हमारे पास एक जाप समाधान था जो एक खाली लाइन के साथ शुरू हुआ था।


ö
>°V©VªV+ß

कोशिश करो

— झबरा
स्रोत

2

पॉवरशेल , 49 बाइट्स

for($a=$l="$args";$a-eq$l){$o+=$l=1..$a|Random}$o

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

Iterative विधि। इनपुट और अस्ट रोल $argsको सेट करता है (ऐसा किया जाता है ताकि हम कम से कम एक बार लूप में प्रवेश करें)। फिर, जब तक अंतिम रोल इनपुट के लिए ual है, तब तक हम रोल करते रहते हैं। लूप के अंदर हम अंतिम रोल में जमा होते हैं , जिसे इनपुट से एक सीमा बनाकर और एक तत्व को चुनकर अपडेट किया जाता है। (ईमानदारी से, मैं थोड़ा आश्चर्यचकित हूं कि काम करता है।) एक बार जब हम लूप से बाहर हो जाते हैं, तो हम पाइपलाइन पर छोड़ देते हैं और आउटपुट निहित है।$a$l-eq$o1$aRandom$o+=$l=$o

— AdmBorkBork
स्रोत

2

फोर्थ (gforth) , 72 बाइट्स

include random.fs
: f >r 0 begin i random 1+ >r i + r> i < until rdrop ;

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

कोड स्पष्टीकरण

include random.fs      \ include library file for random
: f                    \ start a new word definition
  >r                   \ stick the input on the return stack (for easy access)
  0                    \ add a counter to hold the sum
  begin                \ start an indefinite loop
    i random 1+        \ generate a random number from 1 to n
    >r i + r>          \ add the result to the counter, use the return stack to save a few bytes
    i <                \ check if result was less than n
  until                \ end the loop if it was, otherwise go back to begin
  rdrop                \ remove n from the return stack
;                      \ end the word definition

— reffu
स्रोत

2

बैच, 70 बाइट्स

@set t=0
:g
@set/at+=d=%random%%%%1+1
@if %d%==%1 goto g
@echo %t%

nकमांड-लाइन पैरामीटर के रूप में इनपुट लेता है %1। dवर्तमान रोल है, tकुल संचयी। बस तब तक लुढ़कता रहता है जब तक dकि वह बराबर न हो जाए n।

— नील
स्रोत

2

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

x⁹X€Ä%ƇµḢ

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

एक मौद्रिक लिंक जो अपने तर्क के रूप में n लेता है और एक विस्फोट एन-साइडेड डाई द्वारा उत्पन्न संख्या देता है। यह 1 से n तक 256 नंबर उत्पन्न करता है और पहला संचयी योग लौटाता है जो n का एक से अधिक नहीं है। सिद्धांत रूप में यह 256n पर लौट सकता है, लेकिन यहां तक कि एक 2-पक्षीय मृत्यु के लिए यह केवल हर एक होगा $2^{256}$ बार।

एक विकल्प जिसके पास यह सीमा नहीं है:

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

X³X¤+¥³ḍ¥¿

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

नोट दोनों TIO लिंक वितरण को दिखाने के लिए 400 नंबर उत्पन्न करते हैं।

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

2

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

from random import*
def f(x,a=0):
 while a%x<1:a+=randint(1,x)
 return a

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

-9 बाइट्स ArBo के लिए धन्यवाद

व्याख्या

import random             #load the random module              
def explodeDice(num):     #main function
    ans = 0                     #set answer to 0
    while a % num != 0:         #while a isn't a multiple of the input
        ans += random.randint(1, num) #add the next dice roll to answer
    return ans                  #return the answer

— आर्टेमिस मोनिका का समर्थन करता है आर्टेमिस मोनिका
स्रोत

आप from random import*इसके बजाय का उपयोग करके 1 बाइट बचा सकते हैं ।

— आर्थोपलेक्स

1

आप इस पुनरावर्ती समाधान का उपयोग करके इसे 74 बाइट्स तक प्राप्त कर सकते हैं

— मोनिका

1

@squid आप इस तरह 1 बाइट बचा सकते हैं ।

— आर्थोपलेक्स

1

@orthoplex और फिर आप if / else को छोटा कर सकते हैं, और इसे वन-लाइनर बना सकते हैं । मेरे समाधान की तरह दिखने के लिए शुरू होता है;)

— अरबो

1

@ArBo हाँ, यही कारण है कि मैं पुनरावर्ती के लिए नहीं बदला, बस आप की नकल नहीं करना चाहता था।

— आर्टेमिस मोनिका

2

TI-BASIC, 28 23 बाइट्स

-5 बाइट्स इस मेटा पोस्ट के लिए धन्यवाद !

Ans→N:0:Repeat fPart(Ans/N:Ans+randInt(1,N:End:Ans

इनपुट में है Ans।
आउटपुट में हैAns और स्पष्ट रूप से मुद्रित है।

उदाहरण:

स्पष्टीकरण:

Ans→N:0:Repeat fPart(Ans/N:Ans+randInt(1,N:End:Ans   ;full logic

Ans→N                                                ;store the input in "N"
      0                                              ;leave 0 in "Ans"
        Repeat fPart(Ans/N                 End       ;loop until the sum
                                                     ; is not a multiple of
                                                     ; the input
                               randInt(1,N           ;generate a random
                                                     ; integer in [1,N]
                           Ans+                      ;then add it to "Ans"
                                               Ans   ;leave the sum in "Ans"
                                                     ;implicitly print "Ans"

टिप्पणियाँ:

TI-BASIC एक टोकन भाषा है। चरित्र की गिनती नहीं है बाइट काउंट बराबर ।

— ताउ
स्रोत

चूँकि startTmrअब आवश्यक नहीं है, यह प्रस्तुतिकरण अब TI-BASIC के संस्करणों के लिए TI-84 +

— Tau

2

स्माइलबासिक 3, 49 बाइट्स

D N OUT Rपुनरावृत्ति से पासा के रोल को नष्ट करने के लिए फ़ंक्शन के कार्यान्वयन।

DEF D N OUT R
R=RND(N)+1IF R==N THEN R=R+D(N)
END

Ungolfed

DEF D N OUT R  'N is sides and R is output param (shorter than using RETURN in this case)
 R=RND(N)+1  'random number in [1, N]
 IF R==N THEN R=R+D(N)  'if roll is same as N then roll again and add
END

ध्यान दें कि SmileBASIC में, फ़ंक्शंस में कई रिटर्न मान हो सकते हैं। यदि किसी फ़ंक्शन का एक रिटर्न मान है fun in OUT varऔर var = fun(in)वास्तव में एक समान है, यही कारण है कि हम फ़ंक्शन को OUTरूप में परिभाषित कर सकते हैं और इसे फ़ंक्शन बॉडी में ही अभिव्यक्ति में भी कह सकते हैं। अगर मैंने फ़ंक्शन को परिभाषित किया था जैसा कि DEF D(N)मुझे RETURN Rफ़ंक्शन बॉडी में स्पष्ट रूप से बताना होगा ; दोनों वाक्य रचनाओं को मिलाकर मुझे बाइट्स से बचाया।

— snail_
स्रोत

2

PowerShell , 43 बाइट्स (Iterative विधि)

param($n)do{$x+=1..$n|random}until($x%$n)$x

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

शक्ति कोशिका , 48 बाइट्स (पुनरावर्ती विधि)

filter f{if($_-eq($x=1..$_|random)){$x+=$_|f}$x}

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

— Mazzy
स्रोत

2

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

X=Ð¿⁸S_

एक पूर्णांक लिंक जो एक पूर्णांक को स्वीकार करता है, n , जो एक पूर्णांक देता है।

इसे ऑनलाइन आज़माएं! या के मायने देखते हैं $10^5$ रन

कैसे?

X=Ð¿⁸S_ - Link: integer, n
  Ð¿    - Collect up while...
 =  ⁸   - ...condition: equal to chain's left argument, n
X       - ...next value: random number in [1..n]
     S  - sum
      _ - subtract n (since the collection starts with [n])

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

2

स्माइलबासिक, 41 बाइट्स

INPUT N@L
S=S+RND(N)+1ON S MOD N GOTO@L?S

पढ़ने के बाद:

ध्यान दें कि आपको कभी भी एन के किसी भी गुणक का उत्पादन नहीं करना चाहिए, क्योंकि वे हमेशा विस्फोट करेंगे।

मुझे एहसास हुआ कि अगर पासा रोल था तो जाँचने के बजाय n, आप सिर्फ दोहरा सकते हैं जबकि योग एक से अधिक है n।

— 12Me21
स्रोत

2

AnyDice , 36 बाइट्स

लगभग एक अंतर्निहित भाषा:

function:f I:n{result: [explode dI]}

इसके सही होने के लिए मुझे अनंत पुनरावृत्ति गहराई धारणा का दुरुपयोग करना होगा। AnyDice एक वैश्विक संपत्ति अधिकतम फ़ंक्शन गहराई के साथ पुनरावृत्ति की गहराई को सीमित करता है। विस्फोट का निर्माण हालांकि यह खुद का उपयोग करता है; गहराई में विस्फोट - जो 2 को चूकता है।

set "explode depth" to 99

एक और 25 बाइट्स जोड़ना होगा; और यह वास्तव में आवश्यकताओं से मेल नहीं खाता क्योंकि यह सैद्धांतिक रूप से एक पासा के लिए 99 से अधिक बार विस्फोट करने के लिए संभव है।

फ़ंक्शन का आउटपुट एक डाई है, अर्थात। एक AnyDice बिल्ट-इन प्रकार जो परिणाम के लिए परिणामों और संभावनाओं का एक संयोजन है।

— Taemyr
स्रोत

1

मुझे लगता है कि मैं ठीक हूँ इसके साथ बहुत विस्फोट नहीं हुआ है, 36 बाइट एक मेरे द्वारा ठीक है। मैंने यह नहीं कहा कि मैं कोई निर्माण नहीं कर रहा हूँ और मैं यहाँ उनके साथ ठीक हूँ, क्योंकि यह आपके 1 या 0 बाइट के जवाब की तरह नहीं है। लेकिन साइट पर आपका स्वागत है!

— R

2

CJam , 19 बाइट्स

qi{__mr)_T+:T;=}g;T

स्पष्टीकरण:

T is pre-set to 0

qi{__mr)_T+:T;=}g;T - whole code
qi                  - read input as integer (n) | Stack: n
  {            }    - block
   __               - Duplicate twice | Stack: n n n
     mr)            - Choose a random number from 1 to n (r). Since 'mr' picks a
                      number from 0 to n-1, the number has to be incremented with ')' 
                      Stack: n n r
        _           - Duplicate |  Stack: n n r r
         T          - push T | Stack: n n r r T
          +         - add the random number to T (t) | Stack: n n r t
           :T;      - pop the value and store in T | Stack: n n r
              =     - are the top two stack values the same (c) | Stack: n c
               }
                g   - do while loop that pops the condition from the stack after each
                      iteration | Stack: n
                 ;  - pop the top stack element and discard | Stack: T
                  T - push T | Stack: T
                    - implicit output

या स्यूडोकोड में:

input n
var sum = 0
do {
    var random_number = pick random number from 1 to n
    sum = sum + random_number
} while (random_number == n)
output n

फ़्लोचार्ट के रूप में:

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

— lolad
स्रोत

2

एक्सेल VBA, 46 बाइट्स

@TaylorScott को धन्यवाद

Do:v=-Int(-[A1]*Rnd):t=t+v:Loop While[A1]=v:?t

कमांड विंडो में निष्पादित।

उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन के रूप में।

एक्सेल VBA, 108 67 बाइट्स

Function z(i)
Do
v=Int((i*Rnd)+1)
z=z+v
Loop While v=i
End Function

— विलियम कुली
स्रोत

आप इसे एक do.. loop whileलूप का उपयोग करके , और फ़ंक्शन को तत्काल विंडो फ़ंक्शन में परिवर्तित करके काफी कम कर सकते हैं । - Do:v=-Int(-[A1]*Rnd):t=t+v:Loop While[A1]=v:?t- 46 बाइट्स

— टेलर स्कॉट

1

@TaylorScott धन्यवाद, मैं भूल गया कि एक् वीबीए में मौजूद है जबकि x क्या है।

— वियाम पोर्टर

एक्सप्लोडिंग पासा

x86 मशीन कोड (इंटेल आइवी ब्रिज के लिए और बाद में), 17 बाइट्स

पायथन 2 , 66 64 61 बाइट्स

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

आर , 39 बाइट्स

पर्ल 6 , 26 बाइट्स

व्याख्या

जे , 16 11 बाइट्स

व्याख्या

हुक: (f g) xऔरx (f g) y

फोर्क्स: (g h j) x

यह सब एक साथ डालें

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

पायथ - 12 11 बाइट्स

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

05AB1E , 10 बाइट्स

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

आर , 47 42 बाइट्स

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

एपीएल (डायलॉग यूनिकोड) , 15 14 बाइट्स

हास्केल , 77 76 बाइट्स

हास्केल , गैर-प्रतिस्पर्धी, 66 बाइट्स

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

जाप , 13 बाइट्स

जाप , 12 बाइट्स

पॉवरशेल , 49 बाइट्स

फोर्थ (gforth) , 72 बाइट्स

कोड स्पष्टीकरण

बैच, 70 बाइट्स

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

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

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

व्याख्या

TI-BASIC, 28 23 बाइट्स

स्माइलबासिक 3, 49 बाइट्स

Ungolfed

PowerShell , 43 बाइट्स (Iterative विधि)

शक्ति कोशिका , 48 बाइट्स (पुनरावर्ती विधि)

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

कैसे?

स्माइलबासिक, 41 बाइट्स

AnyDice , 36 बाइट्स

CJam , 19 बाइट्स

एक्सेल VBA, 46 बाइट्स

एक्सेल VBA, 108 67 बाइट्स

हुक: `(f g) x`और`x (f g) y`

फोर्क्स: `(g h j) x`