Kumarbazın haksızlığı, yanlışlıkla meydana gelen olayların gelecekte daha az gerçekleşmesi muhtemel olacağını ve bir süre içinde gerçekleşmemiş olayların yakında gerçekleşmesi daha muhtemel olacağını düşündüğümüz bilişsel bir önyargıdır. Görevin bunun belirli bir versiyonunu uygulamak.

Zorluk Açıklaması

Dahil 1 ile 6 arasında rasgele bir tamsayı döndüren bir işlev yazın. Yakalama: işlev ilk çalıştırıldığında, sonuç tekdüze olmalıdır (% 1 içinde), ancak sonraki her çağrı daha önce birkaç kez yuvarlanan değerler lehine eğrilecektir. Özel detaylar aşağıdaki gibidir:

• Kalıp, şu ana kadar üretilen sayıların sayısını hatırlar.
• Her sonuç aşağıdaki formüle göre ağırlıklandırılır:$count_{max} - count_{die} + 1$
  • Örneğin, rulo şu ana kadar sayıyorsa , ağırlıklar , yani daha fazla yuvarlama olasılığı 4 kat fazla .$[1, 0, 3, 2, 1, 0]$$[3, 4, 1, 2, 3, 4]$$2$$3$
  • Formülün, rulo sonuçlarının aynı ağırlıkta olduğu anlamına geldiğini unutmayın.$[a, b, c, d, e, f]$$[a + n, b + n, c + n, d + n, e + n, f + n]$

Kurallar ve Varsayımlar

• Standart G / Ç kuralları ve yasaklı boşluklar geçerlidir
• Kalıp ruloları deterministik olmamalıdır. (yani, tipik olarak bir yapı olarak mevcut olduğu gibi, uçucu bir kaynaktan tohumlanmış bir PRNG kullanın.)
• Rastgele kaynağınız en az 65535 dönem olmalıdır veya gerçek rastgelelik olmalıdır.
• 255'e kadar olan ağırlıklar için dağılımlar% 1 dahilinde olmalıdır
  • 16-bit RNG'ler, yukarıdaki gereklilikleri karşılayacak kadar iyidir. Çoğu yerleşik RNG'ler yeterlidir.
• Bu dağıtımın çağrı tarafından mutasyona uğradığı veya post-roll dağılımı kalıp rulosunun yanına getirildiği sürece mevcut dağıtımdan geçebilirsiniz. Dağıtım / sayıları güncellemek bu zorluğun bir parçasıdır .
• Sayma yerine ağırlıkları kullanabilirsiniz. Bunu yaparken, ağırlık 0'a düştüğünde, depolama sayılarıyla aynı etkiyi elde etmek için tüm ağırlıkların 1 oranında artması gerekir.
  • Bu ağırlıkları bir dizideki öğelerin tekrarları olarak kullanabilirsiniz.

İyi şanslar. Baytlar sizin lehinize olsun.

R , 59 bayt

function(){T[o]<<-T[o<-sample(6,1,,max(T)-T+1)]+1
o}
T=!1:6

Çevrimiçi deneyin!

Argüman Tolarak kullanılmak üzere dönüştürülen sayıları tutar (daha sonra büyük olasılıkla toplanacak şekilde normalize eder ).weightssample1

[<<-Operatör bir değer atamak için kullanılır Tüst ortamları (bu durumda, sadece ana ortam birinde .GlobalEnv).

Python 3 , 112 99 bayt

from random import*
def f(C=[0]*6):c=choices(range(6),[1-a+max(C)for a in C])[0];C[c]+=1;print(c+1)

Çevrimiçi deneyin!

açıklama

# we only need the "choice" function
from random import*

      # C, the array that holds previous choices, is created once when the function is defined
      # and is persisted afterwards unless the function is called with a replacement (i.e. f(C=[0,1,2,3,4,5]) instead of f() )
      C=[0]*6
# named function
def f(.......):
                  # generate weights
                  [1-a+max(C)for a in C]
# take the first item generated using built-in method
c=choices(range(6),......................)[0]
    # increment the counter for this choice
    C[c]+=1
    # since the array is 0-indexed, increase the number by 1 for printing
    print(c+1)

_{Düzenleme: 13 bayt kaydedildi. Sağol Attinat !}

05AB1E , 13 bayt

Z>αāDrÅΓΩ=Q+=

Çevrimiçi deneyin!

Sayım listesini girdi olarak alır. Rulo ve yeni sayım çıktılar.

Açıklama:

Z                 # maximum
 >                # plus 1
  α               # absolute difference (vectorizes)
                  # the stack now has the list of weights
ā                 # range(1, length(top of stack)), in this case [1..6]
 D                # duplicate
  r               # reverse the entire stack
   ÅΓ             # run-length decode, using the weights as the run lengths
     Ω            # pick a random element
                  # the stack is now: counts, [1..6], random roll
=                 # output the roll without popping
 Q                # test for equality, vectorizing
  +               # add to the counts
   =              # output the new counts

JavaScript (ES8), 111 bayt

_=>++C[C.map((v,i)=>s+=''.padEnd(Math.max(...C)-v+1,i),s=''),n=s[Math.random()*s.length|0]]&&++n;[,...C]=1e6+''

Çevrimiçi deneyin!

Nasıl?

Bu, simülasyonu açıklandığı gibi yapan oldukça saf ve muhtemelen en düşük kalitede bir uygulamadır.

sayıları takip ediyoruz . Her bir rulo olarak, bir dizi oluşturmak , her kalıbın oluşan tekrarlı saat ve tek tip bir dağılım ile orada rasgele giriş almak.$C$$s$$i$$max(C)-C_i+1$

APL (Dyalog Unicode) , 32 bayt ^SBCS

-4 aralık bayt yerine çoğaltmayı kullanır.

{1∘+@(⎕←(?∘≢⌷⊢)(1+⍵-⍨⌈/⍵)/⍳6)⊢⍵}

Çevrimiçi deneyin!

Geçerli dağıtımı argüman olarak alan, sonuçtaki ruloyu yazdırır ve güncellenmiş dağıtımı döndüren bir işlev olarak tanımlanır. İlk çalıştırma TIO ile başlayan 100 [0,0,0,0,0,0]çalıştırma, ikinci çalıştırma 1 ile yoğun şekilde önyargılı [0,100,100,100,100,100], son çalıştırma da aynı şekilde 6'ya doğru önyargılı.

Perl 6 , 31 bayt

{--.{$/=.pick}||++«.{1..6};$/}

Çevrimiçi deneyin!

Geçerli ağırlık dağılımını, tüm ağırlıkların 1 olduğu bir taneden başlayarak bir BagHash olarak kabul eder. Dağıtım yerinde mutasyona uğrar.

BagHash pickyöntemi, ilgili ağırlıkları kullanarak rastgele bir anahtar seçer; Bu anahtarın ağırlığı daha sonra bir azalır. Böylece ağırlık sıfır yapılırsa, ++«.{1..6}1-6 arasındaki sayıların ağırlıklarını artırır.

Wolfram Dili (Mathematica) , 91 bayt

w=1~Table~6
F:=Module[{g},g=RandomChoice[w->Range@6];w[[g]]++;w=Array[Max@w-w[[#]]+1&,6];g]

Çevrimiçi deneyin!

Javascript (ES6 +), 97 bayt

d=[1,2,3,4,5,6]
w=[...d]
r=x=>(i=~~(Math.random()*w.length),k=w[i],w.concat(d.filter(x=>x!=k)),k)

açıklama

d=[1,2,3,4,5,6]                   // basic die
w=[...d]                          // weighted die
r=x=>(                            // x is meaningless, just saves 1 byte vs ()
  i=~~(Math.random()*w.length),   // pick a random face of w
  k=w[i],                         // get the value of that face
  w.concat(d.filter(x=>x!=k)),    // add the faces of the basic die that aren't the value
                                  // we just picked to the weighted die
  k                               // return the value we picked
)

Bunun sonunda , js cinsinden maksimum dizi uzunluğu olan w2 ³² -1 uzunluğunu aşıyorsa patlayacağını unutmayın ; ancak 32 bitlik bir int dizi 2 ³² -1 uzunluğunda 16GiB ve bazı (çoğu?) Tarayıcılar 4GiB'den daha fazla kullanmanıza izin vermez.

Perl 6 , 49 bayt

{($!=roll (1..6 X=>1+max 0,|.{*})∖$_:),$_⊎$!}

Çevrimiçi deneyin!

Önceki ruloları Torba (multiset) olarak alır. Yeni ruloyu ve yeni dağıtımı döndürür.

açıklama

{                                            }  # Anon block taking
                                                # distribution in $_
                     max 0,|.{*}  # Maximum count
                   1+             # plus one
           1..6 X=>  # Pair with numbers 1-6
          (                     )∖$_  # Baggy subtract previous counts
     roll                            :  # Pick random element from Bag
 ($!=                                 )  # Store in $! and return
                                       ,$_⊎$!  # Return dist with new roll

Pyth , 22 20 bayt

Xt
hOs.e*]kh-eSQbQQ1

Çevrimiçi deneyin!

Giriş, bir liste olarak önceki frekanslardır, bir sonraki rulonun çıkışını ve güncellenmiş frekansları bir yeni satırla ayırır.

Xt¶hOs.e*]kh-eSQbQQ1   Implicit: Q=eval(input())
                       Newline replaced with ¶
      .e         Q     Map elements of Q, as b with index k, using:
             eSQ         Max element of Q (end of sorted Q)
            -   b        Subtract b from the above
           h             Increment
        *]k              Repeat k the above number of times
                       Result of the above is nested weighted list
                       e.g. [1,0,3,2,1,0] -> [[0, 0, 0], [1, 1, 1, 1], [2], [3, 3], [4, 4, 4], [5, 5, 5, 5]]
     s                 Flatten
    O                  Choose random element
   h                   Increment
  ¶                    Output with newline
 t                     Decrement
X                 Q1   In Q, add 1 to the element with the above index
                       Implicit print

Jöle , 12 bayt

’ạṀJx$X,Ṭ+¥¥

Çevrimiçi deneyin!

Tek bir argüman, o anki sayım listesini alan ve seçilen sayının ve güncellenmiş sayım listesinin bir listesini veren monadik bir bağlantı.

Jöle , 18 bayt

0x6+ɼṀ_®‘Jx$XṬ+ɼṛƊ

Çevrimiçi deneyin!

Alternatif olarak, işte seçilen sayıyı döndüren ve sicildeki sayım listesini izleyen niladik bir bağlantı.