賓果遊戲 | C# Online Compiler

賓果遊戲 by BoxerLin

using System;
using System.Collections.Generic;

public class 賓果遊戲
{
    public int[] 固定十字 = { 2, 7, 10, 11, 12, 13, 14, 17, 22 };
    public int[] 區塊A = { 0, 1, 5, 6 };
    public int[] 區塊B = { 3, 4, 8, 9 };
    public int[] 區塊C = { 15, 16, 20, 21 };
    public int[] 區塊D = { 18, 19, 23, 24 };
    
    public int[] 盤面 = new int[25]; // 紀錄盤面狀態
    public Dictionary<int, double> 開獎機率 = new Dictionary<int, double>(); // 存儲每個數字的出現機率
    public List<int> 開獎數字 = new List<int>(); // 紀錄已開獎的數字

    public 賓果遊戲(Dictionary<int, double> 獎號機率)
    {
        開獎機率 = 獎號機率;
    }

    // 根據旋轉次數，順時針旋轉指定的區塊
    public void 旋轉區塊(int[] 區塊, int 旋轉次數)
    {
        for (int i = 0; i < 旋轉次數; i++)
        {
            int temp = 盤面[區塊[3]];
            盤面[區塊[3]] = 盤面[區塊[2]];
            盤面[區塊[2]] = 盤面[區塊[1]];
            盤面[區塊[1]] = 盤面[區塊[0]];
            盤面[區塊[0]] = temp;
        }
    }

    // 計算盤面中期望得分
    public double 計算期望得分()
    {
        double 得分 = 0.0;

        // 檢查橫排、直排、對角線連線
        // 橫排
        for (int row = 0; row < 5; row++)
        {
            得分 += 檢查期望連線(row * 5, row * 5 + 1, row * 5 + 2, row * 5 + 3, row * 5 + 4);
        }
        // 直排
        for (int col = 0; col < 5; col++)
        {
            得分 += 檢查期望連線(col, col + 5, col + 10, col + 15, col + 20);
        }
        // 對角線
        得分 += 檢查期望連線(0, 6, 12, 18, 24); // 左上到右下
        得分 += 檢查期望連線(4, 8, 12, 16, 20); // 右上到左下

        return 得分;
    }

    // 檢查一組連線，計算該連線的期望得分
    private double 檢查期望連線(params int[] 位置)
    {
        double 期望分數 = 0.0;
        double 連線機率 = 1.0; // 初始化為 1，後面乘上每個位置的機率

        foreach (int i in 位置)
        {
            if (開獎機率.ContainsKey(盤面[i]))
            {
                連線機率 *= 開獎機率[盤面[i]]; // 累乘每個位置的機率
            }
            else
            {
                連線機率 *= 0; // 若某個位置沒有機率，則這條線不成立
                break;
            }
        }

        // 根據連線的長度給予不同的分數權重
        int 連線數 = 位置.Length;

        if (連線數 == 5)
        {
            期望分數 = 8 * 連線機率; // 5 連線
        }
        else if (連線數 == 4)
        {
            期望分數 = 3 * 連線機率; // 4 連線
        }
        else if (連線數 == 3)
        {
            期望分數 = 1 * 連線機率; // 3 連線
        }

        return 期望分數;
    }

    // 模擬整局遊戲，返回期望得分最高的旋轉策略
    public int[] 找到最佳旋轉策略()
    {
        double 最佳得分 = 0.0;
        int[] 最佳旋轉 = new int[4]; // A, B, C, D 的最佳旋轉次數

        // 迭代所有可能的旋轉次數組合 (0, 1, 2, 3次旋轉)
        for (int a = 0; a < 4; a++)
        {
            for (int b = 0; b < 4; b++)
            {
                for (int c = 0; c < 4; c++)
                {
                    for (int d = 0; d < 4; d++)
                    {
                        // 重置盤面
                        Array.Clear(盤面, 0, 盤面.Length);
                        初始化盤面();

                        // 根據旋轉次數旋轉區塊
                        旋轉區塊(區塊A, a);
                        旋轉區塊(區塊B, b);
                        旋轉區塊(區塊C, c);
                        旋轉區塊(區塊D, d);

                        // 計算期望得分
                        double 得分 = 計算期望得分();
                        if (得分 > 最佳得分)
                        {
                            最佳得分 = 得分;
                            最佳旋轉[0] = a;
                            最佳旋轉[1] = b;
                            最佳旋轉[2] = c;
                            最佳旋轉[3] = d;
                        }
                    }
                }
            }
        }

        return 最佳旋轉; // 返回最佳旋轉策略
    }

    // 初始化盤面，固定的十字形不變
    public void 初始化盤面()
    {
        // 將固定的十字形號碼設置到盤面
        foreach (int i in 固定十字)
        {
            盤面[i] = i; // 假設號碼為盤面編號，對應機率中的鍵
        }
    }

    // 計算實際得分
    public int 計算實際得分(List<int> 實際數字)
    {
        int 得分 = 0;

        // 檢查橫排、直排、對角線連線
        // 橫排
        for (int row = 0; row < 5; row++)
        {
            得分 += 檢查實際連線(row * 5, row * 5 + 1, row * 5 + 2, row * 5 + 3, row * 5 + 4, 實際數字);
        }
        // 直排
        for (int col = 0; col < 5; col++)
        {
            得分 += 檢查實際連線(col, col + 5, col + 10, col + 15, col + 20, 實際數字);
        }
        // 對角線
        得分 += 檢查實際連線(0, 6, 12, 18, 24, 實際數字); // 左上到右下
        得分 += 檢查實際連線(4, 8, 12, 16, 20, 實際數字); // 右上到左下

        return 得分;
    }

    // 檢查一組連線，計算實際得分
    private int 檢查實際連線(int pos1, int pos2, int pos3, int pos4, int pos5, List<int> 實際數字)
    {
        int[] 連線 = { pos1, pos2, pos3, pos4, pos5 };
        int 連線數 = 0;

        foreach (int pos in 連線)
        {
            if (實際數字.Contains(盤面[pos]))
            {
                連線數++;
            }
        }

        if (連線數 == 5) return 8;
        if (連線數 == 4) return 3;
        if (連線數 == 3) return 1;
        return 0;
    }

    public static void Main(string[] args)
    {
        Random rnd = new Random();

        // 假設每個數字的出現機率
        Dictionary<int, double> 開獎機率 = new Dictionary<int, double>
        {
            { 2, 0.1 },
            { 7, 0.2 },
            { 10, 0.15 },
            { 11, 0.05 },
            { 12, 0.1 },
            { 13, 0.08 },
            { 14, 0.07 },
            { 17, 0.1 },
            { 22, 0.05 }
        };

        // 初始化遊戲
        賓果遊戲 game = new 賓果遊戲(開獎機率);

        // 模擬 1000 局
        for (int i = 0; i < 1000; i++)
        {
            Console.WriteLine($"第 {i + 1} 局:");

            // 隨機前三個數字
            List<int> 前三個數字 = new List<int>();
            while (前三個數字.Count < 3)
            {
                int 隨機數字 = rnd.Next(2, 23); // 隨機選擇2-22範圍內的數字
                if (!前三個數字.Contains(隨機數字))
                {
                    前三個數字.Add(隨機數字);
                }
            }

            game.開獎數字 = 前三個數字;

            // 找到最佳旋轉策略
            int[] 最佳旋轉策略 = game.找到最佳旋轉策略();

            // 根據最佳旋轉策略旋轉盤面
            game.旋轉區塊(game.區塊A, 最佳旋轉策略[0]);
            game.旋轉區塊(game.區塊B, 最佳旋轉策略[1]);
            game.旋轉區塊(game.區塊C, 最佳旋轉策略[2]);
            game.旋轉區塊(game.區塊D, 最佳旋轉策略[3]);

            // 模擬100次第4、5個數字，計算得分
            int[] 得分分佈 = new int[100];
            for (int j = 0; j < 100; j++)
            {
                List<int> 第四第五個數字 = new List<int>(前三個數字);
                while (第四第五個數字.Count < 5)
                {
                    int 隨機數字 = rnd.Next(2, 23);
                    if (!第四第五個數字.Contains(隨機數字))
                    {
                        第四第五個數字.Add(隨機數字);
                    }
                }

                int 實際得分 = game.計算實際得分(第四第五個數字);
                得分分佈[j] = 實際得分;
            }

            // 統計得分結果
            double 平均得分 = 0;
            for (int k = 0; k < 100; k++)
            {
                平均得分 += 得分分佈[k];
            }
            平均得分 /= 100;

            Console.WriteLine($"第 {i + 1} 局的平均得分: {平均得分}\n");
        }
    }
}

​x
 
using System;
using System.Collections.Generic;
​
public class 賓果遊戲
{
    public int[] 固定十字 = { 2, 7, 10, 11, 12, 13, 14, 17, 22 };
    public int[] 區塊A = { 0, 1, 5, 6 };
    public int[] 區塊B = { 3, 4, 8, 9 };
    public int[] 區塊C = { 15, 16, 20, 21 };
    public int[] 區塊D = { 18, 19, 23, 24 };
    
    public int[] 盤面 = new int[25]; // 紀錄盤面狀態
    public Dictionary<int, double> 開獎機率 = new Dictionary<int, double>(); // 存儲每個數字的出現機率
    public List<int> 開獎數字 = new List<int>(); // 紀錄已開獎的數字
​
    public 賓果遊戲(Dictionary<int, double> 獎號機率)
    {
        開獎機率 = 獎號機率;
    }
​
    // 根據旋轉次數，順時針旋轉指定的區塊
    public void 旋轉區塊(int[] 區塊, int 旋轉次數)
    {
        for (int i = 0; i < 旋轉次數; i++)
        {
            int temp = 盤面[區塊[3]];
            盤面[區塊[3]] = 盤面[區塊[2]];
            盤面[區塊[2]] = 盤面[區塊[1]];
            盤面[區塊[1]] = 盤面[區塊[0]];
            盤面[區塊[0]] = temp;
        }
    }
​
    // 計算盤面中期望得分
    public double 計算期望得分()
    {
        double 得分 = 0.0;
​
        // 檢查橫排、直排、對角線連線
        // 橫排
        for (int row = 0; row < 5; row++)
        {
            得分 += 檢查期望連線(row * 5, row * 5 + 1, row * 5 + 2, row * 5 + 3, row * 5 + 4);
        }
        // 直排
        for (int col = 0; col < 5; col++)
        {
            得分 += 檢查期望連線(col, col + 5, col + 10, col + 15, col + 20);
        }
        // 對角線
        得分 += 檢查期望連線(0, 6, 12, 18, 24); // 左上到右下
        得分 += 檢查期望連線(4, 8, 12, 16, 20); // 右上到左下
​
        return 得分;
    }
​
    // 檢查一組連線，計算該連線的期望得分
    private double 檢查期望連線(params int[] 位置)
    {
        double 期望分數 = 0.0;
        double 連線機率 = 1.0; // 初始化為 1，後面乘上每個位置的機率
​
        foreach (int i in 位置)
        {
            if (開獎機率.ContainsKey(盤面[i]))
            {
                連線機率 *= 開獎機率[盤面[i]]; // 累乘每個位置的機率
            }
            else
            {
                連線機率 *= 0; // 若某個位置沒有機率，則這條線不成立
                break;
            }
        }
​
        // 根據連線的長度給予不同的分數權重
        int 連線數 = 位置.Length;
​
        if (連線數 == 5)
        {
            期望分數 = 8 * 連線機率; // 5 連線
        }
        else if (連線數 == 4)
        {
            期望分數 = 3 * 連線機率; // 4 連線
        }
        else if (連線數 == 3)
        {
            期望分數 = 1 * 連線機率; // 3 連線
        }
​
        return 期望分數;
    }
​
    // 模擬整局遊戲，返回期望得分最高的旋轉策略
    public int[] 找到最佳旋轉策略()
    {
        double 最佳得分 = 0.0;
        int[] 最佳旋轉 = new int[4]; // A, B, C, D 的最佳旋轉次數
​
        // 迭代所有可能的旋轉次數組合 (0, 1, 2, 3次旋轉)
        for (int a = 0; a < 4; a++)
        {
            for (int b = 0; b < 4; b++)
            {
                for (int c = 0; c < 4; c++)
                {
                    for (int d = 0; d < 4; d++)
                    {
                        // 重置盤面
                        Array.Clear(盤面, 0, 盤面.Length);
                        初始化盤面();
​
                        // 根據旋轉次數旋轉區塊
                        旋轉區塊(區塊A, a);
                        旋轉區塊(區塊B, b);
                        旋轉區塊(區塊C, c);
                        旋轉區塊(區塊D, d);
​
                        // 計算期望得分
                        double 得分 = 計算期望得分();
                        if (得分 > 最佳得分)
                        {
                            最佳得分 = 得分;
                            最佳旋轉[0] = a;
                            最佳旋轉[1] = b;
                            最佳旋轉[2] = c;
                            最佳旋轉[3] = d;
                        }
                    }
                }
            }
        }
​
        return 最佳旋轉; // 返回最佳旋轉策略
    }
​
    // 初始化盤面，固定的十字形不變
    public void 初始化盤面()
    {
        // 將固定的十字形號碼設置到盤面
        foreach (int i in 固定十字)
        {
            盤面[i] = i; // 假設號碼為盤面編號，對應機率中的鍵
        }
    }
​
    // 計算實際得分
    public int 計算實際得分(List<int> 實際數字)
    {
        int 得分 = 0;
​
        // 檢查橫排、直排、對角線連線
        // 橫排
        for (int row = 0; row < 5; row++)
        {
            得分 += 檢查實際連線(row * 5, row * 5 + 1, row * 5 + 2, row * 5 + 3, row * 5 + 4, 實際數字);
        }
        // 直排
        for (int col = 0; col < 5; col++)
        {
            得分 += 檢查實際連線(col, col + 5, col + 10, col + 15, col + 20, 實際數字);
        }
        // 對角線
        得分 += 檢查實際連線(0, 6, 12, 18, 24, 實際數字); // 左上到右下
        得分 += 檢查實際連線(4, 8, 12, 16, 20, 實際數字); // 右上到左下
​
        return 得分;
    }
​
    // 檢查一組連線，計算實際得分
    private int 檢查實際連線(int pos1, int pos2, int pos3, int pos4, int pos5, List<int> 實際數字)
    {
        int[] 連線 = { pos1, pos2, pos3, pos4, pos5 };
        int 連線數 = 0;
​
        foreach (int pos in 連線)
        {
            if (實際數字.Contains(盤面[pos]))
            {
                連線數++;
            }
        }
​
        if (連線數 == 5) return 8;
        if (連線數 == 4) return 3;
        if (連線數 == 3) return 1;
        return 0;
    }
​
    public static void Main(string[] args)
    {
        Random rnd = new Random();
​
        // 假設每個數字的出現機率
        Dictionary<int, double> 開獎機率 = new Dictionary<int, double>
        {
            { 2, 0.1 },
            { 7, 0.2 },
            { 10, 0.15 },
            { 11, 0.05 },
            { 12, 0.1 },
            { 13, 0.08 },
            { 14, 0.07 },
            { 17, 0.1 },
            { 22, 0.05 }
        };
​
        // 初始化遊戲
        賓果遊戲 game = new 賓果遊戲(開獎機率);
​
        // 模擬 1000 局
        for (int i = 0; i < 1000; i++)
        {
            Console.WriteLine($"第 {i + 1} 局:");
​
            // 隨機前三個數字
            List<int> 前三個數字 = new List<int>();
            while (前三個數字.Count < 3)
            {
                int 隨機數字 = rnd.Next(2, 23); // 隨機選擇2-22範圍內的數字
                if (!前三個數字.Contains(隨機數字))
                {
                    前三個數字.Add(隨機數字);
                }
            }
​
            game.開獎數字 = 前三個數字;
​
            // 找到最佳旋轉策略
            int[] 最佳旋轉策略 = game.找到最佳旋轉策略();
​
            // 根據最佳旋轉策略旋轉盤面
            game.旋轉區塊(game.區塊A, 最佳旋轉策略[0]);
            game.旋轉區塊(game.區塊B, 最佳旋轉策略[1]);
            game.旋轉區塊(game.區塊C, 最佳旋轉策略[2]);
            game.旋轉區塊(game.區塊D, 最佳旋轉策略[3]);
​
            // 模擬100次第4、5個數字，計算得分
            int[] 得分分佈 = new int[100];
            for (int j = 0; j < 100; j++)
            {
                List<int> 第四第五個數字 = new List<int>(前三個數字);
                while (第四第五個數字.Count < 5)
                {
                    int 隨機數字 = rnd.Next(2, 23);
                    if (!第四第五個數字.Contains(隨機數字))
                    {
                        第四第五個數字.Add(隨機數字);
                    }
                }
​
                int 實際得分 = game.計算實際得分(第四第五個數字);
                得分分佈[j] = 實際得分;
            }
​
            // 統計得分結果
            double 平均得分 = 0;
            for (int k = 0; k < 100; k++)
            {
                平均得分 += 得分分佈[k];
            }
            平均得分 /= 100;
​
            Console.WriteLine($"第 {i + 1} 局的平均得分: {平均得分}\n");
        }
    }
}

View IL Code