ความผิดพลาดของนักการพนันคืออคติทางปัญญาที่เราคาดหวังอย่างไม่เหมาะสมว่าสิ่งต่าง ๆ ที่เกิดขึ้นบ่อยครั้งจะมีโอกาสน้อยที่จะเกิดขึ้นในอนาคตและสิ่งต่าง ๆ ที่ไม่ได้เกิดขึ้นในอีกไม่นาน งานของคุณคือการใช้เวอร์ชันนี้โดยเฉพาะ

คำอธิบายการท้าทาย

เขียนฟังก์ชั่นที่ส่งกลับจำนวนเต็มแบบสุ่มระหว่าง 1 ถึง 6 โดยรวม การดักจับ: ครั้งแรกที่มีการเรียกใช้ฟังก์ชั่นผลลัพธ์ควรเป็นแบบเดียวกัน (ภายใน 1%) อย่างไรก็ตามการเรียกแต่ละครั้งที่ตามมาจะเบ้กับค่าที่มีการหมุนน้อยลงก่อนหน้านี้ รายละเอียดเฉพาะมีดังนี้:

• ผู้จำความตายนับจำนวนที่สร้างขึ้นแล้ว
• ผลลัพธ์แต่ละอย่างจะถูกถ่วงน้ำหนักด้วยสูตรต่อไปนี้: $count_{max} - count_{die} + 1$
  • ตัวอย่างเช่นหากการนับม้วนจนถึง$[1, 0, 3, 2, 1, 0]$น้ำหนักจะเป็น$[3, 4, 1, 2, 3, 4]$นั่นคือคุณจะต้องเป็น มีแนวโน้มที่จะหมุน$2$มากกว่า$3$เท่า
  • โปรดทราบว่าสูตรหมายความว่าผลลัพธ์การหมุนของ$[a, b, c, d, e, f]$นั้นมีน้ำหนักเท่ากับ$[a + n, b + n, c + n, d + n, e + n, f + n]$

กฎและข้อสมมติฐาน

• ใช้กฎ I / O มาตรฐานและช่องว่างที่ถูกแบน
• ไม่ควรกำหนดแม่พิมพ์รีด (เช่นใช้ PRNG seeded จากแหล่งที่ระเหยได้ตามปกติแล้วจะมีอยู่ในตัว)
• แหล่งที่มาแบบสุ่มของคุณต้องมีระยะเวลาอย่างน้อย 65535 หรือสุ่มอย่างแท้จริง
• การแจกแจงต้องไม่เกิน 1% สำหรับน้ำหนักสูงสุด 255
  • RNG แบบ 16 บิตดีพอที่จะตอบสนองความต้องการทั้งสองข้างต้น RNG ในตัวส่วนใหญ่เพียงพอแล้ว
• คุณอาจส่งผ่านการแจกแจงปัจจุบันตราบใดที่การแจกแจงนั้นถูกทำให้กลายพันธุ์โดยการโทร การอัปเดตการกระจาย / การนับเป็นส่วนหนึ่งของความท้าทายนี้
• คุณอาจใช้ตุ้มน้ำหนักแทนการนับ เมื่อทำเช่นนั้นทุกครั้งที่น้ำหนักลดลงถึง 0 น้ำหนักทั้งหมดควรเพิ่มขึ้น 1 เพื่อให้ได้ผลเช่นเดียวกับการนับจำนวน
  • คุณสามารถใช้ตุ้มน้ำหนักเหล่านี้เป็นองค์ประกอบซ้ำในอาเรย์

โชคดี. ไบต์อาจจะอยู่ในความโปรดปรานของคุณ

R , 59 ไบต์

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

ลองออนไลน์!

เก็บค่าในTซึ่งจะถูกนำไปใช้เป็นweightsอาร์กิวเมนต์ให้กับsample(ซึ่งส่วนใหญ่แล้วจะทำให้ค่ารวมเหล่านั้นเป็นปกติ1)

[<<-ผู้ประกอบการจะใช้ในการกำหนดค่าให้กับTหนึ่งในสภาพแวดล้อมที่ผู้ปกครอง (ในกรณีนี้, สภาพแวดล้อมที่พ่อแม่เพียงอย่างเดียวคือ.GlobalEnv)

Python 3 , 112 99 ไบต์

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)

ลองออนไลน์!

คำอธิบาย

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

_{แก้ไข: บันทึก 13 ไบต์ ขอบคุณattinat !}

05AB1E , 13 ไบต์

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

ลองออนไลน์!

ใช้รายการของการนับเป็นอินพุต แสดงผลการหมุนและการนับใหม่

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

อย่างไร?

นี่เป็นการดำเนินการที่ไร้เดียงสาและน่าจะเป็นไปได้มากที่สุดที่จะทำการจำลองตามที่อธิบายไว้

เราติดตามการนับใน $C$. ในแต่ละม้วนเราสร้างสตริง$s$ ประกอบด้วยแต่ละตาย $i$ ซ้ำแล้วซ้ำอีก $max(C)-C_i+1$ครั้งและเลือกรายการแบบสุ่มที่มีการแจกแจงแบบสม่ำเสมอ

APL (Dyalog Unicode) , 32 ไบต์^SBCS

-4 ไบต์ใช้การทำซ้ำแทนดัชนีช่วงเวลา

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

ลองออนไลน์!

กำหนดเป็นฟังก์ชันที่ใช้การแจกแจงปัจจุบันเป็นอาร์กิวเมนต์พิมพ์ผลการหมุนและส่งคืนการกระจายที่อัพเดต การเรียกใช้ครั้งแรกบน TIO คือ 100 การเรียกใช้เริ่มต้นด้วยการ[0,0,0,0,0,0]รันครั้งที่สองจะเอนเอียงอย่างหนักไปที่ 1 ด้วย[0,100,100,100,100,100]และการเรียกใช้ครั้งสุดท้ายจะเอนเอียงอย่างหนักไปที่ 6 ในลักษณะเดียวกัน

Perl 6 , 31 ไบต์

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

ลองออนไลน์!

ยอมรับการกระจายน้ำหนักปัจจุบันเป็น BagHash เริ่มต้นด้วยการที่น้ำหนักทั้งหมดเป็น 1 การกระจายจะถูกแทนที่ในสถานที่

The BagHash pick method selects a key at random using the associated weights; the weight of that key is then decremented by one. If that weight is thereby made zero, ++«.{1..6} increments the weights of all numbers 1-6.

ภาษา Wolfram (Mathematica) , 91 ไบต์

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

ลองออนไลน์!

Javascript (ES6 +), 97 ไบต์

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)

คำอธิบาย

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
)

หมายเหตุนี้ในที่สุดจะระเบิดขึ้นถ้าwเกินกว่าความยาวของ 2 ³² -1 ซึ่งเป็นระยะเวลาสูงสุดในอาร์เรย์ js แต่คุณอาจจะตี จำกัด หน่วยความจำก่อนแล้วพิจารณา 32 บิต int อาร์เรย์ 2 ³² -1 ยาว 16GiB และเบราว์เซอร์ (ส่วนใหญ่?) จะไม่ยอมให้คุณใช้มากกว่า 4GiB

Perl 6 , 49 ไบต์

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

ลองออนไลน์!

นำม้วนก่อนหน้านี้เป็นกระเป๋า (หลายชุด) ส่งคืนม้วนใหม่และการกระจายใหม่

คำอธิบาย

{                                            }  # 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 ไบต์

Xt
hOs.e*]kh-eSQbQQ1

ลองออนไลน์!

อินพุตเป็นความถี่ก่อนหน้านี้ในรายการเอาท์พุทม้วนต่อไปและความถี่ที่อัปเดตคั่นด้วยบรรทัดใหม่

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

เยลลี่ 12 ไบต์

’ạṀJx$X,Ṭ+¥¥

ลองออนไลน์!

ลิงก์ monadic ที่รับอาร์กิวเมนต์เดี่ยวรายการการนับปัจจุบันและส่งคืนรายการหมายเลขที่เลือกและรายการการนับที่อัพเดต

เยลลี่ขนาด 18 ไบต์

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

ลองออนไลน์!

นี่คือลิงค์ niladic ที่ส่งกลับหมายเลขที่เลือกและติดตามรายการการนับในการลงทะเบียน