การจำลองการทอยลูกเต๋าจำนวนมากโดยไม่ต้องวนซ้ำอย่างแม่นยำหรือไม่

ตกลงดังนั้นหากเกมของคุณหมุนลูกเต๋าจำนวนมากคุณสามารถโทรหาตัวสร้างตัวเลขสุ่มในลูป แต่สำหรับลูกเต๋าชุดใดที่มีการกลิ้งบ่อยครั้งพอคุณจะได้เส้นโค้งการกระจาย / ฮิสโตแกรม ดังนั้นคำถามของฉันคือมีการคำนวณอย่างง่ายดีฉันสามารถเรียกใช้ที่จะให้ฉันหมายเลขที่เหมาะกับการกระจายนั้น

เช่น 2D6 - คะแนน -% ความน่าจะเป็น

2 - 2.77%

3 - 5.55%

4 - 8.33%

5 - 11.11%

6 - 13.88%

7 - 16.66%

8 - 13.88%

9 - 11.11%

10 - 8.33%

11 - 5.55%

12 - 2.77%

ดังนั้นการรู้ข้างต้นคุณสามารถหมุน d100 เดี่ยวและหาค่า 2D6 ที่ถูกต้องได้ แต่เมื่อเราเริ่มต้นด้วย 10D6, 50D6, 100D6, 1000D6 สิ่งนี้สามารถประหยัดเวลาการประมวลผลได้มาก ดังนั้นจะต้องมีการสอน / วิธีการ / อัลกอริทึมที่สามารถทำได้อย่างรวดเร็ว? มันอาจจะมีประโยชน์สำหรับตลาดหุ้นคาสิโนเกมกลยุทธ์ป้อมปราการคนแคระเป็นต้นถ้าคุณสามารถจำลองผลลัพธ์ของการต่อสู้เชิงกลยุทธ์ที่สมบูรณ์ซึ่งอาจใช้เวลาหลายชั่วโมงในการเล่นด้วยการเรียกฟังก์ชั่นนี้และคณิตศาสตร์พื้นฐานบางอย่าง?

ดังที่ฉันได้กล่าวถึงในความคิดเห็นของฉันข้างต้นฉันแนะนำให้คุณทำโพรไฟล์นี้ก่อนที่จะเข้าใจรหัสของคุณมากเกินไป การรวมอย่างรวดเร็วของforลูกเต๋าจะทำให้เข้าใจและแก้ไขได้ง่ายกว่าสูตรทางคณิตศาสตร์ที่ซับซ้อนและการสร้างตาราง / การค้นหา ทำรายละเอียดก่อนเสมอเพื่อให้แน่ใจว่าคุณกำลังแก้ปัญหาสำคัญ ;)

ที่กล่าวว่ามีสองวิธีหลักในการสุ่มตัวอย่างการแจกแจงความน่าจะเป็นที่ซับซ้อนในบัดดล:

1. การแจกแจงความน่าจะเป็นแบบสะสม

มีเคล็ดลับเรียบร้อยในการสุ่มตัวอย่างจากการแจกแจงความน่าจะเป็นอย่างต่อเนื่องโดยใช้อินพุตแบบสุ่มชุดเดียวเท่านั้น มันเกี่ยวกับการแจกแจงสะสมฟังก์ชันที่ตอบว่า "ความน่าจะเป็นที่จะได้ค่าไม่เกิน x คืออะไร"

ฟังก์ชันนี้ไม่ลดลงเริ่มต้นที่ 0 และเพิ่มขึ้นเป็น 1 เหนือโดเมน ตัวอย่างสำหรับผลรวมของลูกเต๋าสองด้านหกตัวแสดงอยู่ด้านล่าง:

หากฟังก์ชันการแจกแจงสะสมของคุณมีค่าผกผันที่สะดวกในการคำนวณ (หรือคุณสามารถประมาณค่าได้ด้วยฟังก์ชันที่เป็นชิ้น ๆ เช่นเส้นโค้งเบซิเยร์) คุณสามารถใช้ฟังก์ชันนี้เพื่อสุ่มตัวอย่างจากฟังก์ชันความน่าจะเป็นแบบดั้งเดิม

ฟังก์ชันผกผันจัดการการแยกโดเมนระหว่าง 0 และ 1 เข้ากับช่วงเวลาที่แมปกับแต่ละเอาต์พุตของกระบวนการสุ่มดั้งเดิมโดยมีพื้นที่เก็บกักของแต่ละการจับคู่ความน่าจะเป็นดั้งเดิม (นี่คือความจริงที่ไม่สิ้นสุดสำหรับการแจกแจงแบบต่อเนื่องสำหรับการแจกแจงแบบแยกเช่นม้วนลูกเต๋าเราจำเป็นต้องใช้การปัดเศษอย่างระมัดระวัง)

นี่คือตัวอย่างของการใช้สิ่งนี้เพื่อเลียนแบบ 2d6:

int SimRoll2d6()
{
    // Get a random input in the half-open interval [0, 1).
    float t = Random.Range(0f, 1f);
    float v;

    // Piecewise inverse calculated by hand. ;)
    if(t <= 0.5f)
    {
         v = (1f + sqrt(1f + 288f * t)) * 0.5f;
    }
    else
    {
         v = (25f - sqrt(289f - 288f * t)) * 0.5f;
    }

    return floor(v + 1);
}

เปรียบเทียบสิ่งนี้กับ:

int NaiveRollNd6(int n)
{
    int sum = 0;
    for(int i = 0; i < n; i++)
       sum += Random.Range(1, 7); // I'm used to Range never returning its max
    return sum;
}

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

ดังนั้นก่อนที่คุณจะออกไปด้วยการวนลูปที่ชัดเจนตรวจสอบให้แน่ใจว่าเป็นปัญหาด้านประสิทธิภาพที่คุ้มค่ากับการเสียสละแบบนี้

2. วิธีนามแฝง

วิธีการแจกแจงสะสมทำงานได้ดีเมื่อคุณสามารถแสดงค่าผกผันของฟังก์ชันการแจกแจงสะสมเป็นนิพจน์ทางคณิตศาสตร์อย่างง่าย แต่นั่นอาจไม่ใช่เรื่องง่ายหรือเป็นไปได้เสมอไป ทางเลือกที่เชื่อถือได้สำหรับการกระจายแบบไม่ต่อเนื่องเป็นสิ่งที่เรียกว่าวิธีนามแฝงวิธีนามแฝง

สิ่งนี้ช่วยให้คุณสามารถสุ่มตัวอย่างจากการแจกแจงความน่าจะเป็นแบบไม่ต่อเนื่องใด ๆ โดยใช้อินพุตสุ่มแบบอิสระที่กระจายกันสองชุด

มันทำงานได้โดยการแจกแจงแบบเดียวกับด้านล่างทางซ้าย (ไม่ต้องกังวลว่าพื้นที่ / น้ำหนักไม่ได้รวมเป็น 1 สำหรับวิธี Alias ​​ที่เราสนใจเกี่ยวกับน้ำหนักสัมพัทธ์ ) และแปลงเป็นตารางเช่นเดียวกับ ด้านขวาที่:

• มีหนึ่งคอลัมน์สำหรับแต่ละผลลัพธ์
• แต่ละคอลัมน์จะแบ่งออกเป็นสองส่วนโดยมากแต่ละคอลัมน์จะเชื่อมโยงกับผลลัพธ์ต้นฉบับหนึ่งรายการ
• พื้นที่ / น้ำหนักสัมพัทธ์ของผลลัพธ์แต่ละรายการจะถูกรักษาไว้

(แผนภาพตามภาพจากบทความที่ยอดเยี่ยมเกี่ยวกับวิธีการสุ่มตัวอย่าง )

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

int SampleFromTables(float[] probabiltyTable, int[] aliasTable)
{
    int column = Random.Range(0, probabilityTable.Length);
    float p = Random.Range(0f, 1f);
    if(p < probabilityTable[column])
    {
        return column;
    }
    else
    {
        return aliasTable[column];
    }
}

สิ่งนี้เกี่ยวข้องกับการตั้งค่าเล็กน้อย:

1. คำนวณความน่าจะเป็นสัมพัทธ์ของผลลัพธ์ที่เป็นไปได้ทุกอย่าง (ดังนั้นหากคุณหมุน 1,000d6 เราจำเป็นต้องคำนวณจำนวนวิธีที่จะได้รับผลรวมทุก ๆ 1,000 ถึง 6,000)

2. สร้างคู่ของตารางที่มีรายการสำหรับแต่ละผลลัพธ์ วิธีการเต็มไปเกินขอบเขตของคำตอบนี้ดังนั้นฉันขอแนะนำให้อ้างอิงถึงคำอธิบายของอัลกอริทึมวิธีนามแฝงนี้

3. จัดเก็บตารางเหล่านั้นและอ้างอิงกลับไปที่พวกเขาทุกครั้งที่คุณต้องการม้วนมวนแบบสุ่มใหม่จากการกระจายนี้

นี่คือข้อดีของพื้นที่เวลา ขั้นตอนการคำนวณล่วงหน้าค่อนข้างละเอียดถี่ถ้วนและเราจำเป็นต้องจัดสรรหน่วยความจำให้สอดคล้องกับจำนวนผลลัพธ์ที่เรามี (แม้ว่าจะถึง 1,000d6 เรากำลังพูดถึงตัวเลขกิโลไบต์เดียวดังนั้นไม่มีอะไรเสียเวลานอน) เป็นเวลาคงที่ไม่ว่าการกระจายของเราจะซับซ้อนแค่ไหน

ฉันหวังว่าวิธีการหนึ่งอย่างใดอย่างหนึ่งอาจเป็นประโยชน์บางอย่าง (หรือฉันเชื่อว่าคุณว่าความเรียบง่ายของวิธีการไร้เดียงสานั้นคุ้มค่ากับเวลาที่ใช้ในการวนซ้ำ);)

คำตอบน่าเสียดายที่วิธีนี้จะไม่ส่งผลให้ประสิทธิภาพเพิ่มขึ้น

ฉันเชื่อว่าอาจมีความเข้าใจผิดในคำถามเกี่ยวกับวิธีการสร้างหมายเลขสุ่ม นำตัวอย่างด้านล่าง [Java]:

Random r = new Random();
int n = 20;
int min = 1; //arbitrary
int max = 6; //arbitrary
for(int i = 0; i < n; i++){
    int randomNumber = (r.nextInt(max - min + 1) + min)); //silly maths
    System.out.println("Here's a random number: " + randomNumber);
}

รหัสนี้จะวนซ้ำ 20 เท่าเมื่อพิมพ์ตัวเลขสุ่มระหว่าง 1 ถึง 6 (รวม) เมื่อเราพูดถึงประสิทธิภาพของรหัสนี้มีเวลาในการสร้างวัตถุสุ่ม (ซึ่งเกี่ยวข้องกับการสร้างอาร์เรย์ของจำนวนเต็มแบบหลอกเทียมขึ้นอยู่กับนาฬิกาภายในของคอมพิวเตอร์ในเวลาที่มันถูกสร้างขึ้น) จากนั้นเวลาคงที่ 20 ครั้ง ค้นหาการโทรแต่ละครั้ง nextInt () เนื่องจากการ 'หมุน' แต่ละครั้งเป็นการดำเนินการเวลาที่คงที่สิ่งนี้ทำให้การม้วนเวลามีราคาถูกมาก นอกจากนี้โปรดสังเกตว่าช่วงนาทีถึงสูงสุดไม่สำคัญ (ในคำอื่น ๆ มันเป็นเรื่องง่ายสำหรับคอมพิวเตอร์ที่จะหมุน d6 เพราะมันจะหมุน d10000) การพูดในแง่ของความซับซ้อนของเวลาประสิทธิภาพของการแก้ปัญหาคือเพียง O (n) โดยที่ n คือจำนวนของลูกเต๋า

อีกวิธีหนึ่งเราสามารถประมาณจำนวน d6 ม้วนด้วยหนึ่งม้วน d100 (หรือ d10000 สำหรับเรื่องนั้น) การใช้วิธีนี้เราต้องคำนวณ s [จำนวนใบหน้าไปยังลูกเต๋า] * n [จำนวนของลูกเต๋า] เปอร์เซ็นต์ก่อนที่เราจะหมุน ครึ่งเนื่องจากมันสมมาตรสังเกตว่าในตัวอย่างของคุณสำหรับการจำลองการม้วน 2d6 คุณคำนวณ 11 เปอร์เซ็นต์และ 6 ไม่ซ้ำกัน) หลังจากกลิ้งเราสามารถใช้การค้นหาแบบไบนารี่เพื่อกำหนดช่วงการหมุนของเรา ในแง่ของความซับซ้อนของเวลาโซลูชันนี้ประเมินเป็นโซลูชัน O (s * n) โดยที่ s คือจำนวนข้างและ n คือจำนวนของลูกเต๋า อย่างที่เราเห็นนี่เป็นช้ากว่าโซลูชัน O (n) ที่เสนอในย่อหน้าก่อนหน้า

การประมาณจากนั้นคุณสร้างทั้งสองโปรแกรมเหล่านี้เพื่อจำลองการหมุน 1,000d20 ครั้งแรกที่จะม้วน 1,000 ครั้ง โปรแกรมที่สองจะต้องกำหนดร้อยละ 19,001 (สำหรับช่วงที่มีศักยภาพ 1,000 ถึง 20,000) ก่อนที่จะทำสิ่งอื่น ดังนั้นหากคุณไม่ได้อยู่ในระบบแปลก ๆ ที่การค้นหาหน่วยความจำมีราคาแพงกว่าการดำเนินการจุดลอยตัวอย่างรุนแรงโดยใช้การเรียก nextInt () สำหรับแต่ละม้วนดูเหมือนว่าจะเป็นอย่างไร

หากคุณต้องการจัดเก็บลูกเต๋ารวมกันข่าวดีก็คือว่ามีวิธีแก้ปัญหาที่แย่คือคอมพิวเตอร์ของเรามีข้อ จำกัด ในเรื่องของปัญหานี้

ข่าวดี:

มีวิธีการแบบแยกส่วนของปัญหานี้:

1 / คำนวณการรวมกันทั้งหมดของกลุ่มลูกเต๋าของคุณ

2 / กำหนดความน่าจะเป็นสำหรับแต่ละชุดค่าผสม

3 / ค้นหาในรายการนี้เพื่อผลลัพธ์แทนการโยนลูกเต๋า

ข่าวร้าย:

จำนวนชุดค่าผสมที่มีการทำซ้ำจะได้รับจากสูตรต่อไปนี้

$\Gamma_n^k={n+k-1 \choose k}=\frac{(n+k-1)!}{k!~(n-1)!}$

( จากวิกิพีเดียภาษาฝรั่งเศส ):

นั่นหมายความว่ายกตัวอย่างเช่นด้วย 150 ลูกเต๋าคุณมี 698'526'906 ชุดค่าผสม สมมติว่าคุณเก็บความน่าจะเป็นแบบ 32 บิตคุณจะต้องมีหน่วยความจำ 2,6 GB และคุณยังต้องเพิ่มความต้องการหน่วยความจำสำหรับดัชนี ...

ในแง่การคำนวณหมายเลขการผสมสามารถคำนวณได้โดย convolutions ซึ่งมีประโยชน์ แต่ไม่สามารถแก้ไขข้อ จำกัด ของหน่วยความจำได้

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

แก้ไข

อย่างไรก็ตามในขณะที่คุณสนใจเพียงผลรวมของสี่เหลี่ยมลูกเต๋าคุณสามารถจัดเก็บความน่าจะเป็นที่มีทรัพยากรน้อยกว่ามาก

คุณสามารถคำนวณความน่าจะเป็นที่แม่นยำสำหรับแต่ละผลรวมของลูกเต๋าโดยใช้การแปลง

$F_i(m) = \sum_n F_1(n) F_{i-1}(m - n)$

จากนั้นเริ่มต้นจาก 1/6 ฟอร์มแต่ละผลลัพธ์ด้วย 1 ลูกเต๋าคุณสามารถสร้างความน่าจะเป็นที่ถูกต้องทั้งหมดสำหรับลูกเต๋าจำนวนเท่าใดก็ได้

นี่คือรหัส java คร่าวๆที่ฉันเขียนเพื่อประกอบ (ไม่เหมาะจริง ๆ ):

public class DiceProba {

private float[][] probas;
private int currentCalc;

public int getCurrentCalc() {
    return currentCalc;
}

public float[][] getProbas() {
    return probas;
}

public void calcProb(int faces, int diceNr) {

    if (diceNr < 0) {
        currentCalc = 0;
        return;
    }

    // Initialize
    float baseProba = 1.0f / ((float) faces);
    probas = new float[diceNr][];
    probas[0] = new float[faces + 1];
    probas[0][0] = 0.0f;
    for (int i = 1; i <= faces; ++i)
        probas[0][i] = baseProba;

    for (int i = 1; i < diceNr; ++i) {

        int maxValue = (i + 1) * faces + 1;
        probas[i] = new float[maxValue];

        for (int j = 0; j < maxValue; ++j) {

            probas[i][j] = 0;
            for (int k = 0; k <= j; ++k) {
                probas[i][j] += probability(faces, k, 0) * probability(faces, j - k, i - 1);
            }

        }

    }

    currentCalc = diceNr;

}

private float probability(int faces, int number, int diceNr) {

    if (number < 0 || number > ((diceNr + 1) * faces))
        return 0.0f;

    return probas[diceNr][number];

}

}

โทร calcProb () พร้อมพารามิเตอร์ที่คุณต้องการจากนั้นเข้าถึงตาราง proba สำหรับผลลัพธ์ (ดัชนีแรก: 0 สำหรับ 1 ลูกเต๋า 1 สำหรับ 2 ลูกเต๋าสอง ... )

ฉันตรวจสอบด้วย 1'000D6 บนแล็ปท็อปของฉันใช้เวลา 10 วินาทีในการคำนวณความน่าจะเป็นทั้งหมดตั้งแต่ 1 ถึง 1,000 ชิ้นและจำนวนเงินที่เป็นไปได้ทั้งหมด

ด้วยการประมวลผลล่วงหน้าและพื้นที่เก็บข้อมูลที่มีประสิทธิภาพคุณสามารถได้คำตอบอย่างรวดเร็วสำหรับจำนวนลูกเต๋าที่สูง

หวังว่ามันจะช่วย