运行结果如下

胜率设置：35.0%
胜利赔率：2.5倍
最大下注比例：50.0%
下注降低比例：70.0%
下注增长比例：1.3倍
最小下注金额：1

马丁格尔策略：
平均最终资金: 0.00
最高最终资金: 0.00
最低最终资金: 0.00
爆仓次数: 100 次，爆仓率: 100.00%

反马丁格尔策略：
平均最终资金: 3137.26
最高最终资金: 3904.19
最低最终资金: 2352.77
爆仓次数: 0 次，爆仓率: 0.00%

代码如下

"""
"""
马丁格尔策略 vs 反马丁格尔策略模拟程序

需求说明：
1. 模拟两种博彩策略的效果对比
   - 马丁格尔策略：输了就加倍下注，赢了降低下注（而不是重置为初始赌注）
   - 反马丁格尔策略：赢了就加倍下注，输了降低下注（而不是重置为初始赌注）

2. 核心参数：
   - 初始资金：100
   - 初始赌注：1
   - 每线程游戏次数：10000次
   - 线程数量：100个
   - 胜率：可调整（默认40%）
   - 赔率：可调整（默认1.5倍）
   - 最大下注比例：资金的20%
   - 降低下注比例：示例降低50%
   - 加倍下注比例：示例2倍
   - 最小下注金额：0.1

3. 风险控制：
   - 单次下注不超过当前资金的指定比例
   - 资金为0时停止游戏并记录为爆仓

4. 统计输出：
   - 平均最终资金
   - 最高/最低最终资金
   - 爆仓次数和爆仓率
   - 支持多线程并发模拟
"""

import threading
import random

# 参数配置
INITIAL_CAPITAL = 100     # 初始资金
INITIAL_BET = 1           # 初始赌注
COIN_FLIP_TIMES = 10000   # 每线程抛硬币次数
THREAD_COUNT = 100        # 线程数量
WIN_PROB = 0.35            # 胜率，示例40%
WIN_ODDS = 2.5            # 胜利赔率，示例1.5倍
MAX_BET_RATIO = 0.5       # 最大下注比例，示例20%
BET_REDUCTION_RATIO = 0.7 # 降低下注比例，示例降低30%
BET_INCREASE_RATIO = 1.3  # 加倍下注比例，示例1.3倍
MIN_BET = 1             # 最小下注金额

# 结果存储
results_martingale = []
results_anti_martingale = []

martingale_busts = 0
anti_martingale_busts = 0

lock = threading.Lock()   # 多线程锁，保护共享变量
def simulate(strategy_type):
    global martingale_busts, anti_martingale_busts

    capital = INITIAL_CAPITAL
    bet = INITIAL_BET

    for _ in range(COIN_FLIP_TIMES):
        # 检查是否有足够资金继续游戏
        if capital < MIN_BET:
            with lock:
                if strategy_type == 'martingale':
                    martingale_busts += 1
                else:
                    anti_martingale_busts += 1
            capital = 0
            break

        # 应用最大下注比例限制
        max_bet = capital * MAX_BET_RATIO
        bet = min(bet, max_bet)

        # 确保下注不超过当前资金
        actual_bet = min(bet, capital)

        win = random.random() < WIN_PROB

        if win:
            capital += actual_bet * WIN_ODDS
            if strategy_type == 'anti_martingale':
                bet *= BET_INCREASE_RATIO
            else:  # martingale策略
                bet = max(bet * BET_REDUCTION_RATIO, MIN_BET)
        else:
            capital -= actual_bet
            if strategy_type == 'martingale':
                bet *= BET_INCREASE_RATIO
            else:  # anti_martingale策略
                bet = max(bet * BET_REDUCTION_RATIO, MIN_BET)

    # 无论是否爆仓，都记录最终资金
    with lock:
        if strategy_type == 'martingale':
            results_martingale.append(capital)
        else:
            results_anti_martingale.append(capital)

threads = []

for _ in range(THREAD_COUNT):
    t1 = threading.Thread(target=simulate, args=('martingale',))
    t2 = threading.Thread(target=simulate, args=('anti_martingale',))
    threads.extend([t1, t2])

for t in threads:
    t.start()

for t in threads:
    t.join()

print(f"胜率设置：{WIN_PROB*100:.1f}%")
print(f"胜利赔率：{WIN_ODDS}倍")
print(f"最大下注比例：{MAX_BET_RATIO*100:.1f}%")
print(f"下注降低比例：{BET_REDUCTION_RATIO*100:.1f}%")
print(f"下注增长比例：{BET_INCREASE_RATIO}倍")
print(f"最小下注金额：{MIN_BET}\n")

print("马丁格尔策略：")
if results_martingale:
    print(f"平均最终资金: {sum(results_martingale) / THREAD_COUNT:.2f}")
    print(f"最高最终资金: {max(results_martingale):.2f}")
    print(f"最低最终资金: {min(results_martingale):.2f}")
else:
    print("无数据")
print(f"爆仓次数: {martingale_busts} 次，爆仓率: {martingale_busts / THREAD_COUNT * 100:.2f}%")

print("\n反马丁格尔策略：")
if results_anti_martingale:
    print(f"平均最终资金: {sum(results_anti_martingale) / THREAD_COUNT:.2f}")
    print(f"最高最终资金: {max(results_anti_martingale):.2f}")
    print(f"最低最终资金: {min(results_anti_martingale):.2f}")
else:
    print("无数据")
print(f"爆仓次数: {anti_martingale_busts} 次，爆仓率: {anti_martingale_busts / THREAD_COUNT * 100:.2f}%")