에서 던전 앤 드래곤 , 거의 모든 주사위를 굴려 결정됩니다. 일반적으로 롤이 지정된 값보다 크거나 같으면 원하는 작업을 수행하려는 시도가 성공하고 그렇지 않으면 실패합니다. 가장 일반적으로 20면 다이 (일명 d20)가 롤링에 사용됩니다.

다른 경우에는 기술 챌린지 시스템이 사용됩니다. 위에서 설명한 간단한 시스템과 비슷하지만 성공 여부는 플레이어가 특정 횟수만큼 실패하기 전에 특정 횟수의 롤을 성공했는지 여부에 따라 결정됩니다. 예를 들어, 플레이어 (들)는 제한된 수의 잠금 장치가있는 문에서 여러 개의 잠금 장치를 선택하려고 할 수 있습니다. 개별 성공 롤은 잠금 중 하나를 성공적으로 선택했음을 나타내며 개별 실패 롤은 잠금 선택을 끊는 것을 나타냅니다. 전반적인 성공은 모든 잠금 장치를 끊기 전에 모든 잠금 장치를 성공적으로 선택한다는 의미입니다.

또한, 특정 롤은 중요 롤일 수 있습니다. 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 사이의 정수 값을 무작위로 선택해야합니다. 각 값은 선택 될 확률이 같아야합니다 (또는 가능한 한 비슷해야합니다).

자바 스크립트, 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 을 굴리고 음수 부호를 구분 기호로 사용하여 작동합니다.

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그것이 성공합니다.

파이썬, 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

아주 간단하고 아마도 골프를 조금 더 할 수는 있지만 우리는 이것을 시작하기 위해 무언가가 필요했습니다. 온라인으로 사용해보십시오 .

파이썬 2, 123121 바이트

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모든 실패를 소진하면 0 (Falsey)이고 성공하면 양수 (Truthy)입니다.

보너스로, 출력은 남아있는 실패 횟수를 알려줍니다. 나중에 선택할 잠금이 더 많은 경우에 좋습니다. (심각한 실패 또는 성공으로 종료되지 않은 경우, 출력은 int 대신 부울이됩니다.)

핍 , 39 바이트

^{누군가는 골프 언어로 해결책을 원한다고 말했다 .}

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

이것이 질문보다 새로운 언어 기능을 사용하지 않는다고 확신합니다. 난이도, 성공, 실패 등이 순서대로 입력을 명령 행 인수로 취합니다. 전체 실패의 경우 0을, 전체 성공의 경우 0이 아닙니다. 온라인으로 사용해보십시오!

이 접근법은 상당히 간단한 while-loop 전략이며, 다른 솔루션에서 가져온 트릭이 있습니다. 주석, 공백 및 추가 출력이있는 버전은 다음과 같습니다.

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

루비 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입니다. 각 롤은 줄 바꿈으로 구분됩니다. 이것은 RNG에 내장 된 VBA를 사용하는데, 이는 Not So Randomrnd() 으로 알려져 있지만 가능한 한 최상의 요구 사항을 충족해야합니다.

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이 난이도를 높이고 1을 추가하여 올바른 색인을 업데이트하면 6 행은 0/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)