Seçtiğiniz dilin seçici rastgelelikte ne kadar iyi olduğunu görelim.

Verilen 4 karakter, A, B, C, ve D, veya 4 karakterden oluşan bir dize ABCD girdi olarak , aşağıdaki olasılıkları ile karakterlerin çıkış one:

• A seçilmek için 1/8 (% 12,5) şansa sahip olmalı
• B seçilebilecek 3/8 (% 37,5) şansa sahip olmalı
• C 2/8 (% 25) seçilme şansı olmalı
• D 2/8 (% 25) seçilme şansı olmalı

Bu, aşağıdaki Plinko makine düzenine uygun:

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

Cevabınız açıklanan olasılıklara saygı duymak için gerçek bir girişimde bulunmalıdır. Cevabınızda olasılıkların nasıl hesaplandığına dair doğru bir açıklama (ve neden spesifikasyonlara saygı duydukları, sözde rastgelelik ve büyük sayılar problemlerini göz ardı ettikleri) yeterlidir.

puanlama

Bu kod golf, yani her dilde en az bayt kazanıyor!

Ortalama Fasulye Makinesi Yalın , 55 43 42 bayt

Alex Varga sayesinde -13 bayt

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

Umarım, sadece 2 saat sonra kendi soruma cevap vermeme aldırmazsınız, ancak LMBM'de bir cevap göndermeyi planlayan birinin şüphesi var.

Bu tam anlamıyla sadece OP'de gösterilen Plinko düzenini, gereksiz boşlukları azaltmak için yatay olarak çevrilmiş şekilde yansıtıyor.

Jöle , 6 bayt

Ḋṁ7;ḢX

Dört karakterin bir listesini alan ve açıklanan olasılık dağılımına sahip bir karakter döndüren monadik bir bağlantı.

Çevrimiçi deneyin!

Nasıl?

Ḋṁ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 bayt

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

Online tercümanda göster!

Bu, aşağıdaki küp ağıyla eşleşir:

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

Rastgele Dağıtım Uygulama Açıklaması

Cubix, bir komut göstergesinin bir küpün yüzleri çevresinde dolaşıp karşılaştığı komutları uyguladığı bir dildir. Tek rastgele biçim D, IP'yi rastgele bir yöne gönderen komuttur : 1/4her yöne eşit şans .

Bununla birlikte, bunu doğru ağırlıklı olasılıkları üretmek için kullanabiliriz: Diki kere kullanarak . İlk Dbir vardır 1/4bir saniyenin gitmeden arasında D. DAncak bu saniye , yön > D <göstericiyi Dbaşka bir yön seçmek için geri gönderen oklarla ( ) engellenen iki yöne sahiptir . Bu, her biri 1/8genel bir olma şansı olan , oradan sadece iki olası yön olduğu anlamına gelir . Bu, aşağıdaki şemada gösterildiği gibi doğru karakteri üretmek için kullanılabilir:

(Gerçek kodda, sağdaki okun bir ayna ile değiştirildiğini unutmayın. | )

Kod Açıklaması

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

Talimat göstericisi sağda, karakterde i, sağa doğru başlar. Bu yürütür igirdi olarak ilk karakteri alarak, ve daha sonra üzerine hareket Dyukarıda gösterilen rastgele işlemi başlamadan.

• Char A: İlk önce Dbizi doğuya, ikinci güneyi ise, A karakterini basmamız gerekiyor. Bu zaten birinciden yığında i. Aşağıdakiler yürütülür:

  • \ - IP'yi yansıtın ki doğuya yönelsin
  • i; - Bir giriş yapın, sonra tekrar açın (no-op)
  • U - IP adresini iki kere sola döndürerek U dönüşü yapın
  • o - TOS çıktısı, A karakteri
  • @ - Programı sonlandır

• Char B: Eğer birinci veya ikinci Dkafa kuzeye giderse, bir sonraki giriş olan B karakterini yaratmamız gerekir. Her iki yol da aşağıdaki komutları uygular:

  • ^ - Kuzeye git
  • < - Başını batıya doğru kaydır ...
  • i - Başka bir giriş yapın, B karakteri
  • o - TOS çıktısı, B karakteri
  • ; - TOS'u patlat
  • @ - Programı sonlandır

• C karakteri: İlk Dbizi batıya gönderirse, aşağıdakiler yapılır:

  • i - Başka bir giriş yapın, B karakteri
  • i - Başka bir giriş yapın, C karakteri
  • o - Çıkış TOS, karakter C
  • @ - Programı sonlandır

• Char D: İlki Dbizi güneye gönderirse, aşağıdakiler yapılır:

  • i - Başka bir giriş yapın, B karakteri
  • .. - İki ameliyat dışı
  • i - Başka bir giriş yapın, C karakteri
  • | - Bu ayna doğu-batıyı yansıtıyor, ancak IP kuzeye gidiyor, biz de içinden geçiyoruz.
  • ^ - Bu, B karakteri için alınan yolla birleşir. Ancak, zaten iki girdi aldığımız için dördüncü karakter (D karakteri) basılacaktır.

Python , 50 bayt

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

Dizeleri (veya karakter listelerini) alan ve döndüren adsız bir işlev.

Çevrimiçi deneyin!

Nasıl?

random.choicefonksiyonu, verilen doğru dağılımı olan bir dizi oluşturur, böylece, bir listeden rasgele bir eleman seçer "ABCD", "ABCD"[:2] = "AB"artı "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"hangi "ABBCDBCD".

R , 31 bayt

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

Karakterleri stdinboşluklarla ayırarak okur . sampleikinci girişin miktarındaki ilk girişinden rastgele örnekler çıkarır (1 verilen ağırlıklar ile ), (isteğe bağlı değiştirme argümanı) .

Çevrimiçi deneyin!

Deneyin o nzaman!

İkinci kod için, değiştirmeyi rue (varsayılan olarak yanlış ) olarak nayarlanan zamanları ( nbaşlıkta ayarlanmış ) örneklendiririm T, sonuçları sıralarım nve girdilerin göreceli olasılıklarını görmek için bölerim.

PHP, 28 bayt

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

İle boru olarak çalıştırın -nR.

011122334 üssünde 5551ondalık var ...

Java 8, 53 44 bayt

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

Bu bir Function<char[], Character>.

Çevrimiçi deneyin! (Bu test programı, yukarıda fonksiyonu 1,000,000 kez çalışır ve deneysel olasılıkları verir seçerek A, B, Cve D).

Burada genel bir fikir eşleştirmek için bir yol bulmaktır 0-7için 0-3öyle ki, 0görünür 1/8kez 1görünür 3/8, süreleri 2görüntülendiğinde 2/8kez ve 3görünür 2/8kez. aralık için rastgele bir tamsayı round(abs(k - 6) / 2.0))olduğu için bunun için çalışır . Bu aşağıdaki haritalama ile sonuçlanır:k[0,8)

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

Hangi gördüğünüz gibi, indekslerinde sonuçları 0 111 22 33istenilen olasılıklarını oluşturan, 1/8, 3/8, 2/8ve 2/8.

Fakat bekle! Dünyada -~Math.abs(k-6)/2aynı sonucu nasıl elde eder (yine, karalıktaki rastgele bir tamsayı nerededir [0,8])? Aslında oldukça basit ... (x+1)/2(tam sayıdaki bölüm), ile aynı şey round(x/2)ve x + 1aynı şey -~x. Her ne kadar x+1ve -~xaynı uzunluk, yukarıdaki fonksiyonu gösteren kullanmak daha iyidir vardır -~xo zamandan beri -~parantez gerektirmez böylece önceliklidir ve.

APL, 14 bayt

(?8)⊃1 3 2 2\⊢

Bir dize olarak girin.

Nasıl?

1 3 2 2\⊢- her harfi x kez tekrarlayın ( 'ABCD'→ 'ABBBCCDD')

⊃ - elementi indeks al.

(?8) - rastgele 1-8

Kömür , 11 bayt

‽⟦εεζζηηηθ⟧

Çevrimiçi deneyin! Bağlantılı kod sürümü, ancak buna gerek duymuyorsanız bile; ‽rastgele bir öğe seçer, ⟦⟧bir liste oluşturur ve değişkenler uygun girdi harflerini alanlardır (tersi sıraya göre kendim gibi).

Pyth , 8 7 bayt

O+@Q1t+

Python cevabımdakiyle aynı algoritmayı kullanır.

Burada dene!

Pyth , 10 8 bayt

O+<Q2*2t

Jonathan Allan'ın Python cevabı gibi tam olarak aynı algoritmayı kullanır.

Burada dene!

açıklama

• O- (ile +) ekleyerek yapılan String rastgele bir eleman alır :

  • <Q2 - String'in ilk iki karakteri.
  • *2t*2İlk karakter ( t) hariç tam String ( ) ikiye katlayın .

Bu algoritmayı şunun için uygulamak ABCD:

• <Q2alır AB.
• *2tsürer BCDve onu katına: BCDBCD.
• +İki dizeler katılır: ABBCDBCD.
• O rastgele bir karakter alır.

-2 Leaky Nun sayesinde (ikinci çözüm)

-1 anımsatıcı sayesinde (ilk çözüm)

Jöle , 8 bayt

122b4⁸xX

Çevrimiçi deneyin!

XGörmek için çıkarın "ABBBCCDD". XRasgele bir eleman seçer.

C # (.NET Core) , 76 55 bayt

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

Çevrimiçi deneyin!

İlk cevabım doğrudan cep telefonumu kullanarak TIO'ya yazıyor. Seviye atlamak!

Açıklama: Eğer orijinal string "ABCD" ise, fonksiyon "ABCDBBCD" dizesini yaratır ve ondan rastgele bir eleman alır.

Javascript 35 bayt

ABCDGirdi olarak bir dize alır A, zamanın B1 / 8'ini, zamanın 3 / 8'ini, zamanın C1 / 4'ünü ve zamanın 1 / 4'ünü çıkarır D.

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

açıklama

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 bayt

¦Ćì.R

Çevrimiçi deneyin!

açıklama

¦Ćì.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 bayt

i_ixio;o
ox</;
;\$o

Çevrimiçi deneyin! , veya izle balık oyun alanında !

> <> Kısaca genel bir bakış: Kodun içinde dolanan ve ilerlerken talimatları uygulayan bir balığın 2D dilidir. Kodun kenarına ulaşırsa, diğer tarafa sarılır. Balıklar sol üst köşede başlar ve sağa doğru hareket eder. Rastgele>>> içinde yanıltıcıdır: tek rastgele komutx balığın yönünü yukarı, aşağı, sola ve sağa (eşit olasılıkla) rastgele ayarlayan şeydir.

Programın başlangıcında, balık iki girdiyle giriş yapar i_i(her biri iSTDIN'den yığına bir karakter okur _ve balığın şimdi görmezden geldiği yatay bir aynadır). Sonra bir ulaşırx .

Eğer xbalık sağa gönderir, o bir daha karakteri (üçüncü) içinde olan baskılar okur ove santraline de ;. Sol taraf benzerdir: Balık iki karakter daha okur (yani dördüncü sıradayız), sağa doğru sarılır, dördüncü karakteri basar ve durur. Balıklar yüzerse, yansıtmadan /ve durmadan önce ikinci karakteri sarar ve yazdırır . Aşağıya doğru yüzerse, geriye doğru yansır /ve bir diğerine vurur x.

Bu sefer, iki yöne sadece balığa geri gönderir x(sağa bir ok <ve bir ayna ile _). Dolayısıyla balık x, diğer iki yönün her birinde bundan kaçma şansına sahiptir . Sola doğru, üstteki karakteri ikinci olan yığına basar, ancak aşağı doğru ilk önce yığındaki iki öğeyi değiştirir$ , böylece bu yön ilk karakteri yazdırır.

Özet olarak, üçüncü ve dördüncü karakterler, her biri 1/4 olasılıkla yazdırılıyor; ilk karakterin olasılıkı 1/2 x 1/4 = 1/8; ve ikinci karakterin olasılık 1/4 + 1/2 x 1/4 = 3/8 olabilir.

05AB1E , 8 bayt

ìD1è0ǝ.R

Çevrimiçi deneyin!

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

l3HHvY"1Zr

Çevrimiçi deneyin! Veya 1000 kere çalıştırın (hafifçe değiştirilmiş kod) ve her karakterin görünme sayısını kontrol edin.

açıklama

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

Değiştirilmiş koddaki değişiklikler: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]tekrarlamak için bir döngüdür 1000.
• G Girişin her yinelemenin başında itildiğinden emin olur.
• Sonuçlar, yinelemeler boyunca yığında toplanır. Bu yüzden sadece üst bitiştirmek için vtarafından değiştirilmesi gerekiyor4$v4 sayıları .
• Döngünün sonunda v, 1000sonuçları bir vektörde birleştirir , Ssıralar ve Y'çalışma uzunluğu kodlar. Bu, dört harfe ve göründükleri sayıda verir.

05AB1E , 6 bayt

«À¨Ć.R

Çevrimiçi deneyin!

açıklama

Hem listelerde hem de dizelerde çalışır.

«       # 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 bayt

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

Çevrimiçi deneyin!

Ruby, 34 33 29 27 bayt

@Value Inc sayesinde 2 bayt kaydedildi

Dört karakter olarak giriş yapın

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

dizi oluşturmak [B,B,C,D,A,B,C,D] ve örneklemek.

çevrimiçi deneyin!

nkez dene ! (Daha kolay tekrarlamak için bir işleve dönüştürdüm, ancak algoritma aynı)

Pyth, 7 bayt

@z|O8 1

Test odası

O80'dan 7'ye kadar rasgele bir sayı oluşturur. 0'ı | ... 11'e çeviren ve her şeyi aynı bırakan bir mantıksal veya 1 ile uygulanır. Bu aşamadaki sayı, zamanın 1 / 8'i ve zamanın 2, 3, 4, 5, 6, 7 ya da 8 / 8'idir.

@zbu konumda giriş dizgisine endeksler. İndeksleme, dizenin uzunluğunu modulo olarak gerçekleştirir, yani 4, 0, 5 ve 1 pozisyonlarında indekslenir.

Olasılıklar:

• Konum 0: Rastgele sayı 4. Zamanın 1 / 8'i.

• Konum 1: Rastgele sayı 0, 1 veya 5. Zamanın 3/8.

• Konum 2: Rastgele sayı 2 veya 6.

• Konum 3: Rastgele sayı 3 veya 7.

Javascript, 31 30 bayt / 23 bayt

Asgallant'ın önceki Javascript cevabını görmek JS'yi düşünmemi sağladı. Dediği gibi:

ABCDGirdi olarak bir dize alır A, zamanın B 1 / 8'ini, zamanın 3 / 8'ini, zamanın C1 / 4'ünü ve zamanın 1 / 4'ünü çıkarır D.

Benimki:

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

Açıklama:

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
        ]

Ondan Math.random()*8&7aşağıdaki gibi ayrılır:

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)

Sürüm 2, 23 bayt

Ama sonra dedi ki, peşimden gelen Arnauld'a teşekkür ederim:

Zamana bağlı bir formüle izin verilirse, şunları yapabiliriz:

ki, gerçekten izin veriliyorsa, beni yönlendirdi:

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

içinde olduğu new Date%8gibi aynı arıza tablosunu kullanır.

Ve %8ayrıca olabilir &7; istediğini al. Tekrar teşekkürler, Arnauld.

ngn / apl, 10 bayt

⎕a [⌈ /? 2 4]

?2 4 rastgele bir çift sayı seçer - ilki 0 1 arasında, ikincisi 0 1 2 3 arasında

⌈/ "maks. azaltma" - daha büyük sayıyı bulma

⎕a büyük harfli alfabe

[ ] indeksleme

a∊ {0,1} ve b∊ {0,1,2,3} olduğunda max (a, b) çizelgesine dikkat edin:

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

a ve b rastgele ve bağımsız olarak seçilirse, istenen olasılık dağılımını elde etmek için 0123 = ABCD yerine kullanılabilir.

Python 3 , 64 55 51 bayt

@Ovs sayesinde -9 bayt

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

Çevrimiçi deneyin!

açıklama

random.choice()String'in rastgele bir karakterini alırken , 1/8 s, 2/8 s, 2/8 s ve 3/8 s değerinde bir girdi (s*2)[1:]+s[1]oluşturur .BCDABCDBABCDACDB

QBIC , 27 bayt

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

açıklama

?           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 bayt

v
!

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

Çevrimiçi deneyin!

Çip , 60 bayt

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

Çevrimiçi deneyin!

Üç ?'s, her rastgele bit üretir. İlk döngüde, bu bitler bu tablodan hangi değeri elde edeceğimizi belirlemek için yukarıdaki anahtarlardan ( /lar ve \lar) geçirilir :

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

(nerede _olabilir 0veya1 ). Ardından, girdi boyunca gerektiği şekilde yürüyüp, doğru değere ulaşıldığında yazdırır ve sonlandırırız.

Sonunda büyük alfabetik blob kedi programından toptan kopyalanır, bu çözüm basitçe çıktıyı bastırır ve istenen etkiyi elde etmek için sona erer.

Ruby, 32 bayt

Oldukça basit ..?

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

Çevrimiçi deneyin!

Applesoft, 29 ay , 32 bayt

Küçük bir "retrocomputing" örneği. Benimle ayı, bu konuda yeni. "Girdi" olarak belirtilen şeyin, bayt sayılmasının gerekmediğini kabul ediyorum . OP'de belirtildiği gibi, girdi "ABCD" olarak verilecektir. (Başlangıçta geri kalanı bir bayt aşağıya koyarken 4 byte eklenmiş girdi elde etmeyi belirtmem gerektiğini fark etmedim.)

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

INPUT, RND, PRINT ve MID $ terimlerinin her biri dahili olarak tek baytlık simgeler olarak kodlanır.

İlk olarak, X'e <<X <4 aralığında rastgele bir değer atanır. Bu, (X <.5) + X + 1'e göre I $ 'daki karakterlerden birini seçmek için kullanılır. ifadenin kesilmiş değerlendirmesi. X <.5'ten küçükse X <.5 ekler, aksi takdirde 0 ekler.

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%

Ortak Lisp , 198 bayt

(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"))

Çevrimiçi deneyin!

Okunabilir:

(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"))