Sai lầm của người đánh bạc là một khuynh hướng nhận thức, trong đó chúng ta nhầm tưởng những điều xảy ra thường ít xảy ra trong tương lai và những điều không xảy ra trong một thời gian sẽ sớm xảy ra. Nhiệm vụ của bạn là thực hiện một phiên bản cụ thể của việc này.

Giải thích thách thức

Viết hàm trả về một số nguyên ngẫu nhiên trong khoảng từ 1 đến 6. Bắt: lần đầu tiên chức năng được chạy, kết quả phải đồng nhất (trong vòng 1%), tuy nhiên, mỗi cuộc gọi tiếp theo sẽ bị sai lệch có lợi cho các giá trị đã được cuộn ít lần trước đó. Các chi tiết cụ thể như sau:

• Chết nhớ số lượng tạo ra cho đến nay.
• Mỗi kết quả được tính theo công thức sau:$count_{max} - count_{die} + 1$
  • Chẳng hạn, nếu số lượng cuộn cho đến nay là , các trọng số sẽ là , nghĩa là bạn sẽ 4 lần nhiều khả năng cuộn hơn .$[1, 0, 3, 2, 1, 0]$$[3, 4, 1, 2, 3, 4]$$2$$3$
  • Lưu ý rằng công thức có nghĩa là kết quả cuộn của có trọng số tương đương với$[a, b, c, d, e, f]$$[a + n, b + n, c + n, d + n, e + n, f + n]$

Quy tắc và giả định

• Quy tắc I / O tiêu chuẩn và sơ hở bị cấm áp dụng
• Die cuộn không nên được xác định. (tức là sử dụng PRNG được gieo từ nguồn dễ bay hơi, như thường có sẵn dưới dạng dựng sẵn.)
• Nguồn ngẫu nhiên của bạn phải có khoảng thời gian ít nhất là 65535 hoặc là ngẫu nhiên thực sự.
• Phân phối phải trong vòng 1% cho trọng lượng lên tới 255
  • RNG 16 bit đủ tốt để đáp ứng cả hai yêu cầu trên. Hầu hết các RNG tích hợp là đủ.
• Bạn có thể vượt qua trong phân phối hiện tại miễn là phân phối đó bị đột biến bởi lệnh gọi hoặc phân phối sau cuộn được trả lại cùng với trục lăn. Cập nhật phân phối / số lượng là một phần của thách thức này .
• Bạn có thể sử dụng trọng lượng thay vì đếm. Khi làm như vậy, bất cứ khi nào trọng lượng giảm xuống 0, tất cả các trọng số sẽ tăng thêm 1 để đạt được hiệu quả tương tự như số lượng lưu trữ.
  • Bạn có thể sử dụng các trọng số này như sự lặp lại của các phần tử trong một mảng.

Chúc may mắn. Có thể các byte được bao giờ có lợi cho bạn.

R , 59 byte

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

Hãy thử trực tuyến!

Giữ các số đếm T, sau đó được chuyển đổi để được sử dụng làm weightsđối số sample(mà sau đó rất có thể bình thường hóa chúng để tổng hợp 1).

Các [<<-nhà điều hành được sử dụng để gán giá trị cho Tmột trong các môi trường cha mẹ (trong trường hợp này, môi trường cha mẹ chỉ là .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)

Hãy thử trực tuyến!

Giải trình

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

_{Chỉnh sửa: Đã lưu 13 byte. Cảm ơn, attinat !}

05AB1E , 13 byte

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

Hãy thử trực tuyến!

Lấy danh sách đếm làm đầu vào. Đầu ra cuộn và số mới.

Giải trình:

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+''

Hãy thử trực tuyến!

Làm sao?

Đây là một triển khai khá ngây thơ và có lẽ là tối ưu nhất thực hiện mô phỏng như mô tả.

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

APL (Dyalog Unicode) , ^SBCS 32 byte

-4 byte sử dụng nhân rộng thay vì chỉ số khoảng.

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

Hãy thử trực tuyến!

Được xác định là một hàm lấy phân phối hiện tại làm đối số, in cuộn chết kết quả và trả về phân phối được cập nhật. Lần chạy đầu tiên trên TIO là 100 lần gọi bắt đầu [0,0,0,0,0,0], lần chạy thứ hai thiên về 1 [0,100,100,100,100,100]và lần chạy cuối cùng thiên về 6 theo cách tương tự.

Perl 6 , 31 byte

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

Hãy thử trực tuyến!

Chấp nhận phân phối trọng lượng hiện tại dưới dạng BagHash, bắt đầu bằng một trọng số trong đó tất cả các trọng số là 1. Phân phối được thay đổi tại chỗ.

pickPhương pháp BagHash chọn một khóa ngẫu nhiên bằng cách sử dụng các trọng số liên quan; trọng lượng của khóa đó sau đó giảm đi một. Nếu trọng số đó bằng 0, hãy ++«.{1..6}tăng trọng số của tất cả các số 1-6.

Ngôn ngữ Wolfram (Mathicala) , 91 byte

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

Hãy thử trực tuyến!

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)

Giải trình

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
)

Lưu ý rằng điều này cuối cùng sẽ nổ tung nếu wvượt quá độ dài 2 ³² -1, đó là độ dài mảng tối đa trong js, nhưng có lẽ bạn sẽ đạt giới hạn bộ nhớ trước đó, xem xét một mảng int 32 bit 2 dài ³² -1 là 16GiB và một số trình duyệt (hầu hết?) Sẽ không cho phép bạn sử dụng nhiều hơn 4GiB.

Perl 6 , 49 byte

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

Hãy thử trực tuyến!

Lấy các cuộn trước đó dưới dạng Túi (multiset). Trả về cuộn mới và phân phối mới.

Giải trình

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

Bình thường , 22 20 byte

Xt
hOs.e*]kh-eSQbQQ1

Hãy thử trực tuyến!

Đầu vào là các tần số trước dưới dạng danh sách, xuất ra cuộn tiếp theo và tần số cập nhật được phân tách bằng một dòng mới.

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

Thạch , 12 byte

’ạṀJx$X,Ṭ+¥¥

Hãy thử trực tuyến!

Một liên kết đơn có một đối số duy nhất, danh sách đếm hiện tại và trả về một danh sách các số được chọn và danh sách đếm được cập nhật.

Thạch , 18 byte

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

Hãy thử trực tuyến!

Thay vào đó, đây là một liên kết niladic trả về số đã chọn và theo dõi danh sách đếm trong sổ đăng ký.