Kekeliruan penjudi adalah bias kognitif di mana kita secara keliru mengharapkan hal-hal yang sering terjadi lebih kecil kemungkinannya terjadi di masa depan dan hal-hal yang tidak terjadi dalam beberapa saat untuk lebih mungkin terjadi segera. Tugas Anda adalah mengimplementasikan versi spesifik ini.

Penjelasan Tantangan

Tulis fungsi yang mengembalikan bilangan bulat acak antara 1 dan 6, inklusif. Tangkapan: pertama kali fungsi dijalankan, hasilnya harus seragam (dalam 1%), namun, setiap panggilan berikutnya akan condong ke nilai yang telah digulirkan lebih sedikit kali sebelumnya. Rincian spesifiknya adalah sebagai berikut:

• Die mengingat jumlah angka yang dihasilkan sejauh ini.
• Setiap hasil ditimbang dengan rumus berikut:$count_{max} - count_{die} + 1$
  • Misalnya, jika jumlah roll sejauh ini adalah , bobotnya adalah , artinya Anda akan menjadi 4 kali lebih mungkin untuk menggulung dari .$[1, 0, 3, 2, 1, 0]$$[3, 4, 1, 2, 3, 4]$$2$$3$
  • Perhatikan bahwa rumus tersebut berarti bahwa hasil gulungan ditimbang sama dengan$[a, b, c, d, e, f]$$[a + n, b + n, c + n, d + n, e + n, f + n]$

Aturan dan Asumsi

• Aturan I / O standar dan celah terlarang berlaku
• Gulungan die tidak boleh bersifat deterministik. (yaitu menggunakan PRNG yang diunggulkan dari sumber yang mudah menguap, seperti biasanya tersedia sebagai builtin.)
• Sumber acak Anda harus memiliki periode setidaknya 65535 atau benar-benar acak.
• Distribusi harus dalam 1% untuk berat hingga 255
  • RNG 16-bit cukup baik untuk memenuhi kedua persyaratan di atas. Sebagian besar RNG built-in sudah cukup.
• Anda dapat meneruskan distribusi saat ini selama distribusi tersebut dimutasi oleh panggilan atau distribusi post-roll dikembalikan bersama dengan die roll. Memperbarui distribusi / jumlah adalah bagian dari tantangan ini .
• Anda dapat menggunakan bobot alih-alih menghitung. Saat melakukannya, setiap kali berat turun ke 0, semua bobot harus naik 1 untuk mencapai efek yang sama dengan jumlah penyimpanan.
  • Anda bisa menggunakan bobot ini sebagai pengulangan elemen dalam array.

Semoga berhasil. Semoga byte selalu menguntungkan Anda.

R , 59 byte

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

Cobalah online!

Menyimpan hitungan T, yang kemudian diubah untuk digunakan sebagai weightsargumen sample(yang kemungkinan besar akan menormalkan jumlah mereka 1).

The [<<-operator yang digunakan untuk memberikan nilai pada Tdi salah satu lingkungan orang tua (dalam hal ini, satu-satunya lingkungan induk .GlobalEnv).

Python 3 , 112 99 byte

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)

Cobalah online!

Penjelasan

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

_{Sunting: Disimpan 13 byte. Terima kasih, attinat !}

05AB1E , 13 byte

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

Cobalah online!

Mengambil daftar jumlah sebagai input. Menghasilkan gulungan dan jumlah baru.

Penjelasan:

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 byte

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

Cobalah online!

Bagaimana?

Ini adalah implementasi yang agak naif dan paling mungkin suboptimal yang melakukan simulasi seperti yang dijelaskan.

$C$$s$$i$$max(C)-C_i+1$

APL (Dyalog Unicode) , 32 byte ^SBCS

-4 byte menggunakan replikasi bukan indeks interval.

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

Cobalah online!

Didefinisikan sebagai fungsi yang mengambil distribusi saat ini sebagai argumen, mencetak die roll yang dihasilkan, dan mengembalikan distribusi yang diperbarui. Jalankan pertama pada TIO adalah 100 doa dimulai dengan [0,0,0,0,0,0], jalankan kedua sangat condong ke arah 1 dengan [0,100,100,100,100,100], dan menjalankan terakhir sangat bias menuju 6 ​​dengan cara yang sama.

Perl 6 , 31 byte

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

Cobalah online!

Menerima distribusi berat saat ini sebagai BagHash, dimulai dengan satu di mana semua bobot adalah 1. Distribusi dimutasi di tempat.

pickMetode BagHash memilih kunci secara acak menggunakan bobot terkait; bobot kunci itu kemudian dikurangi satu. Dengan demikian, jika bobot itu dibuat nol, ++«.{1..6}tambah bobot semua angka 1-6.

Bahasa Wolfram (Mathematica) , 91 byte

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

Cobalah online!

Javascript (ES6 +), 97 byte

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)

Penjelasan

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
)

Catatan ini pada akhirnya akan meledak jika wmelebihi panjang 2 ³² -1, yang merupakan panjang array max dalam js, tetapi Anda mungkin akan mencapai batas memori sebelum itu, mengingat array int 32-bit 2 panjang ³² -1 adalah 16GiB, dan beberapa browser (sebagian besar?) Tidak akan membiarkan Anda menggunakan lebih dari 4GiB.

Perl 6 , 49 byte

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

Cobalah online!

Mengambil gulungan sebelumnya sebagai Tas (multiset). Mengembalikan gulungan baru dan distribusi baru.

Penjelasan

{                                            }  # 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 byte

Xt
hOs.e*]kh-eSQbQQ1

Cobalah online!

Input adalah frekuensi sebelumnya sebagai daftar, menampilkan gulungan berikutnya dan frekuensi yang diperbarui dipisahkan oleh baris baru.

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

Jelly , 12 byte

’ạṀJx$X,Ṭ+¥¥

Cobalah online!

Tautan monadik yang mengambil argumen tunggal, daftar penghitungan saat ini, dan mengembalikan daftar nomor yang dipilih dan daftar penghitungan yang diperbarui.

Jelly , 18 byte

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

Cobalah online!

Sebagai alternatif, inilah tautan niladik yang mengembalikan nomor yang dipilih dan melacak daftar hitungan dalam register.