Mal sehen, wie gut Ihre bevorzugte Sprache bei selektiver Zufälligkeit ist.

Gegeben 4 Zeichen, A, B, C, und D, oder eine Kette von 4 Zeichen ABCD als Eingabe , Ausgabe eines des Zeichens mit den folgenden Wahrscheinlichkeiten:

• A sollte eine Chance von 1/8 (12,5%) haben, gewählt zu werden
• B sollte eine 3/8 (37,5%) Chance haben, gewählt zu werden
• C sollte eine 2/8 (25%) Chance haben gewählt zu werden
• D sollte eine 2/8 (25%) Chance haben gewählt zu werden

Dies entspricht dem folgenden Plinko- Maschinenlayout:

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

Ihre Antwort muss einen echten Versuch machen, die beschriebenen Wahrscheinlichkeiten zu respektieren. Es reicht aus, zu erklären, wie Wahrscheinlichkeiten in Ihrer Antwort berechnet werden (und warum sie die Spezifikationen einhalten, wobei Pseudozufälligkeiten und Probleme mit großen Zahlen unberücksichtigt bleiben).

Wertung

Dies ist Codegolf, so dass die wenigsten Bytes in jeder Sprache gewinnen!

Lean Mean Bean Machine , 55 43 42 Bytes

-13 Bytes dank Alex Varga

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

Ich hoffe, dass es euch nichts ausmacht, wenn ich meine Frage nach nur 2 Stunden beantworte, aber ich bezweifle, dass jemand anderes vorhatte, eine Antwort in LMBM zu veröffentlichen.

Dies spiegelt im wahrsten Sinne des Wortes nur das im OP gezeigte Plinko-Layout wider, das horizontal gespiegelt wird, um unnötige Leerzeichen zu reduzieren.

Gelee , 6 Bytes

Ḋṁ7;ḢX

Ein monadischer Link, der eine Liste mit vier Zeichen erstellt und eines mit der beschriebenen Wahrscheinlichkeitsverteilung zurückgibt.

Probieren Sie es online!

Wie?

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

Im Online-Dolmetscher ansehen!

Dies wird dem folgenden Würfelnetz zugeordnet:

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

Random Distribution Implementation Erklärung

Cubix ist eine Sprache, in der ein Anweisungszeiger die Flächen eines Cubes umkreist und die Befehle ausführt, auf die er stößt. Die einzige Form der Zufälligkeit ist der Befehl D, der die IP in eine zufällige Richtung sendet: eine gleiche Chance für 1/4jeden Weg.

Wir können dies jedoch verwenden, um die richtig gewichteten Wahrscheinlichkeiten zu generieren: durch Dzweimalige Verwendung . Die erste Dhat eine 1/4Überschrift zu einer zweiten D. In dieser Sekunde Dsind jedoch zwei Richtungen mit Pfeilen ( > D <) blockiert, die den Befehlszeiger zurück an senden D, um eine andere Richtung zu wählen. Dies bedeutet, dass es von dort aus nur zwei mögliche Richtungen gibt, von denen jede eine 1/8allgemeine Chance hat. Dies kann verwendet werden, um das richtige Zeichen zu generieren, wie in der folgenden Abbildung gezeigt:

(Beachten Sie, dass im aktuellen Code der Pfeil rechts durch einen Spiegel ersetzt wird. |)

Code-Erklärung

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

Der Anweisungszeiger beginnt rechts neben dem Zeichen iund zeigt nach rechts. Dies wird ausgeführt i, wobei das erste Zeichen als Eingabe verwendet wird. Anschließend wird der Doben gezeigte Zufallsprozess gestartet.

• Char A: In dem Fall, dass der erste Duns nach Osten und der zweite nach Süden schickt, müssen wir das Zeichen A drucken. Dies ist bereits auf dem Stapel des ersten i. Folgendes wird ausgeführt:

  • \ - Reflektiere die IP so, dass sie nach Osten geht
  • i; - Nimm eine Eingabe und lege sie erneut ab (no-op)
  • U - Führen Sie eine Kehrtwende durch und drehen Sie die IP zweimal nach links
  • o - Geben Sie die TOS aus, Zeichen A
  • @ - Beenden Sie das Programm

• DZeichen B: Wenn entweder das erste oder das zweite Zeichen nach Norden zeigt, müssen wir das Zeichen B erzeugen, das die nächste Eingabe sein wird. Beide Pfade führen die folgenden Befehle aus:

  • ^ - Richtung Norden
  • < - Gehen Sie nach Westen und wickeln Sie sich um ...
  • i - Nehmen Sie eine andere Eingabe, Zeichen B
  • o - Geben Sie die TOS aus, Zeichen B
  • ; - Pop die AGB
  • @ - Beenden Sie das Programm

• Char C: Wenn der erste Duns nach Westen schickt, wird folgendes ausgeführt:

  • i - Nehmen Sie eine andere Eingabe, Zeichen B
  • i - Nehmen Sie eine andere Eingabe, Zeichen C
  • o - Ausgabe TOS, Zeichen C
  • @ - Beenden Sie das Programm

• Char D: Wenn der erste Duns nach Süden schickt, wird folgendes ausgeführt:

  • i - Nehmen Sie eine andere Eingabe, Zeichen B
  • .. - Zwei No-Ops
  • i - Nehmen Sie eine andere Eingabe, Zeichen C
  • | - Dieser Spiegel reflektiert Ost-West, aber die IP geht nach Norden, also passieren wir ihn.
  • ^ - Dies hängt mit dem Pfad für Zeichen B zusammen. Da wir jedoch bereits zwei Eingaben vorgenommen haben, wird das vierte Zeichen (Zeichen D) gedruckt.

Python , 50 Bytes

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

Eine unbenannte Funktion, die Zeichenfolgen (oder Listen von Zeichen) aufnimmt und zurückgibt.

Probieren Sie es online!

Wie?

random.choiceWählt ein zufälliges Element aus einer Liste aus, so bildet die Funktion einen String mit der richtigen Verteilung, dh gegeben "ABCD", "ABCD"[:2] = "AB"plus "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"was ist "ABBCDBCD".

R , 31 Bytes

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

Liest die Zeichen von stdindurch Leerzeichen getrennten. sampleZeichnet Zufallsstichproben aus der ersten Eingabe in der Menge der zweiten Eingabe (so 1) (optionales Ersetzungsargument), wobei die Gewichtung durch das letzte Argument angegeben wird.

Probieren Sie es online!

Probiere es nmal aus!

Für den letzteren Code probiere ich die nZeiten aus ( nin der Kopfzeile festgelegt), wobei die Ersetzung auf True festgelegt ist (standardmäßig ist sie falsch), tabelliere die Ergebnisse und dividiere durch n, um die relativen Wahrscheinlichkeiten der Eingaben zu sehen.

PHP, 28 Bytes

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

Als Rohr mit laufen lassen -nR.

01112233in der Basis 4 ist 5551in Dezimalzahl ...

Java 8, 53 44 Bytes

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

Das ist ein Function<char[], Character>.

Probieren Sie es online! (Dieses Testprogramm läuft die obige Funktion 1.000.000mal und gibt die experimentellen Wahrscheinlichkeiten des Wählens A, B, C, und D).

Die allgemeine Idee ist , einen Weg zu finden , um Karte 0-7zu 0-3, so dass 0erscheinen 1/8Zeiten, 1erscheinen 3/8mal, 2erscheinen 2/8Zeiten und 3erscheint 2/8mal. round(abs(k - 6) / 2.0))funktioniert dafür, wobei keine zufällige ganze Zahl im Bereich ist [0,8). Daraus ergibt sich folgende Zuordnung:

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

Die, wie Sie sehen können, Ergebnisse in den Indizes 0 111 22 33, die die gewünschten Wahrscheinlichkeiten erzeugt 1/8, 3/8, 2/8und 2/8.

Aber warte! Wie -~Math.abs(k-6)/2um alles in der Welt wird das gleiche Ergebnis erzielt (wieder, wo kist eine zufällige ganze Zahl im Bereich [0,8])? Es ist eigentlich ziemlich einfach ... (x+1)/2(Ganzzahlige Division) ist dasselbe wie round(x/2)und x + 1ist dasselbe wie -~x. Obwohl x+1und -~xgleich lang sind, ist es in der obigen Funktion besser, sie zu verwenden, -~xda sie -~Vorrang hat und daher keine Klammern erfordert.

APL, 14 Bytes

(?8)⊃1 3 2 2\⊢

Eingabe als String.

Wie?

1 3 2 2\⊢- Wiederhole jeden Buchstaben x mal ( 'ABCD'→ 'ABBBCCDD')

⊃ - nimm das Element am Index ..

(?8) - zufällig 1-8

Holzkohle , 11 Bytes

‽⟦εεζζηηηθ⟧

Probieren Sie es online! Der Link ist eine ausführliche Version des Codes, obwohl Sie ihn kaum brauchen. ‽wählt ein zufälliges Element aus, ⟦⟧erstellt eine Liste und die Variablen sind diejenigen, die die entsprechenden Eingabebuchstaben erhalten (in umgekehrter Reihenfolge, weil ich Lust dazu hatte).

Pyth , 8 7 Bytes

O+@Q1t+

Verwendet den exakt gleichen Algorithmus wie in meiner Python-Antwort.

Probieren Sie es hier aus!

Pyth , 10 8 Bytes

O+<Q2*2t

Verwendet den exakt gleichen Algorithmus wie Jonathan Allans Python-Antwort.

Probieren Sie es hier aus!

Erläuterung

• O- Nimmt ein zufälliges Element des Strings, das durch Anhängen (mit +) erstellt wurde:

  • <Q2 - Die ersten beiden Zeichen der Zeichenfolge.
  • *2tVerdoppeln Sie den gesamten String ( *2) mit Ausnahme des ersten Zeichens ( t).

Anwendung dieses Algorithmus für ABCD:

• <Q2nimmt AB.
• *2tnimmt BCDund verdoppelt sie: BCDBCD.
• +verbindet die beiden Strings: ABBCDBCD.
• O nimmt ein zufälliges Zeichen.

-2 dank Leaky Nun (zweite Lösung)

-1 dank Mnemonik (erste Lösung)

Gelee , 8 Bytes

122b4⁸xX

Probieren Sie es online!

Entfernen Sie die, um Xzu sehen "ABBBCCDD". Der Xwählt ein zufälliges Element.

C # (.NET Core) , 76-55 Byte

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

Probieren Sie es online!

Meine erste Antwort wurde direkt auf TIO mit meinem Handy geschrieben. Aufleveln!

Erläuterung: Wenn die ursprüngliche Zeichenfolge "ABCD" ist, erstellt die Funktion die Zeichenfolge "ABCDBBCD" und entnimmt ihr ein zufälliges Element.

Javascript 35 Bytes

Nimmt einen String ABCDals Eingabe gibt A1/8 - tel der Zeit, B3 / 8ths die Zeit, C1/4 der Zeit, und die D1/4 der Zeit.

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

Erläuterung

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online! , oder schau es dir auf dem Fischspielplatz an !

Ein kurzer Überblick über> <>: Es ist eine 2D-Sprache mit einem Fisch, der durch den Code schwimmt und dabei Anweisungen ausführt. Wenn es den Rand des Codes erreicht, wird es auf die andere Seite umgebrochen. Der Fisch beginnt in der oberen linken Ecke und bewegt sich nach rechts. Zufälligkeit ist schwierig in> <>: Die einzige zufällige Anweisung ist x, die die Richtung des Fisches zufällig (mit gleicher Wahrscheinlichkeit) nach oben, unten, links und rechts festlegt.

Zu Beginn des Programms liest der Fisch zwei Zeichen der Eingabe mit ein i_i(jedes iliest ein Zeichen von STDIN auf den Stapel und _ist ein horizontaler Spiegel, den der Fisch jetzt ignoriert). Es erreicht dann eine x.

Wenn der xFisch nach rechts schickt, liest er ein weiteres Zeichen (das dritte) ein, druckt es mit ound hält mit an ;. Die linke Richtung ist ähnlich: Der Fisch liest zwei weitere Zeichen (also sind wir bis zum vierten), dreht sich nach rechts, druckt das vierte Zeichen und hält an. Wenn der Fisch hochschwimmt, wird das zweite Zeichen eingewickelt und gedruckt, bevor es direkt reflektiert /und angehalten wird. Wenn es nach unten schwimmt, wird es von der reflektiert /und trifft eine andere x.

Diesmal schicken zwei Richtungen den Fisch einfach zurück nach x(rechts mit einem Pfeil <und oben mit einem Spiegel _). Der Fisch hat also eine halbe Chance, xin jede der beiden anderen Richtungen zu entkommen . Nach links druckt das oberste Zeichen des Stapels, das zweite, nach unten tauscht jedoch zuerst die beiden Elemente des Stapels aus $, sodass in dieser Richtung das erste Zeichen gedruckt wird.

Zusammenfassend werden das dritte und vierte Zeichen jeweils mit einer Wahrscheinlichkeit von 1/4 gedruckt; das erste Zeichen hat eine Wahrscheinlichkeit von 1/2 x 1/4 = 1/8; und das zweite Zeichen hat eine Wahrscheinlichkeit von 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 Bytes

ìD1è0ǝ.R

Probieren Sie es 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

Probieren Sie es online! Oder führen Sie es 1000 Mal aus (geringfügig geänderter Code) und überprüfen Sie, wie oft jedes Zeichen angezeigt wird.

Erläuterung

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

Änderungen im geänderten Code: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]ist eine Schleife, um die 1000Zeiten zu wiederholen .
• G Stellt sicher, dass die Eingabe zu Beginn jeder Iteration verschoben wird.
• Die Ergebnisse werden über Iterationen hinweg auf dem Stapel gesammelt. So vmuss ersetzt werden durch4$v , nur die Spitze zu verketten 4Zahlen.
• vVerkettet die 1000Ergebnisse am Ende der Schleife zu einem Vektor, Ssortiert sie und Y'codiert sie mit Lauflänge. Dies gibt die vier Buchstaben und die Häufigkeit an, mit der sie aufgetreten sind.

05AB1E , 6 Bytes

«À¨Ć.R

Probieren Sie es online!

Erläuterung

Funktioniert sowohl für Listen als auch für Strings.

«       # 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 bis 49 Bytes

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

Probieren Sie es online!

Ruby, 34 33 29 27 Bytes

2 Bytes gespart dank @Value Inc

Eingabe als vier Zeichen

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

konstruiere ein Array [B,B,C,D,A,B,C,D]und probiere es aus.

versuche es online!

versuch es nmal! (Ich habe es in eine Funktion konvertiert, um es einfacher zu wiederholen, aber der Algorithmus ist der gleiche)

Pyth, 7 Bytes

@z|O8 1

Testsuite

O8generiert eine Zufallszahl von 0 bis 7. | ... 1Wendet ein logisches oder mit 1 an, wandelt die 0 in eine 1 um und lässt alles andere gleich. Die Zahl in diesem Stadium ist 1 2/8 der Zeit und 2, 3, 4, 5, 6, 7 oder 8 1/8 der Zeit.

@zIndexiert an dieser Position in die Eingabezeichenfolge. Die Indizierung erfolgt modulo über die Länge des Strings, also 4 Indizes an Position 0, 5 an Position 1 und so weiter.

Die Wahrscheinlichkeiten sind:

• Position 0: Zufallszahl 4. 1/8 der Zeit.

• Position 1: Zufallszahl 0, 1 oder 5. 3/8 der Zeit.

• Position 2: Zufallszahl 2 oder 6. 2/8 der Zeit.

• Position 3: Zufallszahl 3 oder 7. 2/8 der Zeit.

Javascript, 31 30 Bytes / 23 Bytes

Als ich die frühere Javascript-Antwort von Asgallant sah, musste ich über JS nachdenken. Wie er sagte:

Nimmt einen String ABCDals Eingabe gibt A1/8 - tel der Zeit, B 3 / 8ths die Zeit, C1/4 der Zeit, und die D1/4 der Zeit.

Meins ist:

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

Erläuterung:

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
        ]

Daraus Math.random()*8&7gliedert sich wie folgt:

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 Bytes

Aber dann danke an Arnauld, der nach mir gepostet hat, als er sagte:

Wenn eine zeitabhängige Formel zulässig ist, können wir einfach Folgendes tun:

was mich, wenn es tatsächlich erlaubt ist, zu folgendem geführt hat:

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

in welchem new Date%8 dem dieselbe Aufschlüsselungstabelle wie oben verwendet wird.

Und %8könnte auch sein &7; Treffen Sie Ihre Wahl. Nochmals vielen Dank, Arnauld.

ngn / apl, 10 Bytes

⎕a [⌈ /? 2 4]

?2 4 wählt zufällig ein Zahlenpaar - das erste unter 0 1 und das zweite unter 0 1 2 3

⌈/ ist "max redu" - finde die größere Zahl

⎕a ist das Großbuchstaben

[ ] Indizierung

Beachten Sie die Tabelle für max (a, b), wenn a∊ {0,1} und 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 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

Wenn a und b zufällig und unabhängig voneinander ausgewählt werden, können wir 0123 = ABCD einsetzen, um die gewünschte Wahrscheinlichkeitsverteilung zu erhalten

Python 3 , 64 55 51 Bytes

-9 Bytes dank @ovs

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

Probieren Sie es online!

Erläuterung

random.choice()bekommt ein zufälliges Zeichen des Strings, während (s*2)[1:]+s[1]schafft BCDABCDBfür einen Eingang ABCD, die 1/8 hat As, 2/8 Cs, 2/8 Ds und 3/8 Bs.

QBIC , 27 Bytes

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

Erläuterung

?           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

Probieren Sie es online!

Chip , 60 Bytes

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

Probieren Sie es online!

Die drei ?erzeugen jeweils ein zufälliges Bit. Im ersten Zyklus durchlaufen diese Bits die Schalter oben ( /'s und \' s), um zu bestimmen, welchen Wert wir aus dieser Tabelle ausgeben wollen:

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

(wo _kann entweder 0oder sein1 ). Wir gehen dann nach Bedarf die Eingabe entlang und drucken und beenden, wenn der richtige Wert erreicht ist.

Der große alphabetische Blob am Ende wird aus dem cat-Programm kopiert. Diese Lösung unterdrückt einfach die Ausgabe und wird beendet, um den beabsichtigten Effekt zu erzielen.

Ruby, 32 Bytes

Ziemlich einfach..?

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

Probieren Sie es online!

AppleSoft, 29 Oops, 32 Bytes

Ein kleines "Retrocomputing" -Beispiel. Tragen Sie mit mir, ich bin diesbezüglich brandneu. Ich verstehe, dass das, was als "Eingang" bezeichnet wird, nicht selbst gezählt werden muss. Wie im OP angegeben, würde der Eingang als "ABCD" angegeben. (Anfangs war mir nicht klar, dass ich angeben musste, welche Eingabe erhalten werden soll, was 4 Bytes hinzufügte, während ich den Rest ein Byte lang spielte.)

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

Die Begriffe INPUT, RND, PRINT und MID $ werden jeweils intern als Einzelbyte-Token codiert.

Zunächst wird X ein Zufallswert im Bereich 0 <X <4 zugewiesen. Mit diesem Wert wird eines der Zeichen aus I $ gemäß (X <.5) + X + 1 ausgewählt. Der Wert für die Zeichenposition wird als verwendet abgeschnittene Auswertung des Ausdrucks. X <.5 addiert 1, wenn X kleiner als .5 war, andernfalls addiere 0. Die Ergebnisse von X teilen sich wie folgt auf:

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

Probieren Sie es online!

Lesbar:

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