ในDungeons & Dragonsเกือบทุกอย่างจะถูกตัดสินใจโดยการหมุนตัวตาย โดยทั่วไปแล้วถ้าการหมุนมากกว่าหรือเท่ากับค่าที่ระบุความพยายามในการทำสิ่งที่คุณต้องการจะทำสำเร็จและล้มเหลวเป็นอย่างอื่น โดยทั่วไปจะใช้แม่พิมพ์แบบ 20 ด้าน (aka d20) ในการหมุน

ในบางครั้งระบบจะใช้ความท้าทายทักษะ มันคล้ายกับระบบง่าย ๆ ที่อธิบายข้างต้น แต่ความสำเร็จนั้นพิจารณาจากการที่ผู้เล่นแต่ละคนประสบความสำเร็จในแต่ละครั้งก่อนที่จะล้มเหลวในจำนวนครั้งที่แน่นอน ตัวอย่างเช่นผู้เล่นอาจพยายามเลือกการล็อคหลายครั้งที่ประตูที่มีการล็อคจำนวน จำกัด แต่ละม้วนที่ประสบความสำเร็จเป็นตัวแทนของการเลือกหนึ่งในล็อคที่ประสบความสำเร็จและแต่ละม้วนที่ล้มเหลวแสดงถึงการทำลาย lockpick ความสำเร็จโดยรวมหมายถึงการเลือกล็อคทั้งหมดให้สำเร็จก่อนที่จะทำลายลูกกุญแจทั้งหมด

นอกจากนี้ม้วนบางอย่างอาจเป็นม้วนที่สำคัญ ใน d20 การกลิ้ง a 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)

กฎระเบียบ

• นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ
• คุณต้องสุ่มเลือกค่าจำนวนเต็มระหว่าง 1 ถึง 20 (รวม) สำหรับแต่ละม้วน แต่ละค่าควรมีความน่าจะเป็นเท่ากันในการเลือก (หรือใกล้เคียงกับเท่าที่จะทำได้)

JavaScript, 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เมื่อเป็นf0

เอาท์พุทเป็นรูปแบบการแสดงออกปกติ /^(-\d{1,2})+(0|true)$/ (หรือเข้มงวดยิ่งขึ้น/^(-[1-9]|-1[0-9]|-20)+(0|true)$/) นั่นคืออินพุตมียัติภังค์ชั้นนำจากนั้นหมุนค่าที่กำหนดโดยยัติภังค์และในที่สุดก็เป็นผลลัพธ์สุดท้าย ( 0หรือtrue) ซึ่งไม่ได้แยกจากม้วนสุดท้าย อย่างไรก็ตามนี่ยังคงเป็นไวยากรณ์ที่ไม่คลุมเครือเพราะผลลัพธ์ที่เป็นประโยชน์และการหมุนรอบสุดท้ายสามารถแยกแยะได้เสมอ: อักขระตัวสุดท้ายของเอาต์พุต (ไม่ว่าจะ0หรือe) แสดงถึงผลลัพธ์เสมอและสุดท้าย0ก็มักจะอ่านแยกจากหมายเลข (s) ของม้วนสุดท้าย

ตัวอย่างผลลัพธ์สำหรับ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หากประสบความสำเร็จ

Python ขนาด 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

ค่อนข้างเรียบง่ายน่าจะเล่นกอล์ฟได้มากกว่านี้ แต่เราต้องการบางสิ่งบางอย่าง ลองมันออนไลน์

Python 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ซึ่งเป็นศูนย์ (Falsey) ถ้าเราใช้ความล้มเหลวทั้งหมดของเราและบวก (Truthy) หากเราประสบความสำเร็จ

เป็นโบนัสเอาต์พุตจะบอกคุณว่ามีความล้มเหลวเหลืออยู่เท่าไรซึ่งเป็นสิ่งที่ดีในกรณีที่มีการล็อคมากกว่านั้นให้เลือกในภายหลัง (ยกเว้นว่ามันจะสิ้นสุดลงเมื่อเกิดความล้มเหลวหรือประสบความสำเร็จซึ่งในกรณีนี้ผลลัพธ์จะเป็นบูลีนแทนที่จะเป็น int)

Pip , 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") . ")"

Ruby 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 ที่นี่

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แต่ละม้วนถูกคั่นด้วยบรรทัดใหม่ สิ่งนี้ใช้ VBA ที่สร้างขึ้นใน RNG 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

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 เพื่ออัปเดตดัชนีที่ถูกต้อง

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