Veamos qué tan bueno es su idioma de elección en la aleatoriedad selectiva.

Dadas 4 caracteres, A, B, C, y D, o una cadena de 4 caracteres ABCD como entrada , una salida de los caracteres con las siguientes probabilidades:

• A debe tener una probabilidad de 1/8 (12.5%) de ser elegido
• B debería tener una probabilidad de 3/8 (37.5%) de ser elegido
• C debe tener una probabilidad de 2/8 (25%) de ser elegido
• D debe tener una probabilidad de 2/8 (25%) de ser elegido

Esto está en línea con el siguiente diseño de la máquina Plinko :

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

Su respuesta debe hacer un intento genuino de respetar las probabilidades descritas. Una explicación adecuada de cómo se calculan las probabilidades en su respuesta (y por qué respetan las especificaciones, sin tener en cuenta los problemas de pseudoaleatoriedad y números grandes) es suficiente.

Tanteo

Este es el código de golf, por lo que gana menos bytes en cada idioma .

Lean Mean Bean Machine , 55 43 42 bytes

-13 bytes gracias a Alex Varga

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

Espero que no les importe que responda mi propia pregunta después de solo 2 horas, pero dudo mucho que alguien más haya planeado publicar una respuesta en LMBM.

Esto literalmente refleja el diseño de Plinko que se muestra en el OP, volteado horizontalmente para reducir el espacio en blanco innecesario.

Jalea , 6 bytes

Ḋṁ7;ḢX

Un enlace monádico que toma una lista de cuatro caracteres y devuelve uno con la distribución de probabilidad descrita.

Pruébalo en línea!

¿Cómo?

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

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

Ver en el intérprete en línea!

Esto se asigna a la siguiente red de cubos:

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

Explicación de implementación de distribución aleatoria

Cubix es un lenguaje en el que un puntero de instrucción viaja alrededor de las caras de un cubo, ejecutando los comandos que encuentra. La única forma de aleatoriedad es el comando D, que envía la IP en una dirección aleatoria: una posibilidad igual de1/4 cada sentido.

Sin embargo, podemos usar esto para generar las probabilidades ponderadas correctas: usando Ddos veces. El primero Dtiene un 1/4rumbo a un segundo D. Este segundo D, sin embargo, tiene dos direcciones bloqueadas con flechas ( > D <) que envían el puntero de instrucción de regreso al Dpara elegir otra dirección. Esto significa que solo hay dos direcciones posibles desde allí, cada una con una 1/8posibilidad general de suceder. Esto se puede usar para generar el carácter correcto, como se muestra en el siguiente diagrama:

(Tenga en cuenta que, en el código real, la flecha a la derecha se reemplaza con un espejo |)

Explicación del código

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

El puntero de instrucciones comienza a la derecha, en el personaje i, mirando hacia la derecha. Ejecuta esto i, toma el primer carácter como entrada y luego se mueve hacia el D, comenzando el proceso aleatorio que se muestra arriba.

• Char A: En el caso de que el primero Dnos envíe al este, y el segundo al sur, necesitamos imprimir el carácter A. Esto ya está en la pila del primero i. Se ejecuta lo siguiente:

  • \ - Refleja la IP para que se dirija al este
  • i; - Tome una entrada, luego vuelva a abrirla (sin operación)
  • U - Realizar un cambio de sentido, girando la IP a la izquierda dos veces
  • o - Salida del TOS, carácter A
  • @ - Terminar el programa

• Char B: Si la primera o la segunda se Ddirigen al norte, necesitamos generar el carácter B, que será la próxima entrada. Ambas rutas ejecutan los siguientes comandos:

  • ^ - Dirígete al norte
  • < - Dirígete hacia el oeste, envolviendo para ...
  • i - Toma otra entrada, personaje B
  • o - Salida del TOS, carácter B
  • ; - Pop los TOS
  • @ - Terminar el programa

• Char C: Si el primero Dnos envía al oeste, se ejecuta lo siguiente:

  • i - Toma otra entrada, personaje B
  • i - Toma otra entrada, personaje C
  • o - TOS de salida, carácter C
  • @ - Terminar el programa

• Char D: Si el primero Dnos envía al sur, se ejecuta lo siguiente:

  • i - Toma otra entrada, personaje B
  • .. - Dos no-ops
  • i - Toma otra entrada, personaje C
  • | - Este espejo refleja este-oeste, pero el IP se dirige hacia el norte, por lo que lo atravesamos.
  • ^ - Esto se une con la ruta tomada para el carácter B. Sin embargo, debido a que ya hemos tomado dos entradas, el cuarto carácter (carácter D) terminará siendo impreso.

Python , 50 bytes

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

Una función sin nombre que toma y devuelve cadenas (o listas de caracteres).

Pruébalo en línea!

¿Cómo?

random.choiceelige un elemento aleatorio de una lista, por lo que la función forma una cadena con la distribución correcta, es decir, dada "ABCD", "ABCD"[:2] = "AB"más "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"cuál es "ABBCDBCD".

R , 31 bytes

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

Lee los caracteres stdinseparados por espacios. sampletoma muestras aleatorias de su primera entrada en cantidad de la segunda entrada (entonces1 ), (argumento de reemplazo opcional), con los pesos dados por el último argumento.

Pruébalo en línea!

Pruébalo nveces!

Para el último código, muestro los ntiempos (establecidos nen el encabezado) con el reemplazo establecido en True (es falso por defecto), tabulo los resultados y divido por npara ver las probabilidades relativas de las entradas.

PHP, 28 bytes

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

Ejecutar como tubería con -nR.

01112233en base-4 está 5551en decimal ...

Java 8, 53 44 bytes

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

Se trata de una Function<char[], Character>.

Pruébalo en línea! (este programa de prueba se ejecuta la función anterior de 1.000.000 veces y da salida a las probabilidades experimentales de la elección A, B, C, y D).

La idea general es que encontrar alguna manera de hacer corresponder 0-7a 0-3, de manera que 0figure el 1/8momento, 1parece 3/8veces, 2aparece 2/8veces, y 3aparece 2/8veces. round(abs(k - 6) / 2.0))funciona para esto, donde kes un entero aleatorio en el rango [0,8). Esto da como resultado la siguiente asignación:

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

Lo cual, como se puede ver, los resultados en los índices 0 111 22 33, que produce las probabilidades deseadas de 1/8, 3/8, 2/8y2/8 .

¡Pero espera! ¿Cómo en el mundo -~Math.abs(k-6)/2logra el mismo resultado (de nuevo, ¿dónde kestá un número entero aleatorio en el rango [0,8])? Es bastante simple en realidad ... (x+1)/2(división entera) es lo mismo que round(x/2), y x + 1es lo mismo que -~x. Aunque x+1y -~xson de la misma longitud, en la función anterior es mejor usar -~xya que -~tiene prioridad y, por lo tanto, no requiere paréntesis.

APL, 14 bytes

(?8)⊃1 3 2 2\⊢

Entrada como una cadena.

¿Cómo?

1 3 2 2\⊢- repite cada letra x veces ( 'ABCD'→ 'ABBBCCDD')

⊃ - tome el elemento en el índice ..

(?8) - aleatorio 1-8

Carbón , 11 bytes

‽⟦εεζζηηηθ⟧

Pruébalo en línea! El enlace es a una versión detallada del código, aunque apenas lo necesita; ‽elige un elemento aleatorio, ⟦⟧crea una lista, y las variables son las que obtienen las letras de entrada apropiadas (en orden inverso porque me dio la gana).

Pyth , 8 7 bytes

O+@Q1t+

Utiliza exactamente el mismo algoritmo que en mi respuesta de Python.

Pruébalo aquí!

Pyth , 10 8 bytes

O+<Q2*2t

Utiliza exactamente el mismo algoritmo que la respuesta de Python de Jonathan Allan.

Pruébalo aquí!

Explicación

• O - Toma un elemento aleatorio de la cadena hecha al agregar (con + ):

  • <Q2 - Los dos primeros caracteres de la cadena.
  • *2tDuplique la cadena completa ( *2) excepto el primer carácter ( t).

Aplicando este algoritmo para ABCD :

• <Q2 toma AB .
• *2t toma BCD y lo dobla:BCDBCD .
• + une las dos cadenas: ABBCDBCD .
• O toma un caracter aleatorio.

-2 gracias a Leaky Nun (segunda solución)

-1 gracias a mnemonic (primera solución)

Jalea , 8 bytes

122b4⁸xX

Pruébalo en línea!

Eliminar el Xpara ver "ABBBCCDD". El Xelige un elemento aleatorio.

C # (.NET Core) , 76 55 bytes

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

Pruébalo en línea!

Mi primera respuesta escrita directamente en TIO usando mi teléfono móvil. ¡Elevar a mismo nivel!

Explicación: si la cadena original es "ABCD", la función crea la cadena "ABCDBBCD" y le quita un elemento aleatorio.

Javascript 35 bytes

Toma una cadena ABCDcomo entrada, salida a A1 / octava parte del tiempo, B3 / 8ths de la época, C1 / cuarta parte del tiempo, y D1 / cuarta parte del tiempo.

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

Explicación

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 bytes

¦Ćì.R

Pruébalo en línea!

Explicación

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

i_ixio;o
ox</;
;\$o

Pruébalo en línea! o míralo en el parque de peces !

Una breve descripción de> <>: es un lenguaje 2D con un pez que nada a través del código, ejecutando instrucciones a medida que avanza. Si llega al borde del código, se ajusta al otro lado. El pez comienza en la esquina superior izquierda, moviéndose a la derecha. La aleatoriedad es complicada en> <>: la única instrucción aleatoria esx , que establece la dirección del pez aleatoriamente hacia arriba, abajo, izquierda y derecha (con la misma probabilidad).

Al comienzo del programa, el pez lee en dos caracteres de entrada con i_i(cada uno ilee un carácter de STDIN a la pila, y _es un espejo horizontal, que el pez ignora ahora). Entonces alcanza un x.

Si xenvía el pez hacia la derecha, lee un carácter más (el tercero), lo imprime con oy se detiene con ;. La dirección hacia la izquierda es similar: el pez lee dos caracteres más (así que estamos hasta el cuarto), se enrolla hacia la derecha, imprime el cuarto carácter y se detiene. Si el pez nada hacia arriba, envuelve e imprime el segundo personaje, antes de reflejarse /y detenerse. Si nada hacia abajo, se refleja a la izquierda /y golpea a otrox .

Esta vez, dos direcciones simplemente envían al pez de regreso a la x(derecha con una flecha <, y arriba con un espejo _). Por lo tanto, el pez tiene 1/2 probabilidad de escapar de esto xen cada una de las otras dos direcciones. Hacia la izquierda imprime el carácter superior en la pila, que es el segundo, pero hacia abajo primero intercambia los dos elementos en la pila $, por lo que esta dirección imprime el primer carácter.

En resumen, los caracteres tercero y cuarto se imprimen con probabilidad de 1/4 cada uno; el primer caracter tiene probabilidad 1/2 x 1/4 = 1/8; y el segundo personaje tiene probabilidad 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 bytes

ìD1è0ǝ.R

Pruébalo en línea!

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

l3HHvY"1Zr

Pruébalo en línea! O ejecútelo 1000 veces (código ligeramente modificado) y verifique el número de veces que aparece cada carácter.

Explicación

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

Cambios en el código modificado: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...] es un ciclo para repetir 1000 tiempos.
• G se asegura de que la entrada se empuje al comienzo de cada iteración.
• Los resultados se acumulan en la pila a través de iteraciones. Por lo tanto v, debe reemplazarse 4$vpara concatenar solo la parte superior4 números .
• Al final del ciclo, vconcatena los 1000resultados en un vector, lo Sordena y lo Y'codifica la longitud de ejecución. Esto da las cuatro letras y la cantidad de veces que han aparecido.

05AB1E , 6 bytes

«À¨Ć.R

Pruébalo en línea!

Explicación

Funciona tanto para listas como para cadenas.

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

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

Pruébalo en línea!

Ruby, 34 33 29 27 bytes

Guardado 2 bytes gracias a @Value Inc

Ingrese como cuatro caracteres

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

construir una matriz [B,B,C,D,A,B,C,D]y probarla.

Pruébalo en línea!

pruébalo nveces! (Lo convertí en una función para repetirlo más fácilmente, pero el algoritmo es el mismo)

Pyth, 7 bytes

@z|O8 1

Banco de pruebas

O8genera un número aleatorio de 0 a 7. | ... 1aplica un lógico o con 1, convirtiendo el 0 en 1 y dejando todo lo demás igual. El número en esta etapa es 1 2/8 del tiempo, y 2, 3, 4, 5, 6, 7 u 8 1/8 del tiempo.

@zindexa en la cadena de entrada en esa posición. La indexación se realiza módulo a lo largo de la cadena, entonces 4 índices en la posición 0, 5 en la posición 1, y así sucesivamente.

Las probabilidades son:

• Posición 0: número aleatorio 4. 1/8 de las veces.

• Posición 1: número aleatorio 0, 1 o 5. 3/8 de las veces.

• Posición 2: número aleatorio 2 o 6. 2/8 de las veces.

• Posición 3: número aleatorio 3 o 7. 2/8 de las veces.

Javascript, 31 30 bytes / 23 bytes

Al ver la respuesta anterior de Javascript del asgallant me puse a pensar en JS. Como él dijo:

Toma una cadena ABCDcomo entrada, salida a A1 / octava parte del tiempo, B 3 / 8ths de la época, C1 / cuarta parte del tiempo, y D1 / cuarta parte del tiempo.

El mio es:

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

Explicación:

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
        ]

A partir de Math.random()*8&7él se desglosa de la siguiente manera:

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ón 2, 23 bytes

Pero luego, gracias a Arnauld, quien publicó después de mí, cuando dijo:

Si se permite una fórmula dependiente del tiempo, simplemente podemos hacer:

lo cual, si de hecho está permitido, me llevó a:

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

en el que new Date%8usa la misma tabla de desglose que la anterior.

Y %8también podría ser &7; elige tu opción. Gracias de nuevo, Arnauld.

ngn / apl, 10 bytes

⎕a [⌈ /? 2 4]

?2 4 elige aleatoriamente un par de números: el primero entre 0 1 y el segundo entre 0 1 2 3

⌈/ es "max reduce" - encuentra el número más grande

⎕a es el alfabeto en mayúscula

[ ] indexación

observe la tabla para max (a, b) cuando a∊ {0,1} y 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 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

Si a y b se eligen al azar e independientemente, podemos sustituir 0123 = ABCD para obtener la distribución de probabilidad deseada

Python 3 , 64 55 51 bytes

-9 bytes gracias a @ovs

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

Pruébalo en línea!

Explicación

random.choice()obtiene un carácter aleatorio de la cadena, mientras (s*2)[1:]+s[1]crea BCDABCDBpara una entrada de ABCD, que tiene 1/8 As, 2/8 Cs, 2/8 Dsy 3/8 Bs.

QBIC , 27 bytes

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

Explicación

?           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

Pruébalo en línea!

Chip , 60 bytes

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

Pruébalo en línea!

?Cada uno de los tres produce un bit aleatorio. En el primer ciclo, estos bits se ejecutan a través de los interruptores anteriores ( /'sy \' s) para determinar qué valor vamos a generar de esta tabla:

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

(donde _puede ser cualquiera 0o1 ). Luego caminamos a lo largo de la entrada según sea necesario, imprimiendo y terminando cuando se alcanza el valor correcto.

La gran burbuja alfabética al final se copia al por mayor del programa cat, esta solución simplemente suprime la salida y termina para obtener el efecto deseado.

Ruby, 32 bytes

Muy claro..?

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

Pruébalo en línea!

Applesoft, 29 oops, 32 bytes

Un pequeño ejemplo de "retrocomputación". Ten paciencia conmigo, soy nuevo en esto. Entiendo que lo que se designa como "entrada" no necesita ser contado en bytes. Como se indica en el OP, la entrada se daría como "ABCD". (Inicialmente no me di cuenta de que necesitaba especificar la entrada que se estaba obteniendo, lo que agregó 4 bytes, mientras que el resto del golf se redujo en un byte).

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

Los términos INPUT, RND, PRINT y MID $ están codificados internamente como tokens de un solo byte.

Primero, a X se le asigna un valor aleatorio en el rango 0 <X <4. Esto se usa para elegir uno de los caracteres de I $, de acuerdo con (X <.5) + X + 1. El valor de la posición del personaje se toma como evaluación truncada de la expresión. X <.5 agrega 1 si X era menor que .5, de lo contrario, agrega 0. Los resultados de X se desglosan de la siguiente manera:

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%

Lisp común , 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"))

Pruébalo en línea!

Legible:

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