Vamos ver o quão boa é a sua linguagem de escolha na aleatoriedade seletiva.

Dado 4 caracteres, A, B, C, e D, ou uma cadeia de 4 caracteres ABCD como entrada , um dos caracteres, com as seguintes probabilidades de saída:

• A deve ter 1/8 (12,5%) de chance de ser escolhido
• B deve ter uma chance de 3/8 (37,5%) de ser escolhido
• C deve ter 2/8 (25%) de chance de ser escolhido
• D deve ter 2/8 (25%) de chance de ser escolhido

Isso está alinhado com o seguinte layout da máquina Plinko :

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

Sua resposta deve fazer uma tentativa genuína de respeitar as probabilidades descritas. Uma explicação adequada de como as probabilidades são computadas em sua resposta (e por que elas respeitam as especificações, desconsiderando problemas de pseudo-aleatoriedade e grandes números) é suficiente.

Pontuação

Isso é código-golfe, e o menor número de bytes em cada idioma vence!

Máquina de Feijão Lean Mean , 55 43 42 bytes

-13 bytes graças a Alex Varga

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

Espero que vocês não se importem de eu responder minha própria pergunta após apenas 2 horas, mas duvido que alguém planejasse postar uma resposta no LMBM.

Isso literalmente reflete apenas o layout do Plinko mostrado no OP, invertido horizontalmente para reduzir o espaço em branco desnecessário.

Gelatina , 6 bytes

Ḋṁ7;ḢX

Um link monádico que pega uma lista de quatro caracteres e retorna um com a distribuição de probabilidade descrita.

Experimente online!

Quão?

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

Veja no intérprete online!

Isso mapeia a seguinte rede de cubos:

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

Explanação de implementação de distribuição aleatória

Cubix é uma linguagem na qual um ponteiro de instrução viaja pelas faces de um cubo, executando os comandos que encontra. A única forma de aleatoriedade é o comando D, que envia o IP em uma direção aleatória: uma chance igual em 1/4cada sentido.

No entanto, podemos usar isso para gerar as probabilidades ponderadas corretas: usando Dduas vezes. O primeiro Dtem um 1/4de ir para um segundo D. Este segundo D, no entanto, tem duas direções bloqueadas com setas ( > D <) que enviam o ponteiro de instruções de volta para a Dpara escolher outra direção. Isso significa que existem apenas duas direções possíveis a partir daí, cada uma com uma 1/8chance geral de acontecer. Isso pode ser usado para gerar o caractere correto, conforme mostrado no diagrama abaixo:

(Observe que, no código real, a seta à direita é substituída por um espelho |)

Código Explicação

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

O ponteiro de instruções começa à direita, no personagem i, voltada para a direita. Ele executa isso i, pegando o primeiro caractere como entrada e depois passa para o D, iniciando o processo aleatório mostrado acima.

• Caractere A: No caso em que o primeiro Dnos envie para o leste e o segundo para o sul, precisamos imprimir o caractere A. Isso já está na pilha do primeiro i. O seguinte é executado:

  • \ - Reflita o IP para o leste
  • i; - Pegue uma entrada e clique novamente (sem opção)
  • U - Faça uma inversão de marcha, virando o IP duas vezes para a esquerda
  • o - Saída do TOS, caractere A
  • @ - Encerrar o programa

• Caractere B: Se o primeiro ou o segundo se Ddirigirem ao norte, precisamos gerar o caractere B, que será a próxima entrada. Ambos os caminhos executam os seguintes comandos:

  • ^ - Siga para o norte
  • < - Vá para o oeste, embrulhando para ...
  • i - Pegue outra entrada, caractere B
  • o - Saída do TOS, caractere B
  • ; - Faça o TOS
  • @ - Encerrar o programa

• Caractere C: Se o primeiro Dnos enviar para o oeste, o seguinte será executado:

  • i - Pegue outra entrada, caractere B
  • i - Pegue outra entrada, caractere C
  • o - Saída TOS, caractere C
  • @ - Encerrar o programa

• Caractere D: Se o primeiro Dnos enviar para o sul, o seguinte será executado:

  • i - Pegue outra entrada, caractere B
  • .. - Duas no-ops
  • i - Pegue outra entrada, caractere C
  • | - Esse espelho reflete leste-oeste, mas o IP está indo para o norte, então passamos por ele.
  • ^ - Isso se une ao caminho adotado para o caractere B. No entanto, como já pegamos duas entradas, o quarto caractere (caractere D) acabará sendo impresso.

Python , 50 bytes

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

Uma função sem nome, que recebe e retorna seqüências de caracteres (ou listas de caracteres).

Experimente online!

Quão?

random.choiceescolhe um elemento aleatório de uma lista, de modo que a função forma uma string com a distribuição correta, ou seja, dada "ABCD", "ABCD"[:2] = "AB"mais "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"qual é "ABBCDBCD".

R , 31 bytes

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

Lê os caracteres stdinseparados por espaços. sampleextrai amostras aleatórias de sua primeira entrada em quantidade da segunda entrada (so 1), (argumento de substituição opcional), com pesos dados pelo último argumento.

Experimente online!

Experimente nvezes!

Para o último código, eu amostro os ntempos (definidos nno cabeçalho) com a substituição definida como True (é falso por padrão), tabulo os resultados e divido npara ver as probabilidades relativas das entradas.

PHP, 28 bytes

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

Corra como cano com -nR.

01112233na base-4 está 5551em decimal ...

Java 8, 53 44 bytes

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

Isto é um Function<char[], Character>.

Experimente online! (este programa de teste executa a função acima 1.000.000 vezes e emite as probabilidades experimentais de escolher A, B, C, e D).

A idéia geral aqui é encontrar uma maneira de mapear , 0-7para 0-3que 0apareça 1/8horas, 1apareça 3/8horas, 2apareça 2/8horas e 3apareça 2/8horas. round(abs(k - 6) / 2.0))funciona para isso, onde ké um número inteiro aleatório no intervalo [0,8). Isso resulta no seguinte mapeamento:

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

Que, como você pode ver, os resultados dos índices 0 111 22 33, que produz as probabilidades desejados de 1/8, 3/8, 2/8e 2/8.

Mas espere! Como o mundo -~Math.abs(k-6)/2alcança o mesmo resultado (novamente, onde kestá um número inteiro aleatório no intervalo [0,8])? É bem simples, na verdade ... (x+1)/2(divisão inteira) é a mesma coisa que round(x/2), e x + 1é a mesma coisa que -~x. Embora x+1e -~xtenham o mesmo comprimento, na função acima é melhor usar, -~xpois -~tem precedência e, portanto, não requer parênteses.

APL, 14 bytes

(?8)⊃1 3 2 2\⊢

Entrada como uma string.

Quão?

1 3 2 2\⊢- repita cada letra x vezes ( 'ABCD'→ 'ABBBCCDD')

⊃ - pegue o elemento no índice

(?8) - aleatório 1-8

Carvão , 11 bytes

‽⟦εεζζηηηθ⟧

Experimente online! Link é uma versão detalhada do código, embora você dificilmente precise dele; ‽escolhe um elemento aleatório, ⟦⟧cria uma lista e as variáveis ​​são aquelas que recebem as letras de entrada apropriadas (na ordem inversa, porque eu queria).

Pitão , 8 7 bytes

O+@Q1t+

Usa exatamente o mesmo algoritmo da minha resposta em Python.

Experimente aqui!

Pitão , 10 8 bytes

O+<Q2*2t

Usa exatamente o mesmo algoritmo da resposta Python de Jonathan Allan.

Experimente aqui!

Explicação

• O- Pega um elemento aleatório da String criado anexando (com +):

  • <Q2 - Os dois primeiros caracteres da String.
  • *2tDuplique a String completa ( *2), exceto o primeiro caractere ( t).

Aplicando este algoritmo para ABCD:

• <Q2leva AB.
• *2tleva BCDe dobra-lo: BCDBCD.
• +une as duas cordas: ABBCDBCD.
• O leva um caractere aleatório.

-2 graças a Leaky Nun (segunda solução)

-1 graças a mnemônico (primeira solução)

Geléia , 8 bytes

122b4⁸xX

Experimente online!

Remova o X para ver "ABBBCCDD". O Xescolhe um elemento aleatório.

C # (.NET Core) , 76 55 bytes

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

Experimente online!

Minha primeira resposta foi escrita diretamente no TIO usando meu telefone celular. Upar!

Explicação: se a sequência original for "ABCD", a função criará a sequência "ABCDBBCD" e extrairá dela um elemento aleatório.

Javascript 35 bytes

Toma uma string ABCDcomo entrada, gera A1/8 do tempo, B3/8 do tempo, C1/4 do tempo e D1/4 do tempo.

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

Explicação

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

Experimente online!

Explicação

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

Experimente online! , ou assista ao parque infantil !

Uma breve visão geral de> <>: é uma linguagem 2D com um peixe que nada através do código, executando instruções conforme ele é executado. Se atingir a borda do código, será envolto para o outro lado. O peixe começa no canto superior esquerdo, movendo-se para a direita. A aleatoriedade é complicada em> <>: a única instrução aleatória éx , que define a direção do peixe aleatoriamente para cima, para baixo, esquerda e direita (com igual probabilidade).

No início do programa, o peixe lê em dois caracteres de entrada com i_i(cada ium lê um caractere de STDIN para a pilha e _é um espelho horizontal, que o peixe ignora agora). Em seguida, atinge umx .

Se o xpeixe envia para a direita, ele lê mais um caractere (o terceiro), o imprime com oe para com ;. A direção esquerda é semelhante: o peixe lê mais dois caracteres (então chegamos ao quarto), gira para a direita, imprime o quarto caractere e pára. Se o peixe nada, ele envolve e imprime o segundo caractere, antes de ser refletido /e interrompido. Se nada, é refletido à esquerda pelo/ e bate em outro x.

Desta vez, duas direções apenas enviam o peixe de volta para x(à direita com uma seta,< , e para cima com um espelho _). O peixe, portanto, tem 1/2 chance de escapar disso xem cada uma das outras duas direções. Para a esquerda, imprime o caractere superior da pilha, que é o segundo, mas, para baixo, primeiro troca os dois elementos da pilha por$ , portanto, essa direção imprime o primeiro caractere.

Em resumo, o terceiro e o quarto caracteres são impressos com probabilidade de 1/4 cada; o primeiro caractere tem probabilidade 1/2 x 1/4 = 1/8; e o segundo caractere tem probabilidade 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 bytes

ìD1è0ǝ.R

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

l3HHvY"1Zr

Experimente online! Ou execute-o 1000 vezes (código ligeiramente modificado) e verifique o número de vezes que cada caractere aparece.

Explicação

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

Alterações no código modificado: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]é um loop para repetir 1000vezes.
• G garante que a entrada seja enviada no início de cada iteração.
• Os resultados são acumulados na pilha entre as iterações. Portanto, vprecisa ser substituído por 4$vpara concatenar apenas os 4números principais .
• No final do loop, vconcatena os 1000resultados em um vetor, Sclassifica e Y'codifica na duração. Isso fornece as quatro letras e o número de vezes que elas apareceram.

05AB1E , 6 bytes

«À¨Ć.R

Experimente online!

Explicação

Funciona para listas e seqüências de caracteres.

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

Experimente online!

Ruby, 34 33 29 27 bytes

Economizou 2 bytes graças a @Value Inc

Introduzir como quatro caracteres

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

construa uma matriz [B,B,C,D,A,B,C,D]e faça uma amostra.

experimente online!

tente nvezes! (Eu converti para uma função para repeti-lo mais facilmente, mas o algoritmo é o mesmo)

Pitão, 7 bytes

@z|O8 1

Suíte de teste

O8gera um número aleatório de 0 a 7. | ... 1aplica um lógico ou com 1, convertendo o 0 em 1 e deixando tudo o mesmo. O número nesse estágio é 1/2 / 8 do tempo e 2, 3, 4, 5, 6, 7 ou 8 1/8 do tempo.

@zindexa na sequência de entrada nessa posição. A indexação é realizada modulando o comprimento da string, então 4 indexam na posição 0, 5 na posição 1 e assim por diante.

As probabilidades são:

• Posição 0: Número aleatório 4. 1/8 do tempo.

• Posição 1: Número aleatório 0, 1 ou 5. 3/8 do tempo.

• Posição 2: Número aleatório 2 ou 6. 2/8 do tempo.

• Posição 3: Número aleatório 3 ou 7. 2/8 do tempo.

Javascript, 31 30 bytes / 23 bytes

Ver a resposta Javascript anterior da asgallant me levou a pensar em JS. Como ele disse:

Toma uma string ABCDcomo entrada, gera A1/8 do tempo, B 3/8 do tempo, C1/4 do tempo e D1/4 do tempo.

O meu é:

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

Explicação:

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
        ]

De Math.random()*8&7se decompõe da seguinte forma:

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)

Versão 2, 23 bytes

Mas então, graças a Arnauld, que postou depois de mim, quando ele disse:

Se uma fórmula dependente do tempo for permitida, podemos apenas:

que, se é realmente permitido, me levou a:

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

em que new Date%8usa a mesma tabela de detalhamento acima.

E %8também poderia ser &7; faça sua escolha. Mais uma vez obrigado, Arnauld.

ngn / apl, 10 bytes

[A [⌈ /? 2 4]

?2 4 escolhe aleatoriamente um par de números - o primeiro entre 0 1 e o segundo entre 0 1 2 3

⌈/ é "max reduzir" - encontre o número maior

⎕a é o alfabeto maiúsculo

[ ] indexação

observe o gráfico para 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 a e b são escolhidos aleatoriamente e independentemente, podemos substituir 0123 = ABCD para obter a distribuição de probabilidade desejada

Python 3 , 64 55 51 bytes

-9 bytes graças a @ovs

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

Experimente online!

Explicação

random.choice()obtém um caractere aleatório da String, enquanto (s*2)[1:]+s[1]cria BCDABCDBpara uma entrada de ABCD, que possui 1/8 As, 2/8 Cs, 2/8 se D3/8 Bs.

QBIC , 27 bytes

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

Explicação

?           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

Experimente online!

Chip , 60 bytes

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

Experimente online!

?Cada um dos três produz um bit aleatório. No primeiro ciclo, esses bits são executados nos comutadores acima ( /'s \') para determinar qual valor vamos gerar a partir desta tabela:

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

(onde _pode ser 0ou1 ). Caminhamos pela entrada conforme necessário, imprimindo e finalizando quando o valor correto é atingido.

O grande blob alfabético no final é copiado por atacado do programa cat; essa solução simplesmente suprime a saída e termina para obter o efeito pretendido.

Ruby, 32 bytes

Bem direto..?

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

Experimente online!

Applesoft, 29 oops, 32 bytes

Um pequeno exemplo de "retrocomputação". Tenha paciência comigo, sou novo nisso. Entendo que o que é designado como "entrada" não precisa ser contado em bytes. Conforme declarado no OP, a entrada seria fornecida como "ABCD". (Inicialmente, não percebi que precisava especificar a entrada obtida, o que acrescentou 4 bytes, enquanto eu deduzia o restante em um byte.)

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

Os termos INPUT, RND, PRINT e MID $ são codificados internamente como tokens de byte único.

Primeiro, X é atribuído a um valor aleatório no intervalo 0 <X <4. Isso é usado para escolher um dos caracteres de I $, de acordo com (X <.5) + X + 1. O valor da posição do caracter é tomado como avaliação truncada da expressão. X <0,5 adiciona 1 se X for menor que 0,5, caso contrário, adicione 0. Os resultados de X são divididos da seguinte forma:

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 comum , 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"))

Experimente online!

Legível:

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