Vediamo quanto è buona la tua lingua preferita nella casualità selettiva.

Trovati 4 caratteri, A, B, C, e D, o una stringa di caratteri 4 ABCD come input , uscita uno dei personaggi con le seguenti probabilità:

• A dovrebbe avere una possibilità 1/8 (12,5%) di essere scelto
• B dovrebbe avere una probabilità di 3/8 (37,5%) da scegliere
• C dovrebbe avere una probabilità di 2/8 (25%) di essere scelto
• D dovrebbe avere una probabilità di 2/8 (25%) di essere scelto

Ciò è in linea con il seguente layout della macchina Plinko :

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

La tua risposta deve fare un autentico tentativo di rispettare le probabilità descritte. È sufficiente una spiegazione adeguata di come vengono calcolate le probabilità nella tua risposta (e perché rispettano le specifiche, ignorando la pseudo-casualità e i problemi dei grandi numeri).

punteggio

Si tratta di code-golf quindi vince il minor numero di byte in ogni lingua !

Lean Mean Bean Machine , 55 43 42 byte

-13 byte grazie ad Alex Varga

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

Spero che non vi dispiaccia rispondermi alla mia domanda dopo solo 2 ore, ma dubito fortemente che chiunque altro stesse programmando di pubblicare una risposta in LMBM.

Questo riflette letteralmente solo il layout di Plinko mostrato nell'OP, capovolto in orizzontale per ridurre gli spazi bianchi non necessari.

Gelatina , 6 byte

Ḋṁ7;ḢX

Un collegamento monadico che prende un elenco di quattro caratteri e ne restituisce uno con la distribuzione di probabilità descritta.

Provalo online!

Come?

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

Visualizza nell'interprete online!

Questo viene mappato alla seguente rete cubica:

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

Spiegazione dell'implementazione della distribuzione casuale

Cubix è una lingua in cui un puntatore a istruzioni percorre le facce di un cubo, eseguendo i comandi che incontra. L'unica forma di casualità è il comandoD , che invia l'IP in una direzione casuale: un'eguale probabilità di 1/4ogni modo.

Tuttavia, possiamo usarlo per generare le probabilità ponderate corrette: usando Ddue volte. Il primo Dha un 1/4intestazione di un secondo D. Questo secondo D, tuttavia, ha due direzioni bloccate da frecce ( > D <) che rimandano il puntatore dell'istruzione a Dper scegliere un'altra direzione. Ciò significa che ci sono solo due possibili direzioni da lì, ognuna con una 1/8possibilità complessiva di accadere. Questo può essere usato per generare il carattere corretto, come mostrato nel diagramma seguente:

(Tieni presente che, nel codice effettivo, la freccia a destra viene sostituita con un mirror, | )

Spiegazione del codice

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

Il puntatore dell'istruzione inizia a destra, in corrispondenza del personaggio i, rivolto verso destra. Esegue questo i, prendendo il primo carattere come input, quindi si sposta sul D, iniziando il processo casuale mostrato sopra.

• Char A: Nel caso in cui il primo Dci mandi est, e il secondo sud, dobbiamo stampare il carattere A. Questo è già in pila dal primoi . Viene eseguito quanto segue:

  • \ - Rifletti l'IP in modo che sia diretto a est
  • i; - Prendi un input, quindi pop di nuovo (no-op)
  • U - Eseguire un'inversione a U, ruotando l'IP a sinistra due volte
  • o - Emette il TOS, carattere A
  • @ - Terminare il programma

• Char B: Se la prima o la seconda si Ddirigono verso nord, dobbiamo generare il carattere B, che sarà il prossimo input. Entrambi i percorsi eseguono i seguenti comandi:

  • ^ - Dirigiti a nord
  • < - Dirigiti a ovest, avvolgendoti attorno a ...
  • i - Prendi un altro input, carattere B
  • o - Emette il TOS, carattere B
  • ; - Pop il TOS
  • @ - Terminare il programma

• Char C: Se il primo Dci invia a ovest, viene eseguito quanto segue:

  • i - Prendi un altro input, carattere B
  • i - Prendi un altro input, carattere C
  • o - Output TOS, carattere C
  • @ - Terminare il programma

• Char D: Se il primo Dci invia a sud, viene eseguito quanto segue:

  • i - Prendi un altro input, carattere B
  • .. - Due no-ops
  • i - Prendi un altro input, carattere C
  • | - Questo specchio riflette est-ovest, ma l'IP è diretto a nord, quindi lo attraversiamo.
  • ^ - Questo si unisce al percorso preso per il personaggio B. Tuttavia, poiché abbiamo già preso due input, il quarto carattere (carattere D) finirà per essere stampato.

Python , 50 byte

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

Una funzione senza nome che accetta e restituisce stringhe (o elenchi di caratteri).

Provalo online!

Come?

random.choicesceglie un elemento casuale da un elenco, quindi la funzione forma una stringa con la distribuzione corretta, cioè data "ABCD", "ABCD"[:2] = "AB"più "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"quale è "ABBCDBCD".

R , 31 byte

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

Legge i caratteri stdinseparati da spazi. sampleestrae campioni casuali dal suo primo input in quantità del secondo input (quindi1 ), (argomento di sostituzione opzionale), con i pesi dati dall'ultimo argomento.

Provalo online!

Provalo nvolte!

Per quest'ultimo codice, campiono i ntempi (impostati nnell'intestazione) con la sostituzione impostata su True (è falso per impostazione predefinita), tabulo i risultati e divido nper vedere le relative probabilità degli input.

PHP, 28 byte

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

Esegui come pipe con -nR .

01112233in base-4 è 5551in decimale ...

Java 8, 53 44 byte

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

Questo è un Function<char[], Character>.

Provalo online! (questo programma di test viene eseguito la funzione di cui sopra 1.000.000 volte ed emette le probabilità sperimentali di scelta A, B, C, e D).

L'idea generale è quella di trovare un modo per mappare 0-7a 0-3, tale che 0appare 1/8volte, 1appare 3/8volte, 2appare 2/8volte, e 3appare2/8 volte. round(abs(k - 6) / 2.0))funziona per questo, dove kc'è un numero intero casuale nell'intervallo [0,8). Ciò si traduce nella seguente mappatura:

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

Che, come puoi vedere, risulta negli indici 0 111 22 33 , che produce le probabilità desiderati 1/8, 3/8, 2/8e 2/8.

Ma aspetta! In che modo il mondo ottiene -~Math.abs(k-6)/2lo stesso risultato (di nuovo, dov'è kun numero intero casuale nell'intervallo [0,8])? In realtà è piuttosto semplice ... (x+1)/2(divisione intera) è la stessa cosa di round(x/2), ed x + 1è la stessa cosa di -~x. Sebbene x+1e abbiano -~xla stessa lunghezza, nella funzione sopra è meglio usare -~xpoiché -~ha la precedenza e quindi non richiede parentesi.

APL, 14 byte

(?8)⊃1 3 2 2\⊢

Immettere come stringa.

Come?

1 3 2 2\⊢- ripeti ogni lettera x volte ( 'ABCD'→ 'ABBBCCDD')

⊃ - prendi l'elemento all'indice ..

(?8) - casuale 1-8

Carbone , 11 byte

‽⟦εεζζηηηθ⟧

Provalo online! Il collegamento è alla versione dettagliata del codice, anche se difficilmente ne hai bisogno; ‽seleziona un elemento casuale, ⟦⟧crea un elenco e le variabili sono quelle che ottengono le lettere di input appropriate (in ordine inverso perché mi sembrava).

Pyth , 8 7 byte

O+@Q1t+

Utilizza lo stesso algoritmo della mia risposta Python.

Provalo qui!

Pyth , 10 8 byte

O+<Q2*2t

Utilizza lo stesso algoritmo della risposta Python di Jonathan Allan.

Provalo qui!

Spiegazione

• O- Prende un elemento casuale della stringa creato aggiungendo (con +):

  • <Q2 - I primi due caratteri della stringa.
  • *2tRaddoppia la stringa completa ( *2) ad eccezione del primo carattere ( t).

Applicando questo algoritmo per ABCD:

• <Q2prende AB.
• *2tprende BCDe raddoppia: BCDBCD.
• +unisce le due stringhe: ABBCDBCD.
• O prende un personaggio casuale.

-2 grazie a Leaky Nun (seconda soluzione)

-1 grazie a mnemonic (prima soluzione)

Gelatina , 8 byte

122b4⁸xX

Provalo online!

Rimuovi Xper vedere "ABBBCCDD". Il Xsceglie un elemento casuale.

C # (.NET Core) , 76 55 byte

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

Provalo online!

La mia prima risposta scritta direttamente su TIO usando il mio telefono cellulare. Sali di livello!

Spiegazione: se la stringa originale è "ABCD", la funzione crea la stringa "ABCDBBCD" e ne ricava un elemento casuale.

Javascript 35 byte

Prende una stringa ABCDcome input, emette A1/8 del tempo, B3 / 8th del tempo, C1/4 del tempo e D1/4 del tempo.

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

Spiegazione

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

Provalo online!

Spiegazione

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

Provalo online! o guardalo nel parco giochi per pesci !

Una breve panoramica di> <>: è un linguaggio 2D con un pesce che nuota attraverso il codice, eseguendo le istruzioni mentre procede. Se raggiunge il bordo del codice, si sposta dall'altra parte. Il pesce inizia nell'angolo in alto a sinistra, spostandosi a destra. La casualità è complicata in> <>: l'unica istruzione casuale è x, che imposta casualmente la direzione del pesce da su, giù, sinistra e destra (con uguale probabilità).

All'inizio del programma, il pesce legge due caratteri di input con i_i(ciascuno ilegge un carattere da STDIN alla pila, ed _è uno specchio orizzontale, che il pesce ora ignora). Raggiunge quindi un x.

Se xinvia il pesce a destra, legge un altro carattere (il terzo), lo stampa con oe si ferma con ;. La direzione a sinistra è simile: il pesce legge altri due personaggi (quindi siamo al quarto), si avvolge a destra, stampa il quarto personaggio e si ferma. Se il pesce nuota, avvolge e stampa il secondo personaggio, prima di essere riflesso /e fermarsi. Se nuota verso il basso, viene riflesso lasciato dal /e ne colpisce un altrox .

Questa volta, due direzioni rimandano il pesce a x(a destra con una freccia <e in alto con uno specchio _). Il pesce ha quindi 1/2 possibilità di sfuggire a questo xin ciascuna delle altre due direzioni. Stampa verso sinistra il carattere in cima alla pila, che è il secondo, ma verso il basso scambia prima i due elementi con la pila $, quindi questa direzione stampa il primo carattere.

In sintesi, il terzo e il quarto carattere sono stampati con probabilità 1/4 ciascuno; il primo carattere ha probabilità 1/2 x 1/4 = 1/8; e il secondo personaggio ha probabilità 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 byte

ìD1è0ǝ.R

Provalo 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

Provalo online! Oppure eseguilo 1000 volte (codice leggermente modificato) e controlla il numero di volte che appare ogni carattere.

Spiegazione

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

Cambiamenti nel codice modificato: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]è un ciclo per ripetere i 1000tempi.
• G si assicura che l'input sia inserito all'inizio di ogni iterazione.
• I risultati vengono accumulati nello stack attraverso iterazioni. Quindi vdeve essere sostituito da 4$vconcatenare solo i primi 4numeri.
• Alla fine del ciclo, vconcatena i 1000risultati in un vettore, li Sordina e la Y'lunghezza di esecuzione lo codifica. Questo dà le quattro lettere e il numero di volte che sono apparse.

05AB1E , 6 byte

«À¨Ć.R

Provalo online!

Spiegazione

Funziona sia per gli elenchi che per le stringhe.

«       # 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]];}

Provalo online!

Ruby, 34 33 29 27 byte

Salvato 2 byte grazie a @Value Inc

Inserisci come quattro caratteri

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

costruire un array [B,B,C,D,A,B,C,D]e campionarlo.

provalo online!

provalo nvolte! (L'ho convertito in una funzione per ripeterlo più facilmente, ma l'algoritmo è lo stesso)

Pyth, 7 byte

@z|O8 1

Suite di test

O8genera un numero casuale da 0 a 7. | ... 1applica un valore logico o con 1, convertendo lo 0 in 1 e lasciando tutto il resto uguale. Il numero in questa fase è 1 2 / 8th del tempo e 2, 3, 4, 5, 6, 7 o 8 1/8 del tempo.

@zsi indicizza nella stringa di input in quella posizione. L'indicizzazione viene eseguita per la lunghezza della stringa, quindi 4 indici in posizione 0, 5 in posizione 1 e così via.

Le probabilità sono:

• Posizione 0: numero casuale 4. 1/8 del tempo.

• Posizione 1: numero casuale 0, 1 o 5. 3/8 del tempo.

• Posizione 2: numero casuale 2 o 6. 2/8 del tempo.

• Posizione 3: numero casuale 3 o 7. 2/8 del tempo.

Javascript, 31 30 byte / 23 byte

Vedere la precedente risposta Javascript di asgallant mi ha fatto pensare a JS. Come ha detto:

Prende una stringa ABCDcome input, emette A1/8 del tempo, B 3/8 del tempo, C1/4 del tempo e D1/4 del tempo.

Il mio è:

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

Spiegazione:

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
        ]

Da Math.random()*8&7esso si scompone come segue:

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)

Versione 2, 23 byte

Ma grazie ad Arnauld, che ha postato dopo di me, quando ha detto:

Se è consentita una formula dipendente dal tempo, possiamo semplicemente fare:

che, se è davvero permesso, mi ha portato a:

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

in cui new Date%8utilizza la stessa tabella di suddivisione di cui sopra.

E %8potrebbe anche essere &7; Fai la tua scelta. Grazie ancora, Arnauld.

ngn / apl, 10 byte

[A [⌈ /? 2 4]

?2 4 sceglie in modo casuale una coppia di numeri - il primo tra 0 1 e il secondo tra 0 1 2 3

⌈/ è "riduzione massima": trova il numero più grande

⎕a è l'alfabeto maiuscolo

[ ] indicizzazione

annota il grafico per max (a, b) quando a∊ {0,1} e 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 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

se aeb vengono scelti in modo casuale e indipendente, possiamo sostituire 0123 = ABCD per ottenere la distribuzione di probabilità desiderata

Python 3 , 64 55 51 byte

-9 byte grazie a @ovs

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

Provalo online!

Spiegazione

random.choice() gets a random character of the String, while (s*2)[1:]+s[1] creates BCDABCDB for an input of ABCD, which has 1/8 As, 2/8 Cs, 2/8 Ds and 3/8 Bs.

QBIC, 27 bytes

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

Explanation

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

v
!

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

Try it online!

Chip, 60 bytes

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

Try it online!

The three ?'s each produce a random bit. On the first cycle, these bits are run through the switches above (/'s and \'s) to determine which value we are going to output from this table:

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

(where _ can be either 0 or 1). We then walk along the input as necessary, printing and terminating when the correct value is reached.

The big alphabetic blob at the end is copied wholesale from the cat program, this solution simply suppresses output and terminates to get the intended effect.

Ruby, 32 bytes

Pretty straightforward..?

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

Try it online!

Applesoft, 29 oops, 32 bytes

A little "retrocomputing" example. Bear with me, I'm brand new at this. I gather that what is designated as the "input" need not be byte-counted itself. As stated in the OP, the input would be given as "ABCD". (I didn't initially realize that I needed to specify input being obtained, which added 4 bytes, while I golfed the rest down a byte.)

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

The terms INPUT, RND, PRINT and MID$ are each encoded internally as single-byte tokens.

First, X is assigned a random value in the range 0 < X < 4. This is used to choose one of the characters from I$, according to (X < .5) + X + 1. Character-position value is taken as truncated evaluation of the expression. X < .5 adds 1 if X was less than .5, otherwise add 0. Results from X break down as follows:

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 bytes

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

Try it online!

Readable:

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