มาดูกันว่าภาษาที่คุณเลือกนั้นดีแค่ไหนในการสุ่มเลือก

ได้รับ 4 ตัวอักษรA, B, CและDหรือสตริงของ 4 ตัวอักษรABCD เป็น inputหนึ่งเอาท์พุทของตัวละครที่มีความน่าจะเป็นต่อไปนี้:

• A ควรมีโอกาสเลือก 1/8 (12.5%)
• B ควรมีโอกาส 3/8 (37.5%) ที่จะเลือก
• C ควรมีโอกาส 2/8 (25%) ที่จะเลือก
• D ควรมีโอกาส 2/8 (25%) ที่จะเลือก

นี่สอดคล้องกับเค้าโครงเครื่องPlinkoต่อไปนี้:

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

คำตอบของคุณจะต้องพยายามอย่างแท้จริงในการเคารพความน่าจะเป็นที่อธิบายไว้ คำอธิบายที่เหมาะสมของวิธีคำนวณความน่าจะเป็นในคำตอบของคุณ (และทำไมพวกเขาจึงเคารพรายละเอียดโดยไม่คำนึงถึงปัญหาการสุ่มหลอกและปัญหาจำนวนมาก) ก็เพียงพอแล้ว

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟที่มีจำนวนน้อยที่สุดในแต่ละภาษาที่ชนะ!

เครื่องยันถั่ว , 55 43 42 ไบต์

-13 ไบต์ขอบคุณ Alex Varga

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

หวังว่าพวกคุณจะไม่รังเกียจฉันที่จะตอบคำถามของตัวเองหลังจากผ่านไปเพียง 2 ชั่วโมง แต่ฉันสงสัยอย่างมากว่ามีคนอื่นวางแผนที่จะโพสต์คำตอบใน LMBM

นี่สะท้อนให้เห็นถึงรูปแบบ Plinko ที่แสดงใน OP พลิกในแนวนอนเพื่อลดช่องว่างที่ไม่จำเป็น

เยลลี่ 6 ไบต์

Ḋṁ7;ḢX

ลิงก์ monadic ที่รับรายการอักขระสี่ตัวและส่งคืนหนึ่งตัวพร้อมการแจกแจงความน่าจะเป็นที่อธิบายไว้

ลองออนไลน์!

อย่างไร?

Ḋṁ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 ไบต์

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

ดูในล่ามออนไลน์!

สิ่งนี้แม็พกับคิวบ์เน็ตต่อไปนี้:

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

คำอธิบายการใช้การกระจายแบบสุ่ม

Cubix เป็นภาษาที่ตัวชี้คำแนะนำเดินทางไปทั่วใบหน้าของคิวบ์โดยดำเนินการคำสั่งที่พบ รูปแบบการสุ่มเพียงอย่างเดียวคือคำสั่งDซึ่งจะส่ง IP ในทิศทางที่สุ่ม: โอกาสที่เท่าเทียมกันใน1/4แต่ละวิธี

อย่างไรก็ตามเราสามารถใช้สิ่งนี้เพื่อสร้างความน่าจะเป็นของน้ำหนักที่ถูกต้อง: โดยใช้Dสองครั้ง เป็นครั้งแรกที่Dมีการเดินทางไปครั้งที่สอง1/4 อย่างไรก็ตามDวินาทีนี้Dมีสองทิศทางที่ถูกปิดกั้นด้วยลูกศร ( > D <) ซึ่งส่งตัวชี้คำแนะนำกลับไปที่Dเพื่อเลือกทิศทางอื่น ซึ่งหมายความว่ามีเพียงสองทิศทางที่เป็นไปได้จากที่นั่นแต่ละทิศทางมี1/8โอกาสโดยรวมที่จะเกิดขึ้น สามารถใช้เพื่อสร้างอักขระที่ถูกต้องดังแสดงในแผนภาพด้านล่าง:

(โปรดทราบว่าในรหัสจริงลูกศรด้านขวาจะถูกแทนที่ด้วยมิเรอร์|)

รหัสคำอธิบาย

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

ตัวชี้คำสั่งเริ่มต้นที่ด้านขวาตรงตัวอักษรiหันไปทางขวา มันรันสิ่งนี้iโดยใช้อักขระตัวแรกเป็นอินพุตจากนั้นย้ายไปที่Dจุดเริ่มต้นกระบวนการสุ่มที่แสดงด้านบน

• ถ่าน A:ในกรณีที่คนแรกที่Dส่งให้เราทางทิศตะวันออกและทิศใต้ที่สองเราต้องพิมพ์ตัวอักษร A. iนี้มีอยู่แล้วในกองตั้งแต่แรก ดำเนินการต่อไปนี้:

  • \ - สะท้อน IP ดังนั้นจึงมุ่งหน้าไปทางทิศตะวันออก
  • i; - รับอินพุตจากนั้นเปิดขึ้นอีกครั้ง (ไม่มี op)
  • U - ดำเนินการกลับรถโดยหมุน IP ไปทางซ้ายสองครั้ง
  • o - ออก TOS, ตัวอักษร A
  • @ - ยุติโปรแกรม

• ถ่าน B:ถ้าDหัวแรกหรือหัวที่สองเหนือเราจำเป็นต้องสร้างตัวอักษร B ซึ่งจะเป็นอินพุตต่อไป พา ธ ทั้งคู่ดำเนินการคำสั่งต่อไปนี้:

  • ^ - มุ่งไปทางเหนือ
  • < - มุ่งหน้าไปทางตะวันตกล้อมรอบไปที่ ...
  • i - รับอินพุตอีกตัวอักษร B
  • o - ออก TOS, ตัวอักษร B
  • ; - ป๊อป TOS
  • @ - ยุติโปรแกรม

• ถ่าน C:ถ้าคนแรกDส่งพวกเราไปทางตะวันตก

  • i - รับอินพุตอีกตัวอักษร B
  • i - รับอินพุตอีกตัวอักษร C
  • o - TOS เอาต์พุต, อักขระ C
  • @ - ยุติโปรแกรม

• Char D:ถ้าคนแรกDส่งพวกเราไปทางใต้

  • i - รับอินพุตอีกตัวอักษร B
  • .. - ไม่มีตัวเลือกสองตัว
  • i - รับอินพุตอีกตัวอักษร C
  • | - กระจกนี้สะท้อนตะวันออก - ตะวันตก แต่ IP กำลังมุ่งไปทางทิศเหนือเราจึงผ่านมันไป
  • ^ - สิ่งนี้รวมกับพา ธ ที่ใช้สำหรับตัวละคร B อย่างไรก็ตามเนื่องจากเราได้รับอินพุตสองตัวแล้วตัวละครตัวที่สี่ (ตัว D) จะถูกพิมพ์ออกมา

Pythonขนาด 50 ไบต์

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

ฟังก์ชั่นที่ไม่มีชื่อการรับและส่งคืนสตริง (หรือรายการอักขระ)

ลองออนไลน์!

อย่างไร?

random.choiceเลือกองค์ประกอบที่สุ่มจากรายชื่อเพื่อให้การทำงานในรูปแบบสตริงกับการจัดจำหน่ายที่ถูกต้องนั่นคือการได้รับ"ABCD", "ABCD"[:2] = "AB"บวกซึ่งเป็น"ABCD"[1:]*2 = "BCD"*2 = "BCDBCD""ABBCDBCD"

R , 31 ไบต์

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

อ่านอักขระจากstdinคั่นด้วยช่องว่าง sampleดึงตัวอย่างแบบสุ่มจากอินพุตแรกในปริมาณของอินพุตที่สอง (ดังนั้น1), (อาร์กิวเมนต์การแทนที่เผื่อเลือก) ด้วยน้ำหนักที่กำหนดโดยอาร์กิวเมนต์ล่าสุด

ลองออนไลน์!

ลองnครั้ง!

สำหรับโค้ดหลังฉันสุ่มตัวอย่างn(ตั้งค่าnในส่วนหัว) ด้วยการแทนที่ชุดให้เป็นTรู (มันเป็นค่าเริ่มต้นเป็นเท็จ) จัดระเบียบผลลัพธ์และหารด้วยnเพื่อดูความน่าจะเป็นสัมพัทธ์ของอินพุต

PHP, 28 ไบต์

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

-nRทำงานเป็นท่อด้วย

01112233ใน base-4 เป็น5551ทศนิยม ...

Java 8, 53 44 ไบต์

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

Function<char[], Character>นี่คือ

ลองออนไลน์! (โปรแกรมการทดสอบนี้จะทำงานฟังก์ชั่นข้างต้น 1,000,000 ครั้งและผลการทดลองความน่าจะเป็นของการเลือกA, B, CและD)

แนวคิดทั่วไปที่นี่คือการหาวิธีที่จะ map บางส่วน0-7ไป0-3เช่นที่0ปรากฏขึ้น1/8ครั้ง1ปรากฏ3/8ครั้ง2ปรากฏ2/8ครั้งและ3ปรากฏ2/8ครั้ง round(abs(k - 6) / 2.0))ทำงานนี้ที่เป็นจำนวนเต็มสุ่มในช่วงk [0,8)ผลลัพธ์นี้ในการแมปต่อไปนี้:

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

ซึ่งเป็นคุณสามารถเห็นผลในดัชนี0 111 22 33ซึ่งก่อให้เกิดความน่าจะเป็นที่ต้องการของ1/8, 3/8, และ2/82/8

แต่เดี๋ยวก่อน! ในโลกจะ-~Math.abs(k-6)/2บรรลุผลลัพธ์เดียวกันได้อย่างไร (อีกครั้งซึ่งkเป็นจำนวนเต็มแบบสุ่มในช่วง[0,8]) มันง่ายสวยจริง ... (x+1)/2(จำนวนเต็มหาร) เป็นสิ่งเดียวround(x/2)และเป็นสิ่งเดียวกับx + 1 -~xแม้ว่าx+1และ-~xจะมีความยาวเท่ากัน แต่ในฟังก์ชั่นด้านบนจะดีกว่าที่จะใช้-~xเนื่องจากมัน-~มีความสำคัญกว่าและไม่จำเป็นต้องใช้วงเล็บ

APL, 14 ไบต์

(?8)⊃1 3 2 2\⊢

อินพุตเป็นสตริง

อย่างไร?

1 3 2 2\⊢- ทำซ้ำตัวอักษรแต่ละตัว x ครั้ง ( 'ABCD'→ 'ABBBCCDD')

⊃ - นำองค์ประกอบที่ดัชนี ..

(?8) - สุ่ม 1-8

ถ่าน 11 ไบต์

‽⟦εεζζηηηθ⟧

ลองออนไลน์! การเชื่อมโยงคือการใช้โค้ดเวอร์ชันอย่างละเอียดแม้ว่าคุณจะไม่ต้องการมัน ‽เลือกองค์ประกอบแบบสุ่ม⟦⟧สร้างรายการและตัวแปรเป็นตัวที่ได้รับตัวอักษรที่เหมาะสม (เรียงกลับกันเพราะฉันรู้สึกเหมือนมัน)

Pyth , 8 7 ไบต์

O+@Q1t+

ใช้อัลกอริทึมแบบเดียวกันกับคำตอบ Python ของฉัน

ลองที่นี่!

Pyth , 10 8 ไบต์

O+<Q2*2t

ใช้อัลกอริธึมที่แน่นอนเช่นเดียวกับคำตอบ Python ของ Jonathan Allan

ลองที่นี่!

คำอธิบาย

• O- ใช้องค์ประกอบแบบสุ่มของสตริงที่ทำโดยต่อท้าย (ด้วย+):

  • <Q2 - ตัวละครสองตัวแรกของ String
  • *2tเพิ่มสตริงเป็นสองเท่า ( *2) ยกเว้นอักขระตัวแรก ( t)

ใช้อัลกอริทึมนี้สำหรับABCD:

• <Q2ABใช้เวลา
• *2tใช้BCDและเพิ่มเป็นสองเท่า: BCDBCD.
• +ABBCDBCDร่วมสองสาย:
• O ใช้ตัวอักษรแบบสุ่ม

-2 ขอบคุณ Leaky Nun (ทางออกที่สอง)

-1 ขอบคุณช่วยในการจำ (วิธีแก้ปัญหาแรก)

เยลลี่ขนาด 8 ไบต์

122b4⁸xX

ลองออนไลน์!

ลบที่จะเห็นX เลือกองค์ประกอบแบบสุ่ม"ABBBCCDD"X

C # (.NET Core) , 76 55 ไบต์

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

ลองออนไลน์!

คำตอบแรกของฉันเขียนโดยตรงบน TIO โดยใช้โทรศัพท์มือถือของฉัน ยกระดับ!

คำอธิบาย: หากสตริงเดิมคือ "ABCD" ฟังก์ชั่นจะสร้างสตริง "ABCDBBCD" และใช้องค์ประกอบแบบสุ่มจากมัน

Javascript 35 ไบต์

รับสตริงABCDเป็นอินพุตเอาต์พุตA1 / 8th ของเวลาB3 / 8ths ของเวลาC1 / 4th ของเวลาและD1 / 4th ของเวลา

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

คำอธิบาย

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 ไบต์

¦Ćì.R

ลองออนไลน์!

คำอธิบาย

¦Ćì.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 ไบต์

i_ixio;o
ox</;
;\$o

ลองออนไลน์! หรือดูที่สนามเด็กเล่นปลา !

ภาพรวมคร่าวๆของ> <>: เป็นภาษา 2D ที่มีปลาที่แหวกว่ายไปมาในรหัสโดยดำเนินการตามคำแนะนำ หากถึงขอบของโค้ดมันจะตัดไปอีกด้านหนึ่ง ปลาเริ่มที่มุมซ้ายบนขยับไปทางขวา การสุ่มเป็นเรื่องยุ่งยากใน> <>: คำสั่งแบบสุ่มเพียงอย่างเดียวคือxซึ่งกำหนดทิศทางของปลาโดยการสุ่มขึ้นลงซ้ายและขวา (ด้วยความน่าจะเป็นที่เท่ากัน)

ในช่วงเริ่มต้นของโปรแกรมปลาอ่านด้วยอักขระสองตัวของอินพุตด้วยi_i(แต่ละคนiอ่านอักขระจาก STDIN ไปยังสแต็กและ_เป็นกระจกแนวนอนซึ่งปลาจะไม่สนใจตอนนี้) xจากนั้นก็เอื้อม

ถ้าxส่ง rightwards ปลามันอ่านในอีกหนึ่งตัวอักษร (ที่สาม), พิมพ์ด้วยและหยุดพักด้วยo ;ทิศทางด้านซ้ายจะคล้ายกัน: ปลาอ่านตัวละครอีกสองตัว (ดังนั้นเราจะขึ้นอยู่กับตัวที่สี่) ล้อมรอบไปทางขวาพิมพ์ตัวอักษรตัวที่สี่และหยุดพัก ถ้าปลาแหวกว่ายมันก็จะพันและพิมพ์ตัวอักษรตัวที่สองก่อนที่จะถูกสะท้อน/และหยุดทำงาน ถ้ามันว่ายลงมามันก็จะสะท้อนออกไปทางซ้าย/และชนอีกxตัว

คราวนี้สองทิศทางเพิ่งส่งปลากลับไปที่x(ด้วยลูกศรขวา<และขึ้นกับกระจก_) ปลาจึงมีโอกาส 1/2 ครั้งที่จะรอดพ้นจากสิ่งนี้xในอีกสองทิศทาง ไปทางซ้ายพิมพ์อักขระบนสุดบนสแต็กซึ่งเป็นตัวที่สอง แต่ลงมาก่อนจะสลับสององค์ประกอบบนสแต็กด้วย$ดังนั้นทิศทางนี้จะพิมพ์อักขระตัวแรก

โดยสรุปตัวอักษรที่สามและสี่จะถูกพิมพ์ด้วยความน่าจะเป็น 1/4 แต่ละตัว อักขระตัวแรกมีความน่าจะเป็น 1/2 x 1/4 = 1/8; และอักขระตัวที่สองมีความน่าจะเป็น 1/4 + 1/2 x 1/4 = 3/8

05AB1E , 8 ไบต์

ìD1è0ǝ.R

ลองออนไลน์!

         # 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 ไบต์

l3HHvY"1Zr

ลองออนไลน์! หรือเรียกใช้ 1,000 ครั้ง (แก้ไขรหัสเล็กน้อย) และตรวจสอบจำนวนครั้งที่แต่ละอักขระปรากฏขึ้น

คำอธิบาย

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

การเปลี่ยนแปลงในรหัสที่แก้ไข: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]เป็นการวนซ้ำเพื่อทำซ้ำ1000ครั้ง
• G ทำให้แน่ใจว่าอินพุตถูกผลักไปที่จุดเริ่มต้นของแต่ละการวนซ้ำ
• ผลลัพธ์จะถูกสะสมบนสแต็กในการวนซ้ำ ดังนั้นvจะต้องมีการแทนที่ด้วย4$vเพื่อเชื่อมต่อเฉพาะ4ตัวเลขด้านบน
• ในตอนท้ายของลูปvเชื่อม1000ผลลัพธ์เป็นเวกเตอร์SเรียงลำดับและY'รันความยาวเข้ารหัส นี่ทำให้ตัวอักษรสี่ตัวและจำนวนครั้งที่ปรากฏ

05AB1E , 6 ไบต์

«À¨Ć.R

ลองออนไลน์!

คำอธิบาย

ใช้งานได้ทั้งรายการและสตริง

«       # 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 ไบต์

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

ลองออนไลน์!

Ruby, 34 33 29 27 ไบต์

บันทึก 2 ไบต์ขอบคุณ @Value Inc

อินพุตเป็นอักขระสี่ตัว

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

สร้างอาร์เรย์[B,B,C,D,A,B,C,D]และสุ่มตัวอย่าง

ลองออนไลน์!

ลองnครั้ง! (ฉันแปลงเป็นฟังก์ชันเพื่อทำซ้ำได้ง่ายขึ้น แต่อัลกอริทึมเหมือนกัน)

Pyth, 7 ไบต์

@z|O8 1

ชุดทดสอบ

O8สร้างตัวเลขสุ่มจาก 0 ถึง 7 | ... 1ใช้ตรรกะหรือกับ 1 แปลง 0 เป็น 1 และปล่อยให้ทุกอย่างอื่นเหมือนกัน จำนวนในขั้นตอนนี้คือ 1 2 / 8th ของเวลาและ 2, 3, 4, 5, 6, 7 หรือ 8 1/8 ของเวลา

@zจัดทำดัชนีลงในสตริงอินพุตที่ตำแหน่งนั้น การจัดทำดัชนีจะดำเนินการแบบโมดูโลตามความยาวของสตริงดังนั้น 4 ดัชนีที่ตำแหน่ง 0, 5 ที่ตำแหน่ง 1 และอื่น ๆ

ความน่าจะเป็นคือ:

• ตำแหน่ง 0: สุ่มหมายเลข 4 1/8 ของเวลา

• ตำแหน่งที่ 1: สุ่มหมายเลข 0, 1 หรือ 5 3/8 ของเวลา

• ตำแหน่งที่ 2: สุ่มหมายเลข 2 หรือ 6 2/8 ของเวลา

• ตำแหน่งที่ 3: สุ่มหมายเลข 3 หรือ 7 2/8 ของเวลา

Javascript, 31 30 ไบต์ / 23 ไบต์

การเห็นจาวาสคริปต์ก่อนหน้าของ asgallant ทำให้ฉันคิดถึง JS ในขณะที่เขาพูดว่า:

รับสตริงABCDเป็นอินพุตเอาต์พุตA1 / 8th ของเวลาB 3 / 8ths ของเวลาC1 / 4th ของเวลาและD1 / 4th ของเวลา

ของฉันคือ:

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

คำอธิบาย:

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
        ]

จากMath.random()*8&7นั้นแบ่งลงดังนี้

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)

รุ่น 2, 23 ไบต์

แต่ต้องขอบคุณ Arnauld ผู้โพสต์ตามฉันเมื่อเขาพูดว่า:

หากอนุญาตให้ใช้สูตรขึ้นอยู่กับเวลาเราสามารถทำได้:

ซึ่งหากได้รับอนุญาตแน่นอนนำฉันไปที่:

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

ซึ่งnew Date%8ใช้ตารางการแยกย่อยเช่นเดียวกับด้านบน

และ%8อาจเป็น&7; เลือกของคุณ ขอบคุณอีกครั้ง Arnauld

ngn / apl, 10 ไบต์

⎕a [⌈ /? 2 4]

?2 4 เลือกสุ่มคู่ของตัวเลข - ตัวแรกในหมู่ 0 1 และตัวที่สองในหมู่ 0 1 2 3

⌈/ คือ "max ลด" - ค้นหาจำนวนที่มากขึ้น

⎕a เป็นตัวอักษรตัวพิมพ์ใหญ่

[ ] การจัดทำดัชนี

จดบันทึกแผนภูมิสำหรับ max (a, b) เมื่อ a∊ {0,1} และ 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 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

ถ้า a และ b ถูกเลือกแบบสุ่มและเป็นอิสระเราสามารถแทนที่ 0123 = ABCD เพื่อให้ได้การแจกแจงความน่าจะเป็นที่ต้องการ

Python 3 , 64 55 51 ไบต์

-9 ไบต์ขอบคุณ @ovs

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

ลองออนไลน์!

คำอธิบาย

random.choice()รับตัวอักษรแบบสุ่มของ String ในขณะที่(s*2)[1:]+s[1]สร้างBCDABCDBสำหรับอินพุตABCDซึ่งมี 1/8 As, 2/8 Cs, 2/8 Ds และ 3/8 Bs

QBICขนาด 27 ไบต์

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

คำอธิบาย

?           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 ไบต์

v
!

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

ลองออนไลน์!

ชิป 60 ไบต์

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

ลองออนไลน์!

ทั้งสาม?ต่างสร้างสุ่มขึ้นมา ในรอบแรกบิตเหล่านี้จะทำงานผ่านสวิตช์ด้านบน ( /'s และ\' s) เพื่อกำหนดค่าที่เราจะออกจากตารางนี้:

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

( _สามารถเป็นได้ทั้ง0หรือ1) จากนั้นเราเดินไปตามอินพุตตามความจำเป็นการพิมพ์และการยกเลิกเมื่อถึงค่าที่ถูกต้อง

หยดตัวอักษรขนาดใหญ่ที่ส่วนท้ายจะถูกคัดลอกขายส่งจากโปรแกรม cat โซลูชันนี้จะหยุดเอาต์พุตและยกเลิกเพื่อให้ได้ผลลัพธ์ตามที่ต้องการ

Ruby, 32 ไบต์

ตรงไปตรงมาสวย ..

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

ลองออนไลน์!

Applesoft, 29 oops, 32 bytes

ตัวอย่าง "retrocomputing" เล็กน้อย อดทนกับฉันฉันเป็นคนใหม่ที่นี้ ฉันรวบรวมว่าสิ่งที่ถูกกำหนดให้เป็น "อินพุต" ไม่จำเป็นต้องนับรวมตัวเอง ตามที่ระบุใน OP ข้อมูลจะได้รับเป็น "ABCD" (ตอนแรกฉันไม่ได้ตระหนักว่าฉันต้องระบุอินพุตที่ได้รับซึ่งเพิ่ม 4 ไบต์ในขณะที่ฉันเล่นส่วนที่เหลือลงหนึ่งไบต์)

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

ข้อกำหนด INPUT, RND, PRINT และ MID $ แต่ละรายการมีการเข้ารหัสภายในเป็นโทเค็นไบต์เดียว

ครั้งแรก X ถูกกำหนดค่าสุ่มในช่วง 0 <X <4 ซึ่งใช้เพื่อเลือกหนึ่งในตัวละครจาก I $ ตาม (X <.5) + X + 1 ค่าตำแหน่งตัวละครจะถูกนำมาเป็น การประเมินผลการแสดงออกที่ถูกตัดทอน X <.5 เพิ่ม 1 ถ้า X น้อยกว่า 0.5 หรือเพิ่ม 0 ผลลัพธ์จาก X แยกลงดังนี้:

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 ทั่วไป , 198 ไบต์

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

ลองออนไลน์!

อ่านได้:

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