In Dungeons & Dragons , hemen her şeyi bir zar atması ile karar verilir. Genellikle, rulo belirtilen değerden büyük veya ona eşitse, yapmak istediğiniz her şeyi yapma girişiminiz başarılı olur ve başarısız olur. En yaygın olarak, yuvarlanmak için 20 taraflı bir kalıp (aka d20) kullanılır.

Diğer zamanlarda, beceri meydan okuma sistemi kullanılır. Yukarıda açıklanan basit sisteme benzer, ancak başarı, oyuncu (lar) ın, belirli sayıda kez başarısız olmadan önce bireysel ruloları belirli sayıda oynamış olup olmadığına göre belirlenir. Örneğin, oynatıcı (lar) sınırlı sayıda kilitli kapıya birden fazla kilit almaya çalışıyor olabilir. Bireysel başarılı rulolar, kilitlerden birini başarıyla seçmeyi ve bireysel başarısız rulolar, bir kilit tıklamasını kırmayı temsil eder. Genel başarı, tüm kilitleri kırmadan önce tüm kilitleri başarıyla seçmek anlamına gelir.

Ayrıca, bazı rulolar kritik rulolar olabilir. Bir d20'de, 1'i yuvarlamak kritik bir başarısızlıktır ve bu da tüm zorluğun hemen başarısız olmasına neden olur (yukarıdaki örnekte, oyuncu (lar) yanlışlıkla bir muhafızı uyarabilir). 20'yi yuvarlamak kritik bir başarıdır ve sonuçta tüm mücadeleyi hemen başarırsınız (yukarıdaki örnekte, oyuncu (lar) kilitlere bir takım anahtarlar bulabilir ve bunları seçme ihtiyacını ortadan kaldırabilir). Kritik bir dönme durumunda, meydan okuma hemen sona erer ve önceki başarı ve başarısızlık sayısına bakılmaksızın sonuç kararlaştırılır.

Bu zorlukta size bir zorluk, ihtiyaç duyulan başarı sayısı ve zorluğun başarısız olduğu başarısızlık sayısı verilecektir. Meydan okumaya çalışan bir oyuncuyu simüle etmeli ve sonucu çıkarmalısınız.

Giriş

Bir tek atışta başarılı olmak için karşılanması veya aşılması gereken değeri, mücadelede başarılı olmak için gereken başarı sayısını ve mücadelenin başarısız olduğu başarısızlık sayısını temsil eden 3 tam sayı. Hangi sırayı kullanacağınızı belirlediğiniz sürece, girişlerin sırası ve biçimi önemli değildir. Zorluk 1 ile 20 arasında, başarı ve başarısızlık sayısı da 1 ile 100 arasında olacak.

Çıktı

D20 rulolarının her birinin sonuçları (sırayla tamsayılar) ve zorluğun genel sonucu (gerçek / falsey değeri). Bireysel sonuçlar sırayla olduğu sürece, biçim önemli değildir, genel sonuç, her bir tek tek rulodan önce veya sonra gelir (örneğin, genel sonucu ruloların ortasında çıkaramazsınız) ve hangi çıktı biçimini kullanacağınızı belirtir ve tutarlı olarak kullanırsınız.

Örnekler (parantez içindeki değerler açıklama içindir ve dahil edilmesi gerekmez):

Giriş:

12 5 3 (difficulty successes failures)

Çıktı:

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)

Giriş:

15 2 3 (difficulty failures successes)

Çıktı:

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

Giriş:

5 5 10 (successes failures difficulty)

Çıktı:

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

Giriş:

3 10 3 (failures difficulty successes)

Çıktı:

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

kurallar

• Bu kod golfü , yani bayttaki en kısa kod kazanıyor
• Her rulo için rastgele 1 ile 20 (dahil) arasında bir tamsayı değeri seçmelisiniz. Her bir değerin eşit seçilme olasılığı olmalıdır (veya mümkün olduğunca eşittir).

JavaScript, 83 78 76 75 bayt

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

Bu kod, başarıları ve başarısızlıkları tekrar tekrar sayar. Ya başarılar (zaman s) ya da arızalar ( f) kadar sayıldığını 0, ile biten truedeğeri !szaman solan 0ya da falsy değeriyle fzaman folduğu 0.

Çıktı, normal ifade biçimindedir /^(-\d{1,2})+(0|true)$/(veya daha doğrusu /^(-[1-9]|-1[0-9]|-20)+(0|true)$/). Yani, girdinin önde gelen tiresi, daha sonra tireler tarafından tanımlanan yuvarlanma değerleri ve son olarak son yuvarla- madan tanımlanmayan nihai sonuç ( 0veya true) vardır. Bununla birlikte, bu hala kesin bir dilbilgisidir çünkü utilmate sonucu ve son rulo her zaman ayırt edilebilir: çıktının son karakteri (ya 0da e) her zaman sonucun göstergesidir ve bir final 0her zaman sayılardan ayrı olarak okunur son rulonun.

Örnek çıktılar 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

Açıklama:

Bu kod , negatif işaretleri sınırlayıcı olarak kullanarak negatif bir d20 ve (ab) yuvarlayarak çalışır .

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

Numara-eksi-boolean ifadeleri nedeniyle çalışmak trueve falseşekilde dökülmüştür 1ve 0sayısal bir bağlamda. Bu durumda, d>-rolacaktır 1rulo sonucu başarısızlık ise ve 0bunu bir başarı olsaydı.

Python, 134 bayt

Kaydedilen baytlar için teşekkürler 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

Oldukça basit, muhtemelen biraz daha golf edilebilir, ancak bunu başlatacak bir şeye ihtiyacımız vardı. Çevrimiçi deneyin .

Piton 2, 123 121 bayt

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

(Bu cevap boşlukları ve sekmeleri karıştırır , bu nedenle ilk girinti seviyesi tek bir boşluk iken ikincisi tek bir sekmedir.)

İşlev faşağıdaki bağımsız değişkenleri alır:

a, münferit bir kalıp rulosunun başarı olarak sayılması için eşik,

b, genel başarı için gereken başarı sayısı,

c, genel arıza için gereken arıza sayısı.

Her kalıp rulosunda ya bya cazaltılır (ancak her ikisi birden değil). Her ikisi de olumlu olduğu sürece, kritik başarısızlık veya kritik başarı haricinde tekrar döngüye girer.

Döngü ya tamamlandığında ya bda csıfır olduğunda kritik başarı veya başarısızlık kabul edilmez, ancak her ikisi birden olmaz. Bu durumda işlev c, tüm hatalarımızı tüketirsek sıfır (Falsey) ve başarılı olursa pozitif (Doğruluk) olan geçerli değerini döndürür .

Bir bonus olarak, çıktı size kaç başarısızlık kaldığını söyler, bu da daha sonra seçilecek daha fazla kilit olması durumunda güzeldir. (Kritik bir başarısızlık veya başarıda sona ermediği sürece, bu durumda çıktı int yerine boole olur.)

Pip , 39 bayt

^{Birisi golf dilinde bir çözüm görmek istediklerini söyledi .}

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

Eminim ki bu sorudan daha yeni bir dil özelliği kullanmıyor. Komut satırı bağımsız değişkenleri olarak girişi şu sırayla alır: zorluk, başarılar gerekli, arızalar gerekli. Genel başarısızlık için 0 veya genel başarı için sıfır olmayan çıkışlar. Çevrimiçi deneyin!

Yaklaşım, diğer çözümlerden bir iki numara ile oldukça basit bir süre-döngü stratejisidir. İşte yorumları, boşlukları ve bazı ekstra çıktıları olan bir sürüm:

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

Yakut 2.2, 75 bayt

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}

Temel yinelemeli çözüm. Örnek çalışma:

f[12, 5, 3]

Çıktı olabilir:

11
17
8
14
7
false

Burada IDEONE üzerinde çalıştığını görebilirsiniz .

VBA 180 Bayt

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

Örnek Çıktı

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

Çıktının son basamağı bir 0for Falseveya a 1için olacaktır True. Her Rulo bir satırsonu ile ayrılır. Bu, Rastgele Değilrnd() olarak bilinen RNG'de yerleşik VBA'yı kullanır , ancak bu, gereksinimleri mümkün olan en iyi şekilde yerine getirmelidir.

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 bayt

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

Giriş zorluk, başarı, başarısızlık sırasına göre girilmelidir.

SpecBAS'ın yeni sürümü artık "?" yerine, değişken atamaların önündeki PRINTihtiyacı ortadan kaldırır LET, bu yüzden bunları denemek için güzel bir yoldu.

Diziler varsayılan olarak 1 tabanlı olduğundan, rulo zorluğu aşarsa 6. satır 0/1 değerini döndürür ve doğru dizini güncelleştirmek için 1 ekler.

Perl 6 ,  101   99 bayt

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

Girdi zorluk, başarı, başarısızlık içeren değişken bir dizidir

Çıktı iki elemanlı bir listedir, ilk eleman haddelenmiş değerlerin bir listesidir, ikinci eleman kalan arıza sayısıdır.

Kullanımı:

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