Voyons à quel point votre langue de choix est bonne au hasard sélectif.

Compte tenu de 4 caractères, A, B, C, et D, ou une chaîne de 4 caractères ABCD en entrée , une sortie des caractères avec les probabilités suivantes:

• A devrait avoir 1/8 (12,5%) de chance d'être choisi
• B devrait avoir 3/8 (37,5%) de chance d'être choisi
• C devrait avoir 2/8 (25%) de chance d'être choisi
• D devrait avoir 2/8 (25%) de chance d'être choisi

Ceci est conforme à la configuration de machine Plinko suivante :

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

Votre réponse doit tenter véritablement de respecter les probabilités décrites. Une explication appropriée de la façon dont les probabilités sont calculées dans votre réponse (et pourquoi elles respectent les spécifications, sans tenir compte des problèmes de pseudo-aléatoire et des grands nombres) est suffisante.

Notation

C'est du golf de code donc le moins d'octets dans chaque langue gagne!

Machine Lean Mean Bean , 55 43 42 octets

-13 octets grâce à Alex Varga

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

J'espère que cela ne vous dérange pas que je réponde à ma propre question après seulement 2 heures, mais je doute fortement que quelqu'un d'autre envisage de publier une réponse dans LMBM.

Cela reflète littéralement la disposition Plinko montrée dans l'OP, retournée horizontalement pour réduire les espaces inutiles.

Gelée , 6 octets

Ḋṁ7;ḢX

Un lien monadique prenant une liste de quatre caractères et en renvoyant un avec la distribution de probabilité décrite.

Essayez-le en ligne!

Comment?

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

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

Voir dans l'interprète en ligne!

Cela correspond au réseau de cubes suivant:

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

Explication de la mise en œuvre de la distribution aléatoire

Cubix est un langage dans lequel un pointeur d'instructions parcourt les faces d'un cube, exécutant les commandes qu'il rencontre. La seule forme d'aléatoire est la commande D, qui envoie l'IP dans une direction aléatoire: une chance égale dans 1/4chaque sens.

Cependant, nous pouvons l'utiliser pour générer les probabilités pondérées correctes: en utilisant Ddeux fois. Le premier Da un 1/4cap vers un second D. Cette seconde D, cependant, a deux directions bloquées avec des flèches ( > D <) qui renvoient le pointeur d'instruction à Dpour choisir une autre direction. Cela signifie qu'il n'y a que deux directions possibles à partir de là, chacune ayant une 1/8chance globale de se produire. Cela peut être utilisé pour générer le bon caractère, comme indiqué dans le diagramme ci-dessous:

(Notez que, dans le code actuel, la flèche à droite est remplacée par un miroir, |)

Explication du code

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

Le pointeur d'instruction commence à droite, au niveau du personnage i, face à droite. Il exécute cela i, en prenant le premier caractère en entrée, puis passe au D, en commençant le processus aléatoire illustré ci-dessus.

• Char A: Dans le cas où le premier Dnous envoie vers l'est et le second sud, nous devons imprimer le caractère A. C'est déjà sur la pile du premier i. Ce qui suit est exécuté:

  • \ - Refléter l'IP pour qu'il se dirige vers l'est
  • i; - Prenez une entrée, puis éclatez-la à nouveau (no-op)
  • U - Faites demi-tour en tournant l'IP deux fois à gauche
  • o - Sortie du TOS, caractère A
  • @ - Mettre fin au programme

• Caractère B: Si c'est le premier ou le deuxième Dcap au nord, nous devons générer le caractère B, qui sera la prochaine entrée. Les deux chemins exécutent les commandes suivantes:

  • ^ - Dirigez-vous vers le nord
  • < - Dirigez-vous vers l'ouest, enroulant autour de ...
  • i - Prenez une autre entrée, caractère B
  • o - Sortie du TOS, caractère B
  • ; - Pop the TOS
  • @ - Mettre fin au programme

• Char C: Si le premier Dnous envoie vers l'ouest, ce qui suit est exécuté:

  • i - Prenez une autre entrée, caractère B
  • i - Prenez une autre entrée, caractère C
  • o - Sortie TOS, caractère C
  • @ - Mettre fin au programme

• Char D: Si le premier Dnous envoie au sud, ce qui suit est exécuté:

  • i - Prenez une autre entrée, caractère B
  • .. - Deux no-ops
  • i - Prenez une autre entrée, caractère C
  • | - Ce miroir reflète l'est-ouest, mais l'IP se dirige vers le nord, nous le traversons donc.
  • ^ - Cela rejoint le chemin emprunté pour le caractère B. Cependant, comme nous avons déjà pris deux entrées, le quatrième caractère (caractère D) finira par être imprimé.

Python , 50 octets

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

Une fonction sans nom prenant et renvoyant des chaînes (ou des listes de caractères).

Essayez-le en ligne!

Comment?

random.choicechoisit un élément aléatoire dans une liste, de sorte que la fonction forme une chaîne avec la distribution correcte, c'est-à-dire donnée "ABCD", "ABCD"[:2] = "AB"plus "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"qui l'est "ABBCDBCD".

R , 31 octets

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

Lit les caractères stdinséparés par des espaces. sampletire des échantillons aléatoires de sa première entrée en quantité de la deuxième entrée (so 1), (argument de remplacement facultatif), avec des poids donnés par le dernier argument.

Essayez-le en ligne!

Essayez-le nfois!

Pour ce dernier code, j'échantillonne les ntemps (définis ndans l'en-tête) avec remplacement défini sur True (c'est faux par défaut), tabule les résultats et divise par npour voir les probabilités relatives des entrées.

PHP, 28 octets

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

Exécuter en tant que tuyau avec -nR.

01112233en base 4 est 5551en décimal ...

Java 8, 53 44 octets

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

Ceci est un Function<char[], Character>.

Essayez-le en ligne! (ce programme de test exécute la fonction ci - dessus 1.000.000 fois et fournit les probabilités expérimentales de choisir A, B, Cet D).

L'idée générale est de trouver un moyen de la carte 0-7à 0-3, de sorte que 0semble 1/8fois, 1semble 3/8fois, 2semble 2/8fois, et 3apparaît 2/8fois. round(abs(k - 6) / 2.0))fonctionne pour cela, où kest un entier aléatoire dans la plage [0,8). Il en résulte le mappage suivant:

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

Qui, comme vous pouvez le voir, les résultats des indices 0 111 22 33, qui produit les probabilités souhaitées de 1/8, 3/8, 2/8et 2/8.

Mais attendez! Comment dans le monde -~Math.abs(k-6)/2obtient-on le même résultat (encore une fois, où kest un entier aléatoire dans la plage [0,8])? C'est assez simple en fait ... (x+1)/2(division entière) est la même chose que round(x/2), et x + 1c'est la même chose que -~x. Bien que x+1et -~xsoient de la même longueur, dans la fonction ci-dessus, il est préférable d'utiliser -~xcar il -~a la priorité et ne nécessite donc pas de parenthèses.

APL, 14 octets

(?8)⊃1 3 2 2\⊢

Entrez sous forme de chaîne.

Comment?

1 3 2 2\⊢- répéter chaque lettre x fois ( 'ABCD'→ 'ABBBCCDD')

⊃ - prendre l'élément à l'index ..

(?8) - aléatoire 1-8

Fusain , 11 octets

‽⟦εεζζηηηθ⟧

Essayez-le en ligne! Le lien est vers une version détaillée du code, bien que vous n'en ayez pas besoin; ‽choisit un élément aléatoire, ⟦⟧crée une liste et les variables sont celles qui obtiennent les lettres d'entrée appropriées (dans l'ordre inverse parce que j'en avais envie).

Pyth , 8 7 octets

O+@Q1t+

Utilise exactement le même algorithme que dans ma réponse Python.

Essayez-le ici!

Pyth , 10 8 octets

O+<Q2*2t

Utilise exactement le même algorithme que la réponse Python de Jonathan Allan.

Essayez-le ici!

Explication

• O- Prend un élément aléatoire de la chaîne faite en ajoutant (avec +):

  • <Q2 - Les deux premiers caractères de la chaîne.
  • *2tDoublez la chaîne complète ( *2) à l'exception du premier caractère ( t).

Appliquer cet algorithme pour ABCD:

• <Q2prend AB.
• *2tprend BCDet double il: BCDBCD.
• +joint les deux chaînes: ABBCDBCD.
• O prend un caractère aléatoire.

-2 grâce à Leaky Nun (deuxième solution)

-1 grâce au mnémonique (première solution)

Gelée , 8 octets

122b4⁸xX

Essayez-le en ligne!

Retirez le Xpour voir "ABBBCCDD". Le Xchoisit un élément aléatoire.

C # (.NET Core) , 76 55 octets

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

Essayez-le en ligne!

Ma première réponse écrite directement sur TIO à l'aide de mon téléphone portable. Niveau supérieur!

Explication: si la chaîne d'origine est "ABCD", la fonction crée la chaîne "ABCDBBCD" et en prend un élément aléatoire.

Javascript 35 octets

Prend une chaîne ABCDen entrée, sort A1 / 8ème du temps, B3 / 8ème du temps, C1 / 4ème du temps et D1 / 4ème du temps.

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

Explication

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 octets

¦Ćì.R

Essayez-le en ligne!

Explication

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

i_ixio;o
ox</;
;\$o

Essayez-le en ligne! , ou regardez-le au terrain de pêche !

Un bref aperçu de> <>: c'est un langage 2D avec un poisson qui nage dans le code, exécutant les instructions au fur et à mesure. S'il atteint le bord du code, il passe de l'autre côté. Le poisson commence dans le coin supérieur gauche, se déplaçant vers la droite. L'aléatoire est délicat dans> <>: la seule instruction aléatoire est x, qui définit la direction du poisson de manière aléatoire en haut, en bas, à gauche et à droite (avec une probabilité égale).

Au début du programme, le poisson lit deux caractères d'entrée avec i_i(chacun ilit un caractère de STDIN dans la pile, et _est un miroir horizontal, que le poisson ignore maintenant). Il atteint alors un x.

Si le xenvoie le poisson vers la droite, il lit un caractère de plus (le troisième), l'imprime avec oet s'arrête avec ;. La direction de gauche est similaire: le poisson lit deux autres caractères (nous en sommes donc au quatrième), s'enroule vers la droite, imprime le quatrième caractère et s'arrête. Si le poisson nage, il enveloppe et imprime le deuxième caractère, avant d'être réfléchi /et de s'arrêter. S'il nage, il est réfléchi par le /et en frappe un autre x.

Cette fois, deux directions renvoient le poisson vers la xdroite (avec une flèche <, et vers le haut avec un miroir _). Le poisson a donc 1/2 chance de s'en échapper xdans chacune des deux autres directions. Imprime vers la gauche le premier caractère de la pile, qui est le second, mais vers le bas permute d'abord les deux éléments de la pile $, donc cette direction imprime le premier caractère.

En résumé, les troisième et quatrième caractères sont imprimés avec une probabilité 1/4 chacun; le premier caractère a une probabilité 1/2 x 1/4 = 1/8; et le deuxième caractère a une probabilité 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 octets

ìD1è0ǝ.R

Essayez-le en ligne!

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

l3HHvY"1Zr

Essayez-le en ligne! Ou exécutez-le 1000 fois (code légèrement modifié) et vérifiez le nombre de fois que chaque caractère apparaît.

Explication

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

Changements dans le code modifié: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]est une boucle pour répéter les 1000temps.
• G s'assure que l'entrée est poussée au début de chaque itération.
• Les résultats sont accumulés sur la pile à travers les itérations. Doit donc vêtre remplacé par 4$vpour ne concaténer que les premiers 4chiffres.
• À la fin de la boucle, vconcatène les 1000résultats dans un vecteur, le Strie et l' Y'encode en longueur. Cela donne les quatre lettres et le nombre de fois qu'elles sont apparues.

05AB1E , 6 octets

«À¨Ć.R

Essayez-le en ligne!

Explication

Fonctionne pour les listes et les chaînes.

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

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

Essayez-le en ligne!

Rubis, 34 33 29 27 octets

Sauvegardé 2 octets grâce à @Value Inc

Saisissez quatre caractères

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

construire un tableau [B,B,C,D,A,B,C,D]et l'échantillonner.

essayez-le en ligne!

essayez-le nfois! (Je l'ai converti en fonction pour le répéter plus facilement, mais l'algorithme est le même)

Pyth, 7 octets

@z|O8 1

Suite de tests

O8génère un nombre aléatoire de 0 à 7. | ... 1applique une logique ou avec 1, convertissant le 0 en 1 et laissant tout le reste identique. Le nombre à ce stade est 1 2 / 8ème du temps et 2, 3, 4, 5, 6, 7 ou 8 1/8 du temps.

@zindexe dans la chaîne d'entrée à cette position. L'indexation est effectuée modulo la longueur de la chaîne, donc 4 index en position 0, 5 en position 1, etc.

Les probabilités sont:

• Position 0: numéro aléatoire 4. 1/8 du temps.

• Position 1: numéro aléatoire 0, 1 ou 5. 3/8 du temps.

• Position 2: numéro aléatoire 2 ou 6. 2/8 du temps.

• Position 3: numéro aléatoire 3 ou 7. 2/8 du temps.

Javascript, 31 30 octets / 23 octets

En voyant la réponse Javascript antérieure d'Asgallant, j'ai pensé à JS. Comme il dit:

Prend une chaîne ABCDen entrée, sort A1 / 8ème du temps, B 3 / 8ème du temps, C1 / 4ème du temps et D1 / 4ème du temps.

Le mien est:

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

Explication:

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&7cela se décompose comme suit:

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)

Version 2, 23 octets

Mais merci à Arnauld, qui a posté après moi, quand il a dit:

Si une formule dépendante du temps est autorisée, nous pouvons simplement faire:

ce qui, si c'est effectivement permis, m'a conduit à:

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

dans lequel new Date%8utilise le même tableau de répartition que ci-dessus.

Et %8pourrait aussi être &7; faites votre choix. Merci encore, Arnauld.

ngn / apl, 10 octets

⎕a [⌈ /? 2 4]

?2 4 choisit au hasard une paire de nombres - le premier parmi 0 1 et le second parmi 0 1 2 3

⌈/ est "max réduire" - trouver le plus grand nombre

⎕a est l'alphabet majuscule

[ ] indexage

notez le tableau pour max (a, b) lorsque a∊ {0,1} et 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 et b sont choisis au hasard et indépendamment, nous pouvons substituer 0123 = ABCD pour obtenir la distribution de probabilité souhaitée

Python 3 , 64 55 51 octets

-9 octets grâce à @ovs

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

Essayez-le en ligne!

Explication

random.choice()obtient un caractère aléatoire de la chaîne, tandis que (s*2)[1:]+s[1]crée BCDABCDBpour une entrée de ABCD, qui a 1/8 As, 2/8 Cs, 2/8 Ds et 3/8 Bs.

QBIC , 27 octets

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

Explication

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

v
!

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

Essayez-le en ligne!

Puce , 60 octets

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

Essayez-le en ligne!

Les trois ?produisent chacun un bit aléatoire. Au premier cycle, ces bits sont exécutés via les commutateurs ci-dessus ( /«et \») pour déterminer la valeur que nous allons sortir de ce tableau:

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

(où _peut être soit 0ou 1). Nous parcourons ensuite l'entrée si nécessaire, imprimons et terminons lorsque la valeur correcte est atteinte.

Le gros blob alphabétique à la fin est copié en gros à partir du programme cat, cette solution supprime simplement la sortie et se termine pour obtenir l'effet souhaité.

Rubis, 32 octets

Assez simple..?

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

Essayez-le en ligne!

Applesoft, 29 oops, 32 octets

Un petit exemple de "retrocomputing". Restez avec moi, je suis tout nouveau dans ce domaine. Je suppose que ce qui est désigné comme "entrée" n'a pas besoin d'être compté lui-même. Comme indiqué dans le PO, l'entrée serait donnée comme "ABCD". (Je n'avais pas réalisé au départ que je devais spécifier l'entrée obtenue, qui ajoutait 4 octets, tandis que je jouais le reste sur un octet.)

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

Les termes INPUT, RND, PRINT et MID $ sont chacun codés en interne sous forme de jetons à un octet.

Tout d'abord, X se voit attribuer une valeur aléatoire dans la plage 0 <X <4. Ceci est utilisé pour choisir l'un des caractères parmi I $, selon (X <.5) + X + 1. La valeur de position du caractère est prise évaluation tronquée de l'expression. X <0,5 ajoute 1 si X était inférieur à 0,5, sinon ajoutez 0. Les résultats de X se décomposent comme suit:

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 commun , 198 octets

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

Essayez-le en ligne!

Lisible:

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