In Dungeons & Dragons wird fast alles durch Würfeln entschieden. Wenn der Wurf größer oder gleich einem angegebenen Wert ist, ist Ihr Versuch, das zu tun, was Sie wollten, in der Regel erfolgreich und schlägt andernfalls fehl. Am häufigsten wird ein 20-seitiger Würfel (alias d20) zum Würfeln verwendet.

In anderen Fällen wird das Skill-Challenge-System verwendet. Es ähnelt dem oben beschriebenen einfachen System, aber der Erfolg wird dadurch bestimmt, ob der oder die Spieler einzelne Würfe eine bestimmte Anzahl von Malen erfolgreich abgeschlossen haben oder nicht, bevor sie eine bestimmte Anzahl von Malen gescheitert sind. Beispielsweise versuchen die Spieler möglicherweise, mehrere Schlösser an einer Tür mit einer begrenzten Anzahl von Dietrichen zu knacken. Einzelne erfolgreiche Würfe bedeuten, dass eine der Sperren erfolgreich ausgewählt wurde, und einzelne fehlerhafte Würfe bedeuten, dass ein Dietrich gebrochen wurde. Gesamterfolg würde bedeuten, alle Schlösser erfolgreich zu knacken, bevor alle Dietriche geknackt werden.

Darüber hinaus können bestimmte Rollen kritische Rollen sein. Auf einem d20 ist das Würfeln einer 1 ein kritischer Fehler, der zum sofortigen Scheitern der gesamten Herausforderung führt (im obigen Beispiel könnten die Spieler versehentlich einen Wachmann alarmieren). Das Würfeln einer 20 ist ein kritischer Erfolg, der zum sofortigen Erfolg der gesamten Herausforderung führt. Im Falle eines kritischen Wurfs ist die Herausforderung sofort beendet und das Ergebnis entschieden, unabhängig von der vorherigen Anzahl von Erfolgen und Misserfolgen.

Bei dieser Herausforderung erhalten Sie eine Schwierigkeit, die Anzahl der erforderlichen Erfolge und die Anzahl der Fehler, bei denen die Herausforderung fehlgeschlagen ist. Sie müssen einen Spieler simulieren, der die Herausforderung versucht, und das Ergebnis ausgeben.

Eingang

3 ganze Zahlen, die den Wert darstellen, der erreicht oder überschritten werden muss, um bei einem einzelnen Wurf erfolgreich zu sein, die Anzahl der für den Erfolg bei der Herausforderung erforderlichen Erfolge und die Anzahl der Fehler, bei denen die Herausforderung fehlgeschlagen ist. Die Reihenfolge und das Format der Eingaben spielen keine Rolle, solange Sie angeben, welche Reihenfolge Sie verwenden werden. Der Schwierigkeitsgrad liegt zwischen 1 und 20 (einschließlich), und die Anzahl der Erfolge und Misserfolge liegt zwischen 1 und 100 (einschließlich).

Ausgabe

Die Ergebnisse jeder der d20-Würfe (ganze Zahlen, in Reihenfolge) und das Gesamtergebnis der Herausforderung (ein Wahrheitsgehalt / Falschwert). Das Format spielt keine Rolle, solange die einzelnen Ergebnisse in Ordnung sind. Das Gesamtergebnis kommt entweder vor oder nach allen einzelnen Rollen (Sie können das Gesamtergebnis beispielsweise nicht in der Mitte der Rollen ausgeben) und Sie geben an, welches Ausgabeformat Sie verwenden, und verwenden es konsequent.

Beispiele (Werte in Klammern dienen der Erläuterung und müssen nicht angegeben werden):

Eingang:

12 5 3 (difficulty successes failures)

Ausgabe:

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)

Eingang:

15 2 3 (difficulty failures successes)

Ausgabe:

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

Eingang:

5 5 10 (successes failures difficulty)

Ausgabe:

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

Eingang:

3 10 3 (failures difficulty successes)

Ausgabe:

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

Regeln

• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes
• Sie müssen zufällig einen ganzzahligen Wert zwischen 1 und 20 (einschließlich) für jede Rolle auswählen. Jeder Wert sollte die gleiche Wahrscheinlichkeit haben, ausgewählt zu werden (oder so nahe wie möglich daran).

JavaScript, 83 78 76 75 Bytes

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

Dieser Code zählt rekursiv Erfolge und Misserfolge herunter, sobald sie eintreten. Wenn einer der Erfolge (s ) oder Misserfolge ( f) abwärts gezählt wurden 0, beenden wir den Vorgang mit dem trueWert !swhen sis 0oder mit dem falschen Wert fwhen fis 0.

Die Ausgabe erfolgt in Form eines regulären Ausdrucks /^(-\d{1,2})+(0|true)$/(oder genauer gesagt /^(-[1-9]|-1[0-9]|-20)+(0|true)$/). Das heißt, die Eingabe hat einen führenden Bindestrich, dann Rollwerte, die durch Bindestriche abgegrenzt sind, und schließlich das Endergebnis ( 0oder true), das nicht vom endgültigen Roll abgegrenzt ist. Dies ist jedoch immer noch eine eindeutige Grammatik, da das Nutzergebnis und der endgültige Wurf immer unterschieden werden können: Das letzte Zeichen der Ausgabe (entweder 0oder e) gibt immer das Ergebnis an, und ein Endergebnis 0wird immer getrennt von den Zahlen gelesen. der letzten Rolle.

Beispielausgaben für 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

Erläuterung:

Dieser Code funktioniert, indem ein negatives d20 gewürfelt und (ab) die negativen Vorzeichen als Begrenzer verwendet werden.

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

Zahl-minus-Booleschen Ausdrücken arbeiten , weil trueund falsewerden gegossen 1und 0in einem numerischen Kontext. In diesem Fall d>-rwird10 festgestellt ob die Rolle fehlgeschlagen ist und ob sie erfolgreich war.

Python, 134 Bytes

Danke Pietu1998 für die gesparten Bytes

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

Ziemlich einfach, man kann wahrscheinlich ein bisschen mehr Golf spielen, aber wir brauchten etwas, um dies zu beginnen. Probieren Sie es online aus .

Python 2, 123 121 Bytes

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

(Diese Antwort mischt Leerzeichen und Tabulatoren , sodass die erste Einrückungsstufe ein einzelnes Leerzeichen und die zweite ein einzelnes Tabulatorzeichen ist.)

Die Funktion f akzeptiert die folgenden Argumente:

a, die Schwelle, bis zu der ein einzelner Würfelwurf als Erfolg gewertet wird,

b, die Anzahl der für den Gesamterfolg erforderlichen Erfolge,

c, die Anzahl der Ausfälle, die für einen Gesamtausfall erforderlich sind.

Auf jedem Würfelwurf wird entweder boder cdekrementiert (aber nicht beides). Solange beide positiv sind, wird die Schleife wiederholt, außer bei einem kritischen Ausfall oder einem kritischen Erfolg.

Vorausgesetzt, keine kritischen Erfolge oder Misserfolge, wenn die Schleife entweder beendet wird boder cNull ist, aber nicht beide. In diesem Fall gibt die Funktion nur den aktuellen Wert von zurückc , der Null (Falsey) ist, wenn wir alle unsere Fehler ausgeschöpft haben, und positiv (Truthy), wenn wir erfolgreich waren.

Als Bonus können Sie anhand der Ausgabe ablesen, wie viele Ausfälle noch verblieben sind. Dies ist hilfreich, falls Sie später weitere Sperren auswählen müssen. (Es sei denn, es wurde bei einem kritischen Fehler oder Erfolg beendet. In diesem Fall ist die Ausgabe ein Boolescher Wert anstelle eines int.)

Pip , 39 Bytes

^{Jemand sagte, sie wollten eine Lösung in einer Golfsprache sehen.}

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

Ich bin mir ziemlich sicher, dass dies keine Sprachfunktionen verwendet, die neuer sind als die Frage. Übernimmt Eingaben als Befehlszeilenargumente in dieser Reihenfolge: Schwierigkeit, erforderliche Erfolge, erforderliche Fehler. Gibt 0 für Gesamtfehler oder ungleich Null für Gesamterfolg aus. Probieren Sie es online!

Der Ansatz ist eine recht unkomplizierte Strategie, bei der ein oder zwei Tricks aus anderen Lösungen übernommen werden. Hier ist eine Version mit Kommentaren, Leerzeichen und einigen zusätzlichen Ausgaben:

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

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}

Grundlegende iterative Lösung. Beispiellauf:

f[12, 5, 3]

Ausgabe möglich:

11
17
8
14
7
false

Sie können sehen , es auf IDEONE läuft hier .

VBA 180 Bytes

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

Beispielausgabe

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

Die letzte Stelle der Ausgabe ist ein 0für Falseoder ein 1für True. Jede Rolle ist durch eine neue Linie getrennt. Hierfür wird in RNG integriertes VBA verwendet, von rnd()dem bekannt ist, dass es nicht so zufällig ist. Dies sollte jedoch die Anforderungen so gut wie möglich erfüllen.

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 Bytes

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

Die Eingabe sollte in der Reihenfolge Schwierigkeit, Erfolg, Misserfolg erfolgen.

Die neue Version von SpecBAS erlaubt jetzt "?" statt PRINTund beseitigt die Notwendigkeit fürLET Variablen zuzuweisen. Dies war also eine gute Möglichkeit, sie auszuprobieren.

Da Arrays standardmäßig 1-basiert sind, gibt Zeile 6 0/1 zurück, wenn die Rolle die Schwierigkeit schlägt, und fügt 1 hinzu, um den richtigen Index zu aktualisieren.

Perl 6 ,  101   99 Bytes

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

Input ist ein veränderbares Array, das Schwierigkeiten, Erfolge und Misserfolge enthält

Die Ausgabe ist eine Liste mit zwei Elementen, das erste Element ist eine Liste der gerollten Werte, das zweite Element ist die Anzahl der verbleibenden Fehler.

Verwendung:

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