Mari kita lihat seberapa bagus bahasa pilihan Anda dalam keacakan selektif.

Mengingat 4 karakter, A, B, C, dan D, atau string dari 4 karakter ABCD sebagai masukan , keluaran salah satu karakter dengan probabilitas berikut:

• A harus memiliki 1/8 (12,5%) kesempatan untuk dipilih
• B harus memiliki kesempatan 3/8 (37,5%) untuk dipilih
• C harus memiliki 2/8 (25%) kesempatan untuk dipilih
• D harus memiliki 2/8 (25%) kesempatan untuk dipilih

Ini sejalan dengan tata letak mesin Plinko berikut :

   ^
  ^ ^
 ^ ^ ^
A B \ /
     ^
    C D

Jawaban Anda harus melakukan upaya tulus untuk menghormati probabilitas yang dijelaskan. Penjelasan yang tepat tentang bagaimana probabilitas dihitung dalam jawaban Anda (dan mengapa mereka menghormati spesifikasi, mengabaikan pseudo-randomness dan masalah angka besar) sudah cukup.

Mencetak gol

Ini adalah kode-golf sehingga byte paling sedikit di setiap bahasa menang!

Lean Mean Bean Machine , 55 43 42 byte

-13 byte berkat Alex Varga

  O
  i
  ^
 ^ ^
\ ^ ^
 i / U
 ii
 ^
i U
U

Semoga kalian tidak keberatan saya menjawab pertanyaan saya sendiri setelah hanya 2 jam, tapi saya sangat ragu ada orang lain yang berencana memposting jawaban di LMBM.

Ini benar-benar hanya mencerminkan tata letak Plinko yang ditunjukkan dalam OP, membalik secara horizontal untuk mengurangi ruang putih yang tidak perlu.

Jelly , 6 byte

Ḋṁ7;ḢX

Tautan monadik mengambil daftar empat karakter dan mengembalikan satu dengan distribusi probabilitas yang dijelaskan.

Cobalah online!

Bagaimana?

Ḋṁ7;ḢX - Link: list of characters, s  e.g. ABCD
Ḋ      - dequeue s                         BCD
 ṁ7    - mould like 7 (implicit range)     BCDBCDB
    Ḣ  - head s                            A
   ;   - concatenate                       BCDBCDBA
     X - random choice                     Note that the above has 1*A, 3*B, 2*C, and 2*D

Cubix , 39 24 22 21 19 byte

.<.^iD>D|@oioi.\i;U

Lihat di penerjemah online!

Ini memetakan ke jaring kubus berikut:

    . <
    . ^
i D > D | @ o i
o i . \ i ; U .
    . .
    . .

Penjelasan Implementasi Distribusi Acak

Cubix adalah bahasa di mana penunjuk instruksi berjalan di sekitar wajah sebuah kubus, menjalankan perintah yang dihadapinya. Satu-satunya bentuk keacakan adalah perintah D, yang mengirim IP dalam arah acak: kesempatan yang sama untuk 1/4setiap cara.

Namun, kita bisa menggunakan ini untuk menghasilkan probabilitas tertimbang yang benar: dengan menggunakan Ddua kali. Yang pertama Dmemiliki 1/4judul menuju yang kedua D. Yang kedua ini D, bagaimanapun, memiliki dua arah diblokir dengan panah ( > D <) yang mengirim penunjuk instruksi kembali ke Duntuk memilih arah lain. Ini berarti hanya ada dua kemungkinan arah dari sana, masing-masing dengan 1/8kemungkinan keseluruhan terjadi. Ini dapat digunakan untuk menghasilkan karakter yang benar, seperti yang ditunjukkan pada diagram di bawah ini:

(Perhatikan bahwa, dalam kode aktual, panah di sebelah kanan diganti dengan cermin, |)

Penjelasan Kode

        . <
        . ^
IP> i D > D | @ o i
    o i . \ i ; U .
        . .
        . .

Penunjuk instruksi dimulai di sebelah kanan, di karakter i, menghadap ke kanan. Menjalankan ini i, mengambil karakter pertama sebagai input, dan kemudian bergerak ke D, memulai proses acak yang ditunjukkan di atas.

• Char A: Dalam hal yang pertama Dmengirim kami ke timur, dan selatan yang kedua, kita perlu mencetak karakter A. Ini sudah di stack dari yang pertama i. Berikut ini dieksekusi:

  • \ - Refleksikan IP sehingga mengarah ke timur
  • i; - Ambil input, lalu pop lagi (no-op)
  • U - Lakukan putar-U, putar IP kiri dua kali
  • o - Keluarkan TOS, karakter A
  • @ - Hentikan program

• Char B: Jika kepala pertama atau kedua Dutara, kita perlu menghasilkan karakter B, yang akan menjadi input berikutnya. Kedua jalur menjalankan perintah berikut:

  • ^ - Kepala utara
  • < - Kepala barat, membungkus ...
  • i - Ambil input lain, karakter B
  • o - Keluarkan TOS, karakter B
  • ; - Pop TOS
  • @ - Hentikan program

• Char C: Jika yang pertama Dmengirim kami ke barat, yang berikut ini dijalankan:

  • i - Ambil input lain, karakter B
  • i - Ambil input lain, karakter C
  • o - Keluaran TOS, karakter C
  • @ - Hentikan program

• Char D: Jika yang pertama Dmengirim kami ke selatan, yang berikut ini dijalankan:

  • i - Ambil input lain, karakter B
  • .. - Dua no-ops
  • i - Ambil input lain, karakter C
  • | - Cermin ini memantulkan timur-barat, tetapi IP mengarah ke utara, jadi kami melewatinya.
  • ^ - Ini bergabung dengan jalur yang diambil untuk karakter B. Namun, karena kami telah mengambil dua input, karakter keempat (karakter D) akan berakhir dicetak.

Python , 50 byte

lambda x:choice(x[:2]+x[1:]*2)
from random import*

Fungsi tanpa nama mengambil dan mengembalikan string (atau daftar karakter).

Cobalah online!

Bagaimana?

random.choicememilih elemen acak dari daftar, sehingga fungsi membentuk string dengan distribusi yang benar, yaitu, diberikan "ABCD", "ABCD"[:2] = "AB"ditambah "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"yang mana "ABBCDBCD".

R , 31 byte

sample(scan(,''),1,,c(1,3,2,2))

Membaca karakter dari stdindipisahkan oleh spasi. samplemengambil sampel acak dari input pertama dalam jumlah input kedua (so 1), (argumen penggantian opsional), dengan bobot yang diberikan oleh argumen terakhir.

Cobalah online!

Cobalah nberkali - kali!

Untuk kode yang terakhir, saya sampel nkali (diatur ndi header) dengan penggantian diatur ke True (itu salah secara default), tabulasikan hasilnya, dan bagi dengan nuntuk melihat probabilitas relatif dari input.

PHP, 28 byte

<?=$argn[5551>>2*rand(0,7)];

Jalankan sebagai pipa dengan -nR.

01112233di basis-4 5551dalam desimal ...

Java 8, 53 44 byte

s->s[-~Math.abs((int)(Math.random()*8)-6)/2]

Ini adalah Function<char[], Character>.

Cobalah online! (Program tes ini menjalankan fungsi di atas 1.000.000 kali dan output probabilitas eksperimental memilih A, B, C, dan D).

Ide umum di sini adalah untuk menemukan beberapa cara untuk memetakan 0-7ke 0-3, sehingga 0muncul 1/8kali, 1muncul 3/8kali, 2muncul 2/8kali, dan 3muncul 2/8kali. round(abs(k - 6) / 2.0))bekerja untuk ini, di mana kbilangan bulat acak dalam kisaran [0,8). Ini menghasilkan pemetaan berikut:

k -> k - 6 -> abs(k-6) -> abs(k-6)/2 -> round(abs(k-6)/2)

0 -> -6 -> 6 -> 3   -> 3
1 -> -5 -> 5 -> 2.5 -> 3
2 -> -4 -> 4 -> 2   -> 2
3 -> -3 -> 3 -> 1.5 -> 2
4 -> -2 -> 2 -> 1   -> 1
5 -> -1 -> 1 -> 0.5 -> 1
6 -> 0  -> 0 -> 0   -> 0 
7 -> 1  -> 1 -> 0.5 -> 1

Yang, seperti yang Anda lihat, hasil dalam indeks 0 111 22 33, yang menghasilkan probabilitas yang diinginkan 1/8, 3/8, 2/8dan 2/8.

Tapi tunggu! Bagaimana di dunia -~Math.abs(k-6)/2mencapai hasil yang sama (sekali lagi, di mana kbilangan bulat acak dalam kisaran [0,8])? Ini sebenarnya cukup sederhana ... (x+1)/2(pembagian integer) adalah hal yang sama dengan round(x/2), dan x + 1hal yang sama dengan -~x. Meskipun x+1dan -~xmemiliki panjang yang sama, dalam fungsi di atas lebih baik digunakan -~xkarena lebih -~diutamakan dan dengan demikian tidak memerlukan tanda kurung.

APL, 14 byte

(?8)⊃1 3 2 2\⊢

Input sebagai string.

Bagaimana?

1 3 2 2\⊢- ulangi setiap huruf x kali ( 'ABCD'→ 'ABBBCCDD')

⊃ - ambil elemen di indeks ..

(?8) - acak 1-8

Arang , 11 byte

‽⟦εεζζηηηθ⟧

Cobalah online! Tautan adalah untuk versi kode yang verbose, meskipun Anda tidak membutuhkannya; ‽mengambil elemen acak, ⟦⟧membuat daftar, dan variabelnya adalah mereka yang mendapatkan huruf input yang sesuai (dalam urutan terbalik karena saya merasa menyukainya).

Pyth , 8 7 byte

O+@Q1t+

Menggunakan algoritma yang sama persis seperti pada jawaban Python saya.

Coba di sini!

Pyth , 10 8 byte

O+<Q2*2t

Menggunakan algoritma yang sama persis seperti jawaban Python Jonathan Allan's.

Coba di sini!

Penjelasan

• O- Mengambil elemen acak dari String yang dibuat dengan menambahkan (dengan +):

  • <Q2 - Dua karakter pertama dari String.
  • *2tGandakan seluruh String ( *2) kecuali karakter pertama ( t).

Menerapkan algoritma ini untuk ABCD:

• <Q2mengambil AB.
• *2tmengambil BCDdan ganda itu: BCDBCD.
• +bergabung dengan dua Strings: ABBCDBCD.
• O mengambil karakter acak.

-2 Berkat Leaky Nun (solusi kedua)

-1 berkat mnemonic (solusi pertama)

Jelly , 8 byte

122b4⁸xX

Cobalah online!

Hapus Xuntuk melihat "ABBBCCDD". The Xmemilih elemen acak.

C # (.NET Core) , 76 55 byte

s=>(s+s[1]+s[1]+s[2]+s[3])[new System.Random().Next(8)]

Cobalah online!

Jawaban pertama saya ditulis langsung di TIO menggunakan ponsel saya. Naik tingkat!

Penjelasan: jika string asli adalah "ABCD", fungsi tersebut menciptakan string "ABCDBBCD" dan mengambil elemen acak darinya.

Javascript 35 byte

Mengambil string ABCDsebagai input, menghasilkan A1/8 waktu, B3/8 waktu, C1/4 waktu, dan D1/4 waktu.

x=>x[5551>>2*~~(Math.random()*8)&3]

Penjelasan

x=>x[                     // return character at index
    5551                  // 5551 is 0001010110101111 in binary
                          // each pair of digits is a binary number 0-3
                          // represented x times
                          // where x/8 is the probability of selecting
                          // the character at the index 
    >>                    // bitshift right by
    2 *                   // two times
    ~~(                   // double-bitwise negate (convert to int, then 
                          // bitwise negate twice to get the floor for
                          // positive numbers)
        Math.random() * 8 // select a random number from [0, 8)
    )                     // total bitshift is a multiple of 2 from [0, 14]
    &3                    // bitwise and with 3 (111 in binary)
                          // to select a number from [0, 3]
]

05AB1E , 5 byte

¦Ćì.R

Cobalah online!

Penjelasan

¦Ćì.R   Argument s                      "ABCD"
¦       Push s[1:]                      "BCD"
 Ć      Enclose: Pop a, Push a + a[0]   "BCDB"
  ì     Pop a, Concatenate a and s      "ABCDBCDB"
   .R   Random pick

> <> , 25 22 19 byte

i_ixio;o
ox</;
;\$o

Cobalah online! , atau tonton di taman bermain ikan !

Gambaran singkat tentang> <>: ini adalah bahasa 2D dengan ikan yang berenang melalui kode, menjalankan instruksi saat berjalan. Jika mencapai tepi kode, ia membungkus ke sisi lain. Ikan mulai di sudut kiri atas, bergerak ke kanan. Keacakan rumit dalam> <>: satu-satunya instruksi acak adalah x, yang menetapkan arah ikan secara acak dari atas, bawah, kiri dan kanan (dengan probabilitas yang sama).

Pada awal program, ikan membaca dua karakter input dengan i_i(masing-masing imembaca karakter dari STDIN ke tumpukan, dan _merupakan cermin horizontal, yang diabaikan oleh ikan sekarang). Kemudian mencapai x.

Jika xmengirimkan ikan ke kanan, ia membaca dalam satu karakter lagi (yang ketiga), mencetaknya dengan odan berhenti dengan ;. Arah kiri mirip: ikan membaca dua karakter lagi (jadi kita naik ke keempat), membungkus ke kanan, mencetak karakter keempat dan berhenti. Jika ikan berenang, ia membungkus dan mencetak karakter kedua, sebelum dipantulkan oleh /dan dihentikan. Jika berenang turun, itu akan dipantulkan ke kiri oleh /dan mengenai yang lain x.

Kali ini, dua arah hanya mengirim ikan kembali ke x(kanan dengan panah <,, dan ke atas dengan cermin, _). Oleh karena itu ikan memiliki kemungkinan 1/2 lolos dari ini xdi masing-masing dua arah lainnya. Kiri mencetak karakter teratas pada stack, yang merupakan karakter kedua, tetapi ke bawah pertama-tama menukar kedua elemen pada stack dengan $, jadi arah ini mencetak karakter pertama.

Singkatnya, karakter ketiga dan keempat dicetak dengan probabilitas 1/4 masing-masing; karakter pertama memiliki probabilitas 1/2 x 1/4 = 1/8; dan karakter kedua memiliki probabilitas 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 byte

ìD1è0ǝ.R

Cobalah online!

         # Implicit input                            | [A,B,C,D]
ì        # Prepend the input to itself               | [A,B,C,D,A,B,C,D]
 D1è     # Get the second character                  | [A,B,C,D,A,B,C,D], B
    0ǝ   # Replace the first character with this one | [B,B,C,D,A,B,C,D]
      .R # Pick a random character from this array   | D

MATL , 12 10 byte

l3HHvY"1Zr

Cobalah online! Atau jalankan 1000 kali (kode sedikit dimodifikasi) dan periksa berapa kali masing-masing karakter muncul.

Penjelasan

l3HH   % Push 1, 3, 2, 2
v      % Concatenate all stack contents into a column vector: [1; 3; 2; 2]
Y"     % Implicit input. Run-length decode (repeat chars specified number of times)
1Zr    % Pick an entry with uniform probability. Implicit display

Perubahan kode yang dimodifikasi: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]adalah loop untuk mengulang 1000kali.
• G memastikan input ditekan pada setiap awal iterasi.
• Hasil diakumulasikan pada stack di seluruh iterasi. Jadi vperlu diganti dengan 4$vhanya menyatukan 4nomor atas .
• Di akhir loop, vgabungkan 1000hasilnya menjadi vektor, Ssortir, dan Y'run-length mengkodekannya. Ini memberi empat huruf dan berapa kali mereka muncul.

05AB1E , 6 byte

«À¨Ć.R

Cobalah online!

Penjelasan

Berfungsi untuk daftar dan string.

«       # concatenate input with itself
 À      # rotate left
  ¨     # remove the last character/element
   Ć    # enclose, append the head
    .R  # pick a character/element at random

C (gcc) , 50 49 byte

i[8]={1,1,1,2,2,3,3};f(char*m){m=m[i[rand()%8]];}

Cobalah online!

Ruby, 34 33 29 27 byte

Disimpan 2 byte berkat @Value Inc

Masukan sebagai empat karakter

a=$**2
a[0]=a[1]
p a.sample

membangun sebuah array [B,B,C,D,A,B,C,D]dan sampel itu.

coba online!

coba nkali! (Saya mengonversinya menjadi fungsi untuk mengulanginya lebih mudah, tetapi algoritmanya sama)

Pyth, 7 byte

@z|O8 1

Suite uji

O8menghasilkan angka acak dari 0 hingga 7. | ... 1menggunakan logika atau dengan 1, mengonversi 0 menjadi 1 dan membiarkan semuanya tetap sama. Angka pada tahap ini adalah 1 2/8 waktu, dan 2, 3, 4, 5, 6, 7 atau 8 1/8 waktu.

@zmengindeks ke dalam string input pada posisi itu. Pengindeksan dilakukan modulo panjang string, jadi 4 indeks di posisi 0, 5 di posisi 1, dan seterusnya.

Peluangnya adalah:

• Posisi 0: Nomor acak 4. 1/8 dari waktu.

• Posisi 1: Angka acak 0, 1 atau 5. 3/8 dari waktu.

• Posisi 2: Nomor acak 2 atau 6. 2/8 dari waktu.

• Posisi 3: Angka acak 3 atau 7. 2/8 dari waktu.

Javascript, 31 30 byte / 23 byte

Melihat jawaban Javascript sebelumnya asgallant membuat saya berpikir tentang JS. Seperti yang dia katakan:

Mengambil string ABCDsebagai input, menghasilkan A1/8 waktu, B 3/8 waktu, C1/4 waktu, dan D1/4 waktu.

Punya saya:

x=>(x+x)[Math.random()*8&7||1]

Penjelasan:

x=>(x+x)[                 // return character at index of doubled string ('ABCDABCD')
         Math.random()*8  // select a random number from [0, 8]
         &7               // bitwise-and to force to integer (0 to 7)
         ||1              // use it except if 0, then use 1 instead
        ]

Dari Math.random()*8&7itu terurai sebagai berikut:

A from 4      = 12.5% (1/8)
B from 0,1,5  = 37.5% (3/8)
C from 2,6    = 25%   (1/4)
D from 3,7    = 25%   (1/4)

Versi 2, 23 byte

Tapi kemudian terima kasih kepada Arnauld, yang diposting setelah saya, ketika dia berkata:

Jika formula tergantung waktu diizinkan, kita bisa melakukan:

yang, jika memang diizinkan, mengarahkan saya ke:

x=>(x+x)[new Date%8||1]

di mana new Date%8menggunakan tabel break-down yang sama seperti di atas.

Dan %8bisa juga &7; ambil pilihanmu. Sekali lagi terima kasih, Arnauld.

ngn / apl, 10 byte

⎕a [⌈ /? 2 4]

?2 4 memilih secara acak sepasang angka - yang pertama di antara 0 1 dan yang kedua di antara 0 1 2 3

⌈/ adalah "maks. dikurangi" - temukan nomor yang lebih besar

⎕a adalah huruf besar

[ ] pengindeksan

catat bagan untuk maks (a, b) ketika a∊ {0,1} dan b∊ {0,1,2,3}:

    ┏━━━┯━━━┯━━━┯━━━┓
    ┃b=0│b=1│b=2│b=3┃
┏━━━╋━━━┿━━━┿━━━┿━━━┫
┃a=0┃ 0 │ 1 │ 2 │ 3 ┃
┠───╂───┼───┼───┼───┨
┃a=1┃ 1 │ 1 │ 2 │ 3 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

jika a dan b dipilih secara acak dan independen, kita dapat mengganti 0123 = ABCD untuk mendapatkan distribusi probabilitas yang diinginkan

Python 3 , 64 55 51 byte

-9 byte terima kasih kepada @ovs

lambda s:choice((s*2)[1:]+s[1])
from random import*

Cobalah online!

Penjelasan

random.choice()mendapat karakter acak dari String, sementara (s*2)[1:]+s[1]menciptakan BCDABCDBuntuk input ABCD, yang memiliki 1/8 Adetik, 2/8 Cdetik, 2/8 Ddetik dan 3/8 Bdetik.

QBIC , 27 byte

?_s;+;+B+B+;+C+;+D,_r1,8|,1

Penjelasan

?           PRINT
 _s         A substring of
   ;+       A plus
   ;+B+B+   3 instances of B plus
   ;+C+     2 instances of C plus
   ;+D      2 instances of D plus
   ,_r1,8|  from position x randomly chosen between 1 and 8
   ,1       running for 1 character

> <>, 56 byte

v
!

"
D
C
B
A ;
" o
! @
! ^<
x!^xv!
@  v<
@  o
o  ;
;
o

Cobalah online!

Chip , 60 byte

)//Z
)/\Z
)\/^.
)\x/Z
)\\\+t
|???`~S
|z*
`{'AabBCcdDEefFGghH

Cobalah online!

Ketiganya ?menghasilkan bit acak. Pada siklus pertama, bit-bit ini dijalankan melalui sakelar di atas ( /'s dan \' s) untuk menentukan nilai yang akan kita hasilkan dari tabel ini:

000 a
01_ b
0_1 b
10_ c
11_ d

(di mana _bisa menjadi 0atau 1). Kami kemudian berjalan di sepanjang input seperlunya, mencetak dan mengakhiri ketika nilai yang benar tercapai.

Gumpalan alfabetik besar pada akhirnya disalin secara grosir dari program kucing, solusi ini hanya menekan output dan berakhir untuk mendapatkan efek yang diinginkan.

Ruby, 32 byte

Cukup mudah ..?

->s{s[[0,1,1,1,2,2,3,3].sample]}

Cobalah online!

Applesoft, 29 oops, 32 byte

Contoh "retrocomputing" kecil. Bersabarlah dengan saya, saya baru dalam hal ini. Saya berpendapat bahwa apa yang ditunjuk sebagai "input" tidak perlu dihitung sendiri. Sebagaimana dinyatakan dalam OP, input akan diberikan sebagai "ABCD". (Awalnya saya tidak menyadari bahwa saya perlu menentukan input yang diperoleh, yang menambahkan 4 byte, sementara saya memasukkan sisanya ke byte.)

INPUTI$:X=RND(1)*4:PRINTMID$(I$,(X<.5)+X+1,1)

Istilah INPUT, RND, PRINT dan MID $ masing-masing dikodekan secara internal sebagai token byte tunggal.

Pertama, X diberi nilai acak dalam kisaran 0 <X <4. Ini digunakan untuk memilih salah satu karakter dari I $, sesuai dengan (X <.5) + X + 1. Nilai posisi karakter diambil sebagai evaluasi ekspresi terpotong. X <0,5 menambahkan 1 jika X kurang dari 0,5, jika tidak tambahkan 0. Hasil dari X memecah sebagai berikut:

A from .5 ≤ X < 1           = 12.5%
B from X < .5 or 1 ≤ X < 2  = 37.5%
C from 2 ≤ X < 3            = 25%
D from 3 ≤ X < 4            = 25%

Common Lisp , 198 byte

(setf *random-state*(make-random-state t))(defun f(L)(setf n(random 8))(cond((< n 1)(char L 0))((and(>= n 1)(< n 4))(char L 1))((and(>= n 4)(< n 6))(char L 2))((>= n 6)(char L 3))))(princ(f "ABCD"))

Cobalah online!

Dapat dibaca:

(setf *random-state* (make-random-state t))
(defun f(L)
    (setf n (random 8))
    (cond 
            ((< n 1) 
                (char L 0))
            ((and (>= n 1)(< n 4))
                (char L 1))
            ((and (>= n 4)(< n 6))
                (char L 2))
            ((>= n 6)
                (char L 3))
    )
)
(princ (f "abcd"))