Chúng ta hãy xem ngôn ngữ lựa chọn của bạn tốt như thế nào ở sự ngẫu nhiên có chọn lọc.

Với 4 nhân vật, A, B, C, và D, hoặc một chuỗi 4 ký tự ABCD như là đầu vào , một đầu ra của các nhân vật với các xác suất sau:

• A nên có cơ hội 1/8 (12,5%) để được chọn
• B nên có cơ hội 3/8 (37,5%) để được chọn
• C nên có cơ hội 2/8 (25%) để được chọn
• D nên có cơ hội 2/8 (25%) để được chọn

Điều này phù hợp với cách bố trí máy Plinko sau :

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

Câu trả lời của bạn phải thực hiện một nỗ lực đích thực trong việc tôn trọng các xác suất được mô tả. Một lời giải thích phù hợp về cách xác suất được tính toán trong câu trả lời của bạn (và tại sao họ tôn trọng thông số kỹ thuật, coi nhẹ giả ngẫu nhiên và các vấn đề về số lượng lớn) là đủ.

Chấm điểm

Đây là môn đánh gôn để có ít byte nhất trong mỗi ngôn ngữ !

Máy đậu trung bình Lean , 55 43 42 byte

-13 byte nhờ Alex Varga

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

Hy vọng các bạn không phiền tôi trả lời câu hỏi của riêng tôi chỉ sau 2 giờ, nhưng tôi rất nghi ngờ bất kỳ ai khác đang lên kế hoạch đăng câu trả lời trong LMBM.

Điều này theo nghĩa đen chỉ phản ánh bố cục Plinko được hiển thị trong OP, lật theo chiều ngang để cắt giảm khoảng trắng không cần thiết.

Thạch , 6 byte

Ḋṁ7;ḢX

Một liên kết đơn âm lấy một danh sách gồm bốn ký tự và trả về một ký tự có phân phối xác suất được mô tả.

Hãy thử trực tuyến!

Làm sao?

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

Xem trong phiên dịch trực tuyến!

Điều này ánh xạ ra mạng lưới khối sau:

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

Giải thích thực hiện phân phối ngẫu nhiên

Cubix là một ngôn ngữ trong đó một con trỏ lệnh di chuyển xung quanh các mặt của khối lập phương, thực hiện các lệnh mà nó gặp phải. Hình thức ngẫu nhiên duy nhất là lệnh D, sẽ gửi IP theo hướng ngẫu nhiên: cơ hội như nhau của 1/4mỗi cách.

Tuy nhiên, chúng ta có thể sử dụng điều này để tạo ra các xác suất có trọng số chính xác: bằng cách sử dụng Dhai lần. Đầu tiên Dcó một 1/4tiêu đề đến một giây D. DTuy nhiên, thứ hai này có hai hướng bị chặn bằng mũi tên ( > D <) sẽ gửi con trỏ lệnh trở lại Dđể chọn hướng khác. Điều này có nghĩa là chỉ có hai hướng có thể từ đó, mỗi hướng có 1/8cơ hội tổng thể xảy ra. Điều này có thể được sử dụng để tạo ra ký tự chính xác, như thể hiện trong sơ đồ dưới đây:

(Lưu ý rằng, trong mã thực tế, mũi tên bên phải được thay thế bằng gương, |)

Giải thích mã

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

Con trỏ lệnh bắt đầu ở bên phải, tại ký tự i, phải đối mặt với bên phải. Nó thực thi điều này i, lấy ký tự đầu tiên làm đầu vào, sau đó di chuyển lên D, bắt đầu quá trình ngẫu nhiên được hiển thị ở trên.

• Char A: Trong trường hợp cái đầu tiên Dgửi cho chúng ta về phía đông và phía nam thứ hai, chúng ta cần in ký tự A. Cái này đã có trên stack từ cái đầu tiên i. Sau đây được thực hiện:

  • \ - Phản ánh IP để nó đi về hướng đông
  • i; - Lấy một đầu vào, sau đó bật lại (no-op)
  • U - Thực hiện quay đầu, xoay IP trái hai lần
  • o - Xuất ra ĐKDV, ký tự A
  • @ - Chấm dứt chương trình

• Char B: Nếu đầu thứ nhất hoặc thứ hai Dở phía bắc, chúng ta cần tạo ký tự B, đây sẽ là đầu vào tiếp theo. Cả hai đường dẫn thực hiện các lệnh sau:

  • ^ - Đi về hướng Bắc
  • < - Đi về phía tây, vòng đến ...
  • i - Lấy một đầu vào khác, ký tự B
  • o - Xuất ra ĐKDV, ký tự B
  • ; - Bật ĐKDV
  • @ - Chấm dứt chương trình

• Char C: Nếu người đầu tiên Dgửi cho chúng tôi về phía tây, việc sau được thực hiện:

  • i - Lấy một đầu vào khác, ký tự B
  • i - Lấy một đầu vào khác, ký tự C
  • o - Đầu ra Tosh, ký tự C
  • @ - Chấm dứt chương trình

• Char D: Nếu người đầu tiên Dgửi chúng tôi về phía nam, việc sau được thực hiện:

  • i - Lấy một đầu vào khác, ký tự B
  • .. - Hai no-op
  • i - Lấy một đầu vào khác, ký tự C
  • | - Chiếc gương này phản chiếu hướng đông tây, nhưng IP đang hướng về phía bắc, vì vậy chúng tôi đi qua nó.
  • ^ - Điều này kết hợp với đường dẫn dành cho ký tự B. Tuy nhiên, vì chúng ta đã lấy hai đầu vào rồi, ký tự thứ tư (ký tự D) cuối cùng sẽ được in.

Python , 50 byte

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

Một hàm không tên lấy và trả về chuỗi (hoặc danh sách các ký tự).

Hãy thử trực tuyến!

Làm sao?

random.choicechọn một phần tử ngẫu nhiên từ một danh sách, do đó, hàm tạo thành một chuỗi với phân phối chính xác, nghĩa là đã cho "ABCD", "ABCD"[:2] = "AB"cộng với "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"đó là "ABBCDBCD".

R , 31 byte

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

Đọc các ký tự stdincách nhau bởi khoảng trắng. samplelấy các mẫu ngẫu nhiên từ đầu vào đầu tiên của nó về số lượng của đầu vào thứ hai (vì vậy 1), (đối số thay thế tùy chọn), với các trọng số được đưa ra bởi đối số cuối cùng.

Hãy thử trực tuyến!

Hãy thử nó nlần!

Đối với mã sau, tôi lấy mẫu nthời gian (được đặt ntrong tiêu đề) với thay thế được đặt thành True (theo mặc định là sai), lập bảng kết quả và chia ncho để xem xác suất tương đối của các đầu vào.

PHP, 28 byte

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

Chạy như ống với -nR.

01112233trong cơ sở 4 là 5551số thập phân ...

Java 8, 53 44 byte

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

Đây là một Function<char[], Character>.

Hãy thử trực tuyến! (chương trình thử nghiệm này chạy các chức năng trên 1.000.000 lần và kết quả đầu ra xác suất thực nghiệm lựa chọn A, B, C, và D).

Ý tưởng chung ở đây là để tìm thấy một số cách để ánh xạ 0-7tới 0-3, như vậy mà 0xuất hiện 1/8lần, 1xuất hiện 3/8lần, 2xuất hiện 2/8lần, và 3xuất hiện 2/8lần. round(abs(k - 6) / 2.0))làm việc cho điều này, trong đó kmột số nguyên ngẫu nhiên trong phạm vi [0,8). Điều này dẫn đến ánh xạ sau:

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

Trong đó, như bạn có thể thấy, kết quả trong các chỉ số 0 111 22 33, trong đó sản xuất các xác suất mong muốn của 1/8, 3/8, 2/8và 2/8.

Nhưng chờ đã! Làm thế nào trên thế giới -~Math.abs(k-6)/2đạt được kết quả tương tự (một lần nữa, kmột số nguyên ngẫu nhiên trong phạm vi [0,8]) ở đâu? Thật ra nó khá đơn giản ... (x+1)/2(phép chia số nguyên) giống như vậy round(x/2), và x + 1cũng giống như vậy -~x. Mặc dù x+1và -~xcó cùng độ dài, nhưng trong chức năng trên, tốt hơn là sử dụng -~xvì nó -~được ưu tiên và do đó không yêu cầu dấu ngoặc đơn.

APL, 14 byte

(?8)⊃1 3 2 2\⊢

Nhập dưới dạng một chuỗi.

Làm sao?

1 3 2 2\⊢- lặp lại từng chữ x lần ( 'ABCD'→ 'ABBBCCDD')

⊃ - lấy phần tử tại chỉ mục ..

(?8) - ngẫu nhiên 1-8

Than , 11 byte

‽⟦εεζζηηηθ⟧

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã, mặc dù bạn hầu như không cần nó; ‽chọn một phần tử ngẫu nhiên, ⟦⟧tạo một danh sách và các biến là những phần có được các chữ cái đầu vào thích hợp (theo thứ tự ngược lại vì tôi cảm thấy thích nó).

Bình thường , 8 7 byte

O+@Q1t+

Sử dụng thuật toán chính xác giống như trong câu trả lời Python của tôi.

Hãy thử nó ở đây!

Bình thường , 10 8 byte

O+<Q2*2t

Sử dụng thuật toán chính xác giống như câu trả lời Python của Jonathan Allan.

Hãy thử nó ở đây!

Giải trình

• O- Lấy một phần tử ngẫu nhiên của Chuỗi được tạo bằng cách nối thêm (với +):

  • <Q2 - Hai ký tự đầu tiên của Chuỗi.
  • *2tNhân đôi chuỗi đầy đủ ( *2) ngoại trừ ký tự đầu tiên ( t).

Áp dụng thuật toán này cho ABCD:

• <Q2mất AB.
• *2tmất BCDvà nhân đôi nó : BCDBCD.
• +tham gia hai chuỗi : ABBCDBCD.
• O có một nhân vật ngẫu nhiên.

-2 nhờ Leaky Nun (giải pháp thứ hai)

-1 nhờ ghi nhớ (giải pháp đầu tiên)

Thạch , 8 byte

122b4⁸xX

Hãy thử trực tuyến!

Bỏ cái Xđể xem "ABBBCCDD". Việc Xchọn một yếu tố ngẫu nhiên.

C # (.NET Core) , 76 55 byte

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

Hãy thử trực tuyến!

Câu trả lời đầu tiên của tôi được viết trực tiếp trên TIO bằng điện thoại di động của tôi. Lên cấp!

Giải thích: nếu chuỗi gốc là "ABCD", hàm sẽ tạo chuỗi "ABCDBBCD" và lấy một phần tử ngẫu nhiên từ nó.

Javascript 35 byte

Lấy một chuỗi ABCDlàm đầu vào, đầu ra A1/8 thời gian, B3/8 thời gian, C1/4 thời gian và D1/4 thời gian.

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

Giải trình

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

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến! , hoặc xem nó tại sân chơi cá !

Tổng quan ngắn gọn về> <>: đó là ngôn ngữ 2D với một con cá lướt qua mã, thực hiện các hướng dẫn khi nó đi. Nếu nó đạt đến cạnh của mã, nó sẽ bọc sang phía bên kia. Con cá bắt đầu ở góc trên cùng bên trái, di chuyển sang phải. Tính ngẫu nhiên là khó khăn trong> <>: chỉ dẫn ngẫu nhiên duy nhất là xđặt hướng ngẫu nhiên của cá ra khỏi lên, xuống, trái và phải (với xác suất bằng nhau).

Khi bắt đầu chương trình, cá đọc hai ký tự đầu vào với i_i(mỗi iký tự đọc một ký tự từ STDIN đến ngăn xếp và _là một gương ngang, hiện tại cá bỏ qua). Sau đó nó đạt đến mộtx .

Nếu xcon cá gửi thẳng về phía trước, nó sẽ đọc thêm một ký tự (phần ba), in nó ovà dừng lại với ;. Hướng bên trái cũng tương tự: con cá đọc thêm hai ký tự (vì vậy chúng tôi lên đến cái thứ tư), quấn quanh bên phải, in ký tự thứ tư và dừng lại. Nếu con cá bơi lên, nó quấn và in ký tự thứ hai, trước khi bị phản xạ ngay /và dừng lại. Nếu nó bơi xuống, nó sẽ bị phản xạ trái /và va vào người khác x.

Lần này, hai hướng chỉ cần gửi cá trở lại x(bên phải bằng một mũi tên <, và lên bằng gương, _). Do đó, cá có 1/2 cơ hội thoát khỏi điều này xở hai hướng còn lại. Bên trái in ký tự trên cùng trên ngăn xếp, là ký tự thứ hai, nhưng xuống dưới đầu tiên hoán đổi hai phần tử trên ngăn xếp với$ , vì vậy hướng này in ký tự đầu tiên.

Tóm lại, các ký tự thứ ba và thứ tư được in với xác suất 1/4 mỗi ký tự; ký tự đầu tiên có xác suất 1/2 x 1/4 = 1/8; và ký tự thứ hai có xác suất 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 byte

ìD1è0ǝ.R

Hãy thử trực tuyến!

         # 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

Hãy thử trực tuyến! Hoặc chạy nó 1000 lần (mã sửa đổi một chút) và kiểm tra số lần mỗi char xuất hiện.

Giải trình

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

Thay đổi trong mã sửa đổi: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...] là một vòng lặp để lặp lại 1000 lần.
• G đảm bảo đầu vào được đẩy vào đầu mỗi lần lặp.
• Kết quả được tích lũy trên ngăn xếp qua các lần lặp. Vì vậy, vcần phải được thay thế bằng cách 4$vchỉ nối đầu4 số .
• Ở cuối vòng lặp, vghép các 1000kết quả thành một vectơ, Ssắp xếp nó và Y'chạy theo chiều dài mã hóa nó. Điều này cho bốn chữ cái và số lần chúng đã xuất hiện.

05AB1E , 6 byte

«À¨Ć.R

Hãy thử trực tuyến!

Giải trình

Hoạt động cho cả danh sách và chuỗi.

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

Hãy thử trực tuyến!

Ruby, 34 33 29 27 byte

Đã lưu 2 byte nhờ @Value Inc

Nhập dưới dạng bốn ký tự

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

xây dựng một mảng [B,B,C,D,A,B,C,D]và lấy mẫu nó.

thử trực tuyến!

Hãy thử nó nlần! (Tôi đã chuyển đổi nó thành một hàm để lặp lại nó dễ dàng hơn, nhưng thuật toán là như nhau)

Bình thường, 7 byte

@z|O8 1

Bộ kiểm tra

O8tạo một số ngẫu nhiên từ 0 đến 7. | ... 1áp dụng logic hoặc bằng 1, chuyển đổi 0 thành 1 và để mọi thứ khác giống nhau. Số ở giai đoạn này là 1 2/8 thời gian và 2, 3, 4, 5, 6, 7 hoặc 8/8 thời gian.

@zlập chỉ mục vào chuỗi đầu vào tại vị trí đó. Việc lập chỉ mục được thực hiện theo phương thức modulo độ dài của chuỗi, vì vậy 4 chỉ mục ở vị trí 0, 5 ở vị trí 1, v.v.

Các xác suất là:

• Vị trí 0: Số ngẫu nhiên 4. 1/8 thời gian.

• Vị trí 1: Số ngẫu nhiên 0, 1 hoặc 5. 3/8 thời gian.

• Vị trí 2: Số ngẫu nhiên 2 hoặc 6. 2/8 thời gian.

• Vị trí 3: Số ngẫu nhiên 3 hoặc 7. 2/8 thời gian.

Javascript, 31 30 byte / 23 byte

Nhìn thấy câu trả lời Javascript trước đây của asgallant khiến tôi suy nghĩ về JS. Như ông nói:

Lấy một chuỗi ABCDlàm đầu vào, đầu ra A1/8 thời gian, B 3/8 thời gian, C1/4 thời gian và D1/4 thời gian.

Của tôi là:

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

Giải trình:

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
        ]

Từ Math.random()*8&7đó phân tích như sau:

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)

Phiên bản 2, 23 byte

Nhưng sau đó cảm ơn Arnauld, người đã đăng sau tôi, khi anh nói:

Nếu một công thức phụ thuộc vào thời gian được cho phép, chúng ta có thể thực hiện:

mà, nếu nó thực sự được cho phép, đã dẫn tôi đến:

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

trong đó new Date%8 sử dụng cùng bảng phân tích như trên.

Và %8cũng có thể là &7; bạn chọn đi. Cảm ơn một lần nữa, Arnauld.

ngn / apl, 10 byte

⎕a [⌈ /? 2 4]

?2 4 chọn ngẫu nhiên một cặp số - số đầu tiên trong số 0 1 và số thứ hai trong số 0 1 2 3

⌈/ là "giảm tối đa" - tìm số lớn hơn

⎕a là bảng chữ cái viết hoa

[ ] lập chỉ mục

lưu ý biểu đồ cho max (a, b) khi a∊ {0,1} và 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 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

nếu a và b được chọn ngẫu nhiên và độc lập, chúng ta có thể thay thế 0123 = ABCD để có phân phối xác suất mong muốn

Python 3 , 64 55 51 byte

-9 byte nhờ @ovs

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

Hãy thử trực tuyến!

Giải trình

random.choice()nhận được một ký tự ngẫu nhiên của Chuỗi, trong khi (s*2)[1:]+s[1]tạo BCDABCDBcho một đầu vào ABCD, có 1/8 As, 2/8 Cs, 2/8 Ds và 3/8 Bs.

QBIC , 27 byte

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

Giải trình

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

v
!

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

Hãy thử trực tuyến!

Chip , 60 byte

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

Hãy thử trực tuyến!

Cả ba ?đều tạo ra một bit ngẫu nhiên. Trong chu kỳ đầu tiên, các bit này được chạy qua các công tắc ở trên ( /và và \) để xác định giá trị nào chúng ta sẽ xuất ra từ bảng này:

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

(nơi _có thể là 0hay 1). Sau đó chúng tôi đi dọc theo đầu vào khi cần thiết, in và kết thúc khi đạt được giá trị chính xác.

Các blob chữ cái lớn ở cuối được sao chép bán buôn từ chương trình mèo, giải pháp này chỉ đơn giản là triệt tiêu đầu ra và chấm dứt để có được hiệu quả như mong muốn.

Ruby, 32 byte

Khá đơn giản ..?

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

Hãy thử trực tuyến!

Applesoft, 29 oops, 32 byte

Một ví dụ "retrocomputing" nhỏ. Chịu đựng tôi, tôi hoàn toàn mới ở đây. Tôi tập hợp rằng những gì được chỉ định là "đầu vào" không cần phải được tính bằng byte. Như đã nêu trong OP, đầu vào sẽ được đưa ra là "ABCD". (Ban đầu tôi không nhận ra rằng tôi cần xác định đầu vào được lấy, có thêm 4 byte, trong khi tôi đánh gôn phần còn lại xuống một byte.)

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

Các thuật ngữ INPUT, RND, PRINT và MID $ đều được mã hóa bên trong dưới dạng các mã thông báo byte đơn.

Đầu tiên, X được gán một giá trị ngẫu nhiên trong phạm vi 0 <X <4. Điều này được sử dụng để chọn một trong các ký tự từ I $, theo (X <.5) + X + 1. Giá trị vị trí ký tự được lấy là đánh giá cắt ngắn của biểu thức. X <.5 thêm 1 nếu X nhỏ hơn 0,5, nếu không thêm 0. Kết quả từ X bị phá vỡ như sau:

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 thông thường , 198 byte

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

Hãy thử trực tuyến!

Có thể đọc được

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