Trong Dungeons & Dragons , hầu hết mọi thứ được quyết định bằng cách lăn một cái chết. Thông thường, nếu cuộn lớn hơn hoặc bằng một giá trị được chỉ định, bạn sẽ cố gắng làm bất cứ điều gì bạn muốn làm thành công và thất bại. Thông thường nhất, một khuôn 20 mặt (còn gọi là d20) được sử dụng để cuộn.

Những lần khác, hệ thống thử thách kỹ năng được sử dụng. Nó tương tự như hệ thống đơn giản được mô tả ở trên, nhưng thành công được xác định bằng việc người chơi có thành công hay không một số lần nhất định trước khi thất bại một số lần nhất định. Ví dụ, người chơi có thể đang cố gắng chọn nhiều ổ khóa trên một cánh cửa với số lượng khóa hạn chế. Các cuộn thành công riêng lẻ đại diện cho việc chọn thành công một trong các ổ khóa và các cuộn không thành công đại diện cho việc phá khóa. Thành công chung có nghĩa là chọn thành công tất cả các khóa trước khi phá vỡ tất cả các khóa.

Hơn nữa, một số cuộn nhất định có thể là cuộn quan trọng. Trên d20, lăn số 1 là một thất bại nghiêm trọng, dẫn đến ngay lập tức thất bại toàn bộ thử thách (trong ví dụ trên, người chơi có thể vô tình cảnh báo cho người bảo vệ). Cán 20 là một thành công quan trọng, dẫn đến thành công ngay lập tức toàn bộ thử thách (trong ví dụ trên, người chơi có thể tìm thấy một bộ chìa khóa cho ổ khóa, loại bỏ nhu cầu chọn chúng). Trong trường hợp của một cuộn quan trọng, thách thức ngay lập tức kết thúc và kết quả đã quyết định, bất kể số lần thành công và thất bại trước đó.

Trong thử thách này, bạn sẽ gặp một khó khăn, số lần thành công cần thiết và số lần thất bại mà thử thách thất bại. Bạn phải mô phỏng một người chơi đang thử thách và đưa ra kết quả.

Đầu vào

3 số nguyên, đại diện cho giá trị phải đáp ứng hoặc vượt quá để thành công tại một cuộn riêng lẻ, số lần thành công cần thiết để thành công ở thử thách và số lần thất bại trong đó thử thách thất bại. Thứ tự và định dạng của các đầu vào không quan trọng, miễn là bạn chỉ định thứ tự bạn sẽ sử dụng. Khó khăn sẽ nằm trong khoảng từ 1 đến 20, bao gồm cả số lần thành công và thất bại sẽ nằm trong khoảng từ 1 đến 100.

Đầu ra

Kết quả của mỗi cuộn d20 (số nguyên, theo thứ tự) và kết quả chung của thử thách (giá trị trung thực / falsey). Định dạng không quan trọng, miễn là các kết quả riêng lẻ được xếp theo thứ tự, kết quả chung sẽ đến trước hoặc sau tất cả các cuộn riêng lẻ (ví dụ: bạn không thể xuất kết quả tổng thể ở giữa các cuộn) và bạn xác định định dạng đầu ra nào bạn sử dụng và sử dụng nó một cách nhất quán.

Ví dụ (giá trị trong ngoặc là để giải thích và không cần đưa vào):

Đầu vào:

12 5 3 (difficulty successes failures)

Đầu ra:

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)

Đầu vào:

15 2 3 (difficulty failures successes)

Đầu ra:

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

Đầu vào:

5 5 10 (successes failures difficulty)

Đầu ra:

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

Đầu vào:

3 10 3 (failures difficulty successes)

Đầu ra:

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

Quy tắc

• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng
• Bạn phải chọn ngẫu nhiên một giá trị số nguyên từ 1 đến 20 (đã bao gồm) cho mỗi cuộn. Mỗi giá trị nên có xác suất được chọn bằng nhau (hoặc càng gần bằng nhau càng tốt).

JavaScript, 83 78 76 75 byte

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

Mã này đệ quy đếm ngược thành công và thất bại khi chúng xảy ra. Khi một trong hai thành công ( s) hay thất bại ( f) đã đếm xuống 0, chúng ta kết thúc với truegiá trị !skhi slà 0hay với giá trị falsy của fkhi flà 0.

Đầu ra là dạng biểu thức chính quy /^(-\d{1,2})+(0|true)$/(hoặc, nghiêm ngặt hơn, /^(-[1-9]|-1[0-9]|-20)+(0|true)$/). Nghĩa là, đầu vào có dấu gạch nối hàng đầu, sau đó cuộn các giá trị được mô tả bằng dấu gạch nối và cuối cùng là kết quả cuối cùng ( 0hoặc true), không được phân định từ cuộn cuối cùng. Tuy nhiên, đây vẫn là một ngữ pháp rõ ràng bởi vì kết quả của người sử dụng và cuộn cuối cùng luôn có thể được phân biệt: ký tự cuối cùng của đầu ra (hoặc 0hoặc e) luôn luôn chỉ ra kết quả và cuối cùng 0luôn được đọc tách biệt với số (s) của cuộn cuối cùng.

Đầu ra mẫu cho 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

Giải trình:

Mã này hoạt động bằng cách cuộn d20 âm và (ab) sử dụng các dấu âm làm dấu phân cách.

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

Các biểu thức số-trừ-boolean hoạt động vì truevà falseđược truyền tới 1và 0trong một ngữ cảnh số. Trong trường hợp này, d>-rsẽ là 1nếu cuộn là một thất bại và 0nếu đó là một thành công.

Python, 134 byte

Cảm ơn Pietu1998 vì đã lưu byte

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

Khá đơn giản, có thể có thể chơi gôn nhiều hơn một chút, nhưng chúng tôi cần một cái gì đó để khởi động nó. Hãy thử trực tuyến .

Python 2, 123 121 byte

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

(Câu trả lời này trộn các khoảng trắng và các tab , vì vậy mức thụt đầu tiên là một khoảng trắng , trong khi mức thứ hai là một tab duy nhất.)

Hàm flấy các đối số sau:

a, ngưỡng cho một cuộn chết cá nhân được tính là thành công,

b, số lượng thành công cần thiết cho thành công chung,

c, số lượng thất bại cần thiết cho thất bại tổng thể.

Trên mỗi cuộn chết bhoặc clà giảm (nhưng không phải cả hai). Miễn là cả hai đều tích cực, nó sẽ lặp lại, trừ trường hợp thất bại nghiêm trọng hoặc thành công quan trọng.

Giả sử không có thành công hay thất bại quan trọng nào, khi vòng lặp kết thúc bhoặc csẽ bằng không, nhưng không phải cả hai. Trong trường hợp đó, hàm chỉ trả về giá trị hiện tại clà 0 (Falsey) nếu chúng ta cạn kiệt tất cả các thất bại và tích cực (Truthy) nếu chúng ta thành công.

Như một phần thưởng, đầu ra cho bạn biết bạn còn lại bao nhiêu thất bại, điều này thật tuyệt trong trường hợp có nhiều khóa để chọn sau này. (Trừ khi nó kết thúc tại một thất bại hoặc thành công quan trọng, trong trường hợp đó, đầu ra sẽ là một boolean thay vì int.)

Pip , 39 byte

^{Có người nói rằng họ muốn xem một giải pháp bằng ngôn ngữ chơi gôn.}

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

Tôi khá chắc chắn rằng điều này không sử dụng bất kỳ tính năng ngôn ngữ nào mới hơn câu hỏi. Đưa đầu vào như dòng lệnh lập luận theo thứ tự này: khó khăn, yêu cầu thành công, thất bại cần thiết. Đầu ra 0 cho thất bại tổng thể hoặc khác không cho thành công chung. Hãy thử trực tuyến!

Cách tiếp cận là một chiến lược vòng lặp khá đơn giản, với một hoặc hai mẹo từ các giải pháp khác. Đây là phiên bản có nhận xét, khoảng trắng và một số đầu ra bổ sung:

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

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}

Giải pháp lặp cơ bản. Chạy ví dụ:

f[12, 5, 3]

Có thể đầu ra:

11
17
8
14
7
false

Bạn có thể thấy nó chạy trên IDEONE tại đây .

VBA 180 byte

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

Ví dụ đầu ra

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

Chữ số đầu ra cuối cùng sẽ là một 0cho Falsehoặc một 1cho True. Mỗi cuộn được phân tách bằng một dòng mới. Điều này sử dụng VBA được xây dựng trong RNG rnd(), được biết là không ngẫu nhiên , nhưng điều này sẽ đáp ứng các yêu cầu tốt nhất có thể.

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 byte

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

Đầu vào nên được nhập trong khó khăn, thành công, thất bại thứ tự.

Bản phát hành mới của SpecBAS hiện cho phép "?" thay vì PRINTvà loại bỏ sự cần thiết LETtrước các bài tập biến, vì vậy đây là một cách hay để thử chúng.

Vì các mảng được dựa trên 1 theo mặc định, dòng 6 trả về 0/1 nếu gặp khó khăn khi cuộn và thêm 1 để cập nhật chỉ mục đúng.

Perl 6 ,  101   99 byte

->$/ {(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
}

Đầu vào là một mảng có thể thay đổi chứa khó khăn, thành công, thất bại

Đầu ra là danh sách hai phần tử, phần tử đầu tiên là danh sách các giá trị cuộn, phần tử thứ hai là số lỗi còn lại.

Sử dụng:

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