でダンジョンズ＆ドラゴンズ、ほとんどすべては、ダイスを転がすことによって決定されます。通常、ロールが指定された値以上の場合、やりたいことを何でも試みて成功し、そうでなければ失敗します。最も一般的には、20面ダイス（別名d20）を使用してロールします。

また、スキルチャレンジシステムが使用される場合もあります。これは上記の単純なシステムに似ていますが、成功は、プレイヤーが特定の回数失敗する前に個々のロールを特定の回数成功させるかどうかによって決定されます。たとえば、プレイヤーは、限られた数のロックピックでドアの複数のロックを選択しようとしている可能性があります。個々の成功したロールは、ロックの1つを正常に選択することを表し、個々の失敗したロールは、ロックピックを破ることを表します。全体的な成功とは、すべてのロックを解除する前にすべてのロックを正常に選択することを意味します。

さらに、特定のロールはクリティカルロールになる可能性があります。d20では、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する場合fです0。

出力は、正規表現形式/^(-\d{1,2})+(0|true)$/（より厳密には/^(-[1-9]|-1[0-9]|-20)+(0|true)$/）です。つまり、入力には先頭のハイフンがあり、ハイフンで区切られたロール値、最後に最終ロール（0またはtrue）で区切られた最終結果がロールされます。ただし、これはまだ実用的な結果と最終的なロールを常に区別できるため、明確な文法です：出力の最後の文字（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、それが成功した場合。

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

（この回答ではスペースとタブが混在しているため、最初のインデントレベルは1つのスペースで、2番目のインデントレベルは1つのタブです。）

この関数fは次の引数を取ります。

a、成功としてカウントする個々のサイコロのしきい値、

b、全体的な成功に必要な成功の数、

c、全体的な障害に必要な障害の数。

各ダイスロールで、どちらかbまたはc減少します（両方ではありません）。両方が正である限り、重大な失敗または重大な成功の場合を除き、再びループします。

ループがどちらbかcを終了するかゼロになる場合、重大な成功または失敗がないと仮定しますが、両方ではありません。その場合、関数はの現在の値を返しますc。これは、すべての失敗を使い果たした場合はゼロ（Falsey）で、成功した場合は正（Truthy）です。

おまけとして、出力には、残った障害の数が示されます。これは、後で選択するロックが（たとえば）ある場合に便利です。（重大な失敗または成功で終了しない限り、出力はintではなくブール値になります。）

ピップ、39バイト

^{誰かがゴルフの言語で解決策を見たいと言った。}

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

これは質問より新しい言語機能を使用しないと確信しています。入力をコマンドライン引数として次の順序で受け取ります。難易度、成功が必要、失敗が必要です。全体的な失敗の場合は0、全体的な成功の場合は0以外を出力します。オンラインでお試しください！

このアプローチは、他のソリューションから1つまたは2つのトリックを取り入れた、かなり単純なwhileループ戦略です。これは、コメント、空白、および追加の出力を備えたバージョンです。

; 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 

出力の最後の数字は0for Falseまたは1for Trueです。各ロールは改行で区切られます。これは、それほどランダムでrnd()はないことがわかっているRNGに組み込まれたVBAを使用しますが、これは要件を可能な限り満たす必要があります。

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
}

入力は、困難、成功、失敗を含む可変配列です

出力は2つの要素のリストで、最初の要素はロールされた値のリスト、2番目の要素は残りの失敗の数です。

使用法：

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