डी एंड डी कौशल चुनौतियां

Question

में Dungeons और ड्रेगन , लगभग सब कुछ एक मरने रोलिंग द्वारा निर्णय लिया गया है। आमतौर पर, यदि रोल एक निर्दिष्ट मूल्य से अधिक या उसके बराबर है, तो आप जो भी करना चाहते थे, वह करने का आपका प्रयास सफल होता है, और अन्यथा विफल रहता है। आमतौर पर, एक 20-पक्षीय मर (उर्फ d20) को रोल करने के लिए उपयोग किया जाता है।

अन्य समय में, कौशल चुनौती प्रणाली का उपयोग किया जाता है। यह ऊपर वर्णित सरल प्रणाली के समान है, लेकिन सफलता निर्धारित की जाती है कि क्या खिलाड़ी एक बार की निश्चित संख्या को विफल करने से पहले एक निश्चित संख्या में खिलाड़ी के रोल को सफल करता है या नहीं। उदाहरण के लिए, खिलाड़ी एक सीमित संख्या में लॉकपिक्स के साथ एक दरवाजे पर कई ताले लेने की कोशिश कर सकता है। अलग-अलग सफल रोल एक ताले को सफलतापूर्वक उठाते हैं, और अलग-अलग असफल रोल एक लॉकपिक को तोड़ने का प्रतिनिधित्व करते हैं। कुल मिलाकर सफलता का मतलब यह होगा कि सभी ताले तोड़ने से पहले सभी तालों को सफलतापूर्वक उठाया जाए।

इसके अलावा, कुछ रोल महत्वपूर्ण रोल हो सकते हैं। एक डी 20 पर, 1 को रोल करना एक महत्वपूर्ण विफलता है, जिसके परिणामस्वरूप पूरी चुनौती को तुरंत विफल कर दिया जाता है (उपरोक्त उदाहरण में, खिलाड़ी (ओं) को गलती से एक गार्ड सतर्क कर सकता है)। 20 को रोल करना एक महत्वपूर्ण सफलता है, जिसके परिणामस्वरूप पूरी चुनौती को सफलतापूर्वक प्राप्त किया जा सकता है (उपरोक्त उदाहरण में, खिलाड़ी (ओं) को ताले की चाबी मिल सकती है, उन्हें लेने की आवश्यकता को हटाते हुए)। एक महत्वपूर्ण रोल के मामले में, चुनौती तुरंत समाप्त हो गई है और परिणाम का फैसला किया, सफलताओं और असफलताओं की पिछली संख्या की परवाह किए बिना।

इस चुनौती में, आपको एक कठिनाई, सफलताओं की संख्या और आवश्यक असफलताओं की संख्या को चुनौती दी जाएगी। आपको चुनौती का प्रयास करने वाले खिलाड़ी का अनुकरण करना चाहिए, और परिणाम का उत्पादन करना चाहिए।

इनपुट

3 पूर्णांक, एक व्यक्तिगत रोल में सफल होने के लिए मिले या पार होने वाले मूल्य का प्रतिनिधित्व करते हुए, चुनौती पर सफल होने के लिए आवश्यक सफलताओं की संख्या, और विफलताओं की संख्या जिस पर चुनौती विफल है। इनपुट का क्रम और प्रारूप कोई फर्क नहीं पड़ता, जब तक आप निर्दिष्ट करते हैं कि आप किस क्रम का उपयोग कर रहे हैं। कठिनाई 1 और 20 के बीच होगी, समावेशी, और सफलताओं और असफलताओं की संख्या 1 और 100 दोनों के बीच होगी, समावेशी।

उत्पादन

प्रत्येक d20 रोल के परिणाम (पूर्णांक, क्रम में), और चुनौती के समग्र परिणाम (एक सत्य / गलत मूल्य)। प्रारूप में कोई फर्क नहीं पड़ता, जब तक कि व्यक्तिगत परिणाम क्रम में हों, समग्र परिणाम या तो सभी व्यक्तिगत रोल के पहले या बाद में आता है (आप रोल के बीच में समग्र परिणाम का उत्पादन नहीं कर सकते, उदाहरण के लिए), और आप निर्दिष्ट करते हैं कि आप किस आउटपुट स्वरूप का उपयोग करते हैं और इसे लगातार उपयोग करते हैं।

उदाहरण (कोष्ठक में मान स्पष्टीकरण के लिए हैं और इसमें शामिल नहीं होने की आवश्यकता है):

इनपुट:

12 5 3 (difficulty successes failures)

आउटपुट:

15 (success, 1-0)
10 (failure, 1-1)
5  (failure, 1-2)
16 (success, 2-2)
12 (success, 3-2)
15 (success, 4-2)
19 (success, 5-2)
True (overall success)

इनपुट:

15 2 3 (difficulty failures successes)

आउटपुट:

0  (overall failure)
15 (success, 1-0)
12 (failure, 1-1)
13 (failure, 1-2)

इनपुट:

5 5 10 (successes failures difficulty)

आउटपुट:

11 (success, 1-0)
5  (failure, 1-1)
20 (critical success)
1  (overall success)

इनपुट:

3 10 3 (failures difficulty successes)

आउटपुट:

12 (success, 1-0)
11 (success, 2-0)
1  (critical failure)
False (overall failure)

नियम

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है
• आपको प्रत्येक रोल के लिए 1 और 20 (समावेशी) के बीच एक पूर्णांक मान को यादृच्छिक रूप से चुनना होगा। प्रत्येक मूल्य को चुने जाने की एक समान संभावना होनी चाहिए (या जितना संभव हो उतना करीब होना चाहिए)।

Comments

@ ब्रैडगिल्बर्ब २गिल्स the number of successes and failures will both be between 1 and 100, inclusive.तो, हाँ, इस बात की संभावना है कि एक एकल विफलता पूरी चुनौती को विफल कर देती है।

— मेगो

क्या मुझे यह मान लेना चाहिए कि समग्र सफलता का प्रतिनिधित्व करने वाला सही मूल्य हमेशा एक ही सही मूल्य होना चाहिए? या यह सिर्फ विफलताओं की संख्या रह सकती है?

— ब्रैड गिल्बर्ट b2gills

@ ब्रैडगिल्बर्ब २गिल्स का समान वास्तविक मूल्य होना आवश्यक नहीं है; मैं अपने पायथन उत्तर में छोड़ी गई विफलताओं की संख्या का उपयोग करता हूं ।

— मेगो

एह, मैं शायद इसे केवल एक बूल वापस करने के रूप में छोड़ दूंगा, क्योंकि यह केवल एक बाइट है, और यह आउटपुट की पठनीयता में सुधार करने में मदद करता है।

— ब्रैड गिल्बर्ट b2gills

@ ब्रैडगिल्बर्टबी 2 जी की पठनीयता स्कोर की तुलना में बहुत कम महत्वपूर्ण है।

— मेगो

Answer 1

जावास्क्रिप्ट, 83 78 76 75 बाइट्स

F=(d,f,s)=>!s||f&&(r=~(Math.random()*20))+""+F(d,~r&&f-(k=d>-r),r+20&&s-!k)

जैसा कि होता है यह कोड पुन: सफलताओं और असफलताओं को गिनता है। जब या तो सफलताओं ( s) या विफलता ( f) करने के लिए नीचे गिनती है 0, हम साथ खत्म trueमूल्य !sजब sहै 0या की falsy मूल्य के साथ fजब fहै 0।

आउटपुट नियमित-अभिव्यक्ति प्रपत्र /^(-\d{1,2})+(0|true)$/(या, अधिक सख्ती से /^(-[1-9]|-1[0-9]|-20)+(0|true)$/) है। यही है, इनपुट में एक अग्रणी हाइफ़न है, फिर हाइफ़न द्वारा चित्रित रोल वैल्यू, और अंत में अंतिम परिणाम ( 0या true), जो अंतिम रोल से डिलीट नहीं हुआ है। बहरहाल, यह अभी भी एक स्पष्ट व्याकरण क्योंकि utilmate परिणाम और अंतिम रोल हमेशा प्रतिष्ठित किया जा सकता है: उत्पादन का अंतिम वर्ण (या तो 0या e) हमेशा परिणाम का संकेत है, और एक अंतिम 0हमेशा संख्या से अलग पढ़ा जाता है (रों) अंतिम रोल का।

के लिए नमूना आउटपुट F(11,3,4):

-3-14-12-16-16true  // normal success
-2-12-20true        // critical success
-20true             // first-roll critical success
-18-2-8-14-18-90    // normal failure
-18-12-10           // critical failure
-10                 // first-roll critical failure
-4-16-4-100         // normal failure where last roll is a 10

स्पष्टीकरण:

यह कोड एक नकारात्मक d20 और (ab) को नकारात्मक संकेतों का उपयोग करके परिमार्जन के रूप में रोल करके काम करता है ।

F=(d,f,s)=>    // define function F(difficulty, fails, successes)

!s||   // if zero more successes needed, return true
f &&   // if zero more failures needed, return 0

    (r=~(Math.random()*20)  // add negative d20 to output, store in `r`
    +""+                    // string concatenation
    F(                      // recursive call to F with changed fail/success
       d,                   //   pass along d      
       ~r                   //   if r is -1, zero more fails needed
          &&f-              //   otherwise, reduce fails needed by
              (k=d>-r),     //   the boolean `d>-r` (and store in k)
       r+20                 //   if r is -20, zero more successes needed
           &&s-!k           //   otherwise, reduce successes needed by
                            //   the opposite of `k` (which indicates a fail)
      )
   ]

संख्या-ऋण-बूलियन भाव वजह से काम trueऔर falseकरने के लिए डाली कर रहे हैं 1और 0एक अंकीय संदर्भ में। इस मामले में, d>-rयह होगा कि 1क्या रोल विफलता है और 0यदि यह एक सफलता थी।

Answer 2

पायथन, 134 बाइट्स

धन्यवाद बाइट्स के लिए Pietu1998 बचाया

from random import*
def g(a,b,c):
 s,z=[],[c,b]
 while z[0]*z[1]:d=randint(1,20);z[a<d]-=[1,z[a<d]][d in[1,20]];s+=[d]
 return[z[0]]+s

बहुत आसान है, शायद थोड़ा अधिक गोल्फ हो सकता है, लेकिन हमें इसे बंद करने के लिए कुछ चाहिए। इसे ऑनलाइन आज़माएं ।

Comments

आप बाइट्स के एक जोड़े को बचा सकते हैं: आयात को बदलने from random import*और छोड़ने के लिए random., के randint(1,20)बजाय का उपयोग करें randrange(20)+1, के and साथ बदलें *। आपको आउटपुट की शुरुआत में अंतिम परिणाम डालने की भी अनुमति है, जिससे अंतरिक्ष की बचत होगी।

— पुरकाकूदरी

Answer 3

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

from random import*
def f(a,b,c):
 while c*b:
    r=randint(1,20);print r;c-=r<a;b-=r>=a
    if r in[1,20]:return r>9
 return c

(यह उत्तर रिक्त स्थान और टैब को मिलाता है , इसलिए पहला इंडेंटेशन स्तर एक एकल स्थान है, जबकि दूसरा एकल टैब है।)

फ़ंक्शन fनिम्न तर्क लेता है:

a, एक व्यक्ति के लिए एक सफलता के रूप में मरने के लिए दहलीज,

bसमग्र सफलता के लिए आवश्यक सफलताओं की संख्या,

cसमग्र विफलता के लिए आवश्यक विफलताओं की संख्या।

प्रत्येक मरने रोल पर या तो bया cकम कर रहा है (लेकिन दोनों नहीं)। जब तक दोनों सकारात्मक होते हैं, तब तक यह फिर से जारी रहता है, सिवाय महत्वपूर्ण विफलता या महत्वपूर्ण सफलता के।

कोई महत्वपूर्ण सफलताओं या विफलताओं को मानते हुए, जब लूप खत्म हो जाता है bया cशून्य होगा, लेकिन दोनों नहीं। उस स्थिति में फ़ंक्शन केवल वर्तमान मान लौटाता है c, जो कि शून्य (फाल्सी) है यदि हम अपनी सभी विफलताओं को समाप्त कर देते हैं, और यदि हम सफल हुए तो सकारात्मक (सत्य)।

एक बोनस के रूप में, आउटपुट आपको बताता है कि आपने कितनी विफलताओं को शेष रखा था, जो बाद में लेने के लिए अधिक ताले होने की स्थिति में अच्छा है। (जब तक कि यह एक महत्वपूर्ण विफलता या सफलता पर समाप्त नहीं होता है, इस मामले में आउटपुट इंट के बजाय बूलियन होगा।)

Answer 4

पिप , 39 बाइट्स

^{किसी ने कहा कि वे एक गोल्फ भाषा में एक समाधान देखना चाहते हैं।}

Wc&b{Pd:1+RR20d<a?--c--bc*:d>1b*:d<20}c

मुझे पूरा यकीन है कि यह सवाल की तुलना में किसी भी भाषा सुविधाओं का उपयोग नहीं करता है। इस क्रम में कमांड-लाइन आर्गन्स के रूप में इनपुट लेता है: कठिनाई, सफलताओं की आवश्यकता, विफलताओं की आवश्यकता। समग्र सफलता के लिए आउटपुट विफलता या नॉनजरो के लिए 0। इसे ऑनलाइन आज़माएं!

दृष्टिकोण एक सीधा-सरल जबकि लूप रणनीति है, जिसमें एक चाल या दो अन्य समाधान हैं। यहां टिप्पणी, व्हॉट्सएप और कुछ अतिरिक्त आउटपुट के साथ एक संस्करण है:

; a,b,c are initialized to the cmdline args
; a = difficulty (roll >=a succeeds, roll <a fails)
; b = required successes to succeed the task
; c = required failures to fail the task
; d = single die roll

; Loop while c and b are both nonzero:
W c&b {
 ; d gets 1+randrange(20); output it
 O d:1+RR20
 ; If d<a, decrement req'd failures, else decrement req'd successes
 d<a ? --c --b
 ; Verbose output for the ungolfed version
 P " (" . (d=1|d=20 ? "critical " "") . (d<a ? "failure" "success") . ")"
 ; If d=1, req'd failures is * by 0 (becomes 0), else * by 1 (unchanged)
 c *: d>1
 ; If d=20, req'd successes is * by 0 (becomes 0), else * by 1 (unchanged)
 b *: d<20
}
; c, remaining failures, is the output: 0 if overall failure, nonzero if overall success
c . " (overall " . (c ? "success" "failure") . ")"

Answer 5

रूबी 2.2, 75 बाइट्स

f=->(v,s,f){p(r=rand(20)+1)<2?f=0:r>19?s=0:r<v ?f-=1:s-=1while s*f>0
p s<1}

बुनियादी पुनरावृत्ति समाधान। उदाहरण रन:

f[12, 5, 3]

उत्पादन हो सकता है:

11
17
8
14
7
false

आप इसे IDEONE पर यहां देख सकते हैं ।

Comments

मुझे वास्तव में जलन से छुटकारा दिलाता है जहां 0 फाल्सी है!

— पॉल प्रेस्टिज

Answer 6

VBA 180 बाइट्स

Sub P(d,s,f):k=1
Do While x<s And v<f:r=Int(20*Rnd()+1)
If r=20 Then x=s
If r=1 Then v=f
If r>=d Then: x=x+1: Else: v=v+1
Debug.Print r:Loop:If v>=f Then k=0
Debug.Print k:End Sub

उदाहरण आउटपुट

P 12,5,3
 18 
 2 
 19 
 8 
 11 
 0 

आउटपुट का अंतिम अंक एक के 0लिए Falseया एक के 1लिए होगा True। प्रत्येक रोल को एक नई रेखा से अलग किया जाता है। यह RNG में निर्मित VBA का उपयोग करता है rnd()जो नॉट सो रैंडम होने के लिए जाना जाता है, लेकिन यह यथासंभव सर्वोत्तम आवश्यकताओं को पूरा करना चाहिए।

Sub P(d,s,f)
k=1
Do While x<s And v<f               'Keep Rolling while Current Successes and Failures are less then the Maximum Allowed
r=Int(20*Rnd()+1)                'Creates a Randomish Number between 1 and 20
If r=20 Then x=s                   'Checks for Crit Success
If r=1 Then v=f                    'Checks for Crit Failure
If r>=d Then: x=x+1: Else: v=v+1   'Increments Current Success or Fails
Debug.Print r                      'Prints (Could us MSGBOX, it is shorter)
Loop
If v>=f Then k=0                   'Checks & Changes Total Outcome to False
Debug.Print k                      'Prints (Could us MSGBOX, it is shorter)
End Sub

Answer 7

SpecBAS - 165 बाइट्स

1 INPUT d,s,f
2 DIM p(2)
3 DO 
4 r=1+INT(RND*20): ?r
5 IF r IN [1,20] THEN EXIT 
6 INC p((r>=d)+1)
7 LOOP UNTIL p(1)>=f OR p(2)>=s
8  ?IIF$(r=1 OR p(1)>=f,"fail","success")

कठिनाई, सफलताओं, विफलताओं क्रम में इनपुट दर्ज किया जाना चाहिए।

SpecBAS की नई रिलीज़ अब ""? इसके बजाय चर असाइनमेंट के सामने की PRINTआवश्यकता को हटाता है LET, इसलिए उन्हें आज़माने का यह एक अच्छा तरीका था।

चूंकि सरणियाँ डिफ़ॉल्ट रूप से 1-आधारित होती हैं, पंक्ति 6 ​​रिटर्न 0/1 होती है यदि रोल कठिनाई को हराता है और सही इंडेक्स को अपडेट करने के लिए 1 जोड़ता है।

Answer 8

पर्ल 6 ,  101   99 बाइट्स

->$/ {(1..20).roll(*).map({$1*$2||last;$2-=$0>$_;$2=0 when 1;$1-=$_>=$0;$1=0 when 20;$_}).eager,$2}

# 101 bytes
->$/ {
  (1..20).roll(*).map({  # roll an infinite sequence, and map over them
    $1*$2||last;         # stop if either counter is 0
    $2-=$0>$_;           # decrement failure counter when a failure
    $2=0 when 1;         # set failure counter to 0  when a critical failure
    $1-=$_>=$0;          # decrement success counter when a success
    $1=0 when 20;        # set success counter to 0  when a critical success
    $_                   # the rolled value
  }).eager,$2            # the value of failure counter
}

इनपुट एक उत्परिवर्ती सरणी है जिसमें कठिनाई, सफलताएं, असफलताएं हैं

आउटपुट एक दो तत्व सूची है, पहला तत्व लुढ़का मूल्यों की एक सूची है, दूसरा तत्व शेष विफलताओं की संख्या है।

उपयोग:

# give it a name for ease of use
my &code = {...}

for ^10 { say code [12, 5, 3] }

((14 4 15 5 5) 0)
((17 4 16 12 3 8) 0)
((2 14 14 7 14 19 19) 1)
((3 12 13 15 10 1) 0)
((3 17 16 10 11) 0)
((18 11 18 4 6) 0)
((15 13 1) 0)
((13 15 8 2 8) 0)
((16 17 8 10 11) 0)
((9 20) 2)